`ec67731bb0e1`

1 file changed

modifiedpallets/nft/src/lib.rsdiff before after both
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),656657        /// * collection_id658        ///659        /// * item_id660        ///661        /// * sender662        ///663        /// * spender664        ///665        /// * amount666        Approved(CollectionId, TokenId, AccountId, AccountId, u128),667    }668);669670decl_module! {671    pub struct Module<T: Config> for enum Call 672    where 673        origin: T::Origin674    {675        fn deposit_event() = default;676        type Error = Error<T>;677678        fn on_initialize(now: T::BlockNumber) -> Weight {679            0680        }681682        /// 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.683        /// 684        /// # Permissions685        /// 686        /// * Anyone.687        /// 688        /// # Arguments689        /// 690        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.691        /// 692        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.693        /// 694        /// * token_prefix: UTF-8 string with token prefix.695        /// 696        /// * mode: [CollectionMode] collection type and type dependent data.697        // returns collection ID698        #[weight = <T as Config>::WeightInfo::create_collection()]699        #[transactional]700        pub fn create_collection(origin,701                                 collection_name: Vec<u16>,702                                 collection_description: Vec<u16>,703                                 token_prefix: Vec<u8>,704                                 mode: CollectionMode) -> DispatchResult {705706            // Anyone can create a collection707            let who = ensure_signed(origin)?;708709            // Take a (non-refundable) deposit of collection creation710            let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();711            imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(712                &T::TreasuryAccountId::get(),713                T::CollectionCreationPrice::get(),714            ));715            <T as Config>::Currency::settle(716                &who,717                imbalance,718                WithdrawReasons::TRANSFER,719                ExistenceRequirement::KeepAlive,720            ).map_err(|_| Error::<T>::NoPermission)?;721722            let decimal_points = match mode {723                CollectionMode::Fungible(points) => points,724                _ => 0725            };726727            let chain_limit = ChainLimit::get();728729            let created_count = CreatedCollectionCount::get();730            let destroyed_count = DestroyedCollectionCount::get();731732            // bound Total number of collections733            ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);734735            // check params736            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);737            ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);738            ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);739            ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);740741            // Generate next collection ID742            let next_id = created_count743                .checked_add(1)744                .ok_or(Error::<T>::NumOverflow)?;745746            CreatedCollectionCount::put(next_id);747748            let limits = CollectionLimits {749                sponsored_data_size: chain_limit.custom_data_limit,750                ..Default::default()751            };752753            // Create new collection754            let new_collection = Collection {755                owner: who.clone(),756                name: collection_name,757                mode: mode.clone(),758                mint_mode: false,759                access: AccessMode::Normal,760                description: collection_description,761                decimal_points: decimal_points,762                token_prefix: token_prefix,763                offchain_schema: Vec::new(),764                schema_version: SchemaVersion::ImageURL,765                sponsorship: SponsorshipState::Disabled,766                variable_on_chain_schema: Vec::new(),767                const_on_chain_schema: Vec::new(),768                limits,769            };770771            // Add new collection to map772            <CollectionById<T>>::insert(next_id, new_collection);773774            // call event775            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));776777            Ok(())778        }779780        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.781        /// 782        /// # Permissions783        /// 784        /// * Collection Owner.785        /// 786        /// # Arguments787        /// 788        /// * collection_id: collection to destroy.789        #[weight = <T as Config>::WeightInfo::destroy_collection()]790        #[transactional]791        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {792793            let sender = ensure_signed(origin)?;794            let collection = Self::get_collection(collection_id)?;795            Self::check_owner_permissions(&collection, sender)?;796            if !collection.limits.owner_can_destroy {797                fail!(Error::<T>::NoPermission);798            }799800            <AddressTokens<T>>::remove_prefix(collection_id);801            <Allowances<T>>::remove_prefix(collection_id);802            <Balance<T>>::remove_prefix(collection_id);803            <ItemListIndex>::remove(collection_id);804            <AdminList<T>>::remove(collection_id);805            <CollectionById<T>>::remove(collection_id);806            <WhiteList<T>>::remove_prefix(collection_id);807808            <NftItemList<T>>::remove_prefix(collection_id);809            <FungibleItemList<T>>::remove_prefix(collection_id);810            <ReFungibleItemList<T>>::remove_prefix(collection_id);811812            <NftTransferBasket<T>>::remove_prefix(collection_id);813            <FungibleTransferBasket<T>>::remove_prefix(collection_id);814            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);815816            <VariableMetaDataBasket<T>>::remove_prefix(collection_id);817818            DestroyedCollectionCount::put(DestroyedCollectionCount::get()819                .checked_add(1)820                .ok_or(Error::<T>::NumOverflow)?);821822            Ok(())823        }824825        /// Add an address to white list.826        /// 827        /// # Permissions828        /// 829        /// * Collection Owner830        /// * Collection Admin831        /// 832        /// # Arguments833        /// 834        /// * collection_id.835        /// 836        /// * address.837        #[weight = <T as Config>::WeightInfo::add_to_white_list()]838        #[transactional]839        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{840841            let sender = ensure_signed(origin)?;842            let collection = Self::get_collection(collection_id)?;843            Self::check_owner_or_admin_permissions(&collection, sender)?;844845            <WhiteList<T>>::insert(collection_id, address, true);846            847            Ok(())848        }849850        /// Remove an address from white list.851        /// 852        /// # Permissions853        /// 854        /// * Collection Owner855        /// * Collection Admin856        /// 857        /// # Arguments858        /// 859        /// * collection_id.860        /// 861        /// * address.862        #[weight = <T as Config>::WeightInfo::remove_from_white_list()]863        #[transactional]864        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{865866            let sender = ensure_signed(origin)?;867            let collection = Self::get_collection(collection_id)?;868            Self::check_owner_or_admin_permissions(&collection, sender)?;869870            <WhiteList<T>>::remove(collection_id, address);871872            Ok(())873        }874875        /// Toggle between normal and white list access for the methods with access for `Anyone`.876        /// 877        /// # Permissions878        /// 879        /// * Collection Owner.880        /// 881        /// # Arguments882        /// 883        /// * collection_id.884        /// 885        /// * mode: [AccessMode]886        #[weight = <T as Config>::WeightInfo::set_public_access_mode()]887        #[transactional]888        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult889        {890            let sender = ensure_signed(origin)?;891892            let mut target_collection = Self::get_collection(collection_id)?;893            Self::check_owner_permissions(&target_collection, sender)?;894            target_collection.access = mode;895            Self::save_collection(target_collection);896897            Ok(())898        }899900        /// Allows Anyone to create tokens if:901        /// * White List is enabled, and902        /// * Address is added to white list, and903        /// * This method was called with True parameter904        /// 905        /// # Permissions906        /// * Collection Owner907        ///908        /// # Arguments909        /// 910        /// * collection_id.911        /// 912        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.913        #[weight = <T as Config>::WeightInfo::set_mint_permission()]914        #[transactional]915        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult916        {917            let sender = ensure_signed(origin)?;918919            let mut target_collection = Self::get_collection(collection_id)?;920            Self::check_owner_permissions(&target_collection, sender)?;921            target_collection.mint_mode = mint_permission;922            Self::save_collection(target_collection);923924            Ok(())925        }926927        /// Change the owner of the collection.928        /// 929        /// # Permissions930        /// 931        /// * Collection Owner.932        /// 933        /// # Arguments934        /// 935        /// * collection_id.936        /// 937        /// * new_owner.938        #[weight = <T as Config>::WeightInfo::change_collection_owner()]939        #[transactional]940        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {941942            let sender = ensure_signed(origin)?;943            let mut target_collection = Self::get_collection(collection_id)?;944            Self::check_owner_permissions(&target_collection, sender)?;945            target_collection.owner = new_owner;946            Self::save_collection(target_collection);947948            Ok(())949        }950951        /// Adds an admin of the Collection.952        /// 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. 953        /// 954        /// # Permissions955        /// 956        /// * Collection Owner.957        /// * Collection Admin.958        /// 959        /// # Arguments960        /// 961        /// * collection_id: ID of the Collection to add admin for.962        /// 963        /// * new_admin_id: Address of new admin to add.964        #[weight = <T as Config>::WeightInfo::add_collection_admin()]965        #[transactional]966        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {967968            let sender = ensure_signed(origin)?;969            let collection = Self::get_collection(collection_id)?;970            Self::check_owner_or_admin_permissions(&collection, sender)?;971            let mut admin_arr: Vec<T::AccountId> = Vec::new();972973            if <AdminList<T>>::contains_key(collection_id)974            {975                admin_arr = <AdminList<T>>::get(collection_id);976                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);977            }978979            // Number of collection admins980            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);981982            admin_arr.push(new_admin_id);983            <AdminList<T>>::insert(collection_id, admin_arr);984985            Ok(())986        }987988        /// 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.989        ///990        /// # Permissions991        /// 992        /// * Collection Owner.993        /// * Collection Admin.994        /// 995        /// # Arguments996        /// 997        /// * collection_id: ID of the Collection to remove admin for.998        /// 999        /// * account_id: Address of admin to remove.1000        #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1001        #[transactional]1002        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10031004            let sender = ensure_signed(origin)?;1005            let collection = Self::get_collection(collection_id)?;1006            Self::check_owner_or_admin_permissions(&collection, sender)?;1007            ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);10081009            let mut admin_arr = <AdminList<T>>::get(collection_id);1010            admin_arr.retain(|i| *i != account_id);1011            <AdminList<T>>::insert(collection_id, admin_arr);10121013            Ok(())1014        }10151016        /// # Permissions1017        /// 1018        /// * Collection Owner1019        /// 1020        /// # Arguments1021        /// 1022        /// * collection_id.1023        /// 1024        /// * new_sponsor.1025        #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1026        #[transactional]1027        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10281029            let sender = ensure_signed(origin)?;1030            let mut target_collection = Self::get_collection(collection_id)?;1031            Self::check_owner_permissions(&target_collection, sender)?;10321033            target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1034            Self::save_collection(target_collection);10351036            Ok(())1037        }10381039        /// # Permissions1040        /// 1041        /// * Sponsor.1042        /// 1043        /// # Arguments1044        /// 1045        /// * collection_id.1046        #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1047        #[transactional]1048        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10491050            let sender = ensure_signed(origin)?;10511052            let mut target_collection = Self::get_collection(collection_id)?;1053            ensure!(1054                target_collection.sponsorship.pending_sponsor() == Some(&sender),1055                Error::<T>::ConfirmUnsetSponsorFail1056            );10571058            target_collection.sponsorship = SponsorshipState::Confirmed(sender);1059            Self::save_collection(target_collection);10601061            Ok(())1062        }10631064        /// Switch back to pay-per-own-transaction model.1065        ///1066        /// # Permissions1067        ///1068        /// * Collection owner.1069        /// 1070        /// # Arguments1071        /// 1072        /// * collection_id.1073        #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1074        #[transactional]1075        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10761077            let sender = ensure_signed(origin)?;10781079            let mut target_collection = Self::get_collection(collection_id)?;1080            Self::check_owner_permissions(&target_collection, sender)?;10811082            target_collection.sponsorship = SponsorshipState::Disabled;1083            Self::save_collection(target_collection);10841085            Ok(())1086        }10871088        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1089        /// 1090        /// # Permissions1091        /// 1092        /// * Collection Owner.1093        /// * Collection Admin.1094        /// * Anyone if1095        ///     * White List is enabled, and1096        ///     * Address is added to white list, and1097        ///     * MintPermission is enabled (see SetMintPermission method)1098        /// 1099        /// # Arguments1100        /// 1101        /// * collection_id: ID of the collection.1102        /// 1103        /// * owner: Address, initial owner of the NFT.1104        ///1105        /// * data: Token data to store on chain.1106        // #[weight =1107        // (130_000_000 as Weight)1108        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1109        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1110        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11111112        #[weight = <T as Config>::WeightInfo::create_item(data.len())]1113        #[transactional]1114        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11151116            let sender = ensure_signed(origin)?;11171118            let target_collection = Self::get_collection(collection_id)?;11191120            Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1121            Self::validate_create_item_args(&target_collection, &data)?;1122            Self::create_item_no_validation(&target_collection, owner, data)?;11231124            Ok(())1125        }11261127        /// This method creates multiple items in a collection created with CreateCollection method.1128        /// 1129        /// # Permissions1130        /// 1131        /// * Collection Owner.1132        /// * Collection Admin.1133        /// * Anyone if1134        ///     * White List is enabled, and1135        ///     * Address is added to white list, and1136        ///     * MintPermission is enabled (see SetMintPermission method)1137        /// 1138        /// # Arguments1139        /// 1140        /// * collection_id: ID of the collection.1141        /// 1142        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1143        /// 1144        /// * owner: Address, initial owner of the NFT.1145        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1146                               .map(|data| { data.len() })1147                               .sum())]1148        #[transactional]1149        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11501151            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1152            let sender = ensure_signed(origin)?;11531154            let target_collection = Self::get_collection(collection_id)?;11551156            Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11571158            for data in &items_data {1159                Self::validate_create_item_args(&target_collection, data)?;1160            }1161            for data in &items_data {1162                Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1163            }11641165            Ok(())1166        }11671168        /// Destroys a concrete instance of NFT.1169        /// 1170        /// # Permissions1171        /// 1172        /// * Collection Owner.1173        /// * Collection Admin.1174        /// * Current NFT Owner.1175        /// 1176        /// # Arguments1177        /// 1178        /// * collection_id: ID of the collection.1179        /// 1180        /// * item_id: ID of NFT to burn.1181        #[weight = <T as Config>::WeightInfo::burn_item()]1182        #[transactional]1183        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11841185            let sender = ensure_signed(origin)?;11861187            // Transfer permissions check1188            let target_collection = Self::get_collection(collection_id)?;1189            ensure!(1190                Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1191                (1192                    target_collection.limits.owner_can_transfer &&1193                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1194                ),1195                Error::<T>::NoPermission1196            );11971198            if target_collection.access == AccessMode::WhiteList {1199                Self::check_white_list(&target_collection, &sender)?;1200            }12011202            match target_collection.mode1203            {1204                CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1205                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, &target_collection, value)?,1206                CollectionMode::ReFungible  => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1207                _ => ()1208            };12091210            // call event1211            Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12121213            Ok(())1214        }12151216        /// Change ownership of the token.1217        /// 1218        /// # Permissions1219        /// 1220        /// * Collection Owner1221        /// * Collection Admin1222        /// * Current NFT owner1223        ///1224        /// # Arguments1225        /// 1226        /// * recipient: Address of token recipient.1227        /// 1228        /// * collection_id.1229        /// 1230        /// * item_id: ID of the item1231        ///     * Non-Fungible Mode: Required.1232        ///     * Fungible Mode: Ignored.1233        ///     * Re-Fungible Mode: Required.1234        /// 1235        /// * value: Amount to transfer.1236        ///     * Non-Fungible Mode: Ignored1237        ///     * Fungible Mode: Must specify transferred amount1238        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1239        #[weight = <T as Config>::WeightInfo::transfer()]1240        #[transactional]1241        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1242            let sender = ensure_signed(origin)?;1243            let collection = Self::get_collection(collection_id)?;12441245            Self::transfer_internal(sender, recipient, &collection, item_id, value)1246        }12471248        /// Set, change, or remove approved address to transfer the ownership of the NFT.1249        /// 1250        /// # Permissions1251        /// 1252        /// * Collection Owner1253        /// * Collection Admin1254        /// * Current NFT owner1255        /// 1256        /// # Arguments1257        /// 1258        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1259        /// 1260        /// * collection_id.1261        /// 1262        /// * item_id: ID of the item.1263        #[weight = <T as Config>::WeightInfo::approve()]1264        #[transactional]1265        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12661267            let sender = ensure_signed(origin)?;1268            let target_collection = Self::get_collection(collection_id)?;12691270            Self::token_exists(&target_collection, item_id, &sender)?;12711272            // Transfer permissions check1273            let bypasses_limits = target_collection.limits.owner_can_transfer &&1274                Self::is_owner_or_admin_permissions(1275                    &target_collection,1276                    sender.clone(),1277                );12781279            let allowance_limit = if bypasses_limits {1280                None1281            } else if let Some(amount) = Self::owned_amount(1282                sender.clone(),1283                &target_collection,1284                item_id,1285            ) {1286                Some(amount)1287            } else {1288                fail!(Error::<T>::NoPermission);1289            };12901291            if target_collection.access == AccessMode::WhiteList {1292                Self::check_white_list(&target_collection, &sender)?;1293                Self::check_white_list(&target_collection, &spender)?;1294            }12951296            let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1297            let mut allowance: u128 = amount;1298            if allowance_exists {1299                allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1300            }1301            if let Some(limit) = allowance_limit {1302                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1303            }1304            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13051306            Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1307            Ok(())1308        }1309        1310        /// 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.1311        /// 1312        /// # Permissions1313        /// * Collection Owner1314        /// * Collection Admin1315        /// * Current NFT owner1316        /// * Address approved by current NFT owner1317        /// 1318        /// # Arguments1319        /// 1320        /// * from: Address that owns token.1321        /// 1322        /// * recipient: Address of token recipient.1323        /// 1324        /// * collection_id.1325        /// 1326        /// * item_id: ID of the item.1327        /// 1328        /// * value: Amount to transfer.1329        #[weight = <T as Config>::WeightInfo::transfer_from()]1330        #[transactional]1331        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13321333            let sender = ensure_signed(origin)?;1334            let target_collection = Self::get_collection(collection_id)?;13351336            let mut appoved_transfer = false;13371338            // Check approval1339            let mut approval: u128 = 0;1340            if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1341                approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1342                ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1343                appoved_transfer = true;1344            }13451346            // Limits check1347            Self::is_correct_transfer(&target_collection, &recipient)?;13481349            // Transfer permissions check         1350            ensure!(1351                appoved_transfer || 1352                (1353                    target_collection.limits.owner_can_transfer &&1354                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1355                ),1356                Error::<T>::NoPermission1357            );13581359            if target_collection.access == AccessMode::WhiteList {1360                Self::check_white_list(&target_collection, &sender)?;1361                Self::check_white_list(&target_collection, &recipient)?;1362            }13631364            // Reduce approval by transferred amount or remove if remaining approval drops to 01365            if approval.saturating_sub(value) > 0 {1366                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1367            }1368            else {1369                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1370            }13711372            match target_collection.mode1373            {1374                CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from, recipient)?,1375                CollectionMode::Fungible(_)  => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1376                CollectionMode::ReFungible  => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient)?,1377                _ => ()1378            };13791380            Ok(())1381        }13821383        // #[weight = 0]1384        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13851386        //     // let no_perm_mes = "You do not have permissions to modify this collection";1387        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1388        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1389        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13901391        //     // // on_nft_received  call13921393        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;13941395        //     Ok(())1396        // }13971398        /// Set off-chain data schema.1399        /// 1400        /// # Permissions1401        /// 1402        /// * Collection Owner1403        /// * Collection Admin1404        /// 1405        /// # Arguments1406        /// 1407        /// * collection_id.1408        /// 1409        /// * schema: String representing the offchain data schema.1410        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1411        #[transactional]1412        pub fn set_variable_meta_data (1413            origin,1414            collection_id: CollectionId,1415            item_id: TokenId,1416            data: Vec<u8>1417        ) -> DispatchResult {1418            let sender = ensure_signed(origin)?;1419            1420            let target_collection = Self::get_collection(collection_id)?;1421            Self::token_exists(&target_collection, item_id, &sender)?;14221423            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14241425            // Modify permissions check1426            ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1427                Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1428                Error::<T>::NoPermission);14291430            match target_collection.mode1431            {1432                CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1433                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1434                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1435                _ => fail!(Error::<T>::UnexpectedCollectionType)1436            };14371438            Ok(())1439        }1440 1441        /// Set schema standard1442        /// ImageURL1443        /// Unique1444        /// 1445        /// # Permissions1446        /// 1447        /// * Collection Owner1448        /// * Collection Admin1449        /// 1450        /// # Arguments1451        /// 1452        /// * collection_id.1453        /// 1454        /// * schema: SchemaVersion: enum1455        #[weight = <T as Config>::WeightInfo::set_schema_version()]1456        #[transactional]1457        pub fn set_schema_version(1458            origin,1459            collection_id: CollectionId,1460            version: SchemaVersion1461        ) -> DispatchResult {1462            let sender = ensure_signed(origin)?;1463            let mut target_collection = Self::get_collection(collection_id)?;1464            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1465            target_collection.schema_version = version;1466            Self::save_collection(target_collection);14671468            Ok(())1469        }14701471        /// Set off-chain data schema.1472        /// 1473        /// # Permissions1474        /// 1475        /// * Collection Owner1476        /// * Collection Admin1477        /// 1478        /// # Arguments1479        /// 1480        /// * collection_id.1481        /// 1482        /// * schema: String representing the offchain data schema.1483        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1484        #[transactional]1485        pub fn set_offchain_schema(1486            origin,1487            collection_id: CollectionId,1488            schema: Vec<u8>1489        ) -> DispatchResult {1490            let sender = ensure_signed(origin)?;1491            let mut target_collection = Self::get_collection(collection_id)?;1492            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14931494            // check schema limit1495            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14961497            target_collection.offchain_schema = schema;1498            Self::save_collection(target_collection);14991500            Ok(())1501        }15021503        /// Set const on-chain data schema.1504        /// 1505        /// # Permissions1506        /// 1507        /// * Collection Owner1508        /// * Collection Admin1509        /// 1510        /// # Arguments1511        /// 1512        /// * collection_id.1513        /// 1514        /// * schema: String representing the const on-chain data schema.1515        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1516        #[transactional]1517        pub fn set_const_on_chain_schema (1518            origin,1519            collection_id: CollectionId,1520            schema: Vec<u8>1521        ) -> DispatchResult {1522            let sender = ensure_signed(origin)?;1523            let mut target_collection = Self::get_collection(collection_id)?;1524            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15251526            // check schema limit1527            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15281529            target_collection.const_on_chain_schema = schema;1530            Self::save_collection(target_collection);15311532            Ok(())1533        }15341535        /// Set variable on-chain data schema.1536        /// 1537        /// # Permissions1538        /// 1539        /// * Collection Owner1540        /// * Collection Admin1541        /// 1542        /// # Arguments1543        /// 1544        /// * collection_id.1545        /// 1546        /// * schema: String representing the variable on-chain data schema.1547        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1548        #[transactional]1549        pub fn set_variable_on_chain_schema (1550            origin,1551            collection_id: CollectionId,1552            schema: Vec<u8>1553        ) -> DispatchResult {1554            let sender = ensure_signed(origin)?;1555            let mut target_collection = Self::get_collection(collection_id)?;1556            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15571558            // check schema limit1559            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15601561            target_collection.variable_on_chain_schema = schema;1562            Self::save_collection(target_collection);15631564            Ok(())1565        }15661567        // Sudo permissions function1568        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1569        #[transactional]1570        pub fn set_chain_limits(1571            origin,1572            limits: ChainLimits1573        ) -> DispatchResult {15741575            #[cfg(not(feature = "runtime-benchmarks"))]1576            ensure_root(origin)?;15771578            <ChainLimit>::put(limits);1579            Ok(())1580        }15811582        /// Enable smart contract self-sponsoring.1583        /// 1584        /// # Permissions1585        /// 1586        /// * Contract Owner1587        /// 1588        /// # Arguments1589        /// 1590        /// * contract address1591        /// * enable flag1592        /// 1593        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1594        #[transactional]1595        pub fn enable_contract_sponsoring(1596            origin,1597            contract_address: T::AccountId,1598            enable: bool1599        ) -> DispatchResult {16001601            let sender = ensure_signed(origin)?;16021603            #[cfg(feature = "runtime-benchmarks")]1604            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16051606            Self::ensure_contract_owned(sender, &contract_address)?;16071608            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1609            Ok(())1610        }16111612        /// Set the rate limit for contract sponsoring to specified number of blocks.1613        /// 1614        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1615        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1616        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1617        /// from contract endowment if there are at least B blocks between such transactions. 1618        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1619        /// 1620        /// # Permissions1621        /// 1622        /// * Contract Owner1623        /// 1624        /// # Arguments1625        /// 1626        /// -`contract_address`: Address of the contract to sponsor1627        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1628        /// 1629        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1630        #[transactional]1631        pub fn set_contract_sponsoring_rate_limit(1632            origin,1633            contract_address: T::AccountId,1634            rate_limit: T::BlockNumber1635        ) -> DispatchResult {1636            let sender = ensure_signed(origin)?;16371638            #[cfg(feature = "runtime-benchmarks")]1639            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16401641            Self::ensure_contract_owned(sender, &contract_address)?;1642            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1643            Ok(())1644        }16451646        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1647        /// 1648        /// # Permissions1649        /// 1650        /// * Address that deployed smart contract.1651        /// 1652        /// # Arguments1653        /// 1654        /// -`contract_address`: Address of the contract.1655        /// 1656        /// - `enable`: .  1657        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1658        #[transactional]1659        pub fn toggle_contract_white_list(1660            origin,1661            contract_address: T::AccountId,1662            enable: bool1663        ) -> DispatchResult {1664            let sender = ensure_signed(origin)?;16651666            #[cfg(feature = "runtime-benchmarks")]1667            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16681669            Self::ensure_contract_owned(sender, &contract_address)?;1670            <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1671            Ok(())1672        }1673        1674        /// Add an address to smart contract white list.1675        /// 1676        /// # Permissions1677        /// 1678        /// * Address that deployed smart contract.1679        /// 1680        /// # Arguments1681        /// 1682        /// -`contract_address`: Address of the contract.1683        ///1684        /// -`account_address`: Address to add.1685        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1686        #[transactional]1687        pub fn add_to_contract_white_list(1688            origin,1689            contract_address: T::AccountId,1690            account_address: T::AccountId1691        ) -> DispatchResult {1692            let sender = ensure_signed(origin)?;16931694            #[cfg(feature = "runtime-benchmarks")]1695            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1696            1697            Self::ensure_contract_owned(sender, &contract_address)?;      1698            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1699            Ok(())1700        }17011702        /// Remove an address from smart contract white list.1703        /// 1704        /// # Permissions1705        /// 1706        /// * Address that deployed smart contract.1707        /// 1708        /// # Arguments1709        /// 1710        /// -`contract_address`: Address of the contract.1711        ///1712        /// -`account_address`: Address to remove.1713        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1714        #[transactional]1715        pub fn remove_from_contract_white_list(1716            origin,1717            contract_address: T::AccountId,1718            account_address: T::AccountId1719        ) -> DispatchResult {1720            let sender = ensure_signed(origin)?;17211722            #[cfg(feature = "runtime-benchmarks")]1723            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17241725            Self::ensure_contract_owned(sender, &contract_address)?;1726            <ContractWhiteList<T>>::remove(contract_address, account_address);1727            Ok(())1728        }17291730        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1731        #[transactional]1732        pub fn set_collection_limits(1733            origin,1734            collection_id: u32,1735            new_limits: CollectionLimits<T::BlockNumber>,1736        ) -> DispatchResult {1737            let sender = ensure_signed(origin)?;1738            let mut target_collection = Self::get_collection(collection_id)?;1739            Self::check_owner_permissions(&target_collection, sender.clone())?;1740            let old_limits = &target_collection.limits;1741            let chain_limits = ChainLimit::get();17421743            // collection bounds1744            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1745                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1746                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1747                Error::<T>::CollectionLimitBoundsExceeded);17481749            // token_limit   check  prev1750            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1751            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17521753            ensure!(1754                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1755                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1756                Error::<T>::OwnerPermissionsCantBeReverted,1757            );17581759            target_collection.limits = new_limits;1760            Self::save_collection(target_collection);17611762            Ok(())1763        } 1764    }1765}17661767impl<T: Config> Module<T> {17681769    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1770        // Limits check1771        Self::is_correct_transfer(target_collection, &recipient)?;17721773        // Transfer permissions check1774        ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1775            Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1776            Error::<T>::NoPermission);17771778        if target_collection.access == AccessMode::WhiteList {1779            Self::check_white_list(target_collection, &sender)?;1780            Self::check_white_list(target_collection, &recipient)?;1781        }17821783        match target_collection.mode1784        {1785            CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1786            CollectionMode::Fungible(_)  => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1787            CollectionMode::ReFungible  => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1788            _ => ()1789        };17901791        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17921793        Ok(())1794    }179517961797    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1798        let collection_id = collection.id;17991800        // check token limit and account token limit1801        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1802        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1803        1804        Ok(())1805    }18061807    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1808        let collection_id = collection.id;18091810        // check token limit and account token limit1811        let total_items: u32 = ItemListIndex::get(collection_id)1812            .checked_add(amount)1813            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1814        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1815            .checked_add(amount)1816            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1817        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1818        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);18191820        if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1821            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1822            Self::check_white_list(collection, owner)?;1823            Self::check_white_list(collection, sender)?;1824        }18251826        Ok(())1827    }18281829    fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1830        match target_collection.mode1831        {1832            CollectionMode::NFT => {1833                if let CreateItemData::NFT(data) = data {1834                    // check sizes1835                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1836                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1837                } else {1838                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1839                }1840            },1841            CollectionMode::Fungible(_) => {1842                if let CreateItemData::Fungible(_) = data {1843                } else {1844                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1845                }1846            },1847            CollectionMode::ReFungible => {1848                if let CreateItemData::ReFungible(data) = data {18491850                    // check sizes1851                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1852                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18531854                    // Check refungibility limits1855                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1856                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1857                } else {1858                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1859                }1860            },1861            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1862        };18631864        Ok(())1865    }18661867    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1868        match data1869        {1870            CreateItemData::NFT(data) => {1871                let item = NftItemType {1872                    owner: owner.clone(),1873                    const_data: data.const_data,1874                    variable_data: data.variable_data1875                };18761877                Self::add_nft_item(collection, item)?;1878            },1879            CreateItemData::Fungible(data) => {1880                Self::add_fungible_item(collection, &owner, data.value)?;1881            },1882            CreateItemData::ReFungible(data) => {1883                let mut owner_list = Vec::new();1884                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18851886                let item = ReFungibleItemType {1887                    owner: owner_list,1888                    const_data: data.const_data,1889                    variable_data: data.variable_data1890                };18911892                Self::add_refungible_item(collection, item)?;1893            }1894        };18951896        Ok(())1897    }18981899    fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1900        let collection_id = collection.id;19011902        // Does new owner already have an account?1903        let mut balance: u128 = 0;1904        if <FungibleItemList<T>>::contains_key(collection_id, owner) {1905            balance = <FungibleItemList<T>>::get(collection_id, owner).value;1906        } 19071908        // Mint 1909        let item = FungibleItemType {1910            value: balance + value1911        };1912        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19131914        // Update balance1915        let new_balance = <Balance<T>>::get(collection_id, owner)1916            .checked_add(value)1917            .ok_or(Error::<T>::NumOverflow)?;1918        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19191920        Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1921        Ok(())1922    }19231924    fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1925        let collection_id = collection.id;19261927        let current_index = <ItemListIndex>::get(collection_id)1928            .checked_add(1)1929            .ok_or(Error::<T>::NumOverflow)?;1930        let itemcopy = item.clone();19311932        ensure!(1933            item.owner.len() == 1,1934            Error::<T>::BadCreateRefungibleCall,1935        );1936        let item_owner = item.owner.first().expect("only one owner is defined");19371938        let value = item_owner.fraction;1939        let owner = item_owner.owner.clone();19401941        Self::add_token_index(collection_id, current_index, &owner)?;19421943        <ItemListIndex>::insert(collection_id, current_index);1944        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19451946        // Update balance1947        let new_balance = <Balance<T>>::get(collection_id, &owner)1948            .checked_add(value)1949            .ok_or(Error::<T>::NumOverflow)?;1950        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19511952        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1953        Ok(())1954    }19551956    fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1957        let collection_id = collection.id;19581959        let current_index = <ItemListIndex>::get(collection_id)1960            .checked_add(1)1961            .ok_or(Error::<T>::NumOverflow)?;19621963        let item_owner = item.owner.clone();1964        Self::add_token_index(collection_id, current_index, &item.owner)?;19651966        <ItemListIndex>::insert(collection_id, current_index);1967        <NftItemList<T>>::insert(collection_id, current_index, item);19681969        // Update balance1970        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1971            .checked_add(1)1972            .ok_or(Error::<T>::NumOverflow)?;1973        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19741975        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1976        Ok(())1977    }19781979    fn burn_refungible_item(1980        collection: &CollectionHandle<T>,1981        item_id: TokenId,1982        owner: &T::AccountId,1983    ) -> DispatchResult {1984        let collection_id = collection.id;19851986        ensure!(1987            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1988            Error::<T>::TokenNotFound1989        );1990        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1991        let rft_balance = token1992            .owner1993            .iter()1994            .find(|&i| i.owner == *owner)1995            .ok_or(Error::<T>::TokenNotFound)?;1996        Self::remove_token_index(collection_id, item_id, owner)?;19971998        // update balance1999        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2000            .checked_sub(rft_balance.fraction)2001            .ok_or(Error::<T>::NumOverflow)?;2002        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20032004        // Re-create owners list with sender removed2005        let index = token2006            .owner2007            .iter()2008            .position(|i| i.owner == *owner)2009            .expect("owned item is exists");2010        token.owner.remove(index);2011        let owner_count = token.owner.len();20122013        // Burn the token completely if this was the last (only) owner2014        if owner_count == 0 {2015            <ReFungibleItemList<T>>::remove(collection_id, item_id);2016            <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2017        }2018        else {2019            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2020        }20212022        Ok(())2023    }20242025    fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2026        let collection_id = collection.id;20272028        ensure!(2029            <NftItemList<T>>::contains_key(collection_id, item_id),2030            Error::<T>::TokenNotFound2031        );2032        let item = <NftItemList<T>>::get(collection_id, item_id);2033        Self::remove_token_index(collection_id, item_id, &item.owner)?;20342035        // update balance2036        let new_balance = <Balance<T>>::get(collection_id, &item.owner)2037            .checked_sub(1)2038            .ok_or(Error::<T>::NumOverflow)?;2039        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2040        <NftItemList<T>>::remove(collection_id, item_id);2041        <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20422043        Ok(())2044    }20452046    fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2047        let collection_id = collection.id;20482049        ensure!(2050            <FungibleItemList<T>>::contains_key(collection_id, owner),2051            Error::<T>::TokenNotFound2052        );2053        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2054        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20552056        // update balance2057        let new_balance = <Balance<T>>::get(collection_id, owner)2058            .checked_sub(value)2059            .ok_or(Error::<T>::NumOverflow)?;2060        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20612062        if balance.value - value > 0 {2063            balance.value -= value;2064            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2065        }2066        else {2067            <FungibleItemList<T>>::remove(collection_id, owner);2068        }20692070        Ok(())2071    }20722073    pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2074        Ok(<CollectionById<T>>::get(collection_id)2075            .map(|collection| CollectionHandle {2076                id: collection_id,2077                collection2078            })2079            .ok_or(Error::<T>::CollectionNotFound)?)2080    }20812082    fn save_collection(collection: CollectionHandle<T>) {2083        <CollectionById<T>>::insert(collection.id, collection.collection);2084    }20852086    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2087        ensure!(2088            subject == target_collection.owner,2089            Error::<T>::NoPermission2090        );20912092        Ok(())2093    }20942095    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2096        let mut result: bool = subject == collection.owner;2097        let exists = <AdminList<T>>::contains_key(collection.id);20982099        if !result & exists {2100            if <AdminList<T>>::get(collection.id).contains(&subject) {2101                result = true2102            }2103        }21042105        result2106    }21072108    fn check_owner_or_admin_permissions(2109        collection: &CollectionHandle<T>,2110        subject: T::AccountId,2111    ) -> DispatchResult {2112        let result = Self::is_owner_or_admin_permissions(collection, subject.clone());21132114        ensure!(2115            result,2116            Error::<T>::NoPermission2117        );2118        Ok(())2119    }21202121    fn owned_amount(2122        subject: T::AccountId,2123        target_collection: &CollectionHandle<T>,2124        item_id: TokenId,2125    ) -> Option<u128> {2126        let collection_id = target_collection.id;21272128        match target_collection.mode {2129            CollectionMode::NFT => {2130                if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2131                    return Some(1)2132                }2133                None2134            },2135            CollectionMode::Fungible(_) => {2136                if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2137                    return Some(<FungibleItemList<T>>::get(collection_id, &subject)2138                        .value);2139                }2140                None2141            },2142            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2143                .owner2144                .iter()2145                .find(|i| i.owner == subject)2146                .map(|i| i.fraction),2147            CollectionMode::Invalid => None,2148        }2149    }21502151    fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2152        let collection_id = target_collection.id;21532154        match target_collection.mode {2155            CollectionMode::NFT => {2156                <NftItemList<T>>::get(collection_id, item_id).owner == subject2157            }2158            CollectionMode::Fungible(_) => {2159                <FungibleItemList<T>>::contains_key(collection_id, &subject)2160            }2161            CollectionMode::ReFungible => {2162                <ReFungibleItemList<T>>::get(collection_id, item_id)2163                    .owner2164                    .iter()2165                    .any(|i| i.owner == subject)2166            }2167            CollectionMode::Invalid => false,2168        }2169    }21702171    fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2172        let collection_id = collection.id;21732174        let mes = Error::<T>::AddresNotInWhiteList;2175        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21762177        Ok(())2178    }21792180    /// Check if token exists. In case of Fungible, check if there is an entry for 2181    /// the owner in fungible balances double map2182    fn token_exists(2183        target_collection: &CollectionHandle<T>,2184        item_id: TokenId,2185        owner: &T::AccountId2186    ) -> DispatchResult {2187        let collection_id = target_collection.id;2188        let exists = match target_collection.mode2189        {2190            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2191            CollectionMode::Fungible(_)  => <FungibleItemList<T>>::contains_key(collection_id, owner),2192            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2193            _ => false2194        };21952196        ensure!(exists == true, Error::<T>::TokenNotFound);2197        Ok(())2198    }21992200    fn transfer_fungible(2201        collection: &CollectionHandle<T>,2202        value: u128,2203        owner: &T::AccountId,2204        recipient: &T::AccountId,2205    ) -> DispatchResult {2206        let collection_id = collection.id;2207        Self::token_exists(&collection, 0, owner)?;22082209        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2210        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22112212        // Send balance to recipient (updates balanceOf of recipient)2213        Self::add_fungible_item(collection, recipient, value)?;22142215        // update balanceOf of sender2216        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22172218        // Reduce or remove sender2219        if balance.value == value {2220            <FungibleItemList<T>>::remove(collection_id, owner);2221        }2222        else {2223            balance.value -= value;2224            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2225        }22262227        Ok(())2228    }22292230    fn transfer_refungible(2231        collection: &CollectionHandle<T>,2232        item_id: TokenId,2233        value: u128,2234        owner: T::AccountId,2235        new_owner: T::AccountId,2236    ) -> DispatchResult {2237        let collection_id = collection.id;2238        Self::token_exists(collection, item_id, &owner)?;22392240        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2241        let item = full_item2242            .owner2243            .iter()2244            .filter(|i| i.owner == owner)2245            .next()2246            .ok_or(Error::<T>::TokenNotFound)?;2247        let amount = item.fraction;22482249        ensure!(amount >= value, Error::<T>::TokenValueTooLow);22502251        // update balance2252        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2253            .checked_sub(value)2254            .ok_or(Error::<T>::NumOverflow)?;2255        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22562257        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2258            .checked_add(value)2259            .ok_or(Error::<T>::NumOverflow)?;2260        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22612262        let old_owner = item.owner.clone();2263        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22642265        // transfer2266        if amount == value && !new_owner_has_account {2267            // change owner2268            // new owner do not have account2269            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                .owner = new_owner.clone();2276            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22772278            // update index collection2279            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2280        } else {2281            let mut new_full_item = full_item.clone();2282            new_full_item2283                .owner2284                .iter_mut()2285                .find(|i| i.owner == owner)2286                .expect("old owner does present in refungible")2287                .fraction -= value;22882289            // separate amount2290            if new_owner_has_account {2291                // new owner has account2292                new_full_item2293                    .owner2294                    .iter_mut()2295                    .find(|i| i.owner == new_owner)2296                    .expect("new owner has account")2297                    .fraction += value;2298            } else {2299                // new owner do not have account2300                new_full_item.owner.push(Ownership {2301                    owner: new_owner.clone(),2302                    fraction: value,2303                });2304                Self::add_token_index(collection_id, item_id, &new_owner)?;2305            }23062307            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2308        }23092310        Ok(())2311    }23122313    fn transfer_nft(2314        collection: &CollectionHandle<T>,2315        item_id: TokenId,2316        sender: T::AccountId,2317        new_owner: T::AccountId,2318    ) -> DispatchResult {2319        let collection_id = collection.id;2320        Self::token_exists(&collection, item_id, &sender)?;23212322        let mut item = <NftItemList<T>>::get(collection_id, item_id);23232324        ensure!(2325            sender == item.owner,2326            Error::<T>::MustBeTokenOwner2327        );23282329        // update balance2330        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2331            .checked_sub(1)2332            .ok_or(Error::<T>::NumOverflow)?;2333        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23342335        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2336            .checked_add(1)2337            .ok_or(Error::<T>::NumOverflow)?;2338        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23392340        // change owner2341        let old_owner = item.owner.clone();2342        item.owner = new_owner.clone();2343        <NftItemList<T>>::insert(collection_id, item_id, item);23442345        // update index collection2346        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23472348        Ok(())2349    }2350    2351    fn set_re_fungible_variable_data(2352        collection: &CollectionHandle<T>,2353        item_id: TokenId,2354        data: Vec<u8>2355    ) -> DispatchResult {2356        let collection_id = collection.id;2357        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);23582359        item.variable_data = data;23602361        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23622363        Ok(())2364    }23652366    fn set_nft_variable_data(2367        collection: &CollectionHandle<T>,2368        item_id: TokenId,2369        data: Vec<u8>2370    ) -> DispatchResult {2371        let collection_id = collection.id;2372        let mut item = <NftItemList<T>>::get(collection_id, item_id);2373        2374        item.variable_data = data;23752376        <NftItemList<T>>::insert(collection_id, item_id, item);2377        2378        Ok(())2379    }23802381    fn init_collection(item: &Collection<T>) {2382        // check params2383        assert!(2384            item.decimal_points <= MAX_DECIMAL_POINTS,2385            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2386        );2387        assert!(2388            item.name.len() <= 64,2389            "Collection name can not be longer than 63 char"2390        );2391        assert!(2392            item.name.len() <= 256,2393            "Collection description can not be longer than 255 char"2394        );2395        assert!(2396            item.token_prefix.len() <= 16,2397            "Token prefix can not be longer than 15 char"2398        );23992400        // Generate next collection ID2401        let next_id = CreatedCollectionCount::get()2402            .checked_add(1)2403            .unwrap();24042405        CreatedCollectionCount::put(next_id);2406    }24072408    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2409        let current_index = <ItemListIndex>::get(collection_id)2410            .checked_add(1)2411            .unwrap();24122413        let item_owner = item.owner.clone();2414        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24152416        <ItemListIndex>::insert(collection_id, current_index);24172418        // Update balance2419        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2420            .checked_add(1)2421            .unwrap();2422        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2423    }24242425    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2426        let current_index = <ItemListIndex>::get(collection_id)2427            .checked_add(1)2428            .unwrap();24292430        Self::add_token_index(collection_id, current_index, owner).unwrap();24312432        <ItemListIndex>::insert(collection_id, current_index);24332434        // Update balance2435        let new_balance = <Balance<T>>::get(collection_id, owner)2436            .checked_add(item.value)2437            .unwrap();2438        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2439    }24402441    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2442        let current_index = <ItemListIndex>::get(collection_id)2443            .checked_add(1)2444            .unwrap();24452446        let value = item.owner.first().unwrap().fraction;2447        let owner = item.owner.first().unwrap().owner.clone();24482449        Self::add_token_index(collection_id, current_index, &owner).unwrap();24502451        <ItemListIndex>::insert(collection_id, current_index);24522453        // Update balance2454        let new_balance = <Balance<T>>::get(collection_id, &owner)2455            .checked_add(value)2456            .unwrap();2457        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2458    }24592460    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2461        // add to account limit2462        if <AccountItemCount<T>>::contains_key(owner) {24632464            // bound Owned tokens by a single address2465            let count = <AccountItemCount<T>>::get(owner);2466            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24672468            <AccountItemCount<T>>::insert(owner.clone(), count2469                .checked_add(1)2470                .ok_or(Error::<T>::NumOverflow)?);2471        }2472        else {2473            <AccountItemCount<T>>::insert(owner.clone(), 1);2474        }24752476        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2477        if list_exists {2478            let mut list = <AddressTokens<T>>::get(collection_id, owner);2479            let item_contains = list.contains(&item_index.clone());24802481            if !item_contains {2482                list.push(item_index.clone());2483            }24842485            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2486        } else {2487            let mut itm = Vec::new();2488            itm.push(item_index.clone());2489            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2490        }24912492        Ok(())2493    }24942495    fn remove_token_index(2496        collection_id: CollectionId,2497        item_index: TokenId,2498        owner: &T::AccountId,2499    ) -> DispatchResult {25002501        // update counter2502        <AccountItemCount<T>>::insert(owner.clone(), 2503            <AccountItemCount<T>>::get(owner)2504            .checked_sub(1)2505            .ok_or(Error::<T>::NumOverflow)?);250625072508        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2509        if list_exists {2510            let mut list = <AddressTokens<T>>::get(collection_id, owner);2511            let item_contains = list.contains(&item_index.clone());25122513            if item_contains {2514                list.retain(|&item| item != item_index);2515                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2516            }2517        }25182519        Ok(())2520    }25212522    fn move_token_index(2523        collection_id: CollectionId,2524        item_index: TokenId,2525        old_owner: &T::AccountId,2526        new_owner: &T::AccountId,2527    ) -> DispatchResult {2528        Self::remove_token_index(collection_id, item_index, old_owner)?;2529        Self::add_token_index(collection_id, item_index, new_owner)?;25302531        Ok(())2532    }2533    2534    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2535        if <ContractOwner<T>>::contains_key(contract.clone()) {2536            let owner = <ContractOwner<T>>::get(contract);2537            ensure!(account == owner, Error::<T>::NoPermission);2538        } else {2539            fail!(Error::<T>::NoPermission);2540        }25412542        Ok(())2543    }2544}25452546////////////////////////////////////////////////////////////////////////////////////////////////////2547// Economic models2548// #region25492550/// Fee multiplier.2551pub type Multiplier = FixedU128;25522553type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25542555/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2556/// in the queue.2557#[derive(Encode, Decode, Clone, Eq, PartialEq)]2558pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25592560impl<T: Config + Send + Sync> sp_std::fmt::Debug 2561    for ChargeTransactionPayment<T>2562{2563	#[cfg(feature = "std")]2564	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2565		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2566	}2567	#[cfg(not(feature = "std"))]2568	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2569		Ok(())2570	}2571}25722573impl<T: Config> ChargeTransactionPayment<T>2574where2575    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2576    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2577    T::AccountId: AsRef<[u8]>,2578    T::AccountId: UncheckedFrom<T::Hash>,2579{2580    fn traditional_fee(2581        len: usize,2582        info: &DispatchInfoOf<T::Call>,2583        tip: BalanceOf<T>,2584    ) -> BalanceOf<T>2585    where2586        T::Call: Dispatchable<Info = DispatchInfo>,2587    {2588        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2589    }25902591	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2592        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2593        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2594        let len_saturation = max_block_length as u64 / (len as u64).max(1);2595        let coefficient: BalanceOf<T> = weight_saturation2596            .min(len_saturation)2597            .saturated_into::<BalanceOf<T>>();2598        final_fee2599            .saturating_mul(coefficient)2600            .saturated_into::<TransactionPriority>()2601    }26022603    fn withdraw_fee(2604        &self,2605        who: &T::AccountId,2606        call: &T::Call,2607        info: &DispatchInfoOf<T::Call>,2608        len: usize,2609	) -> Result<2610		(2611			BalanceOf<T>,2612			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2613		),2614		TransactionValidityError,2615	> {2616        let tip = self.0;26172618        let fee = Self::traditional_fee(len, info, tip);26192620        // Only mess with balances if fee is not zero.2621        if fee.is_zero() {2622            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2623			.map(|i| (fee, i));2624        }26252626        // Determine who is paying transaction fee based on ecnomic model2627        // Parse call to extract collection ID and access collection sponsor2628        let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2629            Some(Call::create_item(collection_id, _owner, _properties)) => {2630                let collection = <CollectionById<T>>::get(collection_id)?;26312632                // sponsor timeout2633                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26342635                let limit = collection.limits.sponsor_transfer_timeout;2636                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2637                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2638                    let limit_time = last_tx_block + limit.into();2639                    if block_number <= limit_time {2640                        return None;2641                    }2642                }2643                <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26442645                // check free create limit2646                if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2647                    collection.sponsorship.sponsor()2648                        .cloned()2649                } else {2650                    None2651                }2652            }2653            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2654                let collection = <CollectionById<T>>::get(collection_id)?;2655                2656                let mut sponsor_transfer = false;2657                if collection.sponsorship.confirmed() {26582659                    let collection_limits = collection.limits;2660                    let collection_mode = collection.mode;2661    2662                    // sponsor timeout2663                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2664                    sponsor_transfer = match collection_mode {2665                        CollectionMode::NFT => {2666    2667                            // get correct limit2668                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2669                                collection_limits.sponsor_transfer_timeout2670                            } else {2671                                ChainLimit::get().nft_sponsor_transfer_timeout2672                            };2673    2674                            let mut sponsored = true;2675                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2676                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2677                                let limit_time = last_tx_block + limit.into();2678                                if block_number <= limit_time {2679                                    sponsored = false;2680                                }2681                            }2682                            if sponsored {2683                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2684                            }26852686                            sponsored2687                        }2688                        CollectionMode::Fungible(_) => {2689    2690                            // get correct limit2691                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2692                                collection_limits.sponsor_transfer_timeout2693                            } else {2694                                ChainLimit::get().fungible_sponsor_transfer_timeout2695                            };2696    2697                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2698                            let mut sponsored = true;2699                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2700                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2701                                let limit_time = last_tx_block + limit.into();2702                                if block_number <= limit_time {2703                                    sponsored = false;2704                                }2705                            }2706                            if sponsored {2707                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2708                            }27092710                            sponsored2711                        }2712                        CollectionMode::ReFungible => {2713    2714                            // get correct limit2715                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2716                                collection_limits.sponsor_transfer_timeout2717                            } else {2718                                ChainLimit::get().refungible_sponsor_transfer_timeout2719                            };2720    2721                            let mut sponsored = true;2722                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2723                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2724                                let limit_time = last_tx_block + limit.into();2725                                if block_number <= limit_time {2726                                    sponsored = false;2727                                }2728                            }2729                            if sponsored {2730                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2731                            }27322733                            sponsored2734                        }2735                        _ => {2736                            false2737                        },2738                    };2739                }27402741                if !sponsor_transfer {2742                    None2743                } else {2744                    collection.sponsorship.sponsor()2745                        .cloned()2746                }2747            }27482749            Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2750                let mut sponsor_metadata_changes = false;27512752                let collection = <CollectionById<T>>::get(collection_id)?;27532754                if2755                    collection.sponsorship.confirmed() &&2756                    // Can't sponsor fungible collection, this tx will be rejected2757                    // as invalid2758                    !matches!(collection.mode, CollectionMode::Fungible(_)) &&2759                    data.len() <= collection.limits.sponsored_data_size as usize2760                {2761                    if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2762                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27632764                        if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2765                            .map(|last_block| block_number - last_block > rate_limit)2766                            .unwrap_or(true) 2767                        {2768                            sponsor_metadata_changes = true;2769                            <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2770                        }2771                    }2772                }27732774                if !sponsor_metadata_changes {2775                    None2776                } else {2777                    collection.sponsorship.sponsor().cloned()2778                }2779            }27802781            _ => None,2782        })();27832784        match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2785            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27862787                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27882789                let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2790                  && <ContractOwner<T>>::get(called_contract.clone()) == *who;2791                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2792                  2793                if !owned_contract && white_list_enabled {2794                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2795                        return Err(InvalidTransaction::Call.into());2796                    }2797                }2798            },2799            _ => {},2800        }28012802        // Sponsor smart contracts2803        sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28042805            // On instantiation: set the contract owner2806            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28072808                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2809                    &who,2810                    code_hash,2811                    salt,2812                );2813                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28142815                None2816            },28172818            // On instantiation with code: set the contract owner2819            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {28202821                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2822                    &who,2823                    &T::Hashing::hash(&_code),2824                    _salt,2825                );28262827                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28282829                None2830            }28312832            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2833            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28342835                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28362837                let mut sponsor_transfer = false;2838                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2839                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2840                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2841                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2842                    let limit_time = last_tx_block + rate_limit;28432844                    if block_number >= limit_time {2845                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2846                        sponsor_transfer = true;2847                    }2848                } else {2849                    sponsor_transfer = false;2850                }2851               2852                if sponsor_transfer {2853                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2854                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2855                            return Some(called_contract);2856                        }2857                    }2858                }28592860                None2861            },28622863            _ => None,2864        });28652866        let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28672868		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2869			.map(|i| (fee, i))2870    }2871}287228732874impl<T: Config + Send + Sync> SignedExtension2875    for ChargeTransactionPayment<T>2876where2877    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2878    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2879    T::AccountId: AsRef<[u8]>,2880    T::AccountId: UncheckedFrom<T::Hash>,2881{2882    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2883    type AccountId = T::AccountId;2884    type Call = T::Call;2885    type AdditionalSigned = ();2886    type Pre = (2887        // tip2888        BalanceOf<T>,2889        // who pays fee2890        Self::AccountId,2891		// imbalance resulting from withdrawing the fee2892		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2893    );2894    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2895        Ok(())2896    }28972898    fn validate(2899        &self,2900        who: &Self::AccountId,2901        call: &Self::Call,2902        info: &DispatchInfoOf<Self::Call>,2903        len: usize,2904    ) -> TransactionValidity {2905		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2906		Ok(ValidTransaction {2907			priority: Self::get_priority(len, info, fee),2908			..Default::default()2909		})2910    }29112912    fn pre_dispatch(2913        self,2914        who: &Self::AccountId,2915        call: &Self::Call,2916        info: &DispatchInfoOf<Self::Call>,2917        len: usize,2918    ) -> Result<Self::Pre, TransactionValidityError> {2919        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2920        Ok((self.0, who.clone(), imbalance))2921    }29222923    fn post_dispatch(2924        pre: Self::Pre,2925        info: &DispatchInfoOf<Self::Call>,2926        post_info: &PostDispatchInfoOf<Self::Call>,2927        len: usize,2928        _result: &DispatchResult,2929    ) -> Result<(), TransactionValidityError> {2930		let (tip, who, imbalance) = pre;2931		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2932			len as u32,2933			info,2934			post_info,2935			tip,2936		);2937		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2938		Ok(())2939    }2940}29412942// #endregion