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

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 core::ops::{Deref, DerefMut};17use codec::{Decode, Encode};18pub use frame_support::{19    construct_runtime, decl_event, decl_module, decl_storage, decl_error,20    dispatch::DispatchResult,21    ensure, fail, parameter_types,22    traits::{23        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24        Randomness, IsSubType, WithdrawReasons,25    },26    weights::{27        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29        WeightToFeePolynomial, DispatchClass,30    },31    StorageValue,32    transactional,33};3435use frame_system::{self as system, ensure_signed, ensure_root};36use sp_runtime::sp_std::prelude::Vec;37use sp_runtime::{38    traits::{39        Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,40    },41    transaction_validity::{42        TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,43    },44    FixedPointOperand, FixedU128,45};46use sp_runtime::traits::StaticLookup;47use pallet_contracts::chain_extension::UncheckedFrom;48use pallet_transaction_payment::OnChargeTransaction;4950#[cfg(test)]51mod mock;5253#[cfg(test)]54mod tests;5556mod default_weights;5758pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;59pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;60pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;61pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6263// Structs64// #region6566pub type CollectionId = u32;67pub type TokenId = u32;68pub type DecimalPoints = u8;6970#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]71#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]72pub enum CollectionMode {73    Invalid,74    NFT,75    // decimal points76    Fungible(DecimalPoints),77    ReFungible,78}7980impl Default for CollectionMode {81    fn default() -> Self {82        Self::Invalid83    }84}8586impl Into<u8> for CollectionMode {87    fn into(self) -> u8 {88        match self {89            CollectionMode::Invalid => 0,90            CollectionMode::NFT => 1,91            CollectionMode::Fungible(_) => 2,92            CollectionMode::ReFungible => 3,93        }94    }95}9697#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]98#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]99pub enum AccessMode {100    Normal,101    WhiteList,102}103impl Default for AccessMode {104    fn default() -> Self {105        Self::Normal106    }107}108109#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]110#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]111pub enum SchemaVersion {112    ImageURL,113    Unique,114}115impl Default for SchemaVersion {116    fn default() -> Self {117        Self::ImageURL118    }119}120121#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]122#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]123pub struct Ownership<AccountId> {124    pub owner: AccountId,125    pub fraction: u128,126}127128#[derive(Encode, Decode, Debug, Clone, PartialEq)]129#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]130pub enum SponsorshipState<AccountId> {131    /// The fees are applied to the transaction sender132    Disabled,133    Unconfirmed(AccountId),134    /// Transactions are sponsored by specified account135    Confirmed(AccountId),136}137138impl<AccountId> SponsorshipState<AccountId> {139    fn sponsor(&self) -> Option<&AccountId> {140        match self {141            Self::Confirmed(sponsor) => Some(sponsor),142            _ => None,143        }144    }145146    fn pending_sponsor(&self) -> Option<&AccountId> {147        match self {148            Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),149            _ => None,150        }151    }152153    fn confirmed(&self) -> bool {154        matches!(self, Self::Confirmed(_))155    }156}157158impl<T> Default for SponsorshipState<T> {159    fn default() -> Self {160        Self::Disabled161    }162}163164#[derive(Encode, Decode, Clone, PartialEq)]165#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]166pub struct Collection<T: Config> {167    pub owner: T::AccountId,168    pub mode: CollectionMode,169    pub access: AccessMode,170    pub decimal_points: DecimalPoints,171    pub name: Vec<u16>,        // 64 include null escape char172    pub description: Vec<u16>, // 256 include null escape char173    pub token_prefix: Vec<u8>, // 16 include null escape char174    pub mint_mode: bool,175    pub offchain_schema: Vec<u8>,176    pub schema_version: SchemaVersion,177    pub sponsorship: SponsorshipState<T::AccountId>,178    pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 179    pub variable_on_chain_schema: Vec<u8>, //180    pub const_on_chain_schema: Vec<u8>, //181}182183pub struct CollectionHandle<T: Config> {184    pub id: CollectionId,185    collection: Collection<T>,186}187188impl<T: Config> Deref for CollectionHandle<T> {189    type Target = Collection<T>;190191    fn deref(&self) -> &Self::Target {192        &self.collection193    }194}195196impl<T: Config> DerefMut for CollectionHandle<T> {197    fn deref_mut(&mut self) -> &mut Self::Target {198        &mut self.collection199    }200}201202#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]203#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]204pub struct NftItemType<AccountId> {205    pub owner: AccountId,206    pub const_data: Vec<u8>,207    pub variable_data: Vec<u8>,208}209210#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]211#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]212pub struct FungibleItemType {213    pub value: u128,214}215216#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]217#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]218pub struct ReFungibleItemType<AccountId> {219    pub owner: Vec<Ownership<AccountId>>,220    pub const_data: Vec<u8>,221    pub variable_data: Vec<u8>,222}223224// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]225// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]226// pub struct VestingItem<AccountId, Moment> {227//     pub sender: AccountId,228//     pub recipient: AccountId,229//     pub collection_id: CollectionId,230//     pub item_id: TokenId,231//     pub amount: u64,232//     pub vesting_date: Moment,233// }234235#[derive(Encode, Decode, Debug, Clone, PartialEq)]236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]237pub struct CollectionLimits<BlockNumber: Encode + Decode> {238    pub account_token_ownership_limit: u32,239    pub sponsored_data_size: u32,240    /// None - setVariableMetadata is not sponsored241    /// Some(v) - setVariableMetadata is sponsored 242    ///           if there is v block between txs243    pub sponsored_data_rate_limit: Option<BlockNumber>,244    pub token_limit: u32,245246    // Timeouts for item types in passed blocks247    pub sponsor_transfer_timeout: u32,248    pub owner_can_transfer: bool,249    pub owner_can_destroy: bool,250}251252impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {253    fn default() -> Self {254        Self { 255            account_token_ownership_limit: 10_000_000, 256            token_limit: u32::max_value(),257            sponsored_data_size: u32::MAX, 258            sponsored_data_rate_limit: None,259            sponsor_transfer_timeout: 14400,260            owner_can_transfer: true,261            owner_can_destroy: true262        }263    }264}265266#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]267#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]268pub struct ChainLimits {269    pub collection_numbers_limit: u32,270    pub account_token_ownership_limit: u32,271    pub collections_admins_limit: u64,272    pub custom_data_limit: u32,273274    // Timeouts for item types in passed blocks275    pub nft_sponsor_transfer_timeout: u32,276    pub fungible_sponsor_transfer_timeout: u32,277    pub refungible_sponsor_transfer_timeout: u32,278279    // Schema limits280    pub offchain_schema_limit: u32,281    pub variable_on_chain_schema_limit: u32,282    pub const_on_chain_schema_limit: u32,283}284285pub trait WeightInfo {286	fn create_collection() -> Weight;287	fn destroy_collection() -> Weight;288	fn add_to_white_list() -> Weight;289	fn remove_from_white_list() -> Weight;290    fn set_public_access_mode() -> Weight;291    fn set_mint_permission() -> Weight;292    fn change_collection_owner() -> Weight;293    fn add_collection_admin() -> Weight;294    fn remove_collection_admin() -> Weight;295    fn set_collection_sponsor() -> Weight;296    fn confirm_sponsorship() -> Weight;297    fn remove_collection_sponsor() -> Weight;298    fn create_item(s: usize) -> Weight;299    fn burn_item() -> Weight;300    fn transfer() -> Weight;301    fn approve() -> Weight;302    fn transfer_from() -> Weight;303    fn set_offchain_schema() -> Weight;304    fn set_const_on_chain_schema() -> Weight;305    fn set_variable_on_chain_schema() -> Weight;306    fn set_variable_meta_data() -> Weight;307    fn enable_contract_sponsoring() -> Weight;308    fn set_schema_version() -> Weight;309    fn set_chain_limits() -> Weight;310    fn set_contract_sponsoring_rate_limit() -> Weight;311    fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;312    fn toggle_contract_white_list() -> Weight;313    fn add_to_contract_white_list() -> Weight;314    fn remove_from_contract_white_list() -> Weight;315    fn set_collection_limits() -> Weight;316}317318#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]319#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]320pub struct CreateNftData {321    pub const_data: Vec<u8>,322    pub variable_data: Vec<u8>,323}324325#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]326#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]327pub struct CreateFungibleData {328    pub value: u128,329}330331#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]332#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]333pub struct CreateReFungibleData {334    pub const_data: Vec<u8>,335    pub variable_data: Vec<u8>,336    pub pieces: u128,337}338339#[derive(Encode, Decode, Debug, Clone, PartialEq)]340#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]341pub enum CreateItemData {342    NFT(CreateNftData),343    Fungible(CreateFungibleData),344    ReFungible(CreateReFungibleData),345}346347impl CreateItemData {348    pub fn len(&self) -> usize {349        let len = match self {350            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),351            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),352            _ => 0353        };354        355        return len;356    }357}358359impl From<CreateNftData> for CreateItemData {360    fn from(item: CreateNftData) -> Self {361        CreateItemData::NFT(item)362    }363}364365impl From<CreateReFungibleData> for CreateItemData {366    fn from(item: CreateReFungibleData) -> Self {367        CreateItemData::ReFungible(item)368    }369}370371impl From<CreateFungibleData> for CreateItemData {372    fn from(item: CreateFungibleData) -> Self {373        CreateItemData::Fungible(item)374    }375}376377378decl_error! {379	/// Error for non-fungible-token module.380	pub enum Error for Module<T: Config> {381        /// Total collections bound exceeded.382        TotalCollectionsLimitExceeded,383		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.384        CollectionDecimalPointLimitExceeded, 385        /// Collection name can not be longer than 63 char.386        CollectionNameLimitExceeded, 387        /// Collection description can not be longer than 255 char.388        CollectionDescriptionLimitExceeded, 389        /// Token prefix can not be longer than 15 char.390        CollectionTokenPrefixLimitExceeded,391        /// This collection does not exist.392        CollectionNotFound,393        /// Item not exists.394        TokenNotFound,395        /// Admin not found396        AdminNotFound,397        /// Arithmetic calculation overflow.398        NumOverflow,       399        /// Account already has admin role.400        AlreadyAdmin,  401        /// You do not own this collection.402        NoPermission,403        /// This address is not set as sponsor, use setCollectionSponsor first.404        ConfirmUnsetSponsorFail,405        /// Collection is not in mint mode.406        PublicMintingNotAllowed,407        /// Sender parameter and item owner must be equal.408        MustBeTokenOwner,409        /// Item balance not enough.410        TokenValueTooLow,411        /// Size of item is too large.412        NftSizeLimitExceeded,413        /// No approve found414        ApproveNotFound,415        /// Requested value more than approved.416        TokenValueNotEnough,417        /// Only approved addresses can call this method.418        ApproveRequired,419        /// Address is not in white list.420        AddresNotInWhiteList,421        /// Number of collection admins bound exceeded.422        CollectionAdminsLimitExceeded,423        /// Owned tokens by a single address bound exceeded.424        AddressOwnershipLimitExceeded,425        /// Length of items properties must be greater than 0.426        EmptyArgument,427        /// const_data exceeded data limit.428        TokenConstDataLimitExceeded,429        /// variable_data exceeded data limit.430        TokenVariableDataLimitExceeded,431        /// Not NFT item data used to mint in NFT collection.432        NotNftDataUsedToMintNftCollectionToken,433        /// Not Fungible item data used to mint in Fungible collection.434        NotFungibleDataUsedToMintFungibleCollectionToken,435        /// Not Re Fungible item data used to mint in Re Fungible collection.436        NotReFungibleDataUsedToMintReFungibleCollectionToken,437        /// Unexpected collection type.438        UnexpectedCollectionType,439        /// Can't store metadata in fungible tokens.440        CantStoreMetadataInFungibleTokens,441        /// Collection token limit exceeded442        CollectionTokenLimitExceeded,443        /// Account token limit exceeded per collection444        AccountTokenLimitExceeded,445        /// Collection limit bounds per collection exceeded446        CollectionLimitBoundsExceeded,447        /// Tried to enable permissions which are only permitted to be disabled448        OwnerPermissionsCantBeReverted,449        /// Schema data size limit bound exceeded450        SchemaDataLimitExceeded,451        /// Maximum refungibility exceeded452        WrongRefungiblePieces,453        /// createRefungible should be called with one owner454        BadCreateRefungibleCall,455	}456}457458pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {459    type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;460461    /// Weight information for extrinsics in this pallet.462	type WeightInfo: WeightInfo;463464    type Currency: Currency<Self::AccountId>;465    type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;466    type TreasuryAccountId: Get<Self::AccountId>;467}468469#[cfg(feature = "runtime-benchmarks")]470mod benchmarking;471472// #endregion473474// # Used definitions475//476// ## User control levels477//478// chain-controlled - key is uncontrolled by user479//                    i.e autoincrementing index480//                    can use non-cryptographic hash481// real - key is controlled by user482//        but it is hard to generate enough colliding values, i.e owner of signed txs483//        can use non-cryptographic hash484// controlled - key is completly controlled by users485//              i.e maps with mutable keys486//              should use cryptographic hash487//488// ## User control level downgrade reasons489//490// ?1 - chain-controlled -> controlled491//      collections/tokens can be destroyed, resulting in massive holes492// ?2 - chain-controlled -> controlled493//      same as ?1, but can be only added, resulting in easier exploitation494// ?3 - real -> controlled495//      no confirmation required, so addresses can be easily generated496decl_storage! {497    trait Store for Module<T: Config> as Nft {498499        //#region Private members500        /// Id of next collection501        CreatedCollectionCount: u32;502        /// Used for migrations503        ChainVersion: u64;504        /// Id of last collection token505        /// Collection id (controlled?1)506        ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;507        //#endregion508509        //#region Chain limits struct510        pub ChainLimit get(fn chain_limit) config(): ChainLimits;511        //#endregion512513        //#region Bound counters514        /// Amount of collections destroyed, used for total amount tracking with515        /// CreatedCollectionCount516        DestroyedCollectionCount: u32;517        /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)518        /// Account id (real)519        pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;520        //#endregion521522        //#region Basic collections523        /// Collection info524        /// Collection id (controlled?1)525        pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;526        /// List of collection admins527        /// Collection id (controlled?2)528        pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;529        /// Whitelisted collection users530        /// Collection id (controlled?2), user id (controlled?3)531        pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;532        //#endregion533534        /// How many of collection items user have535        /// Collection id (controlled?2), account id (real)536        pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;537538        /// Amount of items which spender can transfer out of owners account (via transferFrom)539        /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))540        pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;541542        //#region Item collections543        /// Collection id (controlled?2), token id (controlled?1)544        pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;545        /// Collection id (controlled?2), owner (controlled?2)546        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;547        /// Collection id (controlled?2), token id (controlled?1)548        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;549        //#endregion550551        //#region Index list552        /// Collection id (controlled?2), tokens owner (controlled?2)553        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;554        //#endregion555556        //#region Tokens transfer rate limit baskets557        /// (Collection id (controlled?2), who created (real))558        pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;559        /// Collection id (controlled?2), token id (controlled?2)560        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;561        /// Collection id (controlled?2), owning user (real)562        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;563        /// Collection id (controlled?2), token id (controlled?2)564        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;565        //#endregion566567        /// Variable metadata sponsoring568        /// Collection id (controlled?2), token id (controlled?2)569        pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;570      571        //#region Contract Sponsorship and Ownership572        /// Contract address (real)573        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;574        /// Contract address (real)575        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;576        /// (Contract address(real), caller (real))577        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;578        /// Contract address (real)579        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;580        /// Contract address (real)581        pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 582        /// Contract address (real) => Whitelisted user (controlled?3)583        pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 584        //#endregion585    }586    add_extra_genesis {587        build(|config: &GenesisConfig<T>| {588            // Modification of storage589            for (_num, _c) in &config.collection_id {590                <Module<T>>::init_collection(_c);591            }592593            for (_num, _c, _i) in &config.nft_item_id {594                <Module<T>>::init_nft_token(*_c, _i);595            }596597            for (collection_id, account_id, fungible_item) in &config.fungible_item_id {598                <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);599            }600601            for (_num, _c, _i) in &config.refungible_item_id {602                <Module<T>>::init_refungible_token(*_c, _i);603            }604        })605    }606}607608decl_event!(609    pub enum Event<T>610    where611        AccountId = <T as system::Config>::AccountId,612    {613        /// New collection was created614        /// 615        /// # Arguments616        /// 617        /// * collection_id: Globally unique identifier of newly created collection.618        /// 619        /// * mode: [CollectionMode] converted into u8.620        /// 621        /// * account_id: Collection owner.622        Created(CollectionId, u8, AccountId),623624        /// New item was created.625        /// 626        /// # Arguments627        /// 628        /// * collection_id: Id of the collection where item was created.629        /// 630        /// * item_id: Id of an item. Unique within the collection.631        ///632        /// * recipient: Owner of newly created item 633        ItemCreated(CollectionId, TokenId, AccountId),634635        /// Collection item was burned.636        /// 637        /// # Arguments638        /// 639        /// collection_id.640        /// 641        /// item_id: Identifier of burned NFT.642        ItemDestroyed(CollectionId, TokenId),643644        /// Item was transferred645        ///646        /// * collection_id: Id of collection to which item is belong647        ///648        /// * item_id: Id of an item649        ///650        /// * sender: Original owner of item651        ///652        /// * recipient: New owner of item653        ///654        /// * amount: Always 1 for NFT655        Transfer(CollectionId, TokenId, AccountId, AccountId, u128),656    }657);658659decl_module! {660    pub struct Module<T: Config> for enum Call 661    where 662        origin: T::Origin663    {664        fn deposit_event() = default;665        type Error = Error<T>;666667        fn on_initialize(now: T::BlockNumber) -> Weight {668            0669        }670671        /// 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.672        /// 673        /// # Permissions674        /// 675        /// * Anyone.676        /// 677        /// # Arguments678        /// 679        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.680        /// 681        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.682        /// 683        /// * token_prefix: UTF-8 string with token prefix.684        /// 685        /// * mode: [CollectionMode] collection type and type dependent data.686        // returns collection ID687        #[weight = <T as Config>::WeightInfo::create_collection()]688        #[transactional]689        pub fn create_collection(origin,690                                 collection_name: Vec<u16>,691                                 collection_description: Vec<u16>,692                                 token_prefix: Vec<u8>,693                                 mode: CollectionMode) -> DispatchResult {694695            // Anyone can create a collection696            let who = ensure_signed(origin)?;697698            // Take a (non-refundable) deposit of collection creation699            let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();700            imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(701                &T::TreasuryAccountId::get(),702                T::CollectionCreationPrice::get(),703            ));704            <T as Config>::Currency::settle(705                &who,706                imbalance,707                WithdrawReasons::TRANSFER,708                ExistenceRequirement::KeepAlive,709            ).map_err(|_| Error::<T>::NoPermission)?;710711            let decimal_points = match mode {712                CollectionMode::Fungible(points) => points,713                _ => 0714            };715716            let chain_limit = ChainLimit::get();717718            let created_count = CreatedCollectionCount::get();719            let destroyed_count = DestroyedCollectionCount::get();720721            // bound Total number of collections722            ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);723724            // check params725            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);726            ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);727            ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);728            ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);729730            // Generate next collection ID731            let next_id = created_count732                .checked_add(1)733                .ok_or(Error::<T>::NumOverflow)?;734735            CreatedCollectionCount::put(next_id);736737            let limits = CollectionLimits {738                sponsored_data_size: chain_limit.custom_data_limit,739                ..Default::default()740            };741742            // Create new collection743            let new_collection = Collection {744                owner: who.clone(),745                name: collection_name,746                mode: mode.clone(),747                mint_mode: false,748                access: AccessMode::Normal,749                description: collection_description,750                decimal_points: decimal_points,751                token_prefix: token_prefix,752                offchain_schema: Vec::new(),753                schema_version: SchemaVersion::ImageURL,754                sponsorship: SponsorshipState::Disabled,755                variable_on_chain_schema: Vec::new(),756                const_on_chain_schema: Vec::new(),757                limits,758            };759760            // Add new collection to map761            <CollectionById<T>>::insert(next_id, new_collection);762763            // call event764            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));765766            Ok(())767        }768769        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.770        /// 771        /// # Permissions772        /// 773        /// * Collection Owner.774        /// 775        /// # Arguments776        /// 777        /// * collection_id: collection to destroy.778        #[weight = <T as Config>::WeightInfo::destroy_collection()]779        #[transactional]780        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {781782            let sender = ensure_signed(origin)?;783            let collection = Self::get_collection(collection_id)?;784            Self::check_owner_permissions(&collection, sender)?;785            if !collection.limits.owner_can_destroy {786                fail!(Error::<T>::NoPermission);787            }788789            <AddressTokens<T>>::remove_prefix(collection_id);790            <Allowances<T>>::remove_prefix(collection_id);791            <Balance<T>>::remove_prefix(collection_id);792            <ItemListIndex>::remove(collection_id);793            <AdminList<T>>::remove(collection_id);794            <CollectionById<T>>::remove(collection_id);795            <WhiteList<T>>::remove_prefix(collection_id);796797            <NftItemList<T>>::remove_prefix(collection_id);798            <FungibleItemList<T>>::remove_prefix(collection_id);799            <ReFungibleItemList<T>>::remove_prefix(collection_id);800801            <NftTransferBasket<T>>::remove_prefix(collection_id);802            <FungibleTransferBasket<T>>::remove_prefix(collection_id);803            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);804805            <VariableMetaDataBasket<T>>::remove_prefix(collection_id);806807            DestroyedCollectionCount::put(DestroyedCollectionCount::get()808                .checked_add(1)809                .ok_or(Error::<T>::NumOverflow)?);810811            Ok(())812        }813814        /// Add an address to white list.815        /// 816        /// # Permissions817        /// 818        /// * Collection Owner819        /// * Collection Admin820        /// 821        /// # Arguments822        /// 823        /// * collection_id.824        /// 825        /// * address.826        #[weight = <T as Config>::WeightInfo::add_to_white_list()]827        #[transactional]828        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{829830            let sender = ensure_signed(origin)?;831            let collection = Self::get_collection(collection_id)?;832            Self::check_owner_or_admin_permissions(&collection, sender)?;833834            <WhiteList<T>>::insert(collection_id, address, true);835            836            Ok(())837        }838839        /// Remove an address from white list.840        /// 841        /// # Permissions842        /// 843        /// * Collection Owner844        /// * Collection Admin845        /// 846        /// # Arguments847        /// 848        /// * collection_id.849        /// 850        /// * address.851        #[weight = <T as Config>::WeightInfo::remove_from_white_list()]852        #[transactional]853        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{854855            let sender = ensure_signed(origin)?;856            let collection = Self::get_collection(collection_id)?;857            Self::check_owner_or_admin_permissions(&collection, sender)?;858859            <WhiteList<T>>::remove(collection_id, address);860861            Ok(())862        }863864        /// Toggle between normal and white list access for the methods with access for `Anyone`.865        /// 866        /// # Permissions867        /// 868        /// * Collection Owner.869        /// 870        /// # Arguments871        /// 872        /// * collection_id.873        /// 874        /// * mode: [AccessMode]875        #[weight = <T as Config>::WeightInfo::set_public_access_mode()]876        #[transactional]877        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult878        {879            let sender = ensure_signed(origin)?;880881            let mut target_collection = Self::get_collection(collection_id)?;882            Self::check_owner_permissions(&target_collection, sender)?;883            target_collection.access = mode;884            Self::save_collection(target_collection);885886            Ok(())887        }888889        /// Allows Anyone to create tokens if:890        /// * White List is enabled, and891        /// * Address is added to white list, and892        /// * This method was called with True parameter893        /// 894        /// # Permissions895        /// * Collection Owner896        ///897        /// # Arguments898        /// 899        /// * collection_id.900        /// 901        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.902        #[weight = <T as Config>::WeightInfo::set_mint_permission()]903        #[transactional]904        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult905        {906            let sender = ensure_signed(origin)?;907908            let mut target_collection = Self::get_collection(collection_id)?;909            Self::check_owner_permissions(&target_collection, sender)?;910            target_collection.mint_mode = mint_permission;911            Self::save_collection(target_collection);912913            Ok(())914        }915916        /// Change the owner of the collection.917        /// 918        /// # Permissions919        /// 920        /// * Collection Owner.921        /// 922        /// # Arguments923        /// 924        /// * collection_id.925        /// 926        /// * new_owner.927        #[weight = <T as Config>::WeightInfo::change_collection_owner()]928        #[transactional]929        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {930931            let sender = ensure_signed(origin)?;932            let mut target_collection = Self::get_collection(collection_id)?;933            Self::check_owner_permissions(&target_collection, sender)?;934            target_collection.owner = new_owner;935            Self::save_collection(target_collection);936937            Ok(())938        }939940        /// Adds an admin of the Collection.941        /// 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. 942        /// 943        /// # Permissions944        /// 945        /// * Collection Owner.946        /// * Collection Admin.947        /// 948        /// # Arguments949        /// 950        /// * collection_id: ID of the Collection to add admin for.951        /// 952        /// * new_admin_id: Address of new admin to add.953        #[weight = <T as Config>::WeightInfo::add_collection_admin()]954        #[transactional]955        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {956957            let sender = ensure_signed(origin)?;958            let collection = Self::get_collection(collection_id)?;959            Self::check_owner_or_admin_permissions(&collection, sender)?;960            let mut admin_arr: Vec<T::AccountId> = Vec::new();961962            if <AdminList<T>>::contains_key(collection_id)963            {964                admin_arr = <AdminList<T>>::get(collection_id);965                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);966            }967968            // Number of collection admins969            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);970971            admin_arr.push(new_admin_id);972            <AdminList<T>>::insert(collection_id, admin_arr);973974            Ok(())975        }976977        /// 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.978        ///979        /// # Permissions980        /// 981        /// * Collection Owner.982        /// * Collection Admin.983        /// 984        /// # Arguments985        /// 986        /// * collection_id: ID of the Collection to remove admin for.987        /// 988        /// * account_id: Address of admin to remove.989        #[weight = <T as Config>::WeightInfo::remove_collection_admin()]990        #[transactional]991        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {992993            let sender = ensure_signed(origin)?;994            let collection = Self::get_collection(collection_id)?;995            Self::check_owner_or_admin_permissions(&collection, sender)?;996            ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);997998            let mut admin_arr = <AdminList<T>>::get(collection_id);999            admin_arr.retain(|i| *i != account_id);1000            <AdminList<T>>::insert(collection_id, admin_arr);10011002            Ok(())1003        }10041005        /// # Permissions1006        /// 1007        /// * Collection Owner1008        /// 1009        /// # Arguments1010        /// 1011        /// * collection_id.1012        /// 1013        /// * new_sponsor.1014        #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1015        #[transactional]1016        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10171018            let sender = ensure_signed(origin)?;1019            let mut target_collection = Self::get_collection(collection_id)?;1020            Self::check_owner_permissions(&target_collection, sender)?;10211022            target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1023            Self::save_collection(target_collection);10241025            Ok(())1026        }10271028        /// # Permissions1029        /// 1030        /// * Sponsor.1031        /// 1032        /// # Arguments1033        /// 1034        /// * collection_id.1035        #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1036        #[transactional]1037        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10381039            let sender = ensure_signed(origin)?;10401041            let mut target_collection = Self::get_collection(collection_id)?;1042            ensure!(1043                target_collection.sponsorship.pending_sponsor() == Some(&sender),1044                Error::<T>::ConfirmUnsetSponsorFail1045            );10461047            target_collection.sponsorship = SponsorshipState::Confirmed(sender);1048            Self::save_collection(target_collection);10491050            Ok(())1051        }10521053        /// Switch back to pay-per-own-transaction model.1054        ///1055        /// # Permissions1056        ///1057        /// * Collection owner.1058        /// 1059        /// # Arguments1060        /// 1061        /// * collection_id.1062        #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1063        #[transactional]1064        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10651066            let sender = ensure_signed(origin)?;10671068            let mut target_collection = Self::get_collection(collection_id)?;1069            Self::check_owner_permissions(&target_collection, sender)?;10701071            target_collection.sponsorship = SponsorshipState::Disabled;1072            Self::save_collection(target_collection);10731074            Ok(())1075        }10761077        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1078        /// 1079        /// # Permissions1080        /// 1081        /// * Collection Owner.1082        /// * Collection Admin.1083        /// * Anyone if1084        ///     * White List is enabled, and1085        ///     * Address is added to white list, and1086        ///     * MintPermission is enabled (see SetMintPermission method)1087        /// 1088        /// # Arguments1089        /// 1090        /// * collection_id: ID of the collection.1091        /// 1092        /// * owner: Address, initial owner of the NFT.1093        ///1094        /// * data: Token data to store on chain.1095        // #[weight =1096        // (130_000_000 as Weight)1097        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1098        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1099        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11001101        #[weight = <T as Config>::WeightInfo::create_item(data.len())]1102        #[transactional]1103        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11041105            let sender = ensure_signed(origin)?;11061107            let target_collection = Self::get_collection(collection_id)?;11081109            Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1110            Self::validate_create_item_args(&target_collection, &data)?;1111            Self::create_item_no_validation(&target_collection, owner, data)?;11121113            Ok(())1114        }11151116        /// This method creates multiple items in a collection created with CreateCollection method.1117        /// 1118        /// # Permissions1119        /// 1120        /// * Collection Owner.1121        /// * Collection Admin.1122        /// * Anyone if1123        ///     * White List is enabled, and1124        ///     * Address is added to white list, and1125        ///     * MintPermission is enabled (see SetMintPermission method)1126        /// 1127        /// # Arguments1128        /// 1129        /// * collection_id: ID of the collection.1130        /// 1131        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1132        /// 1133        /// * owner: Address, initial owner of the NFT.1134        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1135                               .map(|data| { data.len() })1136                               .sum())]1137        #[transactional]1138        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11391140            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1141            let sender = ensure_signed(origin)?;11421143            let target_collection = Self::get_collection(collection_id)?;11441145            Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11461147            for data in &items_data {1148                Self::validate_create_item_args(&target_collection, data)?;1149            }1150            for data in &items_data {1151                Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1152            }11531154            Ok(())1155        }11561157        /// Destroys a concrete instance of NFT.1158        /// 1159        /// # Permissions1160        /// 1161        /// * Collection Owner.1162        /// * Collection Admin.1163        /// * Current NFT Owner.1164        /// 1165        /// # Arguments1166        /// 1167        /// * collection_id: ID of the collection.1168        /// 1169        /// * item_id: ID of NFT to burn.1170        #[weight = <T as Config>::WeightInfo::burn_item()]1171        #[transactional]1172        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11731174            let sender = ensure_signed(origin)?;11751176            // Transfer permissions check1177            let target_collection = Self::get_collection(collection_id)?;1178            ensure!(1179                Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1180                (1181                    target_collection.limits.owner_can_transfer &&1182                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1183                ),1184                Error::<T>::NoPermission1185            );11861187            if target_collection.access == AccessMode::WhiteList {1188                Self::check_white_list(&target_collection, &sender)?;1189            }11901191            match target_collection.mode1192            {1193                CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1194                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, &target_collection, value)?,1195                CollectionMode::ReFungible  => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1196                _ => ()1197            };11981199            // call event1200            Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12011202            Ok(())1203        }12041205        /// Change ownership of the token.1206        /// 1207        /// # Permissions1208        /// 1209        /// * Collection Owner1210        /// * Collection Admin1211        /// * Current NFT owner1212        ///1213        /// # Arguments1214        /// 1215        /// * recipient: Address of token recipient.1216        /// 1217        /// * collection_id.1218        /// 1219        /// * item_id: ID of the item1220        ///     * Non-Fungible Mode: Required.1221        ///     * Fungible Mode: Ignored.1222        ///     * Re-Fungible Mode: Required.1223        /// 1224        /// * value: Amount to transfer.1225        ///     * Non-Fungible Mode: Ignored1226        ///     * Fungible Mode: Must specify transferred amount1227        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1228        #[weight = <T as Config>::WeightInfo::transfer()]1229        #[transactional]1230        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1231            let sender = ensure_signed(origin)?;1232            let collection = Self::get_collection(collection_id)?;12331234            Self::transfer_internal(sender, recipient, &collection, item_id, value)1235        }12361237        /// Set, change, or remove approved address to transfer the ownership of the NFT.1238        /// 1239        /// # Permissions1240        /// 1241        /// * Collection Owner1242        /// * Collection Admin1243        /// * Current NFT owner1244        /// 1245        /// # Arguments1246        /// 1247        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1248        /// 1249        /// * collection_id.1250        /// 1251        /// * item_id: ID of the item.1252        #[weight = <T as Config>::WeightInfo::approve()]1253        #[transactional]1254        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12551256            let sender = ensure_signed(origin)?;1257            let target_collection = Self::get_collection(collection_id)?;12581259            Self::token_exists(&target_collection, item_id, &sender)?;12601261            // Transfer permissions check1262            let bypasses_limits = target_collection.limits.owner_can_transfer &&1263                Self::is_owner_or_admin_permissions(1264                    &target_collection,1265                    sender.clone(),1266                );12671268            let allowance_limit = if bypasses_limits {1269                None1270            } else if let Some(amount) = Self::owned_amount(1271                sender.clone(),1272                &target_collection,1273                item_id,1274            ) {1275                Some(amount)1276            } else {1277                fail!(Error::<T>::NoPermission);1278            };12791280            if target_collection.access == AccessMode::WhiteList {1281                Self::check_white_list(&target_collection, &sender)?;1282                Self::check_white_list(&target_collection, &spender)?;1283            }12841285            let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1286            let mut allowance: u128 = amount;1287            if allowance_exists {1288                allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1289            }1290            if let Some(limit) = allowance_limit {1291                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1292            }1293            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12941295            Ok(())1296        }1297        1298        /// 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.1299        /// 1300        /// # Permissions1301        /// * Collection Owner1302        /// * Collection Admin1303        /// * Current NFT owner1304        /// * Address approved by current NFT owner1305        /// 1306        /// # Arguments1307        /// 1308        /// * from: Address that owns token.1309        /// 1310        /// * recipient: Address of token recipient.1311        /// 1312        /// * collection_id.1313        /// 1314        /// * item_id: ID of the item.1315        /// 1316        /// * value: Amount to transfer.1317        #[weight = <T as Config>::WeightInfo::transfer_from()]1318        #[transactional]1319        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13201321            let sender = ensure_signed(origin)?;1322            let target_collection = Self::get_collection(collection_id)?;13231324            let mut appoved_transfer = false;13251326            // Check approval1327            let mut approval: u128 = 0;1328            if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1329                approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1330                ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1331                appoved_transfer = true;1332            }13331334            // Limits check1335            Self::is_correct_transfer(&target_collection, &recipient)?;13361337            // Transfer permissions check         1338            ensure!(1339                appoved_transfer || 1340                (1341                    target_collection.limits.owner_can_transfer &&1342                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1343                ),1344                Error::<T>::NoPermission1345            );13461347            if target_collection.access == AccessMode::WhiteList {1348                Self::check_white_list(&target_collection, &sender)?;1349                Self::check_white_list(&target_collection, &recipient)?;1350            }13511352            // Reduce approval by transferred amount or remove if remaining approval drops to 01353            if approval.saturating_sub(value) > 0 {1354                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1355            }1356            else {1357                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1358            }13591360            match target_collection.mode1361            {1362                CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from, recipient)?,1363                CollectionMode::Fungible(_)  => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1364                CollectionMode::ReFungible  => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient)?,1365                _ => ()1366            };13671368            Ok(())1369        }13701371        // #[weight = 0]1372        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13731374        //     // let no_perm_mes = "You do not have permissions to modify this collection";1375        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1376        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1377        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13781379        //     // // on_nft_received  call13801381        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;13821383        //     Ok(())1384        // }13851386        /// Set off-chain data schema.1387        /// 1388        /// # Permissions1389        /// 1390        /// * Collection Owner1391        /// * Collection Admin1392        /// 1393        /// # Arguments1394        /// 1395        /// * collection_id.1396        /// 1397        /// * schema: String representing the offchain data schema.1398        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1399        #[transactional]1400        pub fn set_variable_meta_data (1401            origin,1402            collection_id: CollectionId,1403            item_id: TokenId,1404            data: Vec<u8>1405        ) -> DispatchResult {1406            let sender = ensure_signed(origin)?;1407            1408            let target_collection = Self::get_collection(collection_id)?;1409            Self::token_exists(&target_collection, item_id, &sender)?;14101411            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14121413            // Modify permissions check1414            ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1415                Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1416                Error::<T>::NoPermission);14171418            match target_collection.mode1419            {1420                CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1421                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1422                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1423                _ => fail!(Error::<T>::UnexpectedCollectionType)1424            };14251426            Ok(())1427        }1428 1429        /// Set schema standard1430        /// ImageURL1431        /// Unique1432        /// 1433        /// # Permissions1434        /// 1435        /// * Collection Owner1436        /// * Collection Admin1437        /// 1438        /// # Arguments1439        /// 1440        /// * collection_id.1441        /// 1442        /// * schema: SchemaVersion: enum1443        #[weight = <T as Config>::WeightInfo::set_schema_version()]1444        #[transactional]1445        pub fn set_schema_version(1446            origin,1447            collection_id: CollectionId,1448            version: SchemaVersion1449        ) -> DispatchResult {1450            let sender = ensure_signed(origin)?;1451            let mut target_collection = Self::get_collection(collection_id)?;1452            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1453            target_collection.schema_version = version;1454            Self::save_collection(target_collection);14551456            Ok(())1457        }14581459        /// Set off-chain data schema.1460        /// 1461        /// # Permissions1462        /// 1463        /// * Collection Owner1464        /// * Collection Admin1465        /// 1466        /// # Arguments1467        /// 1468        /// * collection_id.1469        /// 1470        /// * schema: String representing the offchain data schema.1471        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1472        #[transactional]1473        pub fn set_offchain_schema(1474            origin,1475            collection_id: CollectionId,1476            schema: Vec<u8>1477        ) -> DispatchResult {1478            let sender = ensure_signed(origin)?;1479            let mut target_collection = Self::get_collection(collection_id)?;1480            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14811482            // check schema limit1483            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14841485            target_collection.offchain_schema = schema;1486            Self::save_collection(target_collection);14871488            Ok(())1489        }14901491        /// Set const on-chain data schema.1492        /// 1493        /// # Permissions1494        /// 1495        /// * Collection Owner1496        /// * Collection Admin1497        /// 1498        /// # Arguments1499        /// 1500        /// * collection_id.1501        /// 1502        /// * schema: String representing the const on-chain data schema.1503        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1504        #[transactional]1505        pub fn set_const_on_chain_schema (1506            origin,1507            collection_id: CollectionId,1508            schema: Vec<u8>1509        ) -> DispatchResult {1510            let sender = ensure_signed(origin)?;1511            let mut target_collection = Self::get_collection(collection_id)?;1512            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15131514            // check schema limit1515            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15161517            target_collection.const_on_chain_schema = schema;1518            Self::save_collection(target_collection);15191520            Ok(())1521        }15221523        /// Set variable on-chain data schema.1524        /// 1525        /// # Permissions1526        /// 1527        /// * Collection Owner1528        /// * Collection Admin1529        /// 1530        /// # Arguments1531        /// 1532        /// * collection_id.1533        /// 1534        /// * schema: String representing the variable on-chain data schema.1535        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1536        #[transactional]1537        pub fn set_variable_on_chain_schema (1538            origin,1539            collection_id: CollectionId,1540            schema: Vec<u8>1541        ) -> DispatchResult {1542            let sender = ensure_signed(origin)?;1543            let mut target_collection = Self::get_collection(collection_id)?;1544            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15451546            // check schema limit1547            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15481549            target_collection.variable_on_chain_schema = schema;1550            Self::save_collection(target_collection);15511552            Ok(())1553        }15541555        // Sudo permissions function1556        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1557        #[transactional]1558        pub fn set_chain_limits(1559            origin,1560            limits: ChainLimits1561        ) -> DispatchResult {15621563            #[cfg(not(feature = "runtime-benchmarks"))]1564            ensure_root(origin)?;15651566            <ChainLimit>::put(limits);1567            Ok(())1568        }15691570        /// Enable smart contract self-sponsoring.1571        /// 1572        /// # Permissions1573        /// 1574        /// * Contract Owner1575        /// 1576        /// # Arguments1577        /// 1578        /// * contract address1579        /// * enable flag1580        /// 1581        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1582        #[transactional]1583        pub fn enable_contract_sponsoring(1584            origin,1585            contract_address: T::AccountId,1586            enable: bool1587        ) -> DispatchResult {15881589            let sender = ensure_signed(origin)?;15901591            #[cfg(feature = "runtime-benchmarks")]1592            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15931594            Self::ensure_contract_owned(sender, &contract_address)?;15951596            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1597            Ok(())1598        }15991600        /// Set the rate limit for contract sponsoring to specified number of blocks.1601        /// 1602        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1603        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1604        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1605        /// from contract endowment if there are at least B blocks between such transactions. 1606        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1607        /// 1608        /// # Permissions1609        /// 1610        /// * Contract Owner1611        /// 1612        /// # Arguments1613        /// 1614        /// -`contract_address`: Address of the contract to sponsor1615        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1616        /// 1617        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1618        #[transactional]1619        pub fn set_contract_sponsoring_rate_limit(1620            origin,1621            contract_address: T::AccountId,1622            rate_limit: T::BlockNumber1623        ) -> DispatchResult {1624            let sender = ensure_signed(origin)?;16251626            #[cfg(feature = "runtime-benchmarks")]1627            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16281629            Self::ensure_contract_owned(sender, &contract_address)?;1630            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1631            Ok(())1632        }16331634        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1635        /// 1636        /// # Permissions1637        /// 1638        /// * Address that deployed smart contract.1639        /// 1640        /// # Arguments1641        /// 1642        /// -`contract_address`: Address of the contract.1643        /// 1644        /// - `enable`: .  1645        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1646        #[transactional]1647        pub fn toggle_contract_white_list(1648            origin,1649            contract_address: T::AccountId,1650            enable: bool1651        ) -> DispatchResult {1652            let sender = ensure_signed(origin)?;16531654            #[cfg(feature = "runtime-benchmarks")]1655            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16561657            Self::ensure_contract_owned(sender, &contract_address)?;1658            <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1659            Ok(())1660        }1661        1662        /// Add an address to smart contract white list.1663        /// 1664        /// # Permissions1665        /// 1666        /// * Address that deployed smart contract.1667        /// 1668        /// # Arguments1669        /// 1670        /// -`contract_address`: Address of the contract.1671        ///1672        /// -`account_address`: Address to add.1673        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1674        #[transactional]1675        pub fn add_to_contract_white_list(1676            origin,1677            contract_address: T::AccountId,1678            account_address: T::AccountId1679        ) -> DispatchResult {1680            let sender = ensure_signed(origin)?;16811682            #[cfg(feature = "runtime-benchmarks")]1683            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1684            1685            Self::ensure_contract_owned(sender, &contract_address)?;      1686            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1687            Ok(())1688        }16891690        /// Remove an address from smart contract white list.1691        /// 1692        /// # Permissions1693        /// 1694        /// * Address that deployed smart contract.1695        /// 1696        /// # Arguments1697        /// 1698        /// -`contract_address`: Address of the contract.1699        ///1700        /// -`account_address`: Address to remove.1701        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1702        #[transactional]1703        pub fn remove_from_contract_white_list(1704            origin,1705            contract_address: T::AccountId,1706            account_address: T::AccountId1707        ) -> DispatchResult {1708            let sender = ensure_signed(origin)?;17091710            #[cfg(feature = "runtime-benchmarks")]1711            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17121713            Self::ensure_contract_owned(sender, &contract_address)?;1714            <ContractWhiteList<T>>::remove(contract_address, account_address);1715            Ok(())1716        }17171718        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1719        #[transactional]1720        pub fn set_collection_limits(1721            origin,1722            collection_id: u32,1723            new_limits: CollectionLimits<T::BlockNumber>,1724        ) -> DispatchResult {1725            let sender = ensure_signed(origin)?;1726            let mut target_collection = Self::get_collection(collection_id)?;1727            Self::check_owner_permissions(&target_collection, sender.clone())?;1728            let old_limits = &target_collection.limits;1729            let chain_limits = ChainLimit::get();17301731            // collection bounds1732            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1733                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1734                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1735                Error::<T>::CollectionLimitBoundsExceeded);17361737            // token_limit   check  prev1738            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1739            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17401741            ensure!(1742                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1743                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1744                Error::<T>::OwnerPermissionsCantBeReverted,1745            );17461747            target_collection.limits = new_limits;1748            Self::save_collection(target_collection);17491750            Ok(())1751        } 1752    }1753}17541755impl<T: Config> Module<T> {17561757    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1758        // Limits check1759        Self::is_correct_transfer(target_collection, &recipient)?;17601761        // Transfer permissions check1762        ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1763            Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1764            Error::<T>::NoPermission);17651766        if target_collection.access == AccessMode::WhiteList {1767            Self::check_white_list(target_collection, &sender)?;1768            Self::check_white_list(target_collection, &recipient)?;1769        }17701771        match target_collection.mode1772        {1773            CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1774            CollectionMode::Fungible(_)  => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1775            CollectionMode::ReFungible  => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1776            _ => ()1777        };17781779        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17801781        Ok(())1782    }178317841785    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1786        let collection_id = collection.id;17871788        // check token limit and account token limit1789        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1790        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1791        1792        Ok(())1793    }17941795    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1796        let collection_id = collection.id;17971798        // check token limit and account token limit1799        let total_items: u32 = ItemListIndex::get(collection_id)1800            .checked_add(amount)1801            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1802        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1803            .checked_add(amount)1804            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1805        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1806        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);18071808        if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1809            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1810            Self::check_white_list(collection, owner)?;1811            Self::check_white_list(collection, sender)?;1812        }18131814        Ok(())1815    }18161817    fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1818        match target_collection.mode1819        {1820            CollectionMode::NFT => {1821                if let CreateItemData::NFT(data) = data {1822                    // check sizes1823                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1824                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1825                } else {1826                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1827                }1828            },1829            CollectionMode::Fungible(_) => {1830                if let CreateItemData::Fungible(_) = data {1831                } else {1832                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1833                }1834            },1835            CollectionMode::ReFungible => {1836                if let CreateItemData::ReFungible(data) = data {18371838                    // check sizes1839                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1840                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18411842                    // Check refungibility limits1843                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1844                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1845                } else {1846                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1847                }1848            },1849            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1850        };18511852        Ok(())1853    }18541855    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1856        match data1857        {1858            CreateItemData::NFT(data) => {1859                let item = NftItemType {1860                    owner: owner.clone(),1861                    const_data: data.const_data,1862                    variable_data: data.variable_data1863                };18641865                Self::add_nft_item(collection, item)?;1866            },1867            CreateItemData::Fungible(data) => {1868                Self::add_fungible_item(collection, &owner, data.value)?;1869            },1870            CreateItemData::ReFungible(data) => {1871                let mut owner_list = Vec::new();1872                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18731874                let item = ReFungibleItemType {1875                    owner: owner_list,1876                    const_data: data.const_data,1877                    variable_data: data.variable_data1878                };18791880                Self::add_refungible_item(collection, item)?;1881            }1882        };18831884        Ok(())1885    }18861887    fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1888        let collection_id = collection.id;18891890        // Does new owner already have an account?1891        let mut balance: u128 = 0;1892        if <FungibleItemList<T>>::contains_key(collection_id, owner) {1893            balance = <FungibleItemList<T>>::get(collection_id, owner).value;1894        } 18951896        // Mint 1897        let item = FungibleItemType {1898            value: balance + value1899        };1900        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19011902        // Update balance1903        let new_balance = <Balance<T>>::get(collection_id, owner)1904            .checked_add(value)1905            .ok_or(Error::<T>::NumOverflow)?;1906        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19071908        Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1909        Ok(())1910    }19111912    fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1913        let collection_id = collection.id;19141915        let current_index = <ItemListIndex>::get(collection_id)1916            .checked_add(1)1917            .ok_or(Error::<T>::NumOverflow)?;1918        let itemcopy = item.clone();19191920        ensure!(1921            item.owner.len() == 1,1922            Error::<T>::BadCreateRefungibleCall,1923        );1924        let item_owner = item.owner.first().expect("only one owner is defined");19251926        let value = item_owner.fraction;1927        let owner = item_owner.owner.clone();19281929        Self::add_token_index(collection_id, current_index, &owner)?;19301931        <ItemListIndex>::insert(collection_id, current_index);1932        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19331934        // Update balance1935        let new_balance = <Balance<T>>::get(collection_id, &owner)1936            .checked_add(value)1937            .ok_or(Error::<T>::NumOverflow)?;1938        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19391940        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1941        Ok(())1942    }19431944    fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1945        let collection_id = collection.id;19461947        let current_index = <ItemListIndex>::get(collection_id)1948            .checked_add(1)1949            .ok_or(Error::<T>::NumOverflow)?;19501951        let item_owner = item.owner.clone();1952        Self::add_token_index(collection_id, current_index, &item.owner)?;19531954        <ItemListIndex>::insert(collection_id, current_index);1955        <NftItemList<T>>::insert(collection_id, current_index, item);19561957        // Update balance1958        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1959            .checked_add(1)1960            .ok_or(Error::<T>::NumOverflow)?;1961        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19621963        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1964        Ok(())1965    }19661967    fn burn_refungible_item(1968        collection: &CollectionHandle<T>,1969        item_id: TokenId,1970        owner: &T::AccountId,1971    ) -> DispatchResult {1972        let collection_id = collection.id;19731974        ensure!(1975            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1976            Error::<T>::TokenNotFound1977        );1978        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1979        let rft_balance = token1980            .owner1981            .iter()1982            .find(|&i| i.owner == *owner)1983            .ok_or(Error::<T>::TokenNotFound)?;1984        Self::remove_token_index(collection_id, item_id, owner)?;19851986        // update balance1987        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1988            .checked_sub(rft_balance.fraction)1989            .ok_or(Error::<T>::NumOverflow)?;1990        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19911992        // Re-create owners list with sender removed1993        let index = token1994            .owner1995            .iter()1996            .position(|i| i.owner == *owner)1997            .expect("owned item is exists");1998        token.owner.remove(index);1999        let owner_count = token.owner.len();20002001        // Burn the token completely if this was the last (only) owner2002        if owner_count == 0 {2003            <ReFungibleItemList<T>>::remove(collection_id, item_id);2004            <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2005        }2006        else {2007            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2008        }20092010        Ok(())2011    }20122013    fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2014        let collection_id = collection.id;20152016        ensure!(2017            <NftItemList<T>>::contains_key(collection_id, item_id),2018            Error::<T>::TokenNotFound2019        );2020        let item = <NftItemList<T>>::get(collection_id, item_id);2021        Self::remove_token_index(collection_id, item_id, &item.owner)?;20222023        // update balance2024        let new_balance = <Balance<T>>::get(collection_id, &item.owner)2025            .checked_sub(1)2026            .ok_or(Error::<T>::NumOverflow)?;2027        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2028        <NftItemList<T>>::remove(collection_id, item_id);2029        <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20302031        Ok(())2032    }20332034    fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2035        let collection_id = collection.id;20362037        ensure!(2038            <FungibleItemList<T>>::contains_key(collection_id, owner),2039            Error::<T>::TokenNotFound2040        );2041        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2042        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20432044        // update balance2045        let new_balance = <Balance<T>>::get(collection_id, owner)2046            .checked_sub(value)2047            .ok_or(Error::<T>::NumOverflow)?;2048        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20492050        if balance.value - value > 0 {2051            balance.value -= value;2052            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2053        }2054        else {2055            <FungibleItemList<T>>::remove(collection_id, owner);2056        }20572058        Ok(())2059    }20602061    pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2062        Ok(<CollectionById<T>>::get(collection_id)2063            .map(|collection| CollectionHandle {2064                id: collection_id,2065                collection2066            })2067            .ok_or(Error::<T>::CollectionNotFound)?)2068    }20692070    fn save_collection(collection: CollectionHandle<T>) {2071        <CollectionById<T>>::insert(collection.id, collection.collection);2072    }20732074    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2075        ensure!(2076            subject == target_collection.owner,2077            Error::<T>::NoPermission2078        );20792080        Ok(())2081    }20822083    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2084        let mut result: bool = subject == collection.owner;2085        let exists = <AdminList<T>>::contains_key(collection.id);20862087        if !result & exists {2088            if <AdminList<T>>::get(collection.id).contains(&subject) {2089                result = true2090            }2091        }20922093        result2094    }20952096    fn check_owner_or_admin_permissions(2097        collection: &CollectionHandle<T>,2098        subject: T::AccountId,2099    ) -> DispatchResult {2100        let result = Self::is_owner_or_admin_permissions(collection, subject.clone());21012102        ensure!(2103            result,2104            Error::<T>::NoPermission2105        );2106        Ok(())2107    }21082109    fn owned_amount(2110        subject: T::AccountId,2111        target_collection: &CollectionHandle<T>,2112        item_id: TokenId,2113    ) -> Option<u128> {2114        let collection_id = target_collection.id;21152116        match target_collection.mode {2117            CollectionMode::NFT => {2118                if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2119                    return Some(1)2120                }2121                None2122            },2123            CollectionMode::Fungible(_) => {2124                if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2125                    return Some(<FungibleItemList<T>>::get(collection_id, &subject)2126                        .value);2127                }2128                None2129            },2130            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2131                .owner2132                .iter()2133                .find(|i| i.owner == subject)2134                .map(|i| i.fraction),2135            CollectionMode::Invalid => None,2136        }2137    }21382139    fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2140        let collection_id = target_collection.id;21412142        match target_collection.mode {2143            CollectionMode::NFT => {2144                <NftItemList<T>>::get(collection_id, item_id).owner == subject2145            }2146            CollectionMode::Fungible(_) => {2147                <FungibleItemList<T>>::contains_key(collection_id, &subject)2148            }2149            CollectionMode::ReFungible => {2150                <ReFungibleItemList<T>>::get(collection_id, item_id)2151                    .owner2152                    .iter()2153                    .any(|i| i.owner == subject)2154            }2155            CollectionMode::Invalid => false,2156        }2157    }21582159    fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2160        let collection_id = collection.id;21612162        let mes = Error::<T>::AddresNotInWhiteList;2163        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21642165        Ok(())2166    }21672168    /// Check if token exists. In case of Fungible, check if there is an entry for 2169    /// the owner in fungible balances double map2170    fn token_exists(2171        target_collection: &CollectionHandle<T>,2172        item_id: TokenId,2173        owner: &T::AccountId2174    ) -> DispatchResult {2175        let collection_id = target_collection.id;2176        let exists = match target_collection.mode2177        {2178            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2179            CollectionMode::Fungible(_)  => <FungibleItemList<T>>::contains_key(collection_id, owner),2180            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2181            _ => false2182        };21832184        ensure!(exists == true, Error::<T>::TokenNotFound);2185        Ok(())2186    }21872188    fn transfer_fungible(2189        collection: &CollectionHandle<T>,2190        value: u128,2191        owner: &T::AccountId,2192        recipient: &T::AccountId,2193    ) -> DispatchResult {2194        let collection_id = collection.id;2195        Self::token_exists(&collection, 0, owner)?;21962197        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2198        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21992200        // Send balance to recipient (updates balanceOf of recipient)2201        Self::add_fungible_item(collection, recipient, value)?;22022203        // update balanceOf of sender2204        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22052206        // Reduce or remove sender2207        if balance.value == value {2208            <FungibleItemList<T>>::remove(collection_id, owner);2209        }2210        else {2211            balance.value -= value;2212            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2213        }22142215        Ok(())2216    }22172218    fn transfer_refungible(2219        collection: &CollectionHandle<T>,2220        item_id: TokenId,2221        value: u128,2222        owner: T::AccountId,2223        new_owner: T::AccountId,2224    ) -> DispatchResult {2225        let collection_id = collection.id;2226        Self::token_exists(collection, item_id, &owner)?;22272228        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2229        let item = full_item2230            .owner2231            .iter()2232            .filter(|i| i.owner == owner)2233            .next()2234            .ok_or(Error::<T>::TokenNotFound)?;2235        let amount = item.fraction;22362237        ensure!(amount >= value, Error::<T>::TokenValueTooLow);22382239        // update balance2240        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2241            .checked_sub(value)2242            .ok_or(Error::<T>::NumOverflow)?;2243        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22442245        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2246            .checked_add(value)2247            .ok_or(Error::<T>::NumOverflow)?;2248        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22492250        let old_owner = item.owner.clone();2251        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22522253        // transfer2254        if amount == value && !new_owner_has_account {2255            // change owner2256            // new owner do not have account2257            let mut new_full_item = full_item.clone();2258            new_full_item2259                .owner2260                .iter_mut()2261                .find(|i| i.owner == owner)2262                .expect("old owner does present in refungible")2263                .owner = new_owner.clone();2264            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22652266            // update index collection2267            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2268        } else {2269            let mut new_full_item = full_item.clone();2270            new_full_item2271                .owner2272                .iter_mut()2273                .find(|i| i.owner == owner)2274                .expect("old owner does present in refungible")2275                .fraction -= value;22762277            // separate amount2278            if new_owner_has_account {2279                // new owner has account2280                new_full_item2281                    .owner2282                    .iter_mut()2283                    .find(|i| i.owner == new_owner)2284                    .expect("new owner has account")2285                    .fraction += value;2286            } else {2287                // new owner do not have account2288                new_full_item.owner.push(Ownership {2289                    owner: new_owner.clone(),2290                    fraction: value,2291                });2292                Self::add_token_index(collection_id, item_id, &new_owner)?;2293            }22942295            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2296        }22972298        Ok(())2299    }23002301    fn transfer_nft(2302        collection: &CollectionHandle<T>,2303        item_id: TokenId,2304        sender: T::AccountId,2305        new_owner: T::AccountId,2306    ) -> DispatchResult {2307        let collection_id = collection.id;2308        Self::token_exists(&collection, item_id, &sender)?;23092310        let mut item = <NftItemList<T>>::get(collection_id, item_id);23112312        ensure!(2313            sender == item.owner,2314            Error::<T>::MustBeTokenOwner2315        );23162317        // update balance2318        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2319            .checked_sub(1)2320            .ok_or(Error::<T>::NumOverflow)?;2321        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23222323        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2324            .checked_add(1)2325            .ok_or(Error::<T>::NumOverflow)?;2326        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23272328        // change owner2329        let old_owner = item.owner.clone();2330        item.owner = new_owner.clone();2331        <NftItemList<T>>::insert(collection_id, item_id, item);23322333        // update index collection2334        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23352336        Ok(())2337    }2338    2339    fn set_re_fungible_variable_data(2340        collection: &CollectionHandle<T>,2341        item_id: TokenId,2342        data: Vec<u8>2343    ) -> DispatchResult {2344        let collection_id = collection.id;2345        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);23462347        item.variable_data = data;23482349        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23502351        Ok(())2352    }23532354    fn set_nft_variable_data(2355        collection: &CollectionHandle<T>,2356        item_id: TokenId,2357        data: Vec<u8>2358    ) -> DispatchResult {2359        let collection_id = collection.id;2360        let mut item = <NftItemList<T>>::get(collection_id, item_id);2361        2362        item.variable_data = data;23632364        <NftItemList<T>>::insert(collection_id, item_id, item);2365        2366        Ok(())2367    }23682369    fn init_collection(item: &Collection<T>) {2370        // check params2371        assert!(2372            item.decimal_points <= MAX_DECIMAL_POINTS,2373            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2374        );2375        assert!(2376            item.name.len() <= 64,2377            "Collection name can not be longer than 63 char"2378        );2379        assert!(2380            item.name.len() <= 256,2381            "Collection description can not be longer than 255 char"2382        );2383        assert!(2384            item.token_prefix.len() <= 16,2385            "Token prefix can not be longer than 15 char"2386        );23872388        // Generate next collection ID2389        let next_id = CreatedCollectionCount::get()2390            .checked_add(1)2391            .unwrap();23922393        CreatedCollectionCount::put(next_id);2394    }23952396    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2397        let current_index = <ItemListIndex>::get(collection_id)2398            .checked_add(1)2399            .unwrap();24002401        let item_owner = item.owner.clone();2402        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24032404        <ItemListIndex>::insert(collection_id, current_index);24052406        // Update balance2407        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2408            .checked_add(1)2409            .unwrap();2410        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2411    }24122413    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2414        let current_index = <ItemListIndex>::get(collection_id)2415            .checked_add(1)2416            .unwrap();24172418        Self::add_token_index(collection_id, current_index, owner).unwrap();24192420        <ItemListIndex>::insert(collection_id, current_index);24212422        // Update balance2423        let new_balance = <Balance<T>>::get(collection_id, owner)2424            .checked_add(item.value)2425            .unwrap();2426        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2427    }24282429    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2430        let current_index = <ItemListIndex>::get(collection_id)2431            .checked_add(1)2432            .unwrap();24332434        let value = item.owner.first().unwrap().fraction;2435        let owner = item.owner.first().unwrap().owner.clone();24362437        Self::add_token_index(collection_id, current_index, &owner).unwrap();24382439        <ItemListIndex>::insert(collection_id, current_index);24402441        // Update balance2442        let new_balance = <Balance<T>>::get(collection_id, &owner)2443            .checked_add(value)2444            .unwrap();2445        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2446    }24472448    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2449        // add to account limit2450        if <AccountItemCount<T>>::contains_key(owner) {24512452            // bound Owned tokens by a single address2453            let count = <AccountItemCount<T>>::get(owner);2454            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24552456            <AccountItemCount<T>>::insert(owner.clone(), count2457                .checked_add(1)2458                .ok_or(Error::<T>::NumOverflow)?);2459        }2460        else {2461            <AccountItemCount<T>>::insert(owner.clone(), 1);2462        }24632464        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2465        if list_exists {2466            let mut list = <AddressTokens<T>>::get(collection_id, owner);2467            let item_contains = list.contains(&item_index.clone());24682469            if !item_contains {2470                list.push(item_index.clone());2471            }24722473            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2474        } else {2475            let mut itm = Vec::new();2476            itm.push(item_index.clone());2477            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2478        }24792480        Ok(())2481    }24822483    fn remove_token_index(2484        collection_id: CollectionId,2485        item_index: TokenId,2486        owner: &T::AccountId,2487    ) -> DispatchResult {24882489        // update counter2490        <AccountItemCount<T>>::insert(owner.clone(), 2491            <AccountItemCount<T>>::get(owner)2492            .checked_sub(1)2493            .ok_or(Error::<T>::NumOverflow)?);249424952496        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2497        if list_exists {2498            let mut list = <AddressTokens<T>>::get(collection_id, owner);2499            let item_contains = list.contains(&item_index.clone());25002501            if item_contains {2502                list.retain(|&item| item != item_index);2503                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2504            }2505        }25062507        Ok(())2508    }25092510    fn move_token_index(2511        collection_id: CollectionId,2512        item_index: TokenId,2513        old_owner: &T::AccountId,2514        new_owner: &T::AccountId,2515    ) -> DispatchResult {2516        Self::remove_token_index(collection_id, item_index, old_owner)?;2517        Self::add_token_index(collection_id, item_index, new_owner)?;25182519        Ok(())2520    }2521    2522    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2523        if <ContractOwner<T>>::contains_key(contract.clone()) {2524            let owner = <ContractOwner<T>>::get(contract);2525            ensure!(account == owner, Error::<T>::NoPermission);2526        } else {2527            fail!(Error::<T>::NoPermission);2528        }25292530        Ok(())2531    }2532}25332534////////////////////////////////////////////////////////////////////////////////////////////////////2535// Economic models2536// #region25372538/// Fee multiplier.2539pub type Multiplier = FixedU128;25402541type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25422543/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2544/// in the queue.2545#[derive(Encode, Decode, Clone, Eq, PartialEq)]2546pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25472548impl<T: Config + Send + Sync> sp_std::fmt::Debug 2549    for ChargeTransactionPayment<T>2550{2551	#[cfg(feature = "std")]2552	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2553		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2554	}2555	#[cfg(not(feature = "std"))]2556	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2557		Ok(())2558	}2559}25602561impl<T: Config> ChargeTransactionPayment<T>2562where2563    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2564    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2565    T::AccountId: AsRef<[u8]>,2566    T::AccountId: UncheckedFrom<T::Hash>,2567{2568    fn traditional_fee(2569        len: usize,2570        info: &DispatchInfoOf<T::Call>,2571        tip: BalanceOf<T>,2572    ) -> BalanceOf<T>2573    where2574        T::Call: Dispatchable<Info = DispatchInfo>,2575    {2576        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2577    }25782579	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2580        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2581        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2582        let len_saturation = max_block_length as u64 / (len as u64).max(1);2583        let coefficient: BalanceOf<T> = weight_saturation2584            .min(len_saturation)2585            .saturated_into::<BalanceOf<T>>();2586        final_fee2587            .saturating_mul(coefficient)2588            .saturated_into::<TransactionPriority>()2589    }25902591    fn withdraw_fee(2592        &self,2593        who: &T::AccountId,2594        call: &T::Call,2595        info: &DispatchInfoOf<T::Call>,2596        len: usize,2597	) -> Result<2598		(2599			BalanceOf<T>,2600			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2601		),2602		TransactionValidityError,2603	> {2604        let tip = self.0;26052606        let fee = Self::traditional_fee(len, info, tip);26072608        // Only mess with balances if fee is not zero.2609        if fee.is_zero() {2610            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2611			.map(|i| (fee, i));2612        }26132614        // Determine who is paying transaction fee based on ecnomic model2615        // Parse call to extract collection ID and access collection sponsor2616        let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2617            Some(Call::create_item(collection_id, _owner, _properties)) => {2618                let collection = <CollectionById<T>>::get(collection_id)?;26192620                // sponsor timeout2621                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26222623                let limit = collection.limits.sponsor_transfer_timeout;2624                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2625                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2626                    let limit_time = last_tx_block + limit.into();2627                    if block_number <= limit_time {2628                        return None;2629                    }2630                }2631                <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26322633                // check free create limit2634                if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2635                    collection.sponsorship.sponsor()2636                        .cloned()2637                } else {2638                    None2639                }2640            }2641            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2642                let collection = <CollectionById<T>>::get(collection_id)?;2643                2644                let mut sponsor_transfer = false;2645                if collection.sponsorship.confirmed() {26462647                    let collection_limits = collection.limits;2648                    let collection_mode = collection.mode;2649    2650                    // sponsor timeout2651                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2652                    sponsor_transfer = match collection_mode {2653                        CollectionMode::NFT => {2654    2655                            // get correct limit2656                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2657                                collection_limits.sponsor_transfer_timeout2658                            } else {2659                                ChainLimit::get().nft_sponsor_transfer_timeout2660                            };2661    2662                            let mut sponsored = true;2663                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2664                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2665                                let limit_time = last_tx_block + limit.into();2666                                if block_number <= limit_time {2667                                    sponsored = false;2668                                }2669                            }2670                            if sponsored {2671                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2672                            }26732674                            sponsored2675                        }2676                        CollectionMode::Fungible(_) => {2677    2678                            // get correct limit2679                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2680                                collection_limits.sponsor_transfer_timeout2681                            } else {2682                                ChainLimit::get().fungible_sponsor_transfer_timeout2683                            };2684    2685                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2686                            let mut sponsored = true;2687                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2688                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2689                                let limit_time = last_tx_block + limit.into();2690                                if block_number <= limit_time {2691                                    sponsored = false;2692                                }2693                            }2694                            if sponsored {2695                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2696                            }26972698                            sponsored2699                        }2700                        CollectionMode::ReFungible => {2701    2702                            // get correct limit2703                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2704                                collection_limits.sponsor_transfer_timeout2705                            } else {2706                                ChainLimit::get().refungible_sponsor_transfer_timeout2707                            };2708    2709                            let mut sponsored = true;2710                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2711                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2712                                let limit_time = last_tx_block + limit.into();2713                                if block_number <= limit_time {2714                                    sponsored = false;2715                                }2716                            }2717                            if sponsored {2718                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2719                            }27202721                            sponsored2722                        }2723                        _ => {2724                            false2725                        },2726                    };2727                }27282729                if !sponsor_transfer {2730                    None2731                } else {2732                    collection.sponsorship.sponsor()2733                        .cloned()2734                }2735            }27362737            Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2738                let mut sponsor_metadata_changes = false;27392740                let collection = <CollectionById<T>>::get(collection_id)?;27412742                if2743                    collection.sponsorship.confirmed() &&2744                    // Can't sponsor fungible collection, this tx will be rejected2745                    // as invalid2746                    !matches!(collection.mode, CollectionMode::Fungible(_)) &&2747                    data.len() <= collection.limits.sponsored_data_size as usize2748                {2749                    if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2750                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27512752                        if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2753                            .map(|last_block| block_number - last_block > rate_limit)2754                            .unwrap_or(true) 2755                        {2756                            sponsor_metadata_changes = true;2757                            <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2758                        }2759                    }2760                }27612762                if !sponsor_metadata_changes {2763                    None2764                } else {2765                    collection.sponsorship.sponsor().cloned()2766                }2767            }27682769            _ => None,2770        })();27712772        match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2773            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27742775                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27762777                let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2778                  && <ContractOwner<T>>::get(called_contract.clone()) == *who;2779                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2780                  2781                if !owned_contract && white_list_enabled {2782                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2783                        return Err(InvalidTransaction::Call.into());2784                    }2785                }2786            },2787            _ => {},2788        }27892790        // Sponsor smart contracts2791        sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27922793            // On instantiation: set the contract owner2794            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27952796                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2797                    &who,2798                    code_hash,2799                    salt,2800                );2801                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28022803                None2804            },28052806            // On instantiation with code: set the contract owner2807            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {28082809                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2810                    &who,2811                    &T::Hashing::hash(&_code),2812                    _salt,2813                );28142815                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28162817                None2818            }28192820            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2821            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28222823                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28242825                let mut sponsor_transfer = false;2826                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2827                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2828                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2829                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2830                    let limit_time = last_tx_block + rate_limit;28312832                    if block_number >= limit_time {2833                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2834                        sponsor_transfer = true;2835                    }2836                } else {2837                    sponsor_transfer = false;2838                }2839               2840                if sponsor_transfer {2841                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2842                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2843                            return Some(called_contract);2844                        }2845                    }2846                }28472848                None2849            },28502851            _ => None,2852        });28532854        let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28552856		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2857			.map(|i| (fee, i))2858    }2859}286028612862impl<T: Config + Send + Sync> SignedExtension2863    for ChargeTransactionPayment<T>2864where2865    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2866    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2867    T::AccountId: AsRef<[u8]>,2868    T::AccountId: UncheckedFrom<T::Hash>,2869{2870    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2871    type AccountId = T::AccountId;2872    type Call = T::Call;2873    type AdditionalSigned = ();2874    type Pre = (2875        // tip2876        BalanceOf<T>,2877        // who pays fee2878        Self::AccountId,2879		// imbalance resulting from withdrawing the fee2880		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2881    );2882    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2883        Ok(())2884    }28852886    fn validate(2887        &self,2888        who: &Self::AccountId,2889        call: &Self::Call,2890        info: &DispatchInfoOf<Self::Call>,2891        len: usize,2892    ) -> TransactionValidity {2893		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2894		Ok(ValidTransaction {2895			priority: Self::get_priority(len, info, fee),2896			..Default::default()2897		})2898    }28992900    fn pre_dispatch(2901        self,2902        who: &Self::AccountId,2903        call: &Self::Call,2904        info: &DispatchInfoOf<Self::Call>,2905        len: usize,2906    ) -> Result<Self::Pre, TransactionValidityError> {2907        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2908        Ok((self.0, who.clone(), imbalance))2909    }29102911    fn post_dispatch(2912        pre: Self::Pre,2913        info: &DispatchInfoOf<Self::Call>,2914        post_info: &PostDispatchInfoOf<Self::Call>,2915        len: usize,2916        _result: &DispatchResult,2917    ) -> Result<(), TransactionValidityError> {2918		let (tip, who, imbalance) = pre;2919		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2920			len as u32,2921			info,2922			post_info,2923			tip,2924		);2925		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2926		Ok(())2927    }2928}29292930// #endregion