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

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, 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, 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        /// TODO: Off chain worker should remove from this map when token gets removed541        pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;542543        //#region Item collections544        /// Collection id (controlled?2), token id (controlled?1)545        pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::AccountId>>;546        /// Collection id (controlled?2), owner (controlled?2)547        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;548        /// Collection id (controlled?2), token id (controlled?1)549        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::AccountId>>;550        //#endregion551552        //#region Index list553        /// Collection id (controlled?2), tokens owner (controlled?2)554        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;555        //#endregion556557        //#region Tokens transfer rate limit baskets558        /// (Collection id (controlled?2), who created (real))559        /// TODO: Off chain worker should remove from this map when collection gets removed560        pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;561        /// Collection id (controlled?2), token id (controlled?2)562        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;563        /// Collection id (controlled?2), owning user (real)564        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;565        /// Collection id (controlled?2), token id (controlled?2)566        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;567        //#endregion568569        /// Variable metadata sponsoring570        /// Collection id (controlled?2), token id (controlled?2)571        pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;572      573        //#region Contract Sponsorship and Ownership574        /// Contract address (real)575        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;576        /// Contract address (real)577        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;578        /// (Contract address(real), caller (real))579        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;580        /// Contract address (real)581        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;582        /// Contract address (real)583        pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 584        /// Contract address (real) => Whitelisted user (controlled?3)585        pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 586        //#endregion587    }588    add_extra_genesis {589        build(|config: &GenesisConfig<T>| {590            // Modification of storage591            for (_num, _c) in &config.collection_id {592                <Module<T>>::init_collection(_c);593            }594595            for (_num, _c, _i) in &config.nft_item_id {596                <Module<T>>::init_nft_token(*_c, _i);597            }598599            for (collection_id, account_id, fungible_item) in &config.fungible_item_id {600                <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);601            }602603            for (_num, _c, _i) in &config.refungible_item_id {604                <Module<T>>::init_refungible_token(*_c, _i);605            }606        })607    }608}609610decl_event!(611    pub enum Event<T>612    where613        AccountId = <T as system::Config>::AccountId,614    {615        /// New collection was created616        /// 617        /// # Arguments618        /// 619        /// * collection_id: Globally unique identifier of newly created collection.620        /// 621        /// * mode: [CollectionMode] converted into u8.622        /// 623        /// * account_id: Collection owner.624        CollectionCreated(CollectionId, u8, AccountId),625626        /// New item was created.627        /// 628        /// # Arguments629        /// 630        /// * collection_id: Id of the collection where item was created.631        /// 632        /// * item_id: Id of an item. Unique within the collection.633        ///634        /// * recipient: Owner of newly created item 635        ItemCreated(CollectionId, TokenId, AccountId),636637        /// Collection item was burned.638        /// 639        /// # Arguments640        /// 641        /// collection_id.642        /// 643        /// item_id: Identifier of burned NFT.644        ItemDestroyed(CollectionId, TokenId),645646        /// Item was transferred647        ///648        /// * collection_id: Id of collection to which item is belong649        ///650        /// * item_id: Id of an item651        ///652        /// * sender: Original owner of item653        ///654        /// * recipient: New owner of item655        ///656        /// * amount: Always 1 for NFT657        Transfer(CollectionId, TokenId, AccountId, AccountId, u128),658659        /// * collection_id660        ///661        /// * item_id662        ///663        /// * sender664        ///665        /// * spender666        ///667        /// * amount668        Approved(CollectionId, TokenId, AccountId, AccountId, u128),669    }670);671672decl_module! {673    pub struct Module<T: Config> for enum Call 674    where 675        origin: T::Origin676    {677        fn deposit_event() = default;678        type Error = Error<T>;679680        fn on_initialize(_now: T::BlockNumber) -> Weight {681            0682        }683684        /// 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.685        /// 686        /// # Permissions687        /// 688        /// * Anyone.689        /// 690        /// # Arguments691        /// 692        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.693        /// 694        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.695        /// 696        /// * token_prefix: UTF-8 string with token prefix.697        /// 698        /// * mode: [CollectionMode] collection type and type dependent data.699        // returns collection ID700        #[weight = <T as Config>::WeightInfo::create_collection()]701        #[transactional]702        pub fn create_collection(origin,703                                 collection_name: Vec<u16>,704                                 collection_description: Vec<u16>,705                                 token_prefix: Vec<u8>,706                                 mode: CollectionMode) -> DispatchResult {707708            // Anyone can create a collection709            let who = ensure_signed(origin)?;710711            // Take a (non-refundable) deposit of collection creation712            let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();713            imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(714                &T::TreasuryAccountId::get(),715                T::CollectionCreationPrice::get(),716            ));717            <T as Config>::Currency::settle(718                &who,719                imbalance,720                WithdrawReasons::TRANSFER,721                ExistenceRequirement::KeepAlive,722            ).map_err(|_| Error::<T>::NoPermission)?;723724            let decimal_points = match mode {725                CollectionMode::Fungible(points) => points,726                _ => 0727            };728729            let chain_limit = ChainLimit::get();730731            let created_count = CreatedCollectionCount::get();732            let destroyed_count = DestroyedCollectionCount::get();733734            // bound Total number of collections735            ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);736737            // check params738            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);739            ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);740            ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);741            ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);742743            // Generate next collection ID744            let next_id = created_count745                .checked_add(1)746                .ok_or(Error::<T>::NumOverflow)?;747748            CreatedCollectionCount::put(next_id);749750            let limits = CollectionLimits {751                sponsored_data_size: chain_limit.custom_data_limit,752                ..Default::default()753            };754755            // Create new collection756            let new_collection = Collection {757                owner: who.clone(),758                name: collection_name,759                mode: mode.clone(),760                mint_mode: false,761                access: AccessMode::Normal,762                description: collection_description,763                decimal_points: decimal_points,764                token_prefix: token_prefix,765                offchain_schema: Vec::new(),766                schema_version: SchemaVersion::ImageURL,767                sponsorship: SponsorshipState::Disabled,768                variable_on_chain_schema: Vec::new(),769                const_on_chain_schema: Vec::new(),770                limits,771            };772773            // Add new collection to map774            <CollectionById<T>>::insert(next_id, new_collection);775776            // call event777            Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who.clone()));778779            Ok(())780        }781782        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.783        /// 784        /// # Permissions785        /// 786        /// * Collection Owner.787        /// 788        /// # Arguments789        /// 790        /// * collection_id: collection to destroy.791        #[weight = <T as Config>::WeightInfo::destroy_collection()]792        #[transactional]793        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {794795            let sender = ensure_signed(origin)?;796            let collection = Self::get_collection(collection_id)?;797            Self::check_owner_permissions(&collection, sender)?;798            if !collection.limits.owner_can_destroy {799                fail!(Error::<T>::NoPermission);800            }801802            <AddressTokens<T>>::remove_prefix(collection_id);803            <Allowances<T>>::remove_prefix(collection_id);804            <Balance<T>>::remove_prefix(collection_id);805            <ItemListIndex>::remove(collection_id);806            <AdminList<T>>::remove(collection_id);807            <CollectionById<T>>::remove(collection_id);808            <WhiteList<T>>::remove_prefix(collection_id);809810            <NftItemList<T>>::remove_prefix(collection_id);811            <FungibleItemList<T>>::remove_prefix(collection_id);812            <ReFungibleItemList<T>>::remove_prefix(collection_id);813814            <NftTransferBasket<T>>::remove_prefix(collection_id);815            <FungibleTransferBasket<T>>::remove_prefix(collection_id);816            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);817818            <VariableMetaDataBasket<T>>::remove_prefix(collection_id);819820            DestroyedCollectionCount::put(DestroyedCollectionCount::get()821                .checked_add(1)822                .ok_or(Error::<T>::NumOverflow)?);823824            Ok(())825        }826827        /// Add an address to white list.828        /// 829        /// # Permissions830        /// 831        /// * Collection Owner832        /// * Collection Admin833        /// 834        /// # Arguments835        /// 836        /// * collection_id.837        /// 838        /// * address.839        #[weight = <T as Config>::WeightInfo::add_to_white_list()]840        #[transactional]841        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{842843            let sender = ensure_signed(origin)?;844            let collection = Self::get_collection(collection_id)?;845846            Self::toggle_white_list_internal(847                &sender,848                &collection,849                &address,850                true,851            )?;852853            Ok(())854        }855856        /// Remove an address from white list.857        /// 858        /// # Permissions859        /// 860        /// * Collection Owner861        /// * Collection Admin862        /// 863        /// # Arguments864        /// 865        /// * collection_id.866        /// 867        /// * address.868        #[weight = <T as Config>::WeightInfo::remove_from_white_list()]869        #[transactional]870        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{871872            let sender = ensure_signed(origin)?;873            let collection = Self::get_collection(collection_id)?;874875            Self::toggle_white_list_internal(876                &sender,877                &collection,878                &address,879                false,880            )?;881882            Ok(())883        }884885        /// Toggle between normal and white list access for the methods with access for `Anyone`.886        /// 887        /// # Permissions888        /// 889        /// * Collection Owner.890        /// 891        /// # Arguments892        /// 893        /// * collection_id.894        /// 895        /// * mode: [AccessMode]896        #[weight = <T as Config>::WeightInfo::set_public_access_mode()]897        #[transactional]898        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult899        {900            let sender = ensure_signed(origin)?;901902            let mut target_collection = Self::get_collection(collection_id)?;903            Self::check_owner_permissions(&target_collection, sender)?;904            target_collection.access = mode;905            Self::save_collection(target_collection);906907            Ok(())908        }909910        /// Allows Anyone to create tokens if:911        /// * White List is enabled, and912        /// * Address is added to white list, and913        /// * This method was called with True parameter914        /// 915        /// # Permissions916        /// * Collection Owner917        ///918        /// # Arguments919        /// 920        /// * collection_id.921        /// 922        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.923        #[weight = <T as Config>::WeightInfo::set_mint_permission()]924        #[transactional]925        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult926        {927            let sender = ensure_signed(origin)?;928929            let mut target_collection = Self::get_collection(collection_id)?;930            Self::check_owner_permissions(&target_collection, sender)?;931            target_collection.mint_mode = mint_permission;932            Self::save_collection(target_collection);933934            Ok(())935        }936937        /// Change the owner of the collection.938        /// 939        /// # Permissions940        /// 941        /// * Collection Owner.942        /// 943        /// # Arguments944        /// 945        /// * collection_id.946        /// 947        /// * new_owner.948        #[weight = <T as Config>::WeightInfo::change_collection_owner()]949        #[transactional]950        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {951952            let sender = ensure_signed(origin)?;953            let mut target_collection = Self::get_collection(collection_id)?;954            Self::check_owner_permissions(&target_collection, sender)?;955            target_collection.owner = new_owner;956            Self::save_collection(target_collection);957958            Ok(())959        }960961        /// Adds an admin of the Collection.962        /// 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. 963        /// 964        /// # Permissions965        /// 966        /// * Collection Owner.967        /// * Collection Admin.968        /// 969        /// # Arguments970        /// 971        /// * collection_id: ID of the Collection to add admin for.972        /// 973        /// * new_admin_id: Address of new admin to add.974        #[weight = <T as Config>::WeightInfo::add_collection_admin()]975        #[transactional]976        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {977978            let sender = ensure_signed(origin)?;979            let collection = Self::get_collection(collection_id)?;980            Self::check_owner_or_admin_permissions(&collection, sender)?;981            let mut admin_arr = <AdminList<T>>::get(collection_id);982983            match admin_arr.binary_search(&new_admin_id) {984                Ok(_) => {},985                Err(idx) => {986                    let limits = ChainLimit::get();987                    ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);988                    admin_arr.insert(idx, new_admin_id);989                    <AdminList<T>>::insert(collection_id, admin_arr);990                }991            }992            Ok(())993        }994995        /// 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.996        ///997        /// # Permissions998        /// 999        /// * Collection Owner.1000        /// * Collection Admin.1001        /// 1002        /// # Arguments1003        /// 1004        /// * collection_id: ID of the Collection to remove admin for.1005        /// 1006        /// * account_id: Address of admin to remove.1007        #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1008        #[transactional]1009        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10101011            let sender = ensure_signed(origin)?;1012            let collection = Self::get_collection(collection_id)?;1013            Self::check_owner_or_admin_permissions(&collection, sender)?;1014            let mut admin_arr = <AdminList<T>>::get(collection_id);10151016            match admin_arr.binary_search(&account_id) {1017                Ok(idx) => {1018                    admin_arr.remove(idx);1019                    <AdminList<T>>::insert(collection_id, admin_arr);1020                },1021                Err(_) => {}1022            }1023            Ok(())1024        }10251026        /// # Permissions1027        /// 1028        /// * Collection Owner1029        /// 1030        /// # Arguments1031        /// 1032        /// * collection_id.1033        /// 1034        /// * new_sponsor.1035        #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1036        #[transactional]1037        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10381039            let sender = ensure_signed(origin)?;1040            let mut target_collection = Self::get_collection(collection_id)?;1041            Self::check_owner_permissions(&target_collection, sender)?;10421043            target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1044            Self::save_collection(target_collection);10451046            Ok(())1047        }10481049        /// # Permissions1050        /// 1051        /// * Sponsor.1052        /// 1053        /// # Arguments1054        /// 1055        /// * collection_id.1056        #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1057        #[transactional]1058        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10591060            let sender = ensure_signed(origin)?;10611062            let mut target_collection = Self::get_collection(collection_id)?;1063            ensure!(1064                target_collection.sponsorship.pending_sponsor() == Some(&sender),1065                Error::<T>::ConfirmUnsetSponsorFail1066            );10671068            target_collection.sponsorship = SponsorshipState::Confirmed(sender);1069            Self::save_collection(target_collection);10701071            Ok(())1072        }10731074        /// Switch back to pay-per-own-transaction model.1075        ///1076        /// # Permissions1077        ///1078        /// * Collection owner.1079        /// 1080        /// # Arguments1081        /// 1082        /// * collection_id.1083        #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1084        #[transactional]1085        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10861087            let sender = ensure_signed(origin)?;10881089            let mut target_collection = Self::get_collection(collection_id)?;1090            Self::check_owner_permissions(&target_collection, sender)?;10911092            target_collection.sponsorship = SponsorshipState::Disabled;1093            Self::save_collection(target_collection);10941095            Ok(())1096        }10971098        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1099        /// 1100        /// # Permissions1101        /// 1102        /// * Collection Owner.1103        /// * Collection Admin.1104        /// * Anyone if1105        ///     * White List is enabled, and1106        ///     * Address is added to white list, and1107        ///     * MintPermission is enabled (see SetMintPermission method)1108        /// 1109        /// # Arguments1110        /// 1111        /// * collection_id: ID of the collection.1112        /// 1113        /// * owner: Address, initial owner of the NFT.1114        ///1115        /// * data: Token data to store on chain.1116        // #[weight =1117        // (130_000_000 as Weight)1118        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1119        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1120        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11211122        #[weight = <T as Config>::WeightInfo::create_item(data.len())]1123        #[transactional]1124        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1125            let sender = ensure_signed(origin)?;1126            Self::create_item_internal(sender, collection_id, owner, data)1127        }11281129        /// This method creates multiple items in a collection created with CreateCollection method.1130        /// 1131        /// # Permissions1132        /// 1133        /// * Collection Owner.1134        /// * Collection Admin.1135        /// * Anyone if1136        ///     * White List is enabled, and1137        ///     * Address is added to white list, and1138        ///     * MintPermission is enabled (see SetMintPermission method)1139        /// 1140        /// # Arguments1141        /// 1142        /// * collection_id: ID of the collection.1143        /// 1144        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1145        /// 1146        /// * owner: Address, initial owner of the NFT.1147        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1148                               .map(|data| { data.len() })1149                               .sum())]1150        #[transactional]1151        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11521153            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1154            let sender = ensure_signed(origin)?;11551156            let target_collection = Self::get_collection(collection_id)?;11571158            Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11591160            for data in &items_data {1161                Self::validate_create_item_args(&target_collection, data)?;1162            }1163            for data in &items_data {1164                Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1165            }11661167            Ok(())1168        }11691170        /// Destroys a concrete instance of NFT.1171        /// 1172        /// # Permissions1173        /// 1174        /// * Collection Owner.1175        /// * Collection Admin.1176        /// * Current NFT Owner.1177        /// 1178        /// # Arguments1179        /// 1180        /// * collection_id: ID of the collection.1181        /// 1182        /// * item_id: ID of NFT to burn.1183        #[weight = <T as Config>::WeightInfo::burn_item()]1184        #[transactional]1185        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11861187            let sender = ensure_signed(origin)?;11881189            // Transfer permissions check1190            let target_collection = Self::get_collection(collection_id)?;1191            ensure!(1192                Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1193                (1194                    target_collection.limits.owner_can_transfer &&1195                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1196                ),1197                Error::<T>::NoPermission1198            );11991200            if target_collection.access == AccessMode::WhiteList {1201                Self::check_white_list(&target_collection, &sender)?;1202            }12031204            match target_collection.mode1205            {1206                CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1207                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, &target_collection, value)?,1208                CollectionMode::ReFungible  => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1209                _ => ()1210            };12111212            // call event1213            Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12141215            Ok(())1216        }12171218        /// Change ownership of the token.1219        /// 1220        /// # Permissions1221        /// 1222        /// * Collection Owner1223        /// * Collection Admin1224        /// * Current NFT owner1225        ///1226        /// # Arguments1227        /// 1228        /// * recipient: Address of token recipient.1229        /// 1230        /// * collection_id.1231        /// 1232        /// * item_id: ID of the item1233        ///     * Non-Fungible Mode: Required.1234        ///     * Fungible Mode: Ignored.1235        ///     * Re-Fungible Mode: Required.1236        /// 1237        /// * value: Amount to transfer.1238        ///     * Non-Fungible Mode: Ignored1239        ///     * Fungible Mode: Must specify transferred amount1240        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1241        #[weight = <T as Config>::WeightInfo::transfer()]1242        #[transactional]1243        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1244            let sender = ensure_signed(origin)?;1245            let collection = Self::get_collection(collection_id)?;12461247            Self::transfer_internal(sender, recipient, &collection, item_id, value)1248        }12491250        /// Set, change, or remove approved address to transfer the ownership of the NFT.1251        /// 1252        /// # Permissions1253        /// 1254        /// * Collection Owner1255        /// * Collection Admin1256        /// * Current NFT owner1257        /// 1258        /// # Arguments1259        /// 1260        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1261        /// 1262        /// * collection_id.1263        /// 1264        /// * item_id: ID of the item.1265        #[weight = <T as Config>::WeightInfo::approve()]1266        #[transactional]1267        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12681269            let sender = ensure_signed(origin)?;1270            let collection = Self::get_collection(collection_id)?;12711272            Self::approve_internal(sender, spender, &collection, item_id, amount)?;12731274            Ok(())1275        }1276        1277        /// 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.1278        /// 1279        /// # Permissions1280        /// * Collection Owner1281        /// * Collection Admin1282        /// * Current NFT owner1283        /// * Address approved by current NFT owner1284        /// 1285        /// # Arguments1286        /// 1287        /// * from: Address that owns token.1288        /// 1289        /// * recipient: Address of token recipient.1290        /// 1291        /// * collection_id.1292        /// 1293        /// * item_id: ID of the item.1294        /// 1295        /// * value: Amount to transfer.1296        #[weight = <T as Config>::WeightInfo::transfer_from()]1297        #[transactional]1298        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12991300            let sender = ensure_signed(origin)?;1301            let collection = Self::get_collection(collection_id)?;13021303            Self::transfer_from_internal(sender, from, recipient, &collection, item_id, value)?;13041305            Ok(())1306        }13071308        // #[weight = 0]1309        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13101311        //     // let no_perm_mes = "You do not have permissions to modify this collection";1312        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1313        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1314        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13151316        //     // // on_nft_received  call13171318        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;13191320        //     Ok(())1321        // }13221323        /// Set off-chain data schema.1324        /// 1325        /// # Permissions1326        /// 1327        /// * Collection Owner1328        /// * Collection Admin1329        /// 1330        /// # Arguments1331        /// 1332        /// * collection_id.1333        /// 1334        /// * schema: String representing the offchain data schema.1335        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1336        #[transactional]1337        pub fn set_variable_meta_data (1338            origin,1339            collection_id: CollectionId,1340            item_id: TokenId,1341            data: Vec<u8>1342        ) -> DispatchResult {1343            let sender = ensure_signed(origin)?;1344            1345            let collection = Self::get_collection(collection_id)?;13461347            Self::set_variable_meta_data_internal(sender, &collection, item_id, data)?;13481349            Ok(())1350        }1351 1352        /// Set schema standard1353        /// ImageURL1354        /// Unique1355        /// 1356        /// # Permissions1357        /// 1358        /// * Collection Owner1359        /// * Collection Admin1360        /// 1361        /// # Arguments1362        /// 1363        /// * collection_id.1364        /// 1365        /// * schema: SchemaVersion: enum1366        #[weight = <T as Config>::WeightInfo::set_schema_version()]1367        #[transactional]1368        pub fn set_schema_version(1369            origin,1370            collection_id: CollectionId,1371            version: SchemaVersion1372        ) -> DispatchResult {1373            let sender = ensure_signed(origin)?;1374            let mut target_collection = Self::get_collection(collection_id)?;1375            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1376            target_collection.schema_version = version;1377            Self::save_collection(target_collection);13781379            Ok(())1380        }13811382        /// Set off-chain data schema.1383        /// 1384        /// # Permissions1385        /// 1386        /// * Collection Owner1387        /// * Collection Admin1388        /// 1389        /// # Arguments1390        /// 1391        /// * collection_id.1392        /// 1393        /// * schema: String representing the offchain data schema.1394        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1395        #[transactional]1396        pub fn set_offchain_schema(1397            origin,1398            collection_id: CollectionId,1399            schema: Vec<u8>1400        ) -> DispatchResult {1401            let sender = ensure_signed(origin)?;1402            let mut target_collection = Self::get_collection(collection_id)?;1403            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14041405            // check schema limit1406            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14071408            target_collection.offchain_schema = schema;1409            Self::save_collection(target_collection);14101411            Ok(())1412        }14131414        /// Set const on-chain data schema.1415        /// 1416        /// # Permissions1417        /// 1418        /// * Collection Owner1419        /// * Collection Admin1420        /// 1421        /// # Arguments1422        /// 1423        /// * collection_id.1424        /// 1425        /// * schema: String representing the const on-chain data schema.1426        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1427        #[transactional]1428        pub fn set_const_on_chain_schema (1429            origin,1430            collection_id: CollectionId,1431            schema: Vec<u8>1432        ) -> DispatchResult {1433            let sender = ensure_signed(origin)?;1434            let mut target_collection = Self::get_collection(collection_id)?;1435            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14361437            // check schema limit1438            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14391440            target_collection.const_on_chain_schema = schema;1441            Self::save_collection(target_collection);14421443            Ok(())1444        }14451446        /// Set variable on-chain data schema.1447        /// 1448        /// # Permissions1449        /// 1450        /// * Collection Owner1451        /// * Collection Admin1452        /// 1453        /// # Arguments1454        /// 1455        /// * collection_id.1456        /// 1457        /// * schema: String representing the variable on-chain data schema.1458        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1459        #[transactional]1460        pub fn set_variable_on_chain_schema (1461            origin,1462            collection_id: CollectionId,1463            schema: Vec<u8>1464        ) -> DispatchResult {1465            let sender = ensure_signed(origin)?;1466            let mut target_collection = Self::get_collection(collection_id)?;1467            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14681469            // check schema limit1470            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14711472            target_collection.variable_on_chain_schema = schema;1473            Self::save_collection(target_collection);14741475            Ok(())1476        }14771478        // Sudo permissions function1479        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1480        #[transactional]1481        pub fn set_chain_limits(1482            origin,1483            limits: ChainLimits1484        ) -> DispatchResult {14851486            #[cfg(not(feature = "runtime-benchmarks"))]1487            ensure_root(origin)?;14881489            <ChainLimit>::put(limits);1490            Ok(())1491        }14921493        /// Enable smart contract self-sponsoring.1494        /// 1495        /// # Permissions1496        /// 1497        /// * Contract Owner1498        /// 1499        /// # Arguments1500        /// 1501        /// * contract address1502        /// * enable flag1503        /// 1504        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1505        #[transactional]1506        pub fn enable_contract_sponsoring(1507            origin,1508            contract_address: T::AccountId,1509            enable: bool1510        ) -> DispatchResult {15111512            let sender = ensure_signed(origin)?;15131514            #[cfg(feature = "runtime-benchmarks")]1515            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15161517            Self::ensure_contract_owned(sender, &contract_address)?;15181519            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1520            Ok(())1521        }15221523        /// Set the rate limit for contract sponsoring to specified number of blocks.1524        /// 1525        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1526        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1527        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1528        /// from contract endowment if there are at least B blocks between such transactions. 1529        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1530        /// 1531        /// # Permissions1532        /// 1533        /// * Contract Owner1534        /// 1535        /// # Arguments1536        /// 1537        /// -`contract_address`: Address of the contract to sponsor1538        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1539        /// 1540        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1541        #[transactional]1542        pub fn set_contract_sponsoring_rate_limit(1543            origin,1544            contract_address: T::AccountId,1545            rate_limit: T::BlockNumber1546        ) -> DispatchResult {1547            let sender = ensure_signed(origin)?;15481549            #[cfg(feature = "runtime-benchmarks")]1550            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15511552            Self::ensure_contract_owned(sender, &contract_address)?;1553            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1554            Ok(())1555        }15561557        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1558        /// 1559        /// # Permissions1560        /// 1561        /// * Address that deployed smart contract.1562        /// 1563        /// # Arguments1564        /// 1565        /// -`contract_address`: Address of the contract.1566        /// 1567        /// - `enable`: .  1568        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1569        #[transactional]1570        pub fn toggle_contract_white_list(1571            origin,1572            contract_address: T::AccountId,1573            enable: bool1574        ) -> DispatchResult {1575            let sender = ensure_signed(origin)?;15761577            #[cfg(feature = "runtime-benchmarks")]1578            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15791580            Self::ensure_contract_owned(sender, &contract_address)?;1581            if enable {1582                <ContractWhiteListEnabled<T>>::insert(contract_address, true);1583            } else {1584                <ContractWhiteListEnabled<T>>::remove(contract_address);1585            }1586            Ok(())1587        }1588        1589        /// Add an address to smart contract white list.1590        /// 1591        /// # Permissions1592        /// 1593        /// * Address that deployed smart contract.1594        /// 1595        /// # Arguments1596        /// 1597        /// -`contract_address`: Address of the contract.1598        ///1599        /// -`account_address`: Address to add.1600        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1601        #[transactional]1602        pub fn add_to_contract_white_list(1603            origin,1604            contract_address: T::AccountId,1605            account_address: T::AccountId1606        ) -> DispatchResult {1607            let sender = ensure_signed(origin)?;16081609            #[cfg(feature = "runtime-benchmarks")]1610            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1611            1612            Self::ensure_contract_owned(sender, &contract_address)?;      1613            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1614            Ok(())1615        }16161617        /// Remove an address from smart contract white list.1618        /// 1619        /// # Permissions1620        /// 1621        /// * Address that deployed smart contract.1622        /// 1623        /// # Arguments1624        /// 1625        /// -`contract_address`: Address of the contract.1626        ///1627        /// -`account_address`: Address to remove.1628        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1629        #[transactional]1630        pub fn remove_from_contract_white_list(1631            origin,1632            contract_address: T::AccountId,1633            account_address: T::AccountId1634        ) -> DispatchResult {1635            let sender = ensure_signed(origin)?;16361637            #[cfg(feature = "runtime-benchmarks")]1638            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16391640            Self::ensure_contract_owned(sender, &contract_address)?;1641            <ContractWhiteList<T>>::remove(contract_address, account_address);1642            Ok(())1643        }16441645        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1646        #[transactional]1647        pub fn set_collection_limits(1648            origin,1649            collection_id: u32,1650            new_limits: CollectionLimits<T::BlockNumber>,1651        ) -> DispatchResult {1652            let sender = ensure_signed(origin)?;1653            let mut target_collection = Self::get_collection(collection_id)?;1654            Self::check_owner_permissions(&target_collection, sender.clone())?;1655            let old_limits = &target_collection.limits;1656            let chain_limits = ChainLimit::get();16571658            // collection bounds1659            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1660                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1661                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1662                Error::<T>::CollectionLimitBoundsExceeded);16631664            // token_limit   check  prev1665            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1666            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16671668            ensure!(1669                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1670                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1671                Error::<T>::OwnerPermissionsCantBeReverted,1672            );16731674            target_collection.limits = new_limits;1675            Self::save_collection(target_collection);16761677            Ok(())1678        } 1679    }1680}16811682impl<T: Config> Module<T> {1683    pub fn create_item_internal(sender: T::AccountId, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1684        let target_collection = Self::get_collection(collection_id)?;16851686        Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1687        Self::validate_create_item_args(&target_collection, &data)?;1688        Self::create_item_no_validation(&target_collection, owner, data)?;16891690        Ok(())1691    }16921693    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1694        // Limits check1695        Self::is_correct_transfer(target_collection, &recipient)?;16961697        // Transfer permissions check1698        ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1699            Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1700            Error::<T>::NoPermission);17011702        if target_collection.access == AccessMode::WhiteList {1703            Self::check_white_list(target_collection, &sender)?;1704            Self::check_white_list(target_collection, &recipient)?;1705        }17061707        match target_collection.mode1708        {1709            CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1710            CollectionMode::Fungible(_)  => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1711            CollectionMode::ReFungible  => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1712            _ => ()1713        };17141715        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17161717        Ok(())1718    }17191720	pub fn approve_internal(1721		sender: T::AccountId,1722		spender: T::AccountId,1723		collection: &CollectionHandle<T>,1724		item_id: TokenId,1725		amount: u128,1726	) -> DispatchResult {1727		Self::token_exists(&collection, item_id)?;17281729		// Transfer permissions check1730		let bypasses_limits = collection.limits.owner_can_transfer &&1731			Self::is_owner_or_admin_permissions(1732				&collection,1733				sender.clone(),1734			);17351736		let allowance_limit = if bypasses_limits {1737			None1738		} else if let Some(amount) = Self::owned_amount(1739			sender.clone(),1740			&collection,1741			item_id,1742		) {1743			Some(amount)1744		} else {1745			fail!(Error::<T>::NoPermission);1746		};17471748		if collection.access == AccessMode::WhiteList {1749			Self::check_white_list(&collection, &sender)?;1750			Self::check_white_list(&collection, &spender)?;1751		}17521753		let allowance: u128 = amount1754			.checked_add(<Allowances<T>>::get(collection.id, (item_id, &sender, &spender)))1755			.ok_or(Error::<T>::NumOverflow)?;1756		if let Some(limit) = allowance_limit {1757			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1758		}1759		<Allowances<T>>::insert(collection.id, (item_id, &sender, &spender), allowance);17601761		Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1762		Ok(())1763	}17641765	pub fn transfer_from_internal(1766		sender: T::AccountId,1767		from: T::AccountId,1768		recipient: T::AccountId,1769		collection: &CollectionHandle<T>,1770		item_id: TokenId,1771		amount: u128,1772	) -> DispatchResult {1773		// Check approval1774		let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, &from, &sender));17751776		// Limits check1777		Self::is_correct_transfer(&collection, &recipient)?;17781779		// Transfer permissions check1780		ensure!(1781			approval >= amount || 1782			(1783				collection.limits.owner_can_transfer &&1784				Self::is_owner_or_admin_permissions(&collection, sender.clone())1785			),1786			Error::<T>::NoPermission1787		);17881789		if collection.access == AccessMode::WhiteList {1790			Self::check_white_list(&collection, &sender)?;1791			Self::check_white_list(&collection, &recipient)?;1792		}17931794		// Reduce approval by transferred amount or remove if remaining approval drops to 01795		let allowance = approval.saturating_sub(amount);1796		if allowance > 0 {1797			<Allowances<T>>::insert(collection.id, (item_id, &from, &sender), allowance);1798		} else {1799			<Allowances<T>>::remove(collection.id, (item_id, &from, &sender));1800		}18011802		match collection.mode {1803			CollectionMode::NFT => {1804				Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1805			}1806			CollectionMode::Fungible(_) => {1807				Self::transfer_fungible(&collection, amount, &from, &recipient)?1808			}1809			CollectionMode::ReFungible => {1810				Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1811			}1812			_ => ()1813		};18141815		Ok(())1816	}18171818    pub fn set_variable_meta_data_internal(1819        sender: T::AccountId,1820        collection: &CollectionHandle<T>, 1821        item_id: TokenId,1822        data: Vec<u8>,1823    ) -> DispatchResult {1824        Self::token_exists(&collection, item_id)?;18251826        ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18271828        // Modify permissions check1829        ensure!(Self::is_item_owner(sender.clone(), &collection, item_id) ||1830            Self::is_owner_or_admin_permissions(&collection, sender.clone()),1831            Error::<T>::NoPermission);18321833        match collection.mode1834        {1835            CollectionMode::NFT => Self::set_nft_variable_data(&collection, item_id, data)?,1836            CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(&collection, item_id, data)?,1837            CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1838            _ => fail!(Error::<T>::UnexpectedCollectionType)1839        };18401841        Ok(())1842    }18431844    pub fn create_multiple_items_internal(1845        sender: T::AccountId,1846        collection: &CollectionHandle<T>,1847        owner: T::AccountId,1848        items_data: Vec<CreateItemData>,1849    ) -> DispatchResult {1850        Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18511852        for data in &items_data {1853            Self::validate_create_item_args(&collection, data)?;1854        }1855        for data in &items_data {1856            Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1857        }18581859        Ok(())1860    }18611862    pub fn toggle_white_list_internal(1863        sender: &T::AccountId,1864        collection: &CollectionHandle<T>,1865        address: &T::AccountId,1866        whitelisted: bool,1867    ) -> DispatchResult {1868        Self::check_owner_or_admin_permissions(&collection, sender.clone())?;18691870        if whitelisted {1871            <WhiteList<T>>::insert(collection.id, address, true);1872        } else {1873            <WhiteList<T>>::remove(collection.id, address);1874        }18751876        Ok(())1877    }18781879    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1880        let collection_id = collection.id;18811882        // check token limit and account token limit1883        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1884        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1885        1886        Ok(())1887    }18881889    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1890        let collection_id = collection.id;18911892        // check token limit and account token limit1893        let total_items: u32 = ItemListIndex::get(collection_id)1894            .checked_add(amount)1895            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1896        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1897            .checked_add(amount)1898            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1899        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1900        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);19011902        if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1903            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1904            Self::check_white_list(collection, owner)?;1905            Self::check_white_list(collection, sender)?;1906        }19071908        Ok(())1909    }19101911    fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1912        match target_collection.mode1913        {1914            CollectionMode::NFT => {1915                if let CreateItemData::NFT(data) = data {1916                    // check sizes1917                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1918                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1919                } else {1920                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1921                }1922            },1923            CollectionMode::Fungible(_) => {1924                if let CreateItemData::Fungible(_) = data {1925                } else {1926                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1927                }1928            },1929            CollectionMode::ReFungible => {1930                if let CreateItemData::ReFungible(data) = data {19311932                    // check sizes1933                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1934                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19351936                    // Check refungibility limits1937                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1938                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1939                } else {1940                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1941                }1942            },1943            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1944        };19451946        Ok(())1947    }19481949    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1950        match data1951        {1952            CreateItemData::NFT(data) => {1953                let item = NftItemType {1954                    owner: owner.clone(),1955                    const_data: data.const_data,1956                    variable_data: data.variable_data1957                };19581959                Self::add_nft_item(collection, item)?;1960            },1961            CreateItemData::Fungible(data) => {1962                Self::add_fungible_item(collection, &owner, data.value)?;1963            },1964            CreateItemData::ReFungible(data) => {1965                let mut owner_list = Vec::new();1966                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19671968                let item = ReFungibleItemType {1969                    owner: owner_list,1970                    const_data: data.const_data,1971                    variable_data: data.variable_data1972                };19731974                Self::add_refungible_item(collection, item)?;1975            }1976        };19771978        Ok(())1979    }19801981    fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1982        let collection_id = collection.id;19831984        // Does new owner already have an account?1985        let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19861987        // Mint 1988        let item = FungibleItemType {1989            value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1990        };1991        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19921993        // Update balance1994        let new_balance = <Balance<T>>::get(collection_id, owner)1995            .checked_add(value)1996            .ok_or(Error::<T>::NumOverflow)?;1997        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19981999        Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));2000        Ok(())2001    }20022003    fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {2004        let collection_id = collection.id;20052006        let current_index = <ItemListIndex>::get(collection_id)2007            .checked_add(1)2008            .ok_or(Error::<T>::NumOverflow)?;2009        let itemcopy = item.clone();20102011        ensure!(2012            item.owner.len() == 1,2013            Error::<T>::BadCreateRefungibleCall,2014        );2015        let item_owner = item.owner.first().expect("only one owner is defined");20162017        let value = item_owner.fraction;2018        let owner = item_owner.owner.clone();20192020        Self::add_token_index(collection_id, current_index, &owner)?;20212022        <ItemListIndex>::insert(collection_id, current_index);2023        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);20242025        // Update balance2026        let new_balance = <Balance<T>>::get(collection_id, &owner)2027            .checked_add(value)2028            .ok_or(Error::<T>::NumOverflow)?;2029        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);20302031        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));2032        Ok(())2033    }20342035    fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {2036        let collection_id = collection.id;20372038        let current_index = <ItemListIndex>::get(collection_id)2039            .checked_add(1)2040            .ok_or(Error::<T>::NumOverflow)?;20412042        let item_owner = item.owner.clone();2043        Self::add_token_index(collection_id, current_index, &item.owner)?;20442045        <ItemListIndex>::insert(collection_id, current_index);2046        <NftItemList<T>>::insert(collection_id, current_index, item);20472048        // Update balance2049        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())2050            .checked_add(1)2051            .ok_or(Error::<T>::NumOverflow)?;2052        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);20532054        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2055        Ok(())2056    }20572058    fn burn_refungible_item(2059        collection: &CollectionHandle<T>,2060        item_id: TokenId,2061        owner: &T::AccountId,2062    ) -> DispatchResult {2063        let collection_id = collection.id;20642065        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2066            .ok_or(Error::<T>::TokenNotFound)?;2067        let rft_balance = token2068            .owner2069            .iter()2070            .find(|&i| i.owner == *owner)2071            .ok_or(Error::<T>::TokenNotFound)?;2072        Self::remove_token_index(collection_id, item_id, owner)?;20732074        // update balance2075        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2076            .checked_sub(rft_balance.fraction)2077            .ok_or(Error::<T>::NumOverflow)?;2078        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20792080        // Re-create owners list with sender removed2081        let index = token2082            .owner2083            .iter()2084            .position(|i| i.owner == *owner)2085            .expect("owned item is exists");2086        token.owner.remove(index);2087        let owner_count = token.owner.len();20882089        // Burn the token completely if this was the last (only) owner2090        if owner_count == 0 {2091            <ReFungibleItemList<T>>::remove(collection_id, item_id);2092            <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2093        }2094        else {2095            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2096        }20972098        Ok(())2099    }21002101    fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2102        let collection_id = collection.id;21032104        let item = <NftItemList<T>>::get(collection_id, item_id)2105            .ok_or(Error::<T>::TokenNotFound)?;2106        Self::remove_token_index(collection_id, item_id, &item.owner)?;21072108        // update balance2109        let new_balance = <Balance<T>>::get(collection_id, &item.owner)2110            .checked_sub(1)2111            .ok_or(Error::<T>::NumOverflow)?;2112        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2113        <NftItemList<T>>::remove(collection_id, item_id);2114        <VariableMetaDataBasket<T>>::remove(collection_id, item_id);21152116        Ok(())2117    }21182119    fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2120        let collection_id = collection.id;21212122        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2123        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);21242125        // update balance2126        let new_balance = <Balance<T>>::get(collection_id, owner)2127            .checked_sub(value)2128            .ok_or(Error::<T>::NumOverflow)?;2129        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);21302131        if balance.value - value > 0 {2132            balance.value -= value;2133            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2134        }2135        else {2136            <FungibleItemList<T>>::remove(collection_id, owner);2137        }21382139        Ok(())2140    }21412142    pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2143        Ok(<CollectionById<T>>::get(collection_id)2144            .map(|collection| CollectionHandle {2145                id: collection_id,2146                collection2147            })2148            .ok_or(Error::<T>::CollectionNotFound)?)2149    }21502151    fn save_collection(collection: CollectionHandle<T>) {2152        <CollectionById<T>>::insert(collection.id, collection.collection);2153    }21542155    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2156        ensure!(2157            subject == target_collection.owner,2158            Error::<T>::NoPermission2159        );21602161        Ok(())2162    }21632164    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2165        subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2166    }21672168    fn check_owner_or_admin_permissions(2169        collection: &CollectionHandle<T>,2170        subject: T::AccountId,2171    ) -> DispatchResult {2172        ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);21732174        Ok(())2175    }21762177    fn owned_amount(2178        subject: T::AccountId,2179        target_collection: &CollectionHandle<T>,2180        item_id: TokenId,2181    ) -> Option<u128> {2182        let collection_id = target_collection.id;21832184        match target_collection.mode {2185            CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2186                .then(|| 1),2187            CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2188                .value),2189            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2190                .owner2191                .iter()2192                .find(|i| i.owner == subject)2193                .map(|i| i.fraction),2194            CollectionMode::Invalid => None,2195        }2196    }21972198    fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2199        match target_collection.mode {2200            CollectionMode::Fungible(_) => true,2201            _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2202        }2203    }22042205    fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2206        let collection_id = collection.id;22072208        let mes = Error::<T>::AddresNotInWhiteList;2209        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);22102211        Ok(())2212    }22132214    /// Check if token exists. In case of Fungible, check if there is an entry for 2215    /// the owner in fungible balances double map2216    fn token_exists(2217        target_collection: &CollectionHandle<T>,2218        item_id: TokenId,2219    ) -> DispatchResult {2220        let collection_id = target_collection.id;2221        let exists = match target_collection.mode2222        {2223            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2224            CollectionMode::Fungible(_)  => true,2225            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2226            _ => false2227        };22282229        ensure!(exists == true, Error::<T>::TokenNotFound);2230        Ok(())2231    }22322233    fn transfer_fungible(2234        collection: &CollectionHandle<T>,2235        value: u128,2236        owner: &T::AccountId,2237        recipient: &T::AccountId,2238    ) -> DispatchResult {2239        let collection_id = collection.id;22402241        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2242        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22432244        // Send balance to recipient (updates balanceOf of recipient)2245        Self::add_fungible_item(collection, recipient, value)?;22462247        // update balanceOf of sender2248        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22492250        // Reduce or remove sender2251        if balance.value == value {2252            <FungibleItemList<T>>::remove(collection_id, owner);2253        }2254        else {2255            balance.value -= value;2256            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2257        }22582259        Ok(())2260    }22612262    fn transfer_refungible(2263        collection: &CollectionHandle<T>,2264        item_id: TokenId,2265        value: u128,2266        owner: T::AccountId,2267        new_owner: T::AccountId,2268    ) -> DispatchResult {2269        let collection_id = collection.id;2270        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2271            .ok_or(Error::<T>::TokenNotFound)?;22722273        let item = full_item2274            .owner2275            .iter()2276            .filter(|i| i.owner == owner)2277            .next()2278            .ok_or(Error::<T>::TokenNotFound)?;2279        let amount = item.fraction;22802281        ensure!(amount >= value, Error::<T>::TokenValueTooLow);22822283        // update balance2284        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2285            .checked_sub(value)2286            .ok_or(Error::<T>::NumOverflow)?;2287        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22882289        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2290            .checked_add(value)2291            .ok_or(Error::<T>::NumOverflow)?;2292        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22932294        let old_owner = item.owner.clone();2295        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22962297        // transfer2298        if amount == value && !new_owner_has_account {2299            // change owner2300            // new owner do not have account2301            let mut new_full_item = full_item.clone();2302            new_full_item2303                .owner2304                .iter_mut()2305                .find(|i| i.owner == owner)2306                .expect("old owner does present in refungible")2307                .owner = new_owner.clone();2308            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);23092310            // update index collection2311            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2312        } else {2313            let mut new_full_item = full_item.clone();2314            new_full_item2315                .owner2316                .iter_mut()2317                .find(|i| i.owner == owner)2318                .expect("old owner does present in refungible")2319                .fraction -= value;23202321            // separate amount2322            if new_owner_has_account {2323                // new owner has account2324                new_full_item2325                    .owner2326                    .iter_mut()2327                    .find(|i| i.owner == new_owner)2328                    .expect("new owner has account")2329                    .fraction += value;2330            } else {2331                // new owner do not have account2332                new_full_item.owner.push(Ownership {2333                    owner: new_owner.clone(),2334                    fraction: value,2335                });2336                Self::add_token_index(collection_id, item_id, &new_owner)?;2337            }23382339            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2340        }23412342        Ok(())2343    }23442345    fn transfer_nft(2346        collection: &CollectionHandle<T>,2347        item_id: TokenId,2348        sender: T::AccountId,2349        new_owner: T::AccountId,2350    ) -> DispatchResult {2351        let collection_id = collection.id;2352        let mut item = <NftItemList<T>>::get(collection_id, item_id)2353            .ok_or(Error::<T>::TokenNotFound)?;23542355        ensure!(2356            sender == item.owner,2357            Error::<T>::MustBeTokenOwner2358        );23592360        // update balance2361        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2362            .checked_sub(1)2363            .ok_or(Error::<T>::NumOverflow)?;2364        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23652366        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2367            .checked_add(1)2368            .ok_or(Error::<T>::NumOverflow)?;2369        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23702371        // change owner2372        let old_owner = item.owner.clone();2373        item.owner = new_owner.clone();2374        <NftItemList<T>>::insert(collection_id, item_id, item);23752376        // update index collection2377        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23782379        Ok(())2380    }2381    2382    fn set_re_fungible_variable_data(2383        collection: &CollectionHandle<T>,2384        item_id: TokenId,2385        data: Vec<u8>2386    ) -> DispatchResult {2387        let collection_id = collection.id;2388        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2389            .ok_or(Error::<T>::TokenNotFound)?;23902391        item.variable_data = data;23922393        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23942395        Ok(())2396    }23972398    fn set_nft_variable_data(2399        collection: &CollectionHandle<T>,2400        item_id: TokenId,2401        data: Vec<u8>2402    ) -> DispatchResult {2403        let collection_id = collection.id;2404        let mut item = <NftItemList<T>>::get(collection_id, item_id)2405            .ok_or(Error::<T>::TokenNotFound)?;2406        2407        item.variable_data = data;24082409        <NftItemList<T>>::insert(collection_id, item_id, item);2410        2411        Ok(())2412    }24132414    #[allow(dead_code)]2415    fn init_collection(item: &Collection<T>) {2416        // check params2417        assert!(2418            item.decimal_points <= MAX_DECIMAL_POINTS,2419            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2420        );2421        assert!(2422            item.name.len() <= 64,2423            "Collection name can not be longer than 63 char"2424        );2425        assert!(2426            item.name.len() <= 256,2427            "Collection description can not be longer than 255 char"2428        );2429        assert!(2430            item.token_prefix.len() <= 16,2431            "Token prefix can not be longer than 15 char"2432        );24332434        // Generate next collection ID2435        let next_id = CreatedCollectionCount::get()2436            .checked_add(1)2437            .unwrap();24382439        CreatedCollectionCount::put(next_id);2440    }24412442    #[allow(dead_code)]2443    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2444        let current_index = <ItemListIndex>::get(collection_id)2445            .checked_add(1)2446            .unwrap();24472448        let item_owner = item.owner.clone();2449        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24502451        <ItemListIndex>::insert(collection_id, current_index);24522453        // Update balance2454        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2455            .checked_add(1)2456            .unwrap();2457        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2458    }24592460    #[allow(dead_code)]2461    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2462        let current_index = <ItemListIndex>::get(collection_id)2463            .checked_add(1)2464            .unwrap();24652466        Self::add_token_index(collection_id, current_index, owner).unwrap();24672468        <ItemListIndex>::insert(collection_id, current_index);24692470        // Update balance2471        let new_balance = <Balance<T>>::get(collection_id, owner)2472            .checked_add(item.value)2473            .unwrap();2474        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2475    }24762477    #[allow(dead_code)]2478    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2479        let current_index = <ItemListIndex>::get(collection_id)2480            .checked_add(1)2481            .unwrap();24822483        let value = item.owner.first().unwrap().fraction;2484        let owner = item.owner.first().unwrap().owner.clone();24852486        Self::add_token_index(collection_id, current_index, &owner).unwrap();24872488        <ItemListIndex>::insert(collection_id, current_index);24892490        // Update balance2491        let new_balance = <Balance<T>>::get(collection_id, &owner)2492            .checked_add(value)2493            .unwrap();2494        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2495    }24962497    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2498        // add to account limit2499        if <AccountItemCount<T>>::contains_key(owner) {25002501            // bound Owned tokens by a single address2502            let count = <AccountItemCount<T>>::get(owner);2503            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);25042505            <AccountItemCount<T>>::insert(owner.clone(), count2506                .checked_add(1)2507                .ok_or(Error::<T>::NumOverflow)?);2508        }2509        else {2510            <AccountItemCount<T>>::insert(owner.clone(), 1);2511        }25122513        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2514        if list_exists {2515            let mut list = <AddressTokens<T>>::get(collection_id, owner);2516            let item_contains = list.contains(&item_index.clone());25172518            if !item_contains {2519                list.push(item_index.clone());2520            }25212522            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2523        } else {2524            let mut itm = Vec::new();2525            itm.push(item_index.clone());2526            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2527        }25282529        Ok(())2530    }25312532    fn remove_token_index(2533        collection_id: CollectionId,2534        item_index: TokenId,2535        owner: &T::AccountId,2536    ) -> DispatchResult {25372538        // update counter2539        <AccountItemCount<T>>::insert(owner.clone(), 2540            <AccountItemCount<T>>::get(owner)2541            .checked_sub(1)2542            .ok_or(Error::<T>::NumOverflow)?);254325442545        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2546        if list_exists {2547            let mut list = <AddressTokens<T>>::get(collection_id, owner);2548            let item_contains = list.contains(&item_index.clone());25492550            if item_contains {2551                list.retain(|&item| item != item_index);2552                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2553            }2554        }25552556        Ok(())2557    }25582559    fn move_token_index(2560        collection_id: CollectionId,2561        item_index: TokenId,2562        old_owner: &T::AccountId,2563        new_owner: &T::AccountId,2564    ) -> DispatchResult {2565        Self::remove_token_index(collection_id, item_index, old_owner)?;2566        Self::add_token_index(collection_id, item_index, new_owner)?;25672568        Ok(())2569    }2570    2571    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2572        ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25732574        Ok(())2575    }2576}25772578////////////////////////////////////////////////////////////////////////////////////////////////////2579// Economic models2580// #region25812582/// Fee multiplier.2583pub type Multiplier = FixedU128;25842585type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25862587/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2588/// in the queue.2589#[derive(Encode, Decode, Clone, Eq, PartialEq)]2590pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25912592impl<T: Config + Send + Sync> sp_std::fmt::Debug 2593    for ChargeTransactionPayment<T>2594{2595	#[cfg(feature = "std")]2596	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2597		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2598	}2599	#[cfg(not(feature = "std"))]2600	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2601		Ok(())2602	}2603}26042605impl<T: Config> ChargeTransactionPayment<T>2606where2607    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2608    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2609    T::AccountId: AsRef<[u8]>,2610    T::AccountId: UncheckedFrom<T::Hash>,2611{2612    fn traditional_fee(2613        len: usize,2614        info: &DispatchInfoOf<T::Call>,2615        tip: BalanceOf<T>,2616    ) -> BalanceOf<T>2617    where2618        T::Call: Dispatchable<Info = DispatchInfo>,2619    {2620        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2621    }26222623	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2624        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2625        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2626        let len_saturation = max_block_length as u64 / (len as u64).max(1);2627        let coefficient: BalanceOf<T> = weight_saturation2628            .min(len_saturation)2629            .saturated_into::<BalanceOf<T>>();2630        final_fee2631            .saturating_mul(coefficient)2632            .saturated_into::<TransactionPriority>()2633    }26342635    fn withdraw_fee(2636        &self,2637        who: &T::AccountId,2638        call: &T::Call,2639        info: &DispatchInfoOf<T::Call>,2640        len: usize,2641	) -> Result<2642		(2643			BalanceOf<T>,2644			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2645		),2646		TransactionValidityError,2647	> {2648        let tip = self.0;26492650        let fee = Self::traditional_fee(len, info, tip);26512652        // Only mess with balances if fee is not zero.2653        if fee.is_zero() {2654            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2655			.map(|i| (fee, i));2656        }26572658        // Determine who is paying transaction fee based on ecnomic model2659        // Parse call to extract collection ID and access collection sponsor2660        let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2661            Some(Call::create_item(collection_id, _owner, _properties)) => {2662                let collection = <CollectionById<T>>::get(collection_id)?;26632664                // sponsor timeout2665                let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;26662667                let limit = collection.limits.sponsor_transfer_timeout;2668                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2669                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2670                    let limit_time = last_tx_block + limit.into();2671                    if block_number <= limit_time {2672                        return None;2673                    }2674                }2675                <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26762677                // check free create limit2678                if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2679                    collection.sponsorship.sponsor()2680                        .cloned()2681                } else {2682                    None2683                }2684            }2685            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2686                let collection = <CollectionById<T>>::get(collection_id)?;2687                2688                let mut sponsor_transfer = false;2689                if collection.sponsorship.confirmed() {26902691                    let collection_limits = collection.limits;2692                    let collection_mode = collection.mode;2693    2694                    // sponsor timeout2695                    let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;2696                    sponsor_transfer = match collection_mode {2697                        CollectionMode::NFT => {2698    2699                            // get correct limit2700                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2701                                collection_limits.sponsor_transfer_timeout2702                            } else {2703                                ChainLimit::get().nft_sponsor_transfer_timeout2704                            };2705    2706                            let mut sponsored = true;2707                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2708                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2709                                let limit_time = last_tx_block + limit.into();2710                                if block_number <= limit_time {2711                                    sponsored = false;2712                                }2713                            }2714                            if sponsored {2715                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2716                            }27172718                            sponsored2719                        }2720                        CollectionMode::Fungible(_) => {2721    2722                            // get correct limit2723                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2724                                collection_limits.sponsor_transfer_timeout2725                            } else {2726                                ChainLimit::get().fungible_sponsor_transfer_timeout2727                            };2728    2729                            let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;2730                            let mut sponsored = true;2731                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2732                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2733                                let limit_time = last_tx_block + limit.into();2734                                if block_number <= limit_time {2735                                    sponsored = false;2736                                }2737                            }2738                            if sponsored {2739                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2740                            }27412742                            sponsored2743                        }2744                        CollectionMode::ReFungible => {2745    2746                            // get correct limit2747                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2748                                collection_limits.sponsor_transfer_timeout2749                            } else {2750                                ChainLimit::get().refungible_sponsor_transfer_timeout2751                            };2752    2753                            let mut sponsored = true;2754                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2755                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2756                                let limit_time = last_tx_block + limit.into();2757                                if block_number <= limit_time {2758                                    sponsored = false;2759                                }2760                            }2761                            if sponsored {2762                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2763                            }27642765                            sponsored2766                        }2767                        _ => {2768                            false2769                        },2770                    };2771                }27722773                if !sponsor_transfer {2774                    None2775                } else {2776                    collection.sponsorship.sponsor()2777                        .cloned()2778                }2779            }27802781            Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2782                let mut sponsor_metadata_changes = false;27832784                let collection = <CollectionById<T>>::get(collection_id)?;27852786                if2787                    collection.sponsorship.confirmed() &&2788                    // Can't sponsor fungible collection, this tx will be rejected2789                    // as invalid2790                    !matches!(collection.mode, CollectionMode::Fungible(_)) &&2791                    data.len() <= collection.limits.sponsored_data_size as usize2792                {2793                    if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2794                        let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;27952796                        if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2797                            .map(|last_block| block_number - last_block > rate_limit)2798                            .unwrap_or(true) 2799                        {2800                            sponsor_metadata_changes = true;2801                            <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2802                        }2803                    }2804                }28052806                if !sponsor_metadata_changes {2807                    None2808                } else {2809                    collection.sponsorship.sponsor().cloned()2810                }2811            }28122813            _ => None,2814        })();28152816        match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2817            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28182819                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28202821                let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2822                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2823                  2824                if !owned_contract && white_list_enabled {2825                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2826                        return Err(InvalidTransaction::Call.into());2827                    }2828                }2829            },2830            _ => {},2831        }28322833        // Sponsor smart contracts2834        sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28352836            // On instantiation: set the contract owner2837            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28382839                let new_contract_address = <pallet_contracts::Pallet<T>>::contract_address(2840                    &who,2841                    code_hash,2842                    salt,2843                );2844                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28452846                None2847            },28482849            // On instantiation with code: set the contract owner2850            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {28512852                let new_contract_address = <pallet_contracts::Pallet<T>>::contract_address(2853                    &who,2854                    &T::Hashing::hash(&_code),2855                    _salt,2856                );28572858                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28592860                None2861            }28622863            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2864            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28652866                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28672868                let mut sponsor_transfer = false;2869                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2870                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2871                    let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;2872                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2873                    let limit_time = last_tx_block + rate_limit;28742875                    if block_number >= limit_time {2876                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2877                        sponsor_transfer = true;2878                    }2879                } else {2880                    sponsor_transfer = false;2881                }2882               2883                if sponsor_transfer {2884                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2885                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2886                            return Some(called_contract);2887                        }2888                    }2889                }28902891                None2892            },28932894            _ => None,2895        });28962897        let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28982899		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2900			.map(|i| (fee, i))2901    }2902}290329042905impl<T: Config + Send + Sync> SignedExtension2906    for ChargeTransactionPayment<T>2907where2908    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2909    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2910    T::AccountId: AsRef<[u8]>,2911    T::AccountId: UncheckedFrom<T::Hash>,2912{2913    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2914    type AccountId = T::AccountId;2915    type Call = T::Call;2916    type AdditionalSigned = ();2917    type Pre = (2918        // tip2919        BalanceOf<T>,2920        // who pays fee2921        Self::AccountId,2922		// imbalance resulting from withdrawing the fee2923		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2924    );2925    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2926        Ok(())2927    }29282929    fn validate(2930        &self,2931        who: &Self::AccountId,2932        call: &Self::Call,2933        info: &DispatchInfoOf<Self::Call>,2934        len: usize,2935    ) -> TransactionValidity {2936		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2937		Ok(ValidTransaction {2938			priority: Self::get_priority(len, info, fee),2939			..Default::default()2940		})2941    }29422943    fn pre_dispatch(2944        self,2945        who: &Self::AccountId,2946        call: &Self::Call,2947        info: &DispatchInfoOf<Self::Call>,2948        len: usize,2949    ) -> Result<Self::Pre, TransactionValidityError> {2950        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2951        Ok((self.0, who.clone(), imbalance))2952    }29532954    fn post_dispatch(2955        pre: Self::Pre,2956        info: &DispatchInfoOf<Self::Call>,2957        post_info: &PostDispatchInfoOf<Self::Call>,2958        len: usize,2959        _result: &DispatchResult,2960    ) -> Result<(), TransactionValidityError> {2961		let (tip, who, imbalance) = pre;2962		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2963			len as u32,2964			info,2965			post_info,2966			tip,2967		);2968		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2969		Ok(())2970    }2971}29722973// #endregion