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

1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use core::ops::{Deref, DerefMut};17use codec::{Decode, Encode};18pub use frame_support::{19    construct_runtime, decl_event, decl_module, decl_storage, decl_error,20    dispatch::DispatchResult,21    ensure, fail, parameter_types,22    traits::{23        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24        Randomness, IsSubType, WithdrawReasons,25    },26    weights::{27        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29        WeightToFeePolynomial, DispatchClass,30    },31    StorageValue,32    transactional,33};3435use frame_system::{self as system, ensure_signed, ensure_root};36use sp_runtime::sp_std::prelude::Vec;37use sp_runtime::{38    traits::{39        Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,40    },41    transaction_validity::{42        TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,43    },44    FixedPointOperand, FixedU128,45};46use sp_runtime::traits::StaticLookup;47use pallet_contracts::chain_extension::UncheckedFrom;48use pallet_transaction_payment::OnChargeTransaction;4950#[cfg(test)]51mod mock;5253#[cfg(test)]54mod tests;5556mod default_weights;5758pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;59pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;60pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;61pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6263// Structs64// #region6566pub type CollectionId = u32;67pub type TokenId = u32;68pub type DecimalPoints = u8;6970#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]71#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]72pub enum CollectionMode {73    Invalid,74    NFT,75    // decimal points76    Fungible(DecimalPoints),77    ReFungible,78}7980impl Default for CollectionMode {81    fn default() -> Self {82        Self::Invalid83    }84}8586impl Into<u8> for CollectionMode {87    fn into(self) -> u8 {88        match self {89            CollectionMode::Invalid => 0,90            CollectionMode::NFT => 1,91            CollectionMode::Fungible(_) => 2,92            CollectionMode::ReFungible => 3,93        }94    }95}9697#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]98#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]99pub enum AccessMode {100    Normal,101    WhiteList,102}103impl Default for AccessMode {104    fn default() -> Self {105        Self::Normal106    }107}108109#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]110#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]111pub enum SchemaVersion {112    ImageURL,113    Unique,114}115impl Default for SchemaVersion {116    fn default() -> Self {117        Self::ImageURL118    }119}120121#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]122#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]123pub struct Ownership<AccountId> {124    pub owner: AccountId,125    pub fraction: u128,126}127128#[derive(Encode, Decode, Debug, Clone, PartialEq)]129#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]130pub enum SponsorshipState<AccountId> {131    /// The fees are applied to the transaction sender132    Disabled,133    Unconfirmed(AccountId),134    /// Transactions are sponsored by specified account135    Confirmed(AccountId),136}137138impl<AccountId> SponsorshipState<AccountId> {139    fn sponsor(&self) -> Option<&AccountId> {140        match self {141            Self::Confirmed(sponsor) => Some(sponsor),142            _ => None,143        }144    }145146    fn pending_sponsor(&self) -> Option<&AccountId> {147        match self {148            Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),149            _ => None,150        }151    }152153    fn confirmed(&self) -> bool {154        matches!(self, Self::Confirmed(_))155    }156}157158impl<T> Default for SponsorshipState<T> {159    fn default() -> Self {160        Self::Disabled161    }162}163164#[derive(Encode, Decode, Clone, PartialEq)]165#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]166pub struct Collection<T: Config> {167    pub owner: T::AccountId,168    pub mode: CollectionMode,169    pub access: AccessMode,170    pub decimal_points: DecimalPoints,171    pub name: Vec<u16>,        // 64 include null escape char172    pub description: Vec<u16>, // 256 include null escape char173    pub token_prefix: Vec<u8>, // 16 include null escape char174    pub mint_mode: bool,175    pub offchain_schema: Vec<u8>,176    pub schema_version: SchemaVersion,177    pub sponsorship: SponsorshipState<AccountId>,178    pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 179    pub variable_on_chain_schema: Vec<u8>, //180    pub const_on_chain_schema: Vec<u8>, //181}182183pub struct CollectionHandle<T: Config> {184    pub id: CollectionId,185    collection: Collection<T>,186}187188impl<T: Config> Deref for CollectionHandle<T> {189    type Target = Collection<T>;190191    fn deref(&self) -> &Self::Target {192        &self.collection193    }194}195196impl<T: Config> DerefMut for CollectionHandle<T> {197    fn deref_mut(&mut self) -> &mut Self::Target {198        &mut self.collection199    }200}201202#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]203#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]204pub struct NftItemType<AccountId> {205    pub owner: AccountId,206    pub const_data: Vec<u8>,207    pub variable_data: Vec<u8>,208}209210#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]211#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]212pub struct FungibleItemType {213    pub value: u128,214}215216#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]217#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]218pub struct ReFungibleItemType<AccountId> {219    pub owner: Vec<Ownership<AccountId>>,220    pub const_data: Vec<u8>,221    pub variable_data: Vec<u8>,222}223224// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]225// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]226// pub struct VestingItem<AccountId, Moment> {227//     pub sender: AccountId,228//     pub recipient: AccountId,229//     pub collection_id: CollectionId,230//     pub item_id: TokenId,231//     pub amount: u64,232//     pub vesting_date: Moment,233// }234235#[derive(Encode, Decode, Debug, Clone, PartialEq)]236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]237pub struct CollectionLimits<BlockNumber: Encode + Decode> {238    pub account_token_ownership_limit: u32,239    pub sponsored_data_size: u32,240    /// None - setVariableMetadata is not sponsored241    /// Some(v) - setVariableMetadata is sponsored 242    ///           if there is v block between txs243    pub sponsored_data_rate_limit: Option<BlockNumber>,244    pub token_limit: u32,245246    // Timeouts for item types in passed blocks247    pub sponsor_transfer_timeout: u32,248    pub owner_can_transfer: bool,249    pub owner_can_destroy: bool,250}251252impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {253    fn default() -> Self {254        Self { 255            account_token_ownership_limit: 10_000_000, 256            token_limit: u32::max_value(),257            sponsored_data_size: u32::MAX, 258            sponsored_data_rate_limit: None,259            sponsor_transfer_timeout: 14400,260            owner_can_transfer: true,261            owner_can_destroy: true262        }263    }264}265266#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]267#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]268pub struct ChainLimits {269    pub collection_numbers_limit: u32,270    pub account_token_ownership_limit: u32,271    pub collections_admins_limit: u64,272    pub custom_data_limit: u32,273274    // Timeouts for item types in passed blocks275    pub nft_sponsor_transfer_timeout: u32,276    pub fungible_sponsor_transfer_timeout: u32,277    pub refungible_sponsor_transfer_timeout: u32,278279    // Schema limits280    pub offchain_schema_limit: u32,281    pub variable_on_chain_schema_limit: u32,282    pub const_on_chain_schema_limit: u32,283}284285pub trait WeightInfo {286	fn create_collection() -> Weight;287	fn destroy_collection() -> Weight;288	fn add_to_white_list() -> Weight;289	fn remove_from_white_list() -> Weight;290    fn set_public_access_mode() -> Weight;291    fn set_mint_permission() -> Weight;292    fn change_collection_owner() -> Weight;293    fn add_collection_admin() -> Weight;294    fn remove_collection_admin() -> Weight;295    fn set_collection_sponsor() -> Weight;296    fn confirm_sponsorship() -> Weight;297    fn remove_collection_sponsor() -> Weight;298    fn create_item(s: usize) -> Weight;299    fn burn_item() -> Weight;300    fn transfer() -> Weight;301    fn approve() -> Weight;302    fn transfer_from() -> Weight;303    fn set_offchain_schema() -> Weight;304    fn set_const_on_chain_schema() -> Weight;305    fn set_variable_on_chain_schema() -> Weight;306    fn set_variable_meta_data() -> Weight;307    fn enable_contract_sponsoring() -> Weight;308    fn set_schema_version() -> Weight;309    fn set_chain_limits() -> Weight;310    fn set_contract_sponsoring_rate_limit() -> Weight;311    fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;312    fn toggle_contract_white_list() -> Weight;313    fn add_to_contract_white_list() -> Weight;314    fn remove_from_contract_white_list() -> Weight;315    fn set_collection_limits() -> Weight;316}317318#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]319#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]320pub struct CreateNftData {321    pub const_data: Vec<u8>,322    pub variable_data: Vec<u8>,323}324325#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]326#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]327pub struct CreateFungibleData {328    pub value: u128,329}330331#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]332#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]333pub struct CreateReFungibleData {334    pub const_data: Vec<u8>,335    pub variable_data: Vec<u8>,336    pub pieces: u128,337}338339#[derive(Encode, Decode, Debug, Clone, PartialEq)]340#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]341pub enum CreateItemData {342    NFT(CreateNftData),343    Fungible(CreateFungibleData),344    ReFungible(CreateReFungibleData),345}346347impl CreateItemData {348    pub fn len(&self) -> usize {349        let len = match self {350            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),351            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),352            _ => 0353        };354        355        return len;356    }357}358359impl From<CreateNftData> for CreateItemData {360    fn from(item: CreateNftData) -> Self {361        CreateItemData::NFT(item)362    }363}364365impl From<CreateReFungibleData> for CreateItemData {366    fn from(item: CreateReFungibleData) -> Self {367        CreateItemData::ReFungible(item)368    }369}370371impl From<CreateFungibleData> for CreateItemData {372    fn from(item: CreateFungibleData) -> Self {373        CreateItemData::Fungible(item)374    }375}376377378decl_error! {379	/// Error for non-fungible-token module.380	pub enum Error for Module<T: Config> {381        /// Total collections bound exceeded.382        TotalCollectionsLimitExceeded,383		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.384        CollectionDecimalPointLimitExceeded, 385        /// Collection name can not be longer than 63 char.386        CollectionNameLimitExceeded, 387        /// Collection description can not be longer than 255 char.388        CollectionDescriptionLimitExceeded, 389        /// Token prefix can not be longer than 15 char.390        CollectionTokenPrefixLimitExceeded,391        /// This collection does not exist.392        CollectionNotFound,393        /// Item not exists.394        TokenNotFound,395        /// Admin not found396        AdminNotFound,397        /// Arithmetic calculation overflow.398        NumOverflow,       399        /// Account already has admin role.400        AlreadyAdmin,  401        /// You do not own this collection.402        NoPermission,403        /// This address is not set as sponsor, use setCollectionSponsor first.404        ConfirmUnsetSponsorFail,405        /// Collection is not in mint mode.406        PublicMintingNotAllowed,407        /// Sender parameter and item owner must be equal.408        MustBeTokenOwner,409        /// Item balance not enough.410        TokenValueTooLow,411        /// Size of item is too large.412        NftSizeLimitExceeded,413        /// No approve found414        ApproveNotFound,415        /// Requested value more than approved.416        TokenValueNotEnough,417        /// Only approved addresses can call this method.418        ApproveRequired,419        /// Address is not in white list.420        AddresNotInWhiteList,421        /// Number of collection admins bound exceeded.422        CollectionAdminsLimitExceeded,423        /// Owned tokens by a single address bound exceeded.424        AddressOwnershipLimitExceeded,425        /// Length of items properties must be greater than 0.426        EmptyArgument,427        /// const_data exceeded data limit.428        TokenConstDataLimitExceeded,429        /// variable_data exceeded data limit.430        TokenVariableDataLimitExceeded,431        /// Not NFT item data used to mint in NFT collection.432        NotNftDataUsedToMintNftCollectionToken,433        /// Not Fungible item data used to mint in Fungible collection.434        NotFungibleDataUsedToMintFungibleCollectionToken,435        /// Not Re Fungible item data used to mint in Re Fungible collection.436        NotReFungibleDataUsedToMintReFungibleCollectionToken,437        /// Unexpected collection type.438        UnexpectedCollectionType,439        /// Can't store metadata in fungible tokens.440        CantStoreMetadataInFungibleTokens,441        /// Collection token limit exceeded442        CollectionTokenLimitExceeded,443        /// Account token limit exceeded per collection444        AccountTokenLimitExceeded,445        /// Collection limit bounds per collection exceeded446        CollectionLimitBoundsExceeded,447        /// Tried to enable permissions which are only permitted to be disabled448        OwnerPermissionsCantBeReverted,449        /// Schema data size limit bound exceeded450        SchemaDataLimitExceeded,451        /// Maximum refungibility exceeded452        WrongRefungiblePieces,453        /// createRefungible should be called with one owner454        BadCreateRefungibleCall,455	}456}457458pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {459    type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;460461    /// Weight information for extrinsics in this pallet.462	type WeightInfo: WeightInfo;463464    type Currency: Currency<Self::AccountId>;465    type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;466    type TreasuryAccountId: Get<Self::AccountId>;467}468469#[cfg(feature = "runtime-benchmarks")]470mod benchmarking;471472// #endregion473474// # Used definitions475//476// ## User control levels477//478// chain-controlled - key is uncontrolled by user479//                    i.e autoincrementing index480//                    can use non-cryptographic hash481// real - key is controlled by user482//        but it is hard to generate enough colliding values, i.e owner of signed txs483//        can use non-cryptographic hash484// controlled - key is completly controlled by users485//              i.e maps with mutable keys486//              should use cryptographic hash487//488// ## User control level downgrade reasons489//490// ?1 - chain-controlled -> controlled491//      collections/tokens can be destroyed, resulting in massive holes492// ?2 - chain-controlled -> controlled493//      same as ?1, but can be only added, resulting in easier exploitation494// ?3 - real -> controlled495//      no confirmation required, so addresses can be easily generated496decl_storage! {497    trait Store for Module<T: Config> as Nft {498499        //#region Private members500        /// Id of next collection501        CreatedCollectionCount: u32;502        /// Used for migrations503        ChainVersion: u64;504        /// Id of last collection token505        /// Collection id (controlled?1)506        ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;507        //#endregion508509        //#region Chain limits struct510        pub ChainLimit get(fn chain_limit) config(): ChainLimits;511        //#endregion512513        //#region Bound counters514        /// Amount of collections destroyed, used for total amount tracking with515        /// CreatedCollectionCount516        DestroyedCollectionCount: u32;517        /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)518        /// Account id (real)519        pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;520        //#endregion521522        //#region Basic collections523        /// Collection info524        /// Collection id (controlled?1)525        pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;526        /// List of collection admins527        /// Collection id (controlled?2)528        pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;529        /// Whitelisted collection users530        /// Collection id (controlled?2), user id (controlled?3)531        pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;532        //#endregion533534        /// How many of collection items user have535        /// Collection id (controlled?2), account id (real)536        pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;537538        /// Amount of items which spender can transfer out of owners account (via transferFrom)539        /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))540        pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;541542        //#region Item collections543        /// Collection id (controlled?2), token id (controlled?1)544        pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;545        /// Collection id (controlled?2), owner (controlled?2)546        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;547        /// Collection id (controlled?2), token id (controlled?1)548        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;549        //#endregion550551        //#region Index list552        /// Collection id (controlled?2), tokens owner (controlled?2)553        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;554        //#endregion555556        //#region Tokens transfer rate limit baskets557        /// (Collection id (controlled?2), who created (real))558        pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;559        /// Collection id (controlled?2), token id (controlled?2)560        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;561        /// Collection id (controlled?2), owning user (real)562        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;563        /// Collection id (controlled?2), token id (controlled?2)564        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;565        //#endregion566567        /// Variable metadata sponsoring568        /// Collection id (controlled?2), token id (controlled?2)569        pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;570      571        //#region Contract Sponsorship and Ownership572        /// Contract address (real)573        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;574        /// Contract address (real)575        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;576        /// (Contract address(real), caller (real))577        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;578        /// Contract address (real)579        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;580        /// Contract address (real)581        pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 582        /// Contract address (real) => Whitelisted user (controlled?3)583        pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 584        //#endregion585    }586    add_extra_genesis {587        build(|config: &GenesisConfig<T>| {588            // Modification of storage589            for (_num, _c) in &config.collection_id {590                <Module<T>>::init_collection(_c);591            }592593            for (_num, _c, _i) in &config.nft_item_id {594                <Module<T>>::init_nft_token(*_c, _i);595            }596597            for (collection_id, account_id, fungible_item) in &config.fungible_item_id {598                <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);599            }600601            for (_num, _c, _i) in &config.refungible_item_id {602                <Module<T>>::init_refungible_token(*_c, _i);603            }604        })605    }606}607608decl_event!(609    pub enum Event<T>610    where611        AccountId = <T as system::Config>::AccountId,612    {613        /// New collection was created614        /// 615        /// # Arguments616        /// 617        /// * collection_id: Globally unique identifier of newly created collection.618        /// 619        /// * mode: [CollectionMode] converted into u8.620        /// 621        /// * account_id: Collection owner.622        Created(CollectionId, u8, AccountId),623624        /// New item was created.625        /// 626        /// # Arguments627        /// 628        /// * collection_id: Id of the collection where item was created.629        /// 630        /// * item_id: Id of an item. Unique within the collection.631        ///632        /// * recipient: Owner of newly created item 633        ItemCreated(CollectionId, TokenId, AccountId),634635        /// Collection item was burned.636        /// 637        /// # Arguments638        /// 639        /// collection_id.640        /// 641        /// item_id: Identifier of burned NFT.642        ItemDestroyed(CollectionId, TokenId),643644        /// Item was transferred645        ///646        /// * collection_id: Id of collection to which item is belong647        ///648        /// * item_id: Id of an item649        ///650        /// * sender: Original owner of item651        ///652        /// * recipient: New owner of item653        ///654        /// * amount: Always 1 for NFT655        Transfer(CollectionId, TokenId, AccountId, AccountId, u128),656    }657);658659decl_module! {660    pub struct Module<T: Config> for enum Call 661    where 662        origin: T::Origin663    {664        fn deposit_event() = default;665        type Error = Error<T>;666667        fn on_initialize(now: T::BlockNumber) -> Weight {668            0669        }670671        /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.672        /// 673        /// # Permissions674        /// 675        /// * Anyone.676        /// 677        /// # Arguments678        /// 679        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.680        /// 681        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.682        /// 683        /// * token_prefix: UTF-8 string with token prefix.684        /// 685        /// * mode: [CollectionMode] collection type and type dependent data.686        // returns collection ID687        #[weight = <T as Config>::WeightInfo::create_collection()]688        #[transactional]689        pub fn create_collection(origin,690                                 collection_name: Vec<u16>,691                                 collection_description: Vec<u16>,692                                 token_prefix: Vec<u8>,693                                 mode: CollectionMode) -> DispatchResult {694695            // Anyone can create a collection696            let who = ensure_signed(origin)?;697698            // Take a (non-refundable) deposit of collection creation699            let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();700            imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(701                &T::TreasuryAccountId::get(),702                T::CollectionCreationPrice::get(),703            ));704            <T as Config>::Currency::settle(705                &who,706                imbalance,707                WithdrawReasons::TRANSFER,708                ExistenceRequirement::KeepAlive,709            ).map_err(|_| Error::<T>::NoPermission)?;710711            let decimal_points = match mode {712                CollectionMode::Fungible(points) => points,713                _ => 0714            };715716            let chain_limit = ChainLimit::get();717718            let created_count = CreatedCollectionCount::get();719            let destroyed_count = DestroyedCollectionCount::get();720721            // bound Total number of collections722            ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);723724            // check params725            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);726            ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);727            ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);728            ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);729730            // Generate next collection ID731            let next_id = created_count732                .checked_add(1)733                .ok_or(Error::<T>::NumOverflow)?;734735            CreatedCollectionCount::put(next_id);736737            let limits = CollectionLimits {738                sponsored_data_size: chain_limit.custom_data_limit,739                ..Default::default()740            };741742            // Create new collection743            let new_collection = Collection {744                owner: who.clone(),745                name: collection_name,746                mode: mode.clone(),747                mint_mode: false,748                access: AccessMode::Normal,749                description: collection_description,750                decimal_points: decimal_points,751                token_prefix: token_prefix,752                offchain_schema: Vec::new(),753                schema_version: SchemaVersion::ImageURL,754                sponsorship: SponsorshipState::Disabled,755                variable_on_chain_schema: Vec::new(),756                const_on_chain_schema: Vec::new(),757                limits,758            };759760            // Add new collection to map761            <CollectionById<T>>::insert(next_id, new_collection);762763            // call event764            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));765766            Ok(())767        }768769        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.770        /// 771        /// # Permissions772        /// 773        /// * Collection Owner.774        /// 775        /// # Arguments776        /// 777        /// * collection_id: collection to destroy.778        #[weight = <T as Config>::WeightInfo::destroy_collection()]779        #[transactional]780        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {781782            let sender = ensure_signed(origin)?;783            let collection = Self::get_collection(collection_id)?;784            Self::check_owner_permissions(&collection, sender)?;785            if !collection.limits.owner_can_destroy {786                fail!(Error::<T>::NoPermission);787            }788789            <AddressTokens<T>>::remove_prefix(collection_id);790            <Allowances<T>>::remove_prefix(collection_id);791            <Balance<T>>::remove_prefix(collection_id);792            <ItemListIndex>::remove(collection_id);793            <AdminList<T>>::remove(collection_id);794            <CollectionById<T>>::remove(collection_id);795            <WhiteList<T>>::remove_prefix(collection_id);796797            <NftItemList<T>>::remove_prefix(collection_id);798            <FungibleItemList<T>>::remove_prefix(collection_id);799            <ReFungibleItemList<T>>::remove_prefix(collection_id);800801            <NftTransferBasket<T>>::remove_prefix(collection_id);802            <FungibleTransferBasket<T>>::remove_prefix(collection_id);803            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);804805            <VariableMetaDataBasket<T>>::remove_prefix(collection_id);806807            DestroyedCollectionCount::put(DestroyedCollectionCount::get()808                .checked_add(1)809                .ok_or(Error::<T>::NumOverflow)?);810811            Ok(())812        }813814        /// Add an address to white list.815        /// 816        /// # Permissions817        /// 818        /// * Collection Owner819        /// * Collection Admin820        /// 821        /// # Arguments822        /// 823        /// * collection_id.824        /// 825        /// * address.826        #[weight = <T as Config>::WeightInfo::add_to_white_list()]827        #[transactional]828        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{829830            let sender = ensure_signed(origin)?;831            let collection = Self::get_collection(collection_id)?;832            Self::check_owner_or_admin_permissions(&collection, sender)?;833834            <WhiteList<T>>::insert(collection_id, address, true);835            836            Ok(())837        }838839        /// Remove an address from white list.840        /// 841        /// # Permissions842        /// 843        /// * Collection Owner844        /// * Collection Admin845        /// 846        /// # Arguments847        /// 848        /// * collection_id.849        /// 850        /// * address.851        #[weight = <T as Config>::WeightInfo::remove_from_white_list()]852        #[transactional]853        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{854855            let sender = ensure_signed(origin)?;856            let collection = Self::get_collection(collection_id)?;857            Self::check_owner_or_admin_permissions(&collection, sender)?;858859            <WhiteList<T>>::remove(collection_id, address);860861            Ok(())862        }863864        /// Toggle between normal and white list access for the methods with access for `Anyone`.865        /// 866        /// # Permissions867        /// 868        /// * Collection Owner.869        /// 870        /// # Arguments871        /// 872        /// * collection_id.873        /// 874        /// * mode: [AccessMode]875        #[weight = <T as Config>::WeightInfo::set_public_access_mode()]876        #[transactional]877        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult878        {879            let sender = ensure_signed(origin)?;880881            let mut target_collection = Self::get_collection(collection_id)?;882            Self::check_owner_permissions(&target_collection, sender)?;883            target_collection.access = mode;884            Self::save_collection(target_collection);885886            Ok(())887        }888889        /// Allows Anyone to create tokens if:890        /// * White List is enabled, and891        /// * Address is added to white list, and892        /// * This method was called with True parameter893        /// 894        /// # Permissions895        /// * Collection Owner896        ///897        /// # Arguments898        /// 899        /// * collection_id.900        /// 901        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.902        #[weight = <T as Config>::WeightInfo::set_mint_permission()]903        #[transactional]904        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult905        {906            let sender = ensure_signed(origin)?;907908            let mut target_collection = Self::get_collection(collection_id)?;909            Self::check_owner_permissions(&target_collection, sender)?;910            target_collection.mint_mode = mint_permission;911            Self::save_collection(target_collection);912913            Ok(())914        }915916        /// Change the owner of the collection.917        /// 918        /// # Permissions919        /// 920        /// * Collection Owner.921        /// 922        /// # Arguments923        /// 924        /// * collection_id.925        /// 926        /// * new_owner.927        #[weight = <T as Config>::WeightInfo::change_collection_owner()]928        #[transactional]929        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {930931            let sender = ensure_signed(origin)?;932            let mut target_collection = Self::get_collection(collection_id)?;933            Self::check_owner_permissions(&target_collection, sender)?;934            target_collection.owner = new_owner;935            Self::save_collection(target_collection);936937            Ok(())938        }939940        /// Adds an admin of the Collection.941        /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership. 942        /// 943        /// # Permissions944        /// 945        /// * Collection Owner.946        /// * Collection Admin.947        /// 948        /// # Arguments949        /// 950        /// * collection_id: ID of the Collection to add admin for.951        /// 952        /// * new_admin_id: Address of new admin to add.953        #[weight = <T as Config>::WeightInfo::add_collection_admin()]954        #[transactional]955        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {956957            let sender = ensure_signed(origin)?;958            let collection = Self::get_collection(collection_id)?;959            Self::check_owner_or_admin_permissions(&collection, sender)?;960            let mut admin_arr: Vec<T::AccountId> = Vec::new();961962            if <AdminList<T>>::contains_key(collection_id)963            {964                admin_arr = <AdminList<T>>::get(collection_id);965                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);966            }967968            // Number of collection admins969            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);970971            admin_arr.push(new_admin_id);972            <AdminList<T>>::insert(collection_id, admin_arr);973974            Ok(())975        }976977        /// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.978        ///979        /// # Permissions980        /// 981        /// * Collection Owner.982        /// * Collection Admin.983        /// 984        /// # Arguments985        /// 986        /// * collection_id: ID of the Collection to remove admin for.987        /// 988        /// * account_id: Address of admin to remove.989        #[weight = <T as Config>::WeightInfo::remove_collection_admin()]990        #[transactional]991        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {992993            let sender = ensure_signed(origin)?;994            let collection = Self::get_collection(collection_id)?;995            Self::check_owner_or_admin_permissions(&collection, sender)?;996            ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);997998            let mut admin_arr = <AdminList<T>>::get(collection_id);999            admin_arr.retain(|i| *i != account_id);1000            <AdminList<T>>::insert(collection_id, admin_arr);10011002            Ok(())1003        }10041005        /// # Permissions1006        /// 1007        /// * Collection Owner1008        /// 1009        /// # Arguments1010        /// 1011        /// * collection_id.1012        /// 1013        /// * new_sponsor.1014        #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1015        #[transactional]1016        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10171018            let sender = ensure_signed(origin)?;1019            let mut target_collection = Self::get_collection(collection_id)?;1020            Self::check_owner_permissions(&target_collection, sender)?;10211022            target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1023            Self::save_collection(target_collection);10241025            Ok(())1026        }10271028        /// # Permissions1029        /// 1030        /// * Sponsor.1031        /// 1032        /// # Arguments1033        /// 1034        /// * collection_id.1035        #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1036        #[transactional]1037        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10381039            let sender = ensure_signed(origin)?;10401041            let mut target_collection = Self::get_collection(collection_id)?;1042            ensure!(1043                target_collection.sponsorship.pending_sponsor() == Some(&sender),1044                Error::<T>::ConfirmUnsetSponsorFail1045            );10461047            target_collection.sponsorship = SponsorshipState::Confirmed(sender);1048            Self::save_collection(target_collection);10491050            Ok(())1051        }10521053        /// Switch back to pay-per-own-transaction model.1054        ///1055        /// # Permissions1056        ///1057        /// * Collection owner.1058        /// 1059        /// # Arguments1060        /// 1061        /// * collection_id.1062        #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1063        #[transactional]1064        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10651066            let sender = ensure_signed(origin)?;10671068            let mut target_collection = Self::get_collection(collection_id)?;1069            Self::check_owner_permissions(&target_collection, sender)?;10701071            target_collection.sponsorship = SponsorshipState::Disabled;1072            Self::save_collection(target_collection);10731074            Ok(())1075        }10761077        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1078        /// 1079        /// # Permissions1080        /// 1081        /// * Collection Owner.1082        /// * Collection Admin.1083        /// * Anyone if1084        ///     * White List is enabled, and1085        ///     * Address is added to white list, and1086        ///     * MintPermission is enabled (see SetMintPermission method)1087        /// 1088        /// # Arguments1089        /// 1090        /// * collection_id: ID of the collection.1091        /// 1092        /// * owner: Address, initial owner of the NFT.1093        ///1094        /// * data: Token data to store on chain.1095        // #[weight =1096        // (130_000_000 as Weight)1097        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1098        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1099        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11001101        #[weight = <T as Config>::WeightInfo::create_item(data.len())]1102        #[transactional]1103        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11041105            let sender = ensure_signed(origin)?;11061107            let target_collection = Self::get_collection(collection_id)?;11081109            Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1110            Self::validate_create_item_args(&target_collection, &data)?;1111            Self::create_item_no_validation(&target_collection, owner, data)?;11121113            Ok(())1114        }11151116        /// This method creates multiple items in a collection created with CreateCollection method.1117        /// 1118        /// # Permissions1119        /// 1120        /// * Collection Owner.1121        /// * Collection Admin.1122        /// * Anyone if1123        ///     * White List is enabled, and1124        ///     * Address is added to white list, and1125        ///     * MintPermission is enabled (see SetMintPermission method)1126        /// 1127        /// # Arguments1128        /// 1129        /// * collection_id: ID of the collection.1130        /// 1131        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1132        /// 1133        /// * owner: Address, initial owner of the NFT.1134        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1135                               .map(|data| { data.len() })1136                               .sum())]1137        #[transactional]1138        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11391140            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1141            let sender = ensure_signed(origin)?;11421143            let target_collection = Self::get_collection(collection_id)?;11441145            Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11461147            for data in &items_data {1148                Self::validate_create_item_args(&target_collection, data)?;1149            }1150            for data in &items_data {1151                Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1152            }11531154            Ok(())1155        }11561157        /// Destroys a concrete instance of NFT.1158        /// 1159        /// # Permissions1160        /// 1161        /// * Collection Owner.1162        /// * Collection Admin.1163        /// * Current NFT Owner.1164        /// 1165        /// # Arguments1166        /// 1167        /// * collection_id: ID of the collection.1168        /// 1169        /// * item_id: ID of NFT to burn.1170        #[weight = <T as Config>::WeightInfo::burn_item()]1171        #[transactional]1172        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11731174            let sender = ensure_signed(origin)?;11751176            // Transfer permissions check1177            let target_collection = Self::get_collection(collection_id)?;1178            ensure!(1179                Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1180                (1181                    target_collection.limits.owner_can_transfer &&1182                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1183                ),1184                Error::<T>::NoPermission1185            );11861187            if target_collection.access == AccessMode::WhiteList {1188                Self::check_white_list(&target_collection, &sender)?;1189            }11901191            match target_collection.mode1192            {1193                CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1194                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, &target_collection, value)?,1195                CollectionMode::ReFungible  => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1196                _ => ()1197            };11981199            // call event1200            Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12011202            Ok(())1203        }12041205        /// Change ownership of the token.1206        /// 1207        /// # Permissions1208        /// 1209        /// * Collection Owner1210        /// * Collection Admin1211        /// * Current NFT owner1212        ///1213        /// # Arguments1214        /// 1215        /// * recipient: Address of token recipient.1216        /// 1217        /// * collection_id.1218        /// 1219        /// * item_id: ID of the item1220        ///     * Non-Fungible Mode: Required.1221        ///     * Fungible Mode: Ignored.1222        ///     * Re-Fungible Mode: Required.1223        /// 1224        /// * value: Amount to transfer.1225        ///     * Non-Fungible Mode: Ignored1226        ///     * Fungible Mode: Must specify transferred amount1227        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1228        #[weight = <T as Config>::WeightInfo::transfer()]1229        #[transactional]1230        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1231            let sender = ensure_signed(origin)?;1232            let collection = Self::get_collection(collection_id)?;12331234            Self::transfer_internal(sender, recipient, &collection, item_id, value)1235        }12361237        /// Set, change, or remove approved address to transfer the ownership of the NFT.1238        /// 1239        /// # Permissions1240        /// 1241        /// * Collection Owner1242        /// * Collection Admin1243        /// * Current NFT owner1244        /// 1245        /// # Arguments1246        /// 1247        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1248        /// 1249        /// * collection_id.1250        /// 1251        /// * item_id: ID of the item.1252        #[weight = <T as Config>::WeightInfo::approve()]1253        #[transactional]1254        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12551256            let sender = ensure_signed(origin)?;1257            let target_collection = Self::get_collection(collection_id)?;12581259            Self::token_exists(&target_collection, item_id, &sender)?;12601261            // Transfer permissions check1262            let bypasses_limits = target_collection.limits.owner_can_transfer &&1263                Self::is_owner_or_admin_permissions(1264                    &target_collection,1265                    sender.clone(),1266                );12671268            let allowance_limit = if bypasses_limits {1269                None1270            } else if let Some(amount) = Self::owned_amount(1271                sender.clone(),1272                &target_collection,1273                item_id,1274            ) {1275                Some(amount)1276            } else {1277                fail!(Error::<T>::NoPermission);1278            };12791280            if target_collection.access == AccessMode::WhiteList {1281                Self::check_white_list(&target_collection, &sender)?;1282                Self::check_white_list(&target_collection, &spender)?;1283            }12841285            let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1286            let mut allowance: u128 = amount;1287            if allowance_exists {1288                allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1289            }1290            if let Some(limit) = allowance_limit {1291                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1292            }1293            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12941295            Ok(())1296        }1297        1298        /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1299        /// 1300        /// # Permissions1301        /// * Collection Owner1302        /// * Collection Admin1303        /// * Current NFT owner1304        /// * Address approved by current NFT owner1305        /// 1306        /// # Arguments1307        /// 1308        /// * from: Address that owns token.1309        /// 1310        /// * recipient: Address of token recipient.1311        /// 1312        /// * collection_id.1313        /// 1314        /// * item_id: ID of the item.1315        /// 1316        /// * value: Amount to transfer.1317        #[weight = <T as Config>::WeightInfo::transfer_from()]1318        #[transactional]1319        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13201321            let sender = ensure_signed(origin)?;1322            let target_collection = Self::get_collection(collection_id)?;13231324            let mut appoved_transfer = false;13251326            // Check approval1327            let mut approval: u128 = 0;1328            if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1329                approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1330                ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1331                appoved_transfer = true;1332            }13331334            // Limits check1335            Self::is_correct_transfer(&target_collection, &recipient)?;13361337            // Transfer permissions check         1338            ensure!(1339                appoved_transfer || 1340                (1341                    target_collection.limits.owner_can_transfer &&1342                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1343                ),1344                Error::<T>::NoPermission1345            );13461347            if target_collection.access == AccessMode::WhiteList {1348                Self::check_white_list(&target_collection, &sender)?;1349                Self::check_white_list(&target_collection, &recipient)?;1350            }13511352            // Reduce approval by transferred amount or remove if remaining approval drops to 01353            if approval.saturating_sub(value) > 0 {1354                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1355            }1356            else {1357                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1358            }13591360            match target_collection.mode1361            {1362                CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from, recipient)?,1363                CollectionMode::Fungible(_)  => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1364                CollectionMode::ReFungible  => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient)?,1365                _ => ()1366            };13671368            Ok(())1369        }13701371        // #[weight = 0]1372        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13731374        //     // let no_perm_mes = "You do not have permissions to modify this collection";1375        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1376        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1377        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13781379        //     // // on_nft_received  call13801381        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;13821383        //     Ok(())1384        // }13851386        /// Set off-chain data schema.1387        /// 1388        /// # Permissions1389        /// 1390        /// * Collection Owner1391        /// * Collection Admin1392        /// 1393        /// # Arguments1394        /// 1395        /// * collection_id.1396        /// 1397        /// * schema: String representing the offchain data schema.1398        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1399        #[transactional]1400        pub fn set_variable_meta_data (1401            origin,1402            collection_id: CollectionId,1403            item_id: TokenId,1404            data: Vec<u8>1405        ) -> DispatchResult {1406            let sender = ensure_signed(origin)?;1407            1408            let target_collection = Self::get_collection(collection_id)?;1409            Self::token_exists(&target_collection, item_id, &sender)?;14101411            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14121413            // Modify permissions check1414            ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1415                Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1416                Error::<T>::NoPermission);14171418            match target_collection.mode1419            {1420                CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1421                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1422                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1423                _ => fail!(Error::<T>::UnexpectedCollectionType)1424            };14251426            Ok(())1427        }1428 1429        /// Set schema standard1430        /// ImageURL1431        /// Unique1432        /// 1433        /// # Permissions1434        /// 1435        /// * Collection Owner1436        /// * Collection Admin1437        /// 1438        /// # Arguments1439        /// 1440        /// * collection_id.1441        /// 1442        /// * schema: SchemaVersion: enum1443        #[weight = <T as Config>::WeightInfo::set_schema_version()]1444        #[transactional]1445        pub fn set_schema_version(1446            origin,1447            collection_id: CollectionId,1448            version: SchemaVersion1449        ) -> DispatchResult {1450            let sender = ensure_signed(origin)?;1451            let mut target_collection = Self::get_collection(collection_id)?;1452            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1453            target_collection.schema_version = version;1454            Self::save_collection(target_collection);14551456            Ok(())1457        }14581459        /// Set off-chain data schema.1460        /// 1461        /// # Permissions1462        /// 1463        /// * Collection Owner1464        /// * Collection Admin1465        /// 1466        /// # Arguments1467        /// 1468        /// * collection_id.1469        /// 1470        /// * schema: String representing the offchain data schema.1471        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1472        #[transactional]1473        pub fn set_offchain_schema(1474            origin,1475            collection_id: CollectionId,1476            schema: Vec<u8>1477        ) -> DispatchResult {1478            let sender = ensure_signed(origin)?;1479            let mut target_collection = Self::get_collection(collection_id)?;1480            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14811482            // check schema limit1483            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14841485            target_collection.offchain_schema = schema;1486            Self::save_collection(target_collection);14871488            Ok(())1489        }14901491        /// Set const on-chain data schema.1492        /// 1493        /// # Permissions1494        /// 1495        /// * Collection Owner1496        /// * Collection Admin1497        /// 1498        /// # Arguments1499        /// 1500        /// * collection_id.1501        /// 1502        /// * schema: String representing the const on-chain data schema.1503        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1504        #[transactional]1505        pub fn set_const_on_chain_schema (1506            origin,1507            collection_id: CollectionId,1508            schema: Vec<u8>1509        ) -> DispatchResult {1510            let sender = ensure_signed(origin)?;1511            let mut target_collection = Self::get_collection(collection_id)?;1512            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15131514            // check schema limit1515            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15161517            target_collection.const_on_chain_schema = schema;1518            Self::save_collection(target_collection);15191520            Ok(())1521        }15221523        /// Set variable on-chain data schema.1524        /// 1525        /// # Permissions1526        /// 1527        /// * Collection Owner1528        /// * Collection Admin1529        /// 1530        /// # Arguments1531        /// 1532        /// * collection_id.1533        /// 1534        /// * schema: String representing the variable on-chain data schema.1535        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1536        #[transactional]1537        pub fn set_variable_on_chain_schema (1538            origin,1539            collection_id: CollectionId,1540            schema: Vec<u8>1541        ) -> DispatchResult {1542            let sender = ensure_signed(origin)?;1543            let mut target_collection = Self::get_collection(collection_id)?;1544            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15451546            // check schema limit1547            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15481549            target_collection.variable_on_chain_schema = schema;1550            Self::save_collection(target_collection);15511552            Ok(())1553        }15541555        // Sudo permissions function1556        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1557        #[transactional]1558        pub fn set_chain_limits(1559            origin,1560            limits: ChainLimits1561        ) -> DispatchResult {15621563            #[cfg(not(feature = "runtime-benchmarks"))]1564            ensure_root(origin)?;15651566            <ChainLimit>::put(limits);1567            Ok(())1568        }15691570        /// Enable smart contract self-sponsoring.1571        /// 1572        /// # Permissions1573        /// 1574        /// * Contract Owner1575        /// 1576        /// # Arguments1577        /// 1578        /// * contract address1579        /// * enable flag1580        /// 1581        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1582        #[transactional]1583        pub fn enable_contract_sponsoring(1584            origin,1585            contract_address: T::AccountId,1586            enable: bool1587        ) -> DispatchResult {15881589            let sender = ensure_signed(origin)?;15901591            #[cfg(feature = "runtime-benchmarks")]1592            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15931594            Self::ensure_contract_owned(sender, &contract_address)?;15951596            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1597            Ok(())1598        }15991600        /// Set the rate limit for contract sponsoring to specified number of blocks.1601        /// 1602        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1603        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1604        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1605        /// from contract endowment if there are at least B blocks between such transactions. 1606        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1607        /// 1608        /// # Permissions1609        /// 1610        /// * Contract Owner1611        /// 1612        /// # Arguments1613        /// 1614        /// -`contract_address`: Address of the contract to sponsor1615        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1616        /// 1617        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1618        #[transactional]1619        pub fn set_contract_sponsoring_rate_limit(1620            origin,1621            contract_address: T::AccountId,1622            rate_limit: T::BlockNumber1623        ) -> DispatchResult {1624            let sender = ensure_signed(origin)?;16251626            #[cfg(feature = "runtime-benchmarks")]1627            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16281629            Self::ensure_contract_owned(sender, &contract_address)?;1630            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1631            Ok(())1632        }16331634        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1635        /// 1636        /// # Permissions1637        /// 1638        /// * Address that deployed smart contract.1639        /// 1640        /// # Arguments1641        /// 1642        /// -`contract_address`: Address of the contract.1643        /// 1644        /// - `enable`: .  1645        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1646        #[transactional]1647        pub fn toggle_contract_white_list(1648            origin,1649            contract_address: T::AccountId,1650            enable: bool1651        ) -> DispatchResult {1652            let sender = ensure_signed(origin)?;16531654            #[cfg(feature = "runtime-benchmarks")]1655            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16561657            Self::ensure_contract_owned(sender, &contract_address)?;1658            <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1659            Ok(())1660        }1661        1662        /// Add an address to smart contract white list.1663        /// 1664        /// # Permissions1665        /// 1666        /// * Address that deployed smart contract.1667        /// 1668        /// # Arguments1669        /// 1670        /// -`contract_address`: Address of the contract.1671        ///1672        /// -`account_address`: Address to add.1673        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1674        #[transactional]1675        pub fn add_to_contract_white_list(1676            origin,1677            contract_address: T::AccountId,1678            account_address: T::AccountId1679        ) -> DispatchResult {1680            let sender = ensure_signed(origin)?;16811682            #[cfg(feature = "runtime-benchmarks")]1683            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1684            1685            Self::ensure_contract_owned(sender, &contract_address)?;      1686            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1687            Ok(())1688        }16891690        /// Remove an address from smart contract white list.1691        /// 1692        /// # Permissions1693        /// 1694        /// * Address that deployed smart contract.1695        /// 1696        /// # Arguments1697        /// 1698        /// -`contract_address`: Address of the contract.1699        ///1700        /// -`account_address`: Address to remove.1701        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1702        #[transactional]1703        pub fn remove_from_contract_white_list(1704            origin,1705            contract_address: T::AccountId,1706            account_address: T::AccountId1707        ) -> DispatchResult {1708            let sender = ensure_signed(origin)?;17091710            #[cfg(feature = "runtime-benchmarks")]1711            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17121713            Self::ensure_contract_owned(sender, &contract_address)?;1714            <ContractWhiteList<T>>::remove(contract_address, account_address);1715            Ok(())1716        }17171718        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1719        #[transactional]1720        pub fn set_collection_limits(1721            origin,1722            collection_id: u32,1723            new_limits: CollectionLimits<T::BlockNumber>,1724        ) -> DispatchResult {1725            let sender = ensure_signed(origin)?;1726            let mut target_collection = Self::get_collection(collection_id)?;1727            Self::check_owner_permissions(&target_collection, sender.clone())?;1728            let old_limits = &target_collection.limits;1729            let chain_limits = ChainLimit::get();17301731            // collection bounds1732            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1733                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1734                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1735                Error::<T>::CollectionLimitBoundsExceeded);17361737            // token_limit   check  prev1738            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1739            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17401741            ensure!(1742                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1743                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1744                Error::<T>::OwnerPermissionsCantBeReverted,1745            );17461747            target_collection.limits = new_limits;1748            Self::save_collection(target_collection);17491750            Ok(())1751        } 1752    }1753}17541755impl<T: Config> Module<T> {17561757    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1758        // Limits check1759        Self::is_correct_transfer(target_collection, &recipient)?;17601761        // Transfer permissions check1762        ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1763            Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1764            Error::<T>::NoPermission);17651766        if target_collection.access == AccessMode::WhiteList {1767            Self::check_white_list(target_collection, &sender)?;1768            Self::check_white_list(target_collection, &recipient)?;1769        }17701771        match target_collection.mode1772        {1773            CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1774            CollectionMode::Fungible(_)  => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1775            CollectionMode::ReFungible  => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1776            _ => ()1777        };17781779        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17801781        Ok(())1782    }178317841785    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1786        let collection_id = collection.id;17871788        // check token limit and account token limit1789        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1790        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1791        1792        Ok(())1793    }17941795    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1796        let collection_id = collection.id;17971798        // check token limit and account token limit1799        let total_items: u32 = ItemListIndex::get(collection_id)1800            .checked_add(amount)1801            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1802        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1803            .checked_add(amount)1804            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1805        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1806        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);18071808        if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1809            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1810            Self::check_white_list(collection, owner)?;1811            Self::check_white_list(collection, sender)?;1812        }18131814        Ok(())1815    }18161817    fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1818        match target_collection.mode1819        {1820            CollectionMode::NFT => {1821                if let CreateItemData::NFT(data) = data {1822                    // check sizes1823                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1824                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1825                } else {1826                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1827                }1828            },1829            CollectionMode::Fungible(_) => {1830                if let CreateItemData::Fungible(_) = data {1831                } else {1832                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1833                }1834            },1835            CollectionMode::ReFungible => {1836                if let CreateItemData::ReFungible(data) = data {18371838                    // check sizes1839                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1840                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18411842                    // Check refungibility limits1843                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1844                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1845                } else {1846                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1847                }1848            },1849            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1850        };18511852        Ok(())1853    }18541855    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1856        let collection_id = collection.id;18571858        match data1859        {1860            CreateItemData::NFT(data) => {1861                let item = NftItemType {1862                    owner: owner.clone(),1863                    const_data: data.const_data,1864                    variable_data: data.variable_data1865                };18661867                Self::add_nft_item(collection, item)?;1868            },1869            CreateItemData::Fungible(data) => {1870                Self::add_fungible_item(collection, &owner, data.value)?;1871            },1872            CreateItemData::ReFungible(data) => {1873                let mut owner_list = Vec::new();1874                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18751876                let item = ReFungibleItemType {1877                    owner: owner_list,1878                    const_data: data.const_data,1879                    variable_data: data.variable_data1880                };18811882                Self::add_refungible_item(collection, item)?;1883            }1884        };18851886        Ok(())1887    }18881889    fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1890        let collection_id = collection.id;18911892        // Does new owner already have an account?1893        let mut balance: u128 = 0;1894        if <FungibleItemList<T>>::contains_key(collection_id, owner) {1895            balance = <FungibleItemList<T>>::get(collection_id, owner).value;1896        } 18971898        // Mint 1899        let item = FungibleItemType {1900            value: balance + value1901        };1902        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19031904        // Update balance1905        let new_balance = <Balance<T>>::get(collection_id, owner)1906            .checked_add(value)1907            .ok_or(Error::<T>::NumOverflow)?;1908        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19091910        Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1911        Ok(())1912    }19131914    fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1915        let collection_id = collection.id;19161917        let current_index = <ItemListIndex>::get(collection_id)1918            .checked_add(1)1919            .ok_or(Error::<T>::NumOverflow)?;1920        let itemcopy = item.clone();19211922        ensure!(1923            item.owner.len() == 1,1924            Error::<T>::BadCreateRefungibleCall,1925        );1926        let item_owner = item.owner.first().expect("only one owner is defined");19271928        let value = item_owner.fraction;1929        let owner = item_owner.owner.clone();19301931        Self::add_token_index(collection_id, current_index, &owner)?;19321933        <ItemListIndex>::insert(collection_id, current_index);1934        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19351936        // Update balance1937        let new_balance = <Balance<T>>::get(collection_id, &owner)1938            .checked_add(value)1939            .ok_or(Error::<T>::NumOverflow)?;1940        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19411942        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1943        Ok(())1944    }19451946    fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1947        let collection_id = collection.id;19481949        let current_index = <ItemListIndex>::get(collection_id)1950            .checked_add(1)1951            .ok_or(Error::<T>::NumOverflow)?;19521953        let item_owner = item.owner.clone();1954        Self::add_token_index(collection_id, current_index, &item.owner)?;19551956        <ItemListIndex>::insert(collection_id, current_index);1957        <NftItemList<T>>::insert(collection_id, current_index, item);19581959        // Update balance1960        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1961            .checked_add(1)1962            .ok_or(Error::<T>::NumOverflow)?;1963        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19641965        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1966        Ok(())1967    }19681969    fn burn_refungible_item(1970        collection: &CollectionHandle<T>,1971        item_id: TokenId,1972        owner: &T::AccountId,1973    ) -> DispatchResult {1974        let collection_id = collection.id;19751976        ensure!(1977            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1978            Error::<T>::TokenNotFound1979        );1980        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1981        let rft_balance = token1982            .owner1983            .iter()1984            .find(|&i| i.owner == *owner)1985            .ok_or(Error::<T>::TokenNotFound)?;1986        Self::remove_token_index(collection_id, item_id, owner)?;19871988        // update balance1989        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1990            .checked_sub(rft_balance.fraction)1991            .ok_or(Error::<T>::NumOverflow)?;1992        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19931994        // Re-create owners list with sender removed1995        let index = token1996            .owner1997            .iter()1998            .position(|i| i.owner == *owner)1999            .expect("owned item is exists");2000        token.owner.remove(index);2001        let owner_count = token.owner.len();20022003        // Burn the token completely if this was the last (only) owner2004        if owner_count == 0 {2005            <ReFungibleItemList<T>>::remove(collection_id, item_id);2006            <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2007        }2008        else {2009            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2010        }20112012        Ok(())2013    }20142015    fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2016        let collection_id = collection.id;20172018        ensure!(2019            <NftItemList<T>>::contains_key(collection_id, item_id),2020            Error::<T>::TokenNotFound2021        );2022        let item = <NftItemList<T>>::get(collection_id, item_id);2023        Self::remove_token_index(collection_id, item_id, &item.owner)?;20242025        // update balance2026        let new_balance = <Balance<T>>::get(collection_id, &item.owner)2027            .checked_sub(1)2028            .ok_or(Error::<T>::NumOverflow)?;2029        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2030        <NftItemList<T>>::remove(collection_id, item_id);2031        <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20322033        Ok(())2034    }20352036    fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2037        let collection_id = collection.id;20382039        ensure!(2040            <FungibleItemList<T>>::contains_key(collection_id, owner),2041            Error::<T>::TokenNotFound2042        );2043        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2044        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20452046        // update balance2047        let new_balance = <Balance<T>>::get(collection_id, owner)2048            .checked_sub(value)2049            .ok_or(Error::<T>::NumOverflow)?;2050        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20512052        if balance.value - value > 0 {2053            balance.value -= value;2054            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2055        }2056        else {2057            <FungibleItemList<T>>::remove(collection_id, owner);2058        }20592060        Ok(())2061    }20622063    pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2064        Ok(<CollectionById<T>>::get(collection_id)2065            .map(|collection| CollectionHandle {2066                id: collection_id,2067                collection2068            })2069            .ok_or(Error::<T>::CollectionNotFound)?)2070    }20712072    fn save_collection(collection: CollectionHandle<T>) {2073        <CollectionById<T>>::insert(collection.id, collection.collection);2074    }20752076    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2077        ensure!(2078            subject == target_collection.owner,2079            Error::<T>::NoPermission2080        );20812082        Ok(())2083    }20842085    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2086        let mut result: bool = subject == collection.owner;2087        let exists = <AdminList<T>>::contains_key(collection.id);20882089        if !result & exists {2090            if <AdminList<T>>::get(collection.id).contains(&subject) {2091                result = true2092            }2093        }20942095        result2096    }20972098    fn check_owner_or_admin_permissions(2099        collection: &CollectionHandle<T>,2100        subject: T::AccountId,2101    ) -> DispatchResult {2102        let result = Self::is_owner_or_admin_permissions(collection, subject.clone());21032104        ensure!(2105            result,2106            Error::<T>::NoPermission2107        );2108        Ok(())2109    }21102111    fn owned_amount(2112        subject: T::AccountId,2113        target_collection: &CollectionHandle<T>,2114        item_id: TokenId,2115    ) -> Option<u128> {2116        let collection_id = target_collection.id;21172118        match target_collection.mode {2119            CollectionMode::NFT => {2120                if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2121                    return Some(1)2122                }2123                None2124            },2125            CollectionMode::Fungible(_) => {2126                if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2127                    return Some(<FungibleItemList<T>>::get(collection_id, &subject)2128                        .value);2129                }2130                None2131            },2132            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2133                .owner2134                .iter()2135                .find(|i| i.owner == subject)2136                .map(|i| i.fraction),2137            CollectionMode::Invalid => None,2138        }2139    }21402141    fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2142        let collection_id = target_collection.id;21432144        match target_collection.mode {2145            CollectionMode::NFT => {2146                <NftItemList<T>>::get(collection_id, item_id).owner == subject2147            }2148            CollectionMode::Fungible(_) => {2149                <FungibleItemList<T>>::contains_key(collection_id, &subject)2150            }2151            CollectionMode::ReFungible => {2152                <ReFungibleItemList<T>>::get(collection_id, item_id)2153                    .owner2154                    .iter()2155                    .any(|i| i.owner == subject)2156            }2157            CollectionMode::Invalid => false,2158        }2159    }21602161    fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2162        let collection_id = collection.id;21632164        let mes = Error::<T>::AddresNotInWhiteList;2165        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21662167        Ok(())2168    }21692170    /// Check if token exists. In case of Fungible, check if there is an entry for 2171    /// the owner in fungible balances double map2172    fn token_exists(2173        target_collection: &CollectionHandle<T>,2174        item_id: TokenId,2175        owner: &T::AccountId2176    ) -> DispatchResult {2177        let collection_id = target_collection.id;2178        let exists = match target_collection.mode2179        {2180            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2181            CollectionMode::Fungible(_)  => <FungibleItemList<T>>::contains_key(collection_id, owner),2182            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2183            _ => false2184        };21852186        ensure!(exists == true, Error::<T>::TokenNotFound);2187        Ok(())2188    }21892190    fn transfer_fungible(2191        collection: &CollectionHandle<T>,2192        value: u128,2193        owner: &T::AccountId,2194        recipient: &T::AccountId,2195    ) -> DispatchResult {2196        let collection_id = collection.id;2197        Self::token_exists(&collection, 0, owner)?;21982199        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2200        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22012202        // Send balance to recipient (updates balanceOf of recipient)2203        Self::add_fungible_item(collection, recipient, value)?;22042205        // update balanceOf of sender2206        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22072208        // Reduce or remove sender2209        if balance.value == value {2210            <FungibleItemList<T>>::remove(collection_id, owner);2211        }2212        else {2213            balance.value -= value;2214            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2215        }22162217        Ok(())2218    }22192220    fn transfer_refungible(2221        collection: &CollectionHandle<T>,2222        item_id: TokenId,2223        value: u128,2224        owner: T::AccountId,2225        new_owner: T::AccountId,2226    ) -> DispatchResult {2227        let collection_id = collection.id;2228        Self::token_exists(collection, item_id, &owner)?;22292230        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2231        let item = full_item2232            .owner2233            .iter()2234            .filter(|i| i.owner == owner)2235            .next()2236            .ok_or(Error::<T>::TokenNotFound)?;2237        let amount = item.fraction;22382239        ensure!(amount >= value, Error::<T>::TokenValueTooLow);22402241        // update balance2242        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2243            .checked_sub(value)2244            .ok_or(Error::<T>::NumOverflow)?;2245        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22462247        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2248            .checked_add(value)2249            .ok_or(Error::<T>::NumOverflow)?;2250        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22512252        let old_owner = item.owner.clone();2253        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22542255        // transfer2256        if amount == value && !new_owner_has_account {2257            // change owner2258            // new owner do not have account2259            let mut new_full_item = full_item.clone();2260            new_full_item2261                .owner2262                .iter_mut()2263                .find(|i| i.owner == owner)2264                .expect("old owner does present in refungible")2265                .owner = new_owner.clone();2266            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22672268            // update index collection2269            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2270        } else {2271            let mut new_full_item = full_item.clone();2272            new_full_item2273                .owner2274                .iter_mut()2275                .find(|i| i.owner == owner)2276                .expect("old owner does present in refungible")2277                .fraction -= value;22782279            // separate amount2280            if new_owner_has_account {2281                // new owner has account2282                new_full_item2283                    .owner2284                    .iter_mut()2285                    .find(|i| i.owner == new_owner)2286                    .expect("new owner has account")2287                    .fraction += value;2288            } else {2289                // new owner do not have account2290                new_full_item.owner.push(Ownership {2291                    owner: new_owner.clone(),2292                    fraction: value,2293                });2294                Self::add_token_index(collection_id, item_id, &new_owner)?;2295            }22962297            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2298        }22992300        Ok(())2301    }23022303    fn transfer_nft(2304        collection: &CollectionHandle<T>,2305        item_id: TokenId,2306        sender: T::AccountId,2307        new_owner: T::AccountId,2308    ) -> DispatchResult {2309        let collection_id = collection.id;2310        Self::token_exists(&collection, item_id, &sender)?;23112312        let mut item = <NftItemList<T>>::get(collection_id, item_id);23132314        ensure!(2315            sender == item.owner,2316            Error::<T>::MustBeTokenOwner2317        );23182319        // update balance2320        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2321            .checked_sub(1)2322            .ok_or(Error::<T>::NumOverflow)?;2323        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23242325        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2326            .checked_add(1)2327            .ok_or(Error::<T>::NumOverflow)?;2328        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23292330        // change owner2331        let old_owner = item.owner.clone();2332        item.owner = new_owner.clone();2333        <NftItemList<T>>::insert(collection_id, item_id, item);23342335        // update index collection2336        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23372338        Ok(())2339    }2340    2341    fn set_re_fungible_variable_data(2342        collection: &CollectionHandle<T>,2343        item_id: TokenId,2344        data: Vec<u8>2345    ) -> DispatchResult {2346        let collection_id = collection.id;2347        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);23482349        item.variable_data = data;23502351        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23522353        Ok(())2354    }23552356    fn set_nft_variable_data(2357        collection: &CollectionHandle<T>,2358        item_id: TokenId,2359        data: Vec<u8>2360    ) -> DispatchResult {2361        let collection_id = collection.id;2362        let mut item = <NftItemList<T>>::get(collection_id, item_id);2363        2364        item.variable_data = data;23652366        <NftItemList<T>>::insert(collection_id, item_id, item);2367        2368        Ok(())2369    }23702371    fn init_collection(item: &Collection<T>) {2372        // check params2373        assert!(2374            item.decimal_points <= MAX_DECIMAL_POINTS,2375            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2376        );2377        assert!(2378            item.name.len() <= 64,2379            "Collection name can not be longer than 63 char"2380        );2381        assert!(2382            item.name.len() <= 256,2383            "Collection description can not be longer than 255 char"2384        );2385        assert!(2386            item.token_prefix.len() <= 16,2387            "Token prefix can not be longer than 15 char"2388        );23892390        // Generate next collection ID2391        let next_id = CreatedCollectionCount::get()2392            .checked_add(1)2393            .unwrap();23942395        CreatedCollectionCount::put(next_id);2396    }23972398    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2399        let current_index = <ItemListIndex>::get(collection_id)2400            .checked_add(1)2401            .unwrap();24022403        let item_owner = item.owner.clone();2404        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24052406        <ItemListIndex>::insert(collection_id, current_index);24072408        // Update balance2409        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2410            .checked_add(1)2411            .unwrap();2412        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2413    }24142415    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2416        let current_index = <ItemListIndex>::get(collection_id)2417            .checked_add(1)2418            .unwrap();24192420        Self::add_token_index(collection_id, current_index, owner).unwrap();24212422        <ItemListIndex>::insert(collection_id, current_index);24232424        // Update balance2425        let new_balance = <Balance<T>>::get(collection_id, owner)2426            .checked_add(item.value)2427            .unwrap();2428        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2429    }24302431    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2432        let current_index = <ItemListIndex>::get(collection_id)2433            .checked_add(1)2434            .unwrap();24352436        let value = item.owner.first().unwrap().fraction;2437        let owner = item.owner.first().unwrap().owner.clone();24382439        Self::add_token_index(collection_id, current_index, &owner).unwrap();24402441        <ItemListIndex>::insert(collection_id, current_index);24422443        // Update balance2444        let new_balance = <Balance<T>>::get(collection_id, &owner)2445            .checked_add(value)2446            .unwrap();2447        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2448    }24492450    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2451        // add to account limit2452        if <AccountItemCount<T>>::contains_key(owner) {24532454            // bound Owned tokens by a single address2455            let count = <AccountItemCount<T>>::get(owner);2456            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24572458            <AccountItemCount<T>>::insert(owner.clone(), count2459                .checked_add(1)2460                .ok_or(Error::<T>::NumOverflow)?);2461        }2462        else {2463            <AccountItemCount<T>>::insert(owner.clone(), 1);2464        }24652466        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2467        if list_exists {2468            let mut list = <AddressTokens<T>>::get(collection_id, owner);2469            let item_contains = list.contains(&item_index.clone());24702471            if !item_contains {2472                list.push(item_index.clone());2473            }24742475            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2476        } else {2477            let mut itm = Vec::new();2478            itm.push(item_index.clone());2479            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2480        }24812482        Ok(())2483    }24842485    fn remove_token_index(2486        collection_id: CollectionId,2487        item_index: TokenId,2488        owner: &T::AccountId,2489    ) -> DispatchResult {24902491        // update counter2492        <AccountItemCount<T>>::insert(owner.clone(), 2493            <AccountItemCount<T>>::get(owner)2494            .checked_sub(1)2495            .ok_or(Error::<T>::NumOverflow)?);249624972498        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2499        if list_exists {2500            let mut list = <AddressTokens<T>>::get(collection_id, owner);2501            let item_contains = list.contains(&item_index.clone());25022503            if item_contains {2504                list.retain(|&item| item != item_index);2505                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2506            }2507        }25082509        Ok(())2510    }25112512    fn move_token_index(2513        collection_id: CollectionId,2514        item_index: TokenId,2515        old_owner: &T::AccountId,2516        new_owner: &T::AccountId,2517    ) -> DispatchResult {2518        Self::remove_token_index(collection_id, item_index, old_owner)?;2519        Self::add_token_index(collection_id, item_index, new_owner)?;25202521        Ok(())2522    }2523    2524    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2525        if <ContractOwner<T>>::contains_key(contract.clone()) {2526            let owner = <ContractOwner<T>>::get(contract);2527            ensure!(account == owner, Error::<T>::NoPermission);2528        } else {2529            fail!(Error::<T>::NoPermission);2530        }25312532        Ok(())2533    }2534}25352536////////////////////////////////////////////////////////////////////////////////////////////////////2537// Economic models2538// #region25392540/// Fee multiplier.2541pub type Multiplier = FixedU128;25422543type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25442545/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2546/// in the queue.2547#[derive(Encode, Decode, Clone, Eq, PartialEq)]2548pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25492550impl<T: Config + Send + Sync> sp_std::fmt::Debug 2551    for ChargeTransactionPayment<T>2552{2553	#[cfg(feature = "std")]2554	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2555		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2556	}2557	#[cfg(not(feature = "std"))]2558	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2559		Ok(())2560	}2561}25622563impl<T: Config> ChargeTransactionPayment<T>2564where2565    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2566    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2567    T::AccountId: AsRef<[u8]>,2568    T::AccountId: UncheckedFrom<T::Hash>,2569{2570    fn traditional_fee(2571        len: usize,2572        info: &DispatchInfoOf<T::Call>,2573        tip: BalanceOf<T>,2574    ) -> BalanceOf<T>2575    where2576        T::Call: Dispatchable<Info = DispatchInfo>,2577    {2578        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2579    }25802581	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2582        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2583        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2584        let len_saturation = max_block_length as u64 / (len as u64).max(1);2585        let coefficient: BalanceOf<T> = weight_saturation2586            .min(len_saturation)2587            .saturated_into::<BalanceOf<T>>();2588        final_fee2589            .saturating_mul(coefficient)2590            .saturated_into::<TransactionPriority>()2591    }25922593    fn withdraw_fee(2594        &self,2595        who: &T::AccountId,2596        call: &T::Call,2597        info: &DispatchInfoOf<T::Call>,2598        len: usize,2599	) -> Result<2600		(2601			BalanceOf<T>,2602			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2603		),2604		TransactionValidityError,2605	> {2606        let tip = self.0;26072608        let fee = Self::traditional_fee(len, info, tip);26092610        // Only mess with balances if fee is not zero.2611        if fee.is_zero() {2612            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2613			.map(|i| (fee, i));2614        }26152616        // Determine who is paying transaction fee based on ecnomic model2617        // Parse call to extract collection ID and access collection sponsor2618        let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2619            Some(Call::create_item(collection_id, _owner, _properties)) => {2620                let collection = <CollectionById<T>>::get(collection_id)?;26212622                // sponsor timeout2623                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26242625                let collection = <Collection<T>>::get(collection_id);26262627                let limit = collection.limits.sponsor_transfer_timeout;2628                let mut sponsored = true;2629                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2630                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2631                    let limit_time = last_tx_block + limit.into();2632                    if block_number <= limit_time {2633                        return None;2634                    }2635                }2636                <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26372638                // check free create limit2639                if (collection.limits.sponsored_data_size >= (_properties.len() as u32)) &&2640                   (sponsored)2641                {2642                    collection.sponsorship.sponsor()2643                        .cloned()2644                } else {2645                    None2646                }2647            }2648            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2649                let collection = <CollectionById<T>>::get(collection_id)?;2650                2651                let mut sponsor_transfer = false;2652                if collection.sponsorship.confirmed() {26532654                    let collection_limits = collection.limits;2655                    let collection_mode = collection.mode;2656    2657                    // sponsor timeout2658                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2659                    sponsor_transfer = match collection_mode {2660                        CollectionMode::NFT => {2661    2662                            // get correct limit2663                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2664                                collection_limits.sponsor_transfer_timeout2665                            } else {2666                                ChainLimit::get().nft_sponsor_transfer_timeout2667                            };2668    2669                            let mut sponsored = true;2670                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2671                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2672                                let limit_time = last_tx_block + limit.into();2673                                if block_number <= limit_time {2674                                    sponsored = false;2675                                }2676                            }2677                            if sponsored {2678                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2679                            }26802681                            sponsored2682                        }2683                        CollectionMode::Fungible(_) => {2684    2685                            // get correct limit2686                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2687                                collection_limits.sponsor_transfer_timeout2688                            } else {2689                                ChainLimit::get().fungible_sponsor_transfer_timeout2690                            };2691    2692                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2693                            let mut sponsored = true;2694                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2695                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2696                                let limit_time = last_tx_block + limit.into();2697                                if block_number <= limit_time {2698                                    sponsored = false;2699                                }2700                            }2701                            if sponsored {2702                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2703                            }27042705                            sponsored2706                        }2707                        CollectionMode::ReFungible => {2708    2709                            // get correct limit2710                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2711                                collection_limits.sponsor_transfer_timeout2712                            } else {2713                                ChainLimit::get().refungible_sponsor_transfer_timeout2714                            };2715    2716                            let mut sponsored = true;2717                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2718                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2719                                let limit_time = last_tx_block + limit.into();2720                                if block_number <= limit_time {2721                                    sponsored = false;2722                                }2723                            }2724                            if sponsored {2725                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2726                            }27272728                            sponsored2729                        }2730                        _ => {2731                            false2732                        },2733                    };2734                }27352736                if !sponsor_transfer {2737                    None2738                } else {2739                    collection.sponsorship.sponsor()2740                        .cloned()2741                }2742            }27432744            Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2745                let mut sponsor_metadata_changes = false;27462747                let collection = <CollectionById<T>>::get(collection_id)?;27482749                if2750                    collection.sponsor_confirmed &&2751                    // Can't sponsor fungible collection, this tx will be rejected2752                    // as invalid2753                    !matches!(collection.mode, CollectionMode::Fungible(_)) &&2754                    data.len() <= collection.limits.sponsored_data_size as usize2755                {2756                    if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2757                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27582759                        if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2760                            .map(|last_block| block_number - last_block > rate_limit)2761                            .unwrap_or(true) 2762                        {2763                            sponsor_metadata_changes = true;2764                            <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2765                        }2766                    }2767                }27682769                if !sponsor_metadata_changes {2770                    None2771                } else {2772                    Some(collection.sponsor)2773                }2774            }27752776            _ => None,2777        })();27782779        match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2780            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27812782                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27832784                let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2785                  && <ContractOwner<T>>::get(called_contract.clone()) == *who;2786                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2787                  2788                if !owned_contract && white_list_enabled {2789                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2790                        return Err(InvalidTransaction::Call.into());2791                    }2792                }2793            },2794            _ => {},2795        }27962797        // Sponsor smart contracts2798        sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27992800            // On instantiation: set the contract owner2801            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28022803                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2804                    &who,2805                    code_hash,2806                    salt,2807                );2808                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28092810                None2811            },28122813            // On instantiation with code: set the contract owner2814            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {28152816                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2817                    &who,2818                    &T::Hashing::hash(&_code),2819                    _salt,2820                );28212822                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28232824                None2825            }28262827            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2828            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28292830                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28312832                let mut sponsor_transfer = false;2833                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2834                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2835                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2836                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2837                    let limit_time = last_tx_block + rate_limit;28382839                    if block_number >= limit_time {2840                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2841                        sponsor_transfer = true;2842                    }2843                } else {2844                    sponsor_transfer = false;2845                }2846               2847                if sponsor_transfer {2848                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2849                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2850                            return Some(called_contract);2851                        }2852                    }2853                }28542855                None2856            },28572858            _ => None,2859        });28602861        let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28622863		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2864			.map(|i| (fee, i))2865    }2866}286728682869impl<T: Config + Send + Sync> SignedExtension2870    for ChargeTransactionPayment<T>2871where2872    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2873    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2874    T::AccountId: AsRef<[u8]>,2875    T::AccountId: UncheckedFrom<T::Hash>,2876{2877    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2878    type AccountId = T::AccountId;2879    type Call = T::Call;2880    type AdditionalSigned = ();2881    type Pre = (2882        // tip2883        BalanceOf<T>,2884        // who pays fee2885        Self::AccountId,2886		// imbalance resulting from withdrawing the fee2887		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2888    );2889    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2890        Ok(())2891    }28922893    fn validate(2894        &self,2895        who: &Self::AccountId,2896        call: &Self::Call,2897        info: &DispatchInfoOf<Self::Call>,2898        len: usize,2899    ) -> TransactionValidity {2900		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2901		Ok(ValidTransaction {2902			priority: Self::get_priority(len, info, fee),2903			..Default::default()2904		})2905    }29062907    fn pre_dispatch(2908        self,2909        who: &Self::AccountId,2910        call: &Self::Call,2911        info: &DispatchInfoOf<Self::Call>,2912        len: usize,2913    ) -> Result<Self::Pre, TransactionValidityError> {2914        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2915        Ok((self.0, who.clone(), imbalance))2916    }29172918    fn post_dispatch(2919        pre: Self::Pre,2920        info: &DispatchInfoOf<Self::Call>,2921        post_info: &PostDispatchInfoOf<Self::Call>,2922        len: usize,2923        _result: &DispatchResult,2924    ) -> Result<(), TransactionValidityError> {2925		let (tip, who, imbalance) = pre;2926		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2927			len as u32,2928			info,2929			post_info,2930			tip,2931		);2932		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2933		Ok(())2934    }2935}29362937// #endregion