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

1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use core::ops::{Deref, DerefMut};17use codec::{Decode, Encode};18pub use frame_support::{19    construct_runtime, decl_event, decl_module, decl_storage, decl_error,20    dispatch::DispatchResult,21    ensure, fail, parameter_types,22    traits::{23        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24        Randomness, IsSubType, WithdrawReasons,25    },26    weights::{27        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29        WeightToFeePolynomial, DispatchClass,30    },31    StorageValue,32    transactional,33};3435use frame_system::{self as system, ensure_signed, ensure_root};36use sp_runtime::sp_std::prelude::Vec;37use sp_runtime::{38    traits::{39        Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,40    },41    transaction_validity::{42        TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,43    },44    FixedPointOperand, FixedU128,45};46use sp_runtime::traits::StaticLookup;47use pallet_contracts::chain_extension::UncheckedFrom;48use pallet_transaction_payment::OnChargeTransaction;4950#[cfg(test)]51mod mock;5253#[cfg(test)]54mod tests;5556mod default_weights;5758pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;59pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;60pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;61pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6263// Structs64// #region6566pub type CollectionId = u32;67pub type TokenId = u32;68pub type DecimalPoints = u8;6970#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]71#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]72pub enum CollectionMode {73    Invalid,74    NFT,75    // decimal points76    Fungible(DecimalPoints),77    ReFungible,78}7980impl Default for CollectionMode {81    fn default() -> Self {82        Self::Invalid83    }84}8586impl Into<u8> for CollectionMode {87    fn into(self) -> u8 {88        match self {89            CollectionMode::Invalid => 0,90            CollectionMode::NFT => 1,91            CollectionMode::Fungible(_) => 2,92            CollectionMode::ReFungible => 3,93        }94    }95}9697#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]98#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]99pub enum AccessMode {100    Normal,101    WhiteList,102}103impl Default for AccessMode {104    fn default() -> Self {105        Self::Normal106    }107}108109#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]110#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]111pub enum SchemaVersion {112    ImageURL,113    Unique,114}115impl Default for SchemaVersion {116    fn default() -> Self {117        Self::ImageURL118    }119}120121#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]122#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]123pub struct Ownership<AccountId> {124    pub owner: AccountId,125    pub fraction: u128,126}127128#[derive(Encode, Decode, Debug, Clone, PartialEq)]129#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]130pub enum SponsorshipState<AccountId> {131    /// The fees are applied to the transaction sender132    Disabled,133    Unconfirmed(AccountId),134    /// Transactions are sponsored by specified account135    Confirmed(AccountId),136}137138impl<AccountId> SponsorshipState<AccountId> {139    fn sponsor(&self) -> Option<&AccountId> {140        match self {141            Self::Confirmed(sponsor) => Some(sponsor),142            _ => None,143        }144    }145146    fn pending_sponsor(&self) -> Option<&AccountId> {147        match self {148            Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),149            _ => None,150        }151    }152153    fn confirmed(&self) -> bool {154        matches!(self, Self::Confirmed(_))155    }156}157158impl<T> Default for SponsorshipState<T> {159    fn default() -> Self {160        Self::Disabled161    }162}163164#[derive(Encode, Decode, Clone, PartialEq)]165#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]166pub struct Collection<T: Config> {167    pub owner: T::AccountId,168    pub mode: CollectionMode,169    pub access: AccessMode,170    pub decimal_points: DecimalPoints,171    pub name: Vec<u16>,        // 64 include null escape char172    pub description: Vec<u16>, // 256 include null escape char173    pub token_prefix: Vec<u8>, // 16 include null escape char174    pub mint_mode: bool,175    pub offchain_schema: Vec<u8>,176    pub schema_version: SchemaVersion,177    pub sponsorship: SponsorshipState<T::AccountId>,178    pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 179    pub variable_on_chain_schema: Vec<u8>, //180    pub const_on_chain_schema: Vec<u8>, //181}182183pub struct CollectionHandle<T: Config> {184    pub id: CollectionId,185    collection: Collection<T>,186}187188impl<T: Config> Deref for CollectionHandle<T> {189    type Target = Collection<T>;190191    fn deref(&self) -> &Self::Target {192        &self.collection193    }194}195196impl<T: Config> DerefMut for CollectionHandle<T> {197    fn deref_mut(&mut self) -> &mut Self::Target {198        &mut self.collection199    }200}201202#[derive(Encode, Decode, Debug, Clone, PartialEq)]203#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]204pub struct NftItemType<AccountId> {205    pub owner: AccountId,206    pub const_data: Vec<u8>,207    pub variable_data: Vec<u8>,208}209210#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]211#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]212pub struct FungibleItemType {213    pub value: u128,214}215216#[derive(Encode, Decode, Debug, Clone, PartialEq)]217#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]218pub struct ReFungibleItemType<AccountId> {219    pub owner: Vec<Ownership<AccountId>>,220    pub const_data: Vec<u8>,221    pub variable_data: Vec<u8>,222}223224// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]225// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]226// pub struct VestingItem<AccountId, Moment> {227//     pub sender: AccountId,228//     pub recipient: AccountId,229//     pub collection_id: CollectionId,230//     pub item_id: TokenId,231//     pub amount: u64,232//     pub vesting_date: Moment,233// }234235#[derive(Encode, Decode, Debug, Clone, PartialEq)]236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]237pub struct CollectionLimits<BlockNumber: Encode + Decode> {238    pub account_token_ownership_limit: u32,239    pub sponsored_data_size: u32,240    /// None - setVariableMetadata is not sponsored241    /// Some(v) - setVariableMetadata is sponsored 242    ///           if there is v block between txs243    pub sponsored_data_rate_limit: Option<BlockNumber>,244    pub token_limit: u32,245246    // Timeouts for item types in passed blocks247    pub sponsor_transfer_timeout: u32,248    pub owner_can_transfer: bool,249    pub owner_can_destroy: bool,250}251252impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {253    fn default() -> Self {254        Self { 255            account_token_ownership_limit: 10_000_000, 256            token_limit: u32::max_value(),257            sponsored_data_size: u32::MAX, 258            sponsored_data_rate_limit: None,259            sponsor_transfer_timeout: 14400,260            owner_can_transfer: true,261            owner_can_destroy: true262        }263    }264}265266#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]267#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]268pub struct ChainLimits {269    pub collection_numbers_limit: u32,270    pub account_token_ownership_limit: u32,271    pub collections_admins_limit: u64,272    pub custom_data_limit: u32,273274    // Timeouts for item types in passed blocks275    pub nft_sponsor_transfer_timeout: u32,276    pub fungible_sponsor_transfer_timeout: u32,277    pub refungible_sponsor_transfer_timeout: u32,278279    // Schema limits280    pub offchain_schema_limit: u32,281    pub variable_on_chain_schema_limit: u32,282    pub const_on_chain_schema_limit: u32,283}284285pub trait WeightInfo {286	fn create_collection() -> Weight;287	fn destroy_collection() -> Weight;288	fn add_to_white_list() -> Weight;289	fn remove_from_white_list() -> Weight;290    fn set_public_access_mode() -> Weight;291    fn set_mint_permission() -> Weight;292    fn change_collection_owner() -> Weight;293    fn add_collection_admin() -> Weight;294    fn remove_collection_admin() -> Weight;295    fn set_collection_sponsor() -> Weight;296    fn confirm_sponsorship() -> Weight;297    fn remove_collection_sponsor() -> Weight;298    fn create_item(s: usize) -> Weight;299    fn burn_item() -> Weight;300    fn transfer() -> Weight;301    fn approve() -> Weight;302    fn transfer_from() -> Weight;303    fn set_offchain_schema() -> Weight;304    fn set_const_on_chain_schema() -> Weight;305    fn set_variable_on_chain_schema() -> Weight;306    fn set_variable_meta_data() -> Weight;307    fn enable_contract_sponsoring() -> Weight;308    fn set_schema_version() -> Weight;309    fn set_chain_limits() -> Weight;310    fn set_contract_sponsoring_rate_limit() -> Weight;311    fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;312    fn toggle_contract_white_list() -> Weight;313    fn add_to_contract_white_list() -> Weight;314    fn remove_from_contract_white_list() -> Weight;315    fn set_collection_limits() -> Weight;316}317318#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]319#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]320pub struct CreateNftData {321    pub const_data: Vec<u8>,322    pub variable_data: Vec<u8>,323}324325#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]326#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]327pub struct CreateFungibleData {328    pub value: u128,329}330331#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]332#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]333pub struct CreateReFungibleData {334    pub const_data: Vec<u8>,335    pub variable_data: Vec<u8>,336    pub pieces: u128,337}338339#[derive(Encode, Decode, Debug, Clone, PartialEq)]340#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]341pub enum CreateItemData {342    NFT(CreateNftData),343    Fungible(CreateFungibleData),344    ReFungible(CreateReFungibleData),345}346347impl CreateItemData {348    pub fn len(&self) -> usize {349        let len = match self {350            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),351            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),352            _ => 0353        };354        355        return len;356    }357}358359impl From<CreateNftData> for CreateItemData {360    fn from(item: CreateNftData) -> Self {361        CreateItemData::NFT(item)362    }363}364365impl From<CreateReFungibleData> for CreateItemData {366    fn from(item: CreateReFungibleData) -> Self {367        CreateItemData::ReFungible(item)368    }369}370371impl From<CreateFungibleData> for CreateItemData {372    fn from(item: CreateFungibleData) -> Self {373        CreateItemData::Fungible(item)374    }375}376377378decl_error! {379	/// Error for non-fungible-token module.380	pub enum Error for Module<T: Config> {381        /// Total collections bound exceeded.382        TotalCollectionsLimitExceeded,383		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.384        CollectionDecimalPointLimitExceeded, 385        /// Collection name can not be longer than 63 char.386        CollectionNameLimitExceeded, 387        /// Collection description can not be longer than 255 char.388        CollectionDescriptionLimitExceeded, 389        /// Token prefix can not be longer than 15 char.390        CollectionTokenPrefixLimitExceeded,391        /// This collection does not exist.392        CollectionNotFound,393        /// Item not exists.394        TokenNotFound,395        /// Admin not found396        AdminNotFound,397        /// Arithmetic calculation overflow.398        NumOverflow,       399        /// Account already has admin role.400        AlreadyAdmin,  401        /// You do not own this collection.402        NoPermission,403        /// This address is not set as sponsor, use setCollectionSponsor first.404        ConfirmUnsetSponsorFail,405        /// Collection is not in mint mode.406        PublicMintingNotAllowed,407        /// Sender parameter and item owner must be equal.408        MustBeTokenOwner,409        /// Item balance not enough.410        TokenValueTooLow,411        /// Size of item is too large.412        NftSizeLimitExceeded,413        /// No approve found414        ApproveNotFound,415        /// Requested value more than approved.416        TokenValueNotEnough,417        /// Only approved addresses can call this method.418        ApproveRequired,419        /// Address is not in white list.420        AddresNotInWhiteList,421        /// Number of collection admins bound exceeded.422        CollectionAdminsLimitExceeded,423        /// Owned tokens by a single address bound exceeded.424        AddressOwnershipLimitExceeded,425        /// Length of items properties must be greater than 0.426        EmptyArgument,427        /// const_data exceeded data limit.428        TokenConstDataLimitExceeded,429        /// variable_data exceeded data limit.430        TokenVariableDataLimitExceeded,431        /// Not NFT item data used to mint in NFT collection.432        NotNftDataUsedToMintNftCollectionToken,433        /// Not Fungible item data used to mint in Fungible collection.434        NotFungibleDataUsedToMintFungibleCollectionToken,435        /// Not Re Fungible item data used to mint in Re Fungible collection.436        NotReFungibleDataUsedToMintReFungibleCollectionToken,437        /// Unexpected collection type.438        UnexpectedCollectionType,439        /// Can't store metadata in fungible tokens.440        CantStoreMetadataInFungibleTokens,441        /// Collection token limit exceeded442        CollectionTokenLimitExceeded,443        /// Account token limit exceeded per collection444        AccountTokenLimitExceeded,445        /// Collection limit bounds per collection exceeded446        CollectionLimitBoundsExceeded,447        /// Tried to enable permissions which are only permitted to be disabled448        OwnerPermissionsCantBeReverted,449        /// Schema data size limit bound exceeded450        SchemaDataLimitExceeded,451        /// Maximum refungibility exceeded452        WrongRefungiblePieces,453        /// createRefungible should be called with one owner454        BadCreateRefungibleCall,455	}456}457458pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {459    type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;460461    /// Weight information for extrinsics in this pallet.462	type WeightInfo: WeightInfo;463464    type Currency: Currency<Self::AccountId>;465    type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;466    type TreasuryAccountId: Get<Self::AccountId>;467}468469#[cfg(feature = "runtime-benchmarks")]470mod benchmarking;471472// #endregion473474// # Used definitions475//476// ## User control levels477//478// chain-controlled - key is uncontrolled by user479//                    i.e autoincrementing index480//                    can use non-cryptographic hash481// real - key is controlled by user482//        but it is hard to generate enough colliding values, i.e owner of signed txs483//        can use non-cryptographic hash484// controlled - key is completly controlled by users485//              i.e maps with mutable keys486//              should use cryptographic hash487//488// ## User control level downgrade reasons489//490// ?1 - chain-controlled -> controlled491//      collections/tokens can be destroyed, resulting in massive holes492// ?2 - chain-controlled -> controlled493//      same as ?1, but can be only added, resulting in easier exploitation494// ?3 - real -> controlled495//      no confirmation required, so addresses can be easily generated496decl_storage! {497    trait Store for Module<T: Config> as Nft {498499        //#region Private members500        /// Id of next collection501        CreatedCollectionCount: u32;502        /// Used for migrations503        ChainVersion: u64;504        /// Id of last collection token505        /// Collection id (controlled?1)506        ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;507        //#endregion508509        //#region Chain limits struct510        pub ChainLimit get(fn chain_limit) config(): ChainLimits;511        //#endregion512513        //#region Bound counters514        /// Amount of collections destroyed, used for total amount tracking with515        /// CreatedCollectionCount516        DestroyedCollectionCount: u32;517        /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)518        /// Account id (real)519        pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;520        //#endregion521522        //#region Basic collections523        /// Collection info524        /// Collection id (controlled?1)525        pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;526        /// List of collection admins527        /// Collection id (controlled?2)528        pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;529        /// Whitelisted collection users530        /// Collection id (controlled?2), user id (controlled?3)531        pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;532        //#endregion533534        /// How many of collection items user have535        /// Collection id (controlled?2), account id (real)536        pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;537538        /// Amount of items which spender can transfer out of owners account (via transferFrom)539        /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))540        /// TODO: Off chain worker should remove from this map when token gets removed541        pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;542543        //#region Item collections544        /// Collection id (controlled?2), token id (controlled?1)545        pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::AccountId>>;546        /// Collection id (controlled?2), owner (controlled?2)547        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;548        /// Collection id (controlled?2), token id (controlled?1)549        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::AccountId>>;550        //#endregion551552        //#region Index list553        /// Collection id (controlled?2), tokens owner (controlled?2)554        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;555        //#endregion556557        //#region Tokens transfer rate limit baskets558        /// (Collection id (controlled?2), who created (real))559        /// TODO: Off chain worker should remove from this map when collection gets removed560        pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;561        /// Collection id (controlled?2), token id (controlled?2)562        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;563        /// Collection id (controlled?2), owning user (real)564        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;565        /// Collection id (controlled?2), token id (controlled?2)566        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;567        //#endregion568569        /// Variable metadata sponsoring570        /// Collection id (controlled?2), token id (controlled?2)571        pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;572      573        //#region Contract Sponsorship and Ownership574        /// Contract address (real)575        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;576        /// Contract address (real)577        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;578        /// (Contract address(real), caller (real))579        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;580        /// Contract address (real)581        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;582        /// Contract address (real)583        pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 584        /// Contract address (real) => Whitelisted user (controlled?3)585        pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 586        //#endregion587    }588    add_extra_genesis {589        build(|config: &GenesisConfig<T>| {590            // Modification of storage591            for (_num, _c) in &config.collection_id {592                <Module<T>>::init_collection(_c);593            }594595            for (_num, _c, _i) in &config.nft_item_id {596                <Module<T>>::init_nft_token(*_c, _i);597            }598599            for (collection_id, account_id, fungible_item) in &config.fungible_item_id {600                <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);601            }602603            for (_num, _c, _i) in &config.refungible_item_id {604                <Module<T>>::init_refungible_token(*_c, _i);605            }606        })607    }608}609610decl_event!(611    pub enum Event<T>612    where613        AccountId = <T as system::Config>::AccountId,614    {615        /// New collection was created616        /// 617        /// # Arguments618        /// 619        /// * collection_id: Globally unique identifier of newly created collection.620        /// 621        /// * mode: [CollectionMode] converted into u8.622        /// 623        /// * account_id: Collection owner.624        CollectionCreated(CollectionId, u8, AccountId),625626        /// New item was created.627        /// 628        /// # Arguments629        /// 630        /// * collection_id: Id of the collection where item was created.631        /// 632        /// * item_id: Id of an item. Unique within the collection.633        ///634        /// * recipient: Owner of newly created item 635        ItemCreated(CollectionId, TokenId, AccountId),636637        /// Collection item was burned.638        /// 639        /// # Arguments640        /// 641        /// collection_id.642        /// 643        /// item_id: Identifier of burned NFT.644        ItemDestroyed(CollectionId, TokenId),645646        /// Item was transferred647        ///648        /// * collection_id: Id of collection to which item is belong649        ///650        /// * item_id: Id of an item651        ///652        /// * sender: Original owner of item653        ///654        /// * recipient: New owner of item655        ///656        /// * amount: Always 1 for NFT657        Transfer(CollectionId, TokenId, AccountId, AccountId, u128),658659        /// * collection_id660        ///661        /// * item_id662        ///663        /// * sender664        ///665        /// * spender666        ///667        /// * amount668        Approved(CollectionId, TokenId, AccountId, AccountId, u128),669    }670);671672decl_module! {673    pub struct Module<T: Config> for enum Call 674    where 675        origin: T::Origin676    {677        fn deposit_event() = default;678        type Error = Error<T>;679680        fn on_initialize(_now: T::BlockNumber) -> Weight {681            0682        }683684        /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.685        /// 686        /// # Permissions687        /// 688        /// * Anyone.689        /// 690        /// # Arguments691        /// 692        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.693        /// 694        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.695        /// 696        /// * token_prefix: UTF-8 string with token prefix.697        /// 698        /// * mode: [CollectionMode] collection type and type dependent data.699        // returns collection ID700        #[weight = <T as Config>::WeightInfo::create_collection()]701        #[transactional]702        pub fn create_collection(origin,703                                 collection_name: Vec<u16>,704                                 collection_description: Vec<u16>,705                                 token_prefix: Vec<u8>,706                                 mode: CollectionMode) -> DispatchResult {707708            // Anyone can create a collection709            let who = ensure_signed(origin)?;710711            // Take a (non-refundable) deposit of collection creation712            let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();713            imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(714                &T::TreasuryAccountId::get(),715                T::CollectionCreationPrice::get(),716            ));717            <T as Config>::Currency::settle(718                &who,719                imbalance,720                WithdrawReasons::TRANSFER,721                ExistenceRequirement::KeepAlive,722            ).map_err(|_| Error::<T>::NoPermission)?;723724            let decimal_points = match mode {725                CollectionMode::Fungible(points) => points,726                _ => 0727            };728729            let chain_limit = ChainLimit::get();730731            let created_count = CreatedCollectionCount::get();732            let destroyed_count = DestroyedCollectionCount::get();733734            // bound Total number of collections735            ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);736737            // check params738            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);739            ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);740            ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);741            ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);742743            // Generate next collection ID744            let next_id = created_count745                .checked_add(1)746                .ok_or(Error::<T>::NumOverflow)?;747748            CreatedCollectionCount::put(next_id);749750            let limits = CollectionLimits {751                sponsored_data_size: chain_limit.custom_data_limit,752                ..Default::default()753            };754755            // Create new collection756            let new_collection = Collection {757                owner: who.clone(),758                name: collection_name,759                mode: mode.clone(),760                mint_mode: false,761                access: AccessMode::Normal,762                description: collection_description,763                decimal_points: decimal_points,764                token_prefix: token_prefix,765                offchain_schema: Vec::new(),766                schema_version: SchemaVersion::ImageURL,767                sponsorship: SponsorshipState::Disabled,768                variable_on_chain_schema: Vec::new(),769                const_on_chain_schema: Vec::new(),770                limits,771            };772773            // Add new collection to map774            <CollectionById<T>>::insert(next_id, new_collection);775776            // call event777            Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who.clone()));778779            Ok(())780        }781782        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.783        /// 784        /// # Permissions785        /// 786        /// * Collection Owner.787        /// 788        /// # Arguments789        /// 790        /// * collection_id: collection to destroy.791        #[weight = <T as Config>::WeightInfo::destroy_collection()]792        #[transactional]793        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {794795            let sender = ensure_signed(origin)?;796            let collection = Self::get_collection(collection_id)?;797            Self::check_owner_permissions(&collection, sender)?;798            if !collection.limits.owner_can_destroy {799                fail!(Error::<T>::NoPermission);800            }801802            <AddressTokens<T>>::remove_prefix(collection_id);803            <Allowances<T>>::remove_prefix(collection_id);804            <Balance<T>>::remove_prefix(collection_id);805            <ItemListIndex>::remove(collection_id);806            <AdminList<T>>::remove(collection_id);807            <CollectionById<T>>::remove(collection_id);808            <WhiteList<T>>::remove_prefix(collection_id);809810            <NftItemList<T>>::remove_prefix(collection_id);811            <FungibleItemList<T>>::remove_prefix(collection_id);812            <ReFungibleItemList<T>>::remove_prefix(collection_id);813814            <NftTransferBasket<T>>::remove_prefix(collection_id);815            <FungibleTransferBasket<T>>::remove_prefix(collection_id);816            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);817818            <VariableMetaDataBasket<T>>::remove_prefix(collection_id);819820            DestroyedCollectionCount::put(DestroyedCollectionCount::get()821                .checked_add(1)822                .ok_or(Error::<T>::NumOverflow)?);823824            Ok(())825        }826827        /// Add an address to white list.828        /// 829        /// # Permissions830        /// 831        /// * Collection Owner832        /// * Collection Admin833        /// 834        /// # Arguments835        /// 836        /// * collection_id.837        /// 838        /// * address.839        #[weight = <T as Config>::WeightInfo::add_to_white_list()]840        #[transactional]841        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{842843            let sender = ensure_signed(origin)?;844            let collection = Self::get_collection(collection_id)?;845            Self::check_owner_or_admin_permissions(&collection, sender)?;846847            <WhiteList<T>>::insert(collection_id, address, true);848            849            Ok(())850        }851852        /// Remove an address from white list.853        /// 854        /// # Permissions855        /// 856        /// * Collection Owner857        /// * Collection Admin858        /// 859        /// # Arguments860        /// 861        /// * collection_id.862        /// 863        /// * address.864        #[weight = <T as Config>::WeightInfo::remove_from_white_list()]865        #[transactional]866        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{867868            let sender = ensure_signed(origin)?;869            let collection = Self::get_collection(collection_id)?;870            Self::check_owner_or_admin_permissions(&collection, sender)?;871872            <WhiteList<T>>::remove(collection_id, address);873874            Ok(())875        }876877        /// Toggle between normal and white list access for the methods with access for `Anyone`.878        /// 879        /// # Permissions880        /// 881        /// * Collection Owner.882        /// 883        /// # Arguments884        /// 885        /// * collection_id.886        /// 887        /// * mode: [AccessMode]888        #[weight = <T as Config>::WeightInfo::set_public_access_mode()]889        #[transactional]890        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult891        {892            let sender = ensure_signed(origin)?;893894            let mut target_collection = Self::get_collection(collection_id)?;895            Self::check_owner_permissions(&target_collection, sender)?;896            target_collection.access = mode;897            Self::save_collection(target_collection);898899            Ok(())900        }901902        /// Allows Anyone to create tokens if:903        /// * White List is enabled, and904        /// * Address is added to white list, and905        /// * This method was called with True parameter906        /// 907        /// # Permissions908        /// * Collection Owner909        ///910        /// # Arguments911        /// 912        /// * collection_id.913        /// 914        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.915        #[weight = <T as Config>::WeightInfo::set_mint_permission()]916        #[transactional]917        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult918        {919            let sender = ensure_signed(origin)?;920921            let mut target_collection = Self::get_collection(collection_id)?;922            Self::check_owner_permissions(&target_collection, sender)?;923            target_collection.mint_mode = mint_permission;924            Self::save_collection(target_collection);925926            Ok(())927        }928929        /// Change the owner of the collection.930        /// 931        /// # Permissions932        /// 933        /// * Collection Owner.934        /// 935        /// # Arguments936        /// 937        /// * collection_id.938        /// 939        /// * new_owner.940        #[weight = <T as Config>::WeightInfo::change_collection_owner()]941        #[transactional]942        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {943944            let sender = ensure_signed(origin)?;945            let mut target_collection = Self::get_collection(collection_id)?;946            Self::check_owner_permissions(&target_collection, sender)?;947            target_collection.owner = new_owner;948            Self::save_collection(target_collection);949950            Ok(())951        }952953        /// Adds an admin of the Collection.954        /// 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. 955        /// 956        /// # Permissions957        /// 958        /// * Collection Owner.959        /// * Collection Admin.960        /// 961        /// # Arguments962        /// 963        /// * collection_id: ID of the Collection to add admin for.964        /// 965        /// * new_admin_id: Address of new admin to add.966        #[weight = <T as Config>::WeightInfo::add_collection_admin()]967        #[transactional]968        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {969970            let sender = ensure_signed(origin)?;971            let collection = Self::get_collection(collection_id)?;972            Self::check_owner_or_admin_permissions(&collection, sender)?;973            let mut admin_arr = <AdminList<T>>::get(collection_id);974975            match admin_arr.binary_search(&new_admin_id) {976                Ok(_) => {},977                Err(idx) => {978                    let limits = ChainLimit::get();979                    ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);980                    admin_arr.insert(idx, new_admin_id);981                    <AdminList<T>>::insert(collection_id, admin_arr);982                }983            }984            Ok(())985        }986987        /// 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.988        ///989        /// # Permissions990        /// 991        /// * Collection Owner.992        /// * Collection Admin.993        /// 994        /// # Arguments995        /// 996        /// * collection_id: ID of the Collection to remove admin for.997        /// 998        /// * account_id: Address of admin to remove.999        #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1000        #[transactional]1001        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10021003            let sender = ensure_signed(origin)?;1004            let collection = Self::get_collection(collection_id)?;1005            Self::check_owner_or_admin_permissions(&collection, sender)?;1006            let mut admin_arr = <AdminList<T>>::get(collection_id);10071008            match admin_arr.binary_search(&account_id) {1009                Ok(idx) => {1010                    admin_arr.remove(idx);1011                    <AdminList<T>>::insert(collection_id, admin_arr);1012                },1013                Err(_) => {}1014            }1015            Ok(())1016        }10171018        /// # Permissions1019        /// 1020        /// * Collection Owner1021        /// 1022        /// # Arguments1023        /// 1024        /// * collection_id.1025        /// 1026        /// * new_sponsor.1027        #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1028        #[transactional]1029        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10301031            let sender = ensure_signed(origin)?;1032            let mut target_collection = Self::get_collection(collection_id)?;1033            Self::check_owner_permissions(&target_collection, sender)?;10341035            target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1036            Self::save_collection(target_collection);10371038            Ok(())1039        }10401041        /// # Permissions1042        /// 1043        /// * Sponsor.1044        /// 1045        /// # Arguments1046        /// 1047        /// * collection_id.1048        #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1049        #[transactional]1050        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10511052            let sender = ensure_signed(origin)?;10531054            let mut target_collection = Self::get_collection(collection_id)?;1055            ensure!(1056                target_collection.sponsorship.pending_sponsor() == Some(&sender),1057                Error::<T>::ConfirmUnsetSponsorFail1058            );10591060            target_collection.sponsorship = SponsorshipState::Confirmed(sender);1061            Self::save_collection(target_collection);10621063            Ok(())1064        }10651066        /// Switch back to pay-per-own-transaction model.1067        ///1068        /// # Permissions1069        ///1070        /// * Collection owner.1071        /// 1072        /// # Arguments1073        /// 1074        /// * collection_id.1075        #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1076        #[transactional]1077        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10781079            let sender = ensure_signed(origin)?;10801081            let mut target_collection = Self::get_collection(collection_id)?;1082            Self::check_owner_permissions(&target_collection, sender)?;10831084            target_collection.sponsorship = SponsorshipState::Disabled;1085            Self::save_collection(target_collection);10861087            Ok(())1088        }10891090        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1091        /// 1092        /// # Permissions1093        /// 1094        /// * Collection Owner.1095        /// * Collection Admin.1096        /// * Anyone if1097        ///     * White List is enabled, and1098        ///     * Address is added to white list, and1099        ///     * MintPermission is enabled (see SetMintPermission method)1100        /// 1101        /// # Arguments1102        /// 1103        /// * collection_id: ID of the collection.1104        /// 1105        /// * owner: Address, initial owner of the NFT.1106        ///1107        /// * data: Token data to store on chain.1108        // #[weight =1109        // (130_000_000 as Weight)1110        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1111        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1112        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11131114        #[weight = <T as Config>::WeightInfo::create_item(data.len())]1115        #[transactional]1116        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1117            let sender = ensure_signed(origin)?;1118            Self::create_item_internal(sender, collection_id, owner, data)1119        }11201121        /// This method creates multiple items in a collection created with CreateCollection method.1122        /// 1123        /// # Permissions1124        /// 1125        /// * Collection Owner.1126        /// * Collection Admin.1127        /// * Anyone if1128        ///     * White List is enabled, and1129        ///     * Address is added to white list, and1130        ///     * MintPermission is enabled (see SetMintPermission method)1131        /// 1132        /// # Arguments1133        /// 1134        /// * collection_id: ID of the collection.1135        /// 1136        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1137        /// 1138        /// * owner: Address, initial owner of the NFT.1139        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1140                               .map(|data| { data.len() })1141                               .sum())]1142        #[transactional]1143        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11441145            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1146            let sender = ensure_signed(origin)?;11471148            let target_collection = Self::get_collection(collection_id)?;11491150            Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11511152            for data in &items_data {1153                Self::validate_create_item_args(&target_collection, data)?;1154            }1155            for data in &items_data {1156                Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1157            }11581159            Ok(())1160        }11611162        /// Destroys a concrete instance of NFT.1163        /// 1164        /// # Permissions1165        /// 1166        /// * Collection Owner.1167        /// * Collection Admin.1168        /// * Current NFT Owner.1169        /// 1170        /// # Arguments1171        /// 1172        /// * collection_id: ID of the collection.1173        /// 1174        /// * item_id: ID of NFT to burn.1175        #[weight = <T as Config>::WeightInfo::burn_item()]1176        #[transactional]1177        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11781179            let sender = ensure_signed(origin)?;11801181            // Transfer permissions check1182            let target_collection = Self::get_collection(collection_id)?;1183            ensure!(1184                Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1185                (1186                    target_collection.limits.owner_can_transfer &&1187                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1188                ),1189                Error::<T>::NoPermission1190            );11911192            if target_collection.access == AccessMode::WhiteList {1193                Self::check_white_list(&target_collection, &sender)?;1194            }11951196            match target_collection.mode1197            {1198                CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1199                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, &target_collection, value)?,1200                CollectionMode::ReFungible  => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1201                _ => ()1202            };12031204            // call event1205            Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12061207            Ok(())1208        }12091210        /// Change ownership of the token.1211        /// 1212        /// # Permissions1213        /// 1214        /// * Collection Owner1215        /// * Collection Admin1216        /// * Current NFT owner1217        ///1218        /// # Arguments1219        /// 1220        /// * recipient: Address of token recipient.1221        /// 1222        /// * collection_id.1223        /// 1224        /// * item_id: ID of the item1225        ///     * Non-Fungible Mode: Required.1226        ///     * Fungible Mode: Ignored.1227        ///     * Re-Fungible Mode: Required.1228        /// 1229        /// * value: Amount to transfer.1230        ///     * Non-Fungible Mode: Ignored1231        ///     * Fungible Mode: Must specify transferred amount1232        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1233        #[weight = <T as Config>::WeightInfo::transfer()]1234        #[transactional]1235        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1236            let sender = ensure_signed(origin)?;1237            let collection = Self::get_collection(collection_id)?;12381239            Self::transfer_internal(sender, recipient, &collection, item_id, value)1240        }12411242        /// Set, change, or remove approved address to transfer the ownership of the NFT.1243        /// 1244        /// # Permissions1245        /// 1246        /// * Collection Owner1247        /// * Collection Admin1248        /// * Current NFT owner1249        /// 1250        /// # Arguments1251        /// 1252        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1253        /// 1254        /// * collection_id.1255        /// 1256        /// * item_id: ID of the item.1257        #[weight = <T as Config>::WeightInfo::approve()]1258        #[transactional]1259        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12601261            let sender = ensure_signed(origin)?;1262            let target_collection = Self::get_collection(collection_id)?;12631264            Self::token_exists(&target_collection, item_id)?;12651266            // Transfer permissions check1267            let bypasses_limits = target_collection.limits.owner_can_transfer &&1268                Self::is_owner_or_admin_permissions(1269                    &target_collection,1270                    sender.clone(),1271                );12721273            let allowance_limit = if bypasses_limits {1274                None1275            } else if let Some(amount) = Self::owned_amount(1276                sender.clone(),1277                &target_collection,1278                item_id,1279            ) {1280                Some(amount)1281            } else {1282                fail!(Error::<T>::NoPermission);1283            };12841285            if target_collection.access == AccessMode::WhiteList {1286                Self::check_white_list(&target_collection, &sender)?;1287                Self::check_white_list(&target_collection, &spender)?;1288            }12891290            let allowance: u128 = amount1291                .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1292                .ok_or(Error::<T>::NumOverflow)?;1293            if let Some(limit) = allowance_limit {1294                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1295            }1296            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12971298            Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1299            Ok(())1300        }1301        1302        /// 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.1303        /// 1304        /// # Permissions1305        /// * Collection Owner1306        /// * Collection Admin1307        /// * Current NFT owner1308        /// * Address approved by current NFT owner1309        /// 1310        /// # Arguments1311        /// 1312        /// * from: Address that owns token.1313        /// 1314        /// * recipient: Address of token recipient.1315        /// 1316        /// * collection_id.1317        /// 1318        /// * item_id: ID of the item.1319        /// 1320        /// * value: Amount to transfer.1321        #[weight = <T as Config>::WeightInfo::transfer_from()]1322        #[transactional]1323        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13241325            let sender = ensure_signed(origin)?;1326            let target_collection = Self::get_collection(collection_id)?;13271328            // Check approval1329            let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13301331            // Limits check1332            Self::is_correct_transfer(&target_collection, &recipient)?;13331334            // Transfer permissions check         1335            ensure!(1336                approval >= value || 1337                (1338                    target_collection.limits.owner_can_transfer &&1339                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1340                ),1341                Error::<T>::NoPermission1342            );13431344            if target_collection.access == AccessMode::WhiteList {1345                Self::check_white_list(&target_collection, &sender)?;1346                Self::check_white_list(&target_collection, &recipient)?;1347            }13481349            // Reduce approval by transferred amount or remove if remaining approval drops to 01350            if approval.saturating_sub(value) > 0 {1351                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1352            }1353            else {1354                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1355            }13561357            match target_collection.mode1358            {1359                CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1360                CollectionMode::Fungible(_)  => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1361                CollectionMode::ReFungible  => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1362                _ => ()1363            };13641365            Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1366            Ok(())1367        }13681369        // #[weight = 0]1370        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13711372        //     // let no_perm_mes = "You do not have permissions to modify this collection";1373        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1374        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1375        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13761377        //     // // on_nft_received  call13781379        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;13801381        //     Ok(())1382        // }13831384        /// Set off-chain data schema.1385        /// 1386        /// # Permissions1387        /// 1388        /// * Collection Owner1389        /// * Collection Admin1390        /// 1391        /// # Arguments1392        /// 1393        /// * collection_id.1394        /// 1395        /// * schema: String representing the offchain data schema.1396        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1397        #[transactional]1398        pub fn set_variable_meta_data (1399            origin,1400            collection_id: CollectionId,1401            item_id: TokenId,1402            data: Vec<u8>1403        ) -> DispatchResult {1404            let sender = ensure_signed(origin)?;1405            1406            let target_collection = Self::get_collection(collection_id)?;1407            Self::token_exists(&target_collection, item_id)?;14081409            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14101411            // Modify permissions check1412            ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1413                Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1414                Error::<T>::NoPermission);14151416            match target_collection.mode1417            {1418                CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1419                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1420                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1421                _ => fail!(Error::<T>::UnexpectedCollectionType)1422            };14231424            Ok(())1425        }1426 1427        /// Set schema standard1428        /// ImageURL1429        /// Unique1430        /// 1431        /// # Permissions1432        /// 1433        /// * Collection Owner1434        /// * Collection Admin1435        /// 1436        /// # Arguments1437        /// 1438        /// * collection_id.1439        /// 1440        /// * schema: SchemaVersion: enum1441        #[weight = <T as Config>::WeightInfo::set_schema_version()]1442        #[transactional]1443        pub fn set_schema_version(1444            origin,1445            collection_id: CollectionId,1446            version: SchemaVersion1447        ) -> DispatchResult {1448            let sender = ensure_signed(origin)?;1449            let mut target_collection = Self::get_collection(collection_id)?;1450            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1451            target_collection.schema_version = version;1452            Self::save_collection(target_collection);14531454            Ok(())1455        }14561457        /// Set off-chain data schema.1458        /// 1459        /// # Permissions1460        /// 1461        /// * Collection Owner1462        /// * Collection Admin1463        /// 1464        /// # Arguments1465        /// 1466        /// * collection_id.1467        /// 1468        /// * schema: String representing the offchain data schema.1469        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1470        #[transactional]1471        pub fn set_offchain_schema(1472            origin,1473            collection_id: CollectionId,1474            schema: Vec<u8>1475        ) -> DispatchResult {1476            let sender = ensure_signed(origin)?;1477            let mut target_collection = Self::get_collection(collection_id)?;1478            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14791480            // check schema limit1481            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14821483            target_collection.offchain_schema = schema;1484            Self::save_collection(target_collection);14851486            Ok(())1487        }14881489        /// Set const on-chain data schema.1490        /// 1491        /// # Permissions1492        /// 1493        /// * Collection Owner1494        /// * Collection Admin1495        /// 1496        /// # Arguments1497        /// 1498        /// * collection_id.1499        /// 1500        /// * schema: String representing the const on-chain data schema.1501        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1502        #[transactional]1503        pub fn set_const_on_chain_schema (1504            origin,1505            collection_id: CollectionId,1506            schema: Vec<u8>1507        ) -> DispatchResult {1508            let sender = ensure_signed(origin)?;1509            let mut target_collection = Self::get_collection(collection_id)?;1510            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15111512            // check schema limit1513            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15141515            target_collection.const_on_chain_schema = schema;1516            Self::save_collection(target_collection);15171518            Ok(())1519        }15201521        /// Set variable on-chain data schema.1522        /// 1523        /// # Permissions1524        /// 1525        /// * Collection Owner1526        /// * Collection Admin1527        /// 1528        /// # Arguments1529        /// 1530        /// * collection_id.1531        /// 1532        /// * schema: String representing the variable on-chain data schema.1533        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1534        #[transactional]1535        pub fn set_variable_on_chain_schema (1536            origin,1537            collection_id: CollectionId,1538            schema: Vec<u8>1539        ) -> DispatchResult {1540            let sender = ensure_signed(origin)?;1541            let mut target_collection = Self::get_collection(collection_id)?;1542            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15431544            // check schema limit1545            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15461547            target_collection.variable_on_chain_schema = schema;1548            Self::save_collection(target_collection);15491550            Ok(())1551        }15521553        // Sudo permissions function1554        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1555        #[transactional]1556        pub fn set_chain_limits(1557            origin,1558            limits: ChainLimits1559        ) -> DispatchResult {15601561            #[cfg(not(feature = "runtime-benchmarks"))]1562            ensure_root(origin)?;15631564            <ChainLimit>::put(limits);1565            Ok(())1566        }15671568        /// Enable smart contract self-sponsoring.1569        /// 1570        /// # Permissions1571        /// 1572        /// * Contract Owner1573        /// 1574        /// # Arguments1575        /// 1576        /// * contract address1577        /// * enable flag1578        /// 1579        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1580        #[transactional]1581        pub fn enable_contract_sponsoring(1582            origin,1583            contract_address: T::AccountId,1584            enable: bool1585        ) -> DispatchResult {15861587            let sender = ensure_signed(origin)?;15881589            #[cfg(feature = "runtime-benchmarks")]1590            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15911592            Self::ensure_contract_owned(sender, &contract_address)?;15931594            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1595            Ok(())1596        }15971598        /// Set the rate limit for contract sponsoring to specified number of blocks.1599        /// 1600        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1601        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1602        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1603        /// from contract endowment if there are at least B blocks between such transactions. 1604        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1605        /// 1606        /// # Permissions1607        /// 1608        /// * Contract Owner1609        /// 1610        /// # Arguments1611        /// 1612        /// -`contract_address`: Address of the contract to sponsor1613        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1614        /// 1615        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1616        #[transactional]1617        pub fn set_contract_sponsoring_rate_limit(1618            origin,1619            contract_address: T::AccountId,1620            rate_limit: T::BlockNumber1621        ) -> DispatchResult {1622            let sender = ensure_signed(origin)?;16231624            #[cfg(feature = "runtime-benchmarks")]1625            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16261627            Self::ensure_contract_owned(sender, &contract_address)?;1628            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1629            Ok(())1630        }16311632        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1633        /// 1634        /// # Permissions1635        /// 1636        /// * Address that deployed smart contract.1637        /// 1638        /// # Arguments1639        /// 1640        /// -`contract_address`: Address of the contract.1641        /// 1642        /// - `enable`: .  1643        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1644        #[transactional]1645        pub fn toggle_contract_white_list(1646            origin,1647            contract_address: T::AccountId,1648            enable: bool1649        ) -> DispatchResult {1650            let sender = ensure_signed(origin)?;16511652            #[cfg(feature = "runtime-benchmarks")]1653            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16541655            Self::ensure_contract_owned(sender, &contract_address)?;1656            if enable {1657                <ContractWhiteListEnabled<T>>::insert(contract_address, true);1658            } else {1659                <ContractWhiteListEnabled<T>>::remove(contract_address);1660            }1661            Ok(())1662        }1663        1664        /// Add an address to smart contract white list.1665        /// 1666        /// # Permissions1667        /// 1668        /// * Address that deployed smart contract.1669        /// 1670        /// # Arguments1671        /// 1672        /// -`contract_address`: Address of the contract.1673        ///1674        /// -`account_address`: Address to add.1675        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1676        #[transactional]1677        pub fn add_to_contract_white_list(1678            origin,1679            contract_address: T::AccountId,1680            account_address: T::AccountId1681        ) -> DispatchResult {1682            let sender = ensure_signed(origin)?;16831684            #[cfg(feature = "runtime-benchmarks")]1685            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1686            1687            Self::ensure_contract_owned(sender, &contract_address)?;      1688            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1689            Ok(())1690        }16911692        /// Remove an address from smart contract white list.1693        /// 1694        /// # Permissions1695        /// 1696        /// * Address that deployed smart contract.1697        /// 1698        /// # Arguments1699        /// 1700        /// -`contract_address`: Address of the contract.1701        ///1702        /// -`account_address`: Address to remove.1703        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1704        #[transactional]1705        pub fn remove_from_contract_white_list(1706            origin,1707            contract_address: T::AccountId,1708            account_address: T::AccountId1709        ) -> DispatchResult {1710            let sender = ensure_signed(origin)?;17111712            #[cfg(feature = "runtime-benchmarks")]1713            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17141715            Self::ensure_contract_owned(sender, &contract_address)?;1716            <ContractWhiteList<T>>::remove(contract_address, account_address);1717            Ok(())1718        }17191720        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1721        #[transactional]1722        pub fn set_collection_limits(1723            origin,1724            collection_id: u32,1725            new_limits: CollectionLimits<T::BlockNumber>,1726        ) -> DispatchResult {1727            let sender = ensure_signed(origin)?;1728            let mut target_collection = Self::get_collection(collection_id)?;1729            Self::check_owner_permissions(&target_collection, sender.clone())?;1730            let old_limits = &target_collection.limits;1731            let chain_limits = ChainLimit::get();17321733            // collection bounds1734            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1735                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1736                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1737                Error::<T>::CollectionLimitBoundsExceeded);17381739            // token_limit   check  prev1740            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1741            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17421743            ensure!(1744                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1745                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1746                Error::<T>::OwnerPermissionsCantBeReverted,1747            );17481749            target_collection.limits = new_limits;1750            Self::save_collection(target_collection);17511752            Ok(())1753        } 1754    }1755}17561757impl<T: Config> Module<T> {1758    pub fn create_item_internal(sender: T::AccountId, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1759        let target_collection = Self::get_collection(collection_id)?;17601761        Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1762        Self::validate_create_item_args(&target_collection, &data)?;1763        Self::create_item_no_validation(&target_collection, owner, data)?;17641765        Ok(())1766    }17671768    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1769        // Limits check1770        Self::is_correct_transfer(target_collection, &recipient)?;17711772        // Transfer permissions check1773        ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1774            Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1775            Error::<T>::NoPermission);17761777        if target_collection.access == AccessMode::WhiteList {1778            Self::check_white_list(target_collection, &sender)?;1779            Self::check_white_list(target_collection, &recipient)?;1780        }17811782        match target_collection.mode1783        {1784            CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1785            CollectionMode::Fungible(_)  => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1786            CollectionMode::ReFungible  => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1787            _ => ()1788        };17891790        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17911792        Ok(())1793    }179417951796    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1797        let collection_id = collection.id;17981799        // check token limit and account token limit1800        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1801        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1802        1803        Ok(())1804    }18051806    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1807        let collection_id = collection.id;18081809        // check token limit and account token limit1810        let total_items: u32 = ItemListIndex::get(collection_id)1811            .checked_add(amount)1812            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1813        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1814            .checked_add(amount)1815            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1816        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1817        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);18181819        if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1820            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1821            Self::check_white_list(collection, owner)?;1822            Self::check_white_list(collection, sender)?;1823        }18241825        Ok(())1826    }18271828    fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1829        match target_collection.mode1830        {1831            CollectionMode::NFT => {1832                if let CreateItemData::NFT(data) = data {1833                    // check sizes1834                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1835                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1836                } else {1837                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1838                }1839            },1840            CollectionMode::Fungible(_) => {1841                if let CreateItemData::Fungible(_) = data {1842                } else {1843                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1844                }1845            },1846            CollectionMode::ReFungible => {1847                if let CreateItemData::ReFungible(data) = data {18481849                    // check sizes1850                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1851                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18521853                    // Check refungibility limits1854                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1855                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1856                } else {1857                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1858                }1859            },1860            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1861        };18621863        Ok(())1864    }18651866    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1867        match data1868        {1869            CreateItemData::NFT(data) => {1870                let item = NftItemType {1871                    owner: owner.clone(),1872                    const_data: data.const_data,1873                    variable_data: data.variable_data1874                };18751876                Self::add_nft_item(collection, item)?;1877            },1878            CreateItemData::Fungible(data) => {1879                Self::add_fungible_item(collection, &owner, data.value)?;1880            },1881            CreateItemData::ReFungible(data) => {1882                let mut owner_list = Vec::new();1883                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18841885                let item = ReFungibleItemType {1886                    owner: owner_list,1887                    const_data: data.const_data,1888                    variable_data: data.variable_data1889                };18901891                Self::add_refungible_item(collection, item)?;1892            }1893        };18941895        Ok(())1896    }18971898    fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1899        let collection_id = collection.id;19001901        // Does new owner already have an account?1902        let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19031904        // Mint 1905        let item = FungibleItemType {1906            value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1907        };1908        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19091910        // Update balance1911        let new_balance = <Balance<T>>::get(collection_id, owner)1912            .checked_add(value)1913            .ok_or(Error::<T>::NumOverflow)?;1914        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19151916        Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1917        Ok(())1918    }19191920    fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1921        let collection_id = collection.id;19221923        let current_index = <ItemListIndex>::get(collection_id)1924            .checked_add(1)1925            .ok_or(Error::<T>::NumOverflow)?;1926        let itemcopy = item.clone();19271928        ensure!(1929            item.owner.len() == 1,1930            Error::<T>::BadCreateRefungibleCall,1931        );1932        let item_owner = item.owner.first().expect("only one owner is defined");19331934        let value = item_owner.fraction;1935        let owner = item_owner.owner.clone();19361937        Self::add_token_index(collection_id, current_index, &owner)?;19381939        <ItemListIndex>::insert(collection_id, current_index);1940        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19411942        // Update balance1943        let new_balance = <Balance<T>>::get(collection_id, &owner)1944            .checked_add(value)1945            .ok_or(Error::<T>::NumOverflow)?;1946        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19471948        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1949        Ok(())1950    }19511952    fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1953        let collection_id = collection.id;19541955        let current_index = <ItemListIndex>::get(collection_id)1956            .checked_add(1)1957            .ok_or(Error::<T>::NumOverflow)?;19581959        let item_owner = item.owner.clone();1960        Self::add_token_index(collection_id, current_index, &item.owner)?;19611962        <ItemListIndex>::insert(collection_id, current_index);1963        <NftItemList<T>>::insert(collection_id, current_index, item);19641965        // Update balance1966        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1967            .checked_add(1)1968            .ok_or(Error::<T>::NumOverflow)?;1969        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19701971        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1972        Ok(())1973    }19741975    fn burn_refungible_item(1976        collection: &CollectionHandle<T>,1977        item_id: TokenId,1978        owner: &T::AccountId,1979    ) -> DispatchResult {1980        let collection_id = collection.id;19811982        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1983            .ok_or(Error::<T>::TokenNotFound)?;1984        let rft_balance = token1985            .owner1986            .iter()1987            .find(|&i| i.owner == *owner)1988            .ok_or(Error::<T>::TokenNotFound)?;1989        Self::remove_token_index(collection_id, item_id, owner)?;19901991        // update balance1992        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1993            .checked_sub(rft_balance.fraction)1994            .ok_or(Error::<T>::NumOverflow)?;1995        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19961997        // Re-create owners list with sender removed1998        let index = token1999            .owner2000            .iter()2001            .position(|i| i.owner == *owner)2002            .expect("owned item is exists");2003        token.owner.remove(index);2004        let owner_count = token.owner.len();20052006        // Burn the token completely if this was the last (only) owner2007        if owner_count == 0 {2008            <ReFungibleItemList<T>>::remove(collection_id, item_id);2009            <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2010        }2011        else {2012            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2013        }20142015        Ok(())2016    }20172018    fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2019        let collection_id = collection.id;20202021        let item = <NftItemList<T>>::get(collection_id, item_id)2022            .ok_or(Error::<T>::TokenNotFound)?;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        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2040        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20412042        // update balance2043        let new_balance = <Balance<T>>::get(collection_id, owner)2044            .checked_sub(value)2045            .ok_or(Error::<T>::NumOverflow)?;2046        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20472048        if balance.value - value > 0 {2049            balance.value -= value;2050            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2051        }2052        else {2053            <FungibleItemList<T>>::remove(collection_id, owner);2054        }20552056        Ok(())2057    }20582059    pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2060        Ok(<CollectionById<T>>::get(collection_id)2061            .map(|collection| CollectionHandle {2062                id: collection_id,2063                collection2064            })2065            .ok_or(Error::<T>::CollectionNotFound)?)2066    }20672068    fn save_collection(collection: CollectionHandle<T>) {2069        <CollectionById<T>>::insert(collection.id, collection.collection);2070    }20712072    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2073        ensure!(2074            subject == target_collection.owner,2075            Error::<T>::NoPermission2076        );20772078        Ok(())2079    }20802081    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2082        subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2083    }20842085    fn check_owner_or_admin_permissions(2086        collection: &CollectionHandle<T>,2087        subject: T::AccountId,2088    ) -> DispatchResult {2089        ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);20902091        Ok(())2092    }20932094    fn owned_amount(2095        subject: T::AccountId,2096        target_collection: &CollectionHandle<T>,2097        item_id: TokenId,2098    ) -> Option<u128> {2099        let collection_id = target_collection.id;21002101        match target_collection.mode {2102            CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2103                .then(|| 1),2104            CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2105                .value),2106            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2107                .owner2108                .iter()2109                .find(|i| i.owner == subject)2110                .map(|i| i.fraction),2111            CollectionMode::Invalid => None,2112        }2113    }21142115    fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2116        match target_collection.mode {2117            CollectionMode::Fungible(_) => true,2118            _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2119        }2120    }21212122    fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2123        let collection_id = collection.id;21242125        let mes = Error::<T>::AddresNotInWhiteList;2126        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21272128        Ok(())2129    }21302131    /// Check if token exists. In case of Fungible, check if there is an entry for 2132    /// the owner in fungible balances double map2133    fn token_exists(2134        target_collection: &CollectionHandle<T>,2135        item_id: TokenId,2136    ) -> DispatchResult {2137        let collection_id = target_collection.id;2138        let exists = match target_collection.mode2139        {2140            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2141            CollectionMode::Fungible(_)  => true,2142            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2143            _ => false2144        };21452146        ensure!(exists == true, Error::<T>::TokenNotFound);2147        Ok(())2148    }21492150    fn transfer_fungible(2151        collection: &CollectionHandle<T>,2152        value: u128,2153        owner: &T::AccountId,2154        recipient: &T::AccountId,2155    ) -> DispatchResult {2156        let collection_id = collection.id;21572158        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2159        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21602161        // Send balance to recipient (updates balanceOf of recipient)2162        Self::add_fungible_item(collection, recipient, value)?;21632164        // update balanceOf of sender2165        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21662167        // Reduce or remove sender2168        if balance.value == value {2169            <FungibleItemList<T>>::remove(collection_id, owner);2170        }2171        else {2172            balance.value -= value;2173            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2174        }21752176        Ok(())2177    }21782179    fn transfer_refungible(2180        collection: &CollectionHandle<T>,2181        item_id: TokenId,2182        value: u128,2183        owner: T::AccountId,2184        new_owner: T::AccountId,2185    ) -> DispatchResult {2186        let collection_id = collection.id;2187        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2188            .ok_or(Error::<T>::TokenNotFound)?;21892190        let item = full_item2191            .owner2192            .iter()2193            .filter(|i| i.owner == owner)2194            .next()2195            .ok_or(Error::<T>::TokenNotFound)?;2196        let amount = item.fraction;21972198        ensure!(amount >= value, Error::<T>::TokenValueTooLow);21992200        // update balance2201        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2202            .checked_sub(value)2203            .ok_or(Error::<T>::NumOverflow)?;2204        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22052206        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2207            .checked_add(value)2208            .ok_or(Error::<T>::NumOverflow)?;2209        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22102211        let old_owner = item.owner.clone();2212        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22132214        // transfer2215        if amount == value && !new_owner_has_account {2216            // change owner2217            // new owner do not have account2218            let mut new_full_item = full_item.clone();2219            new_full_item2220                .owner2221                .iter_mut()2222                .find(|i| i.owner == owner)2223                .expect("old owner does present in refungible")2224                .owner = new_owner.clone();2225            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22262227            // update index collection2228            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2229        } else {2230            let mut new_full_item = full_item.clone();2231            new_full_item2232                .owner2233                .iter_mut()2234                .find(|i| i.owner == owner)2235                .expect("old owner does present in refungible")2236                .fraction -= value;22372238            // separate amount2239            if new_owner_has_account {2240                // new owner has account2241                new_full_item2242                    .owner2243                    .iter_mut()2244                    .find(|i| i.owner == new_owner)2245                    .expect("new owner has account")2246                    .fraction += value;2247            } else {2248                // new owner do not have account2249                new_full_item.owner.push(Ownership {2250                    owner: new_owner.clone(),2251                    fraction: value,2252                });2253                Self::add_token_index(collection_id, item_id, &new_owner)?;2254            }22552256            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2257        }22582259        Ok(())2260    }22612262    fn transfer_nft(2263        collection: &CollectionHandle<T>,2264        item_id: TokenId,2265        sender: T::AccountId,2266        new_owner: T::AccountId,2267    ) -> DispatchResult {2268        let collection_id = collection.id;2269        let mut item = <NftItemList<T>>::get(collection_id, item_id)2270            .ok_or(Error::<T>::TokenNotFound)?;22712272        ensure!(2273            sender == item.owner,2274            Error::<T>::MustBeTokenOwner2275        );22762277        // update balance2278        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2279            .checked_sub(1)2280            .ok_or(Error::<T>::NumOverflow)?;2281        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22822283        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2284            .checked_add(1)2285            .ok_or(Error::<T>::NumOverflow)?;2286        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22872288        // change owner2289        let old_owner = item.owner.clone();2290        item.owner = new_owner.clone();2291        <NftItemList<T>>::insert(collection_id, item_id, item);22922293        // update index collection2294        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22952296        Ok(())2297    }2298    2299    fn set_re_fungible_variable_data(2300        collection: &CollectionHandle<T>,2301        item_id: TokenId,2302        data: Vec<u8>2303    ) -> DispatchResult {2304        let collection_id = collection.id;2305        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2306            .ok_or(Error::<T>::TokenNotFound)?;23072308        item.variable_data = data;23092310        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23112312        Ok(())2313    }23142315    fn set_nft_variable_data(2316        collection: &CollectionHandle<T>,2317        item_id: TokenId,2318        data: Vec<u8>2319    ) -> DispatchResult {2320        let collection_id = collection.id;2321        let mut item = <NftItemList<T>>::get(collection_id, item_id)2322            .ok_or(Error::<T>::TokenNotFound)?;2323        2324        item.variable_data = data;23252326        <NftItemList<T>>::insert(collection_id, item_id, item);2327        2328        Ok(())2329    }23302331    #[allow(dead_code)]2332    fn init_collection(item: &Collection<T>) {2333        // check params2334        assert!(2335            item.decimal_points <= MAX_DECIMAL_POINTS,2336            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2337        );2338        assert!(2339            item.name.len() <= 64,2340            "Collection name can not be longer than 63 char"2341        );2342        assert!(2343            item.name.len() <= 256,2344            "Collection description can not be longer than 255 char"2345        );2346        assert!(2347            item.token_prefix.len() <= 16,2348            "Token prefix can not be longer than 15 char"2349        );23502351        // Generate next collection ID2352        let next_id = CreatedCollectionCount::get()2353            .checked_add(1)2354            .unwrap();23552356        CreatedCollectionCount::put(next_id);2357    }23582359    #[allow(dead_code)]2360    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2361        let current_index = <ItemListIndex>::get(collection_id)2362            .checked_add(1)2363            .unwrap();23642365        let item_owner = item.owner.clone();2366        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23672368        <ItemListIndex>::insert(collection_id, current_index);23692370        // Update balance2371        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2372            .checked_add(1)2373            .unwrap();2374        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2375    }23762377    #[allow(dead_code)]2378    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2379        let current_index = <ItemListIndex>::get(collection_id)2380            .checked_add(1)2381            .unwrap();23822383        Self::add_token_index(collection_id, current_index, owner).unwrap();23842385        <ItemListIndex>::insert(collection_id, current_index);23862387        // Update balance2388        let new_balance = <Balance<T>>::get(collection_id, owner)2389            .checked_add(item.value)2390            .unwrap();2391        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2392    }23932394    #[allow(dead_code)]2395    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2396        let current_index = <ItemListIndex>::get(collection_id)2397            .checked_add(1)2398            .unwrap();23992400        let value = item.owner.first().unwrap().fraction;2401        let owner = item.owner.first().unwrap().owner.clone();24022403        Self::add_token_index(collection_id, current_index, &owner).unwrap();24042405        <ItemListIndex>::insert(collection_id, current_index);24062407        // Update balance2408        let new_balance = <Balance<T>>::get(collection_id, &owner)2409            .checked_add(value)2410            .unwrap();2411        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2412    }24132414    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2415        // add to account limit2416        if <AccountItemCount<T>>::contains_key(owner) {24172418            // bound Owned tokens by a single address2419            let count = <AccountItemCount<T>>::get(owner);2420            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24212422            <AccountItemCount<T>>::insert(owner.clone(), count2423                .checked_add(1)2424                .ok_or(Error::<T>::NumOverflow)?);2425        }2426        else {2427            <AccountItemCount<T>>::insert(owner.clone(), 1);2428        }24292430        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2431        if list_exists {2432            let mut list = <AddressTokens<T>>::get(collection_id, owner);2433            let item_contains = list.contains(&item_index.clone());24342435            if !item_contains {2436                list.push(item_index.clone());2437            }24382439            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2440        } else {2441            let mut itm = Vec::new();2442            itm.push(item_index.clone());2443            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2444        }24452446        Ok(())2447    }24482449    fn remove_token_index(2450        collection_id: CollectionId,2451        item_index: TokenId,2452        owner: &T::AccountId,2453    ) -> DispatchResult {24542455        // update counter2456        <AccountItemCount<T>>::insert(owner.clone(), 2457            <AccountItemCount<T>>::get(owner)2458            .checked_sub(1)2459            .ok_or(Error::<T>::NumOverflow)?);246024612462        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2463        if list_exists {2464            let mut list = <AddressTokens<T>>::get(collection_id, owner);2465            let item_contains = list.contains(&item_index.clone());24662467            if item_contains {2468                list.retain(|&item| item != item_index);2469                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2470            }2471        }24722473        Ok(())2474    }24752476    fn move_token_index(2477        collection_id: CollectionId,2478        item_index: TokenId,2479        old_owner: &T::AccountId,2480        new_owner: &T::AccountId,2481    ) -> DispatchResult {2482        Self::remove_token_index(collection_id, item_index, old_owner)?;2483        Self::add_token_index(collection_id, item_index, new_owner)?;24842485        Ok(())2486    }2487    2488    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2489        ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);24902491        Ok(())2492    }2493}24942495////////////////////////////////////////////////////////////////////////////////////////////////////2496// Economic models2497// #region24982499/// Fee multiplier.2500pub type Multiplier = FixedU128;25012502type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25032504/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2505/// in the queue.2506#[derive(Encode, Decode, Clone, Eq, PartialEq)]2507pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25082509impl<T: Config + Send + Sync> sp_std::fmt::Debug 2510    for ChargeTransactionPayment<T>2511{2512	#[cfg(feature = "std")]2513	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2514		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2515	}2516	#[cfg(not(feature = "std"))]2517	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2518		Ok(())2519	}2520}25212522impl<T: Config> ChargeTransactionPayment<T>2523where2524    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2525    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2526    T::AccountId: AsRef<[u8]>,2527    T::AccountId: UncheckedFrom<T::Hash>,2528{2529    fn traditional_fee(2530        len: usize,2531        info: &DispatchInfoOf<T::Call>,2532        tip: BalanceOf<T>,2533    ) -> BalanceOf<T>2534    where2535        T::Call: Dispatchable<Info = DispatchInfo>,2536    {2537        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2538    }25392540	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2541        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2542        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2543        let len_saturation = max_block_length as u64 / (len as u64).max(1);2544        let coefficient: BalanceOf<T> = weight_saturation2545            .min(len_saturation)2546            .saturated_into::<BalanceOf<T>>();2547        final_fee2548            .saturating_mul(coefficient)2549            .saturated_into::<TransactionPriority>()2550    }25512552    fn withdraw_fee(2553        &self,2554        who: &T::AccountId,2555        call: &T::Call,2556        info: &DispatchInfoOf<T::Call>,2557        len: usize,2558	) -> Result<2559		(2560			BalanceOf<T>,2561			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2562		),2563		TransactionValidityError,2564	> {2565        let tip = self.0;25662567        let fee = Self::traditional_fee(len, info, tip);25682569        // Only mess with balances if fee is not zero.2570        if fee.is_zero() {2571            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2572			.map(|i| (fee, i));2573        }25742575        // Determine who is paying transaction fee based on ecnomic model2576        // Parse call to extract collection ID and access collection sponsor2577        let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2578            Some(Call::create_item(collection_id, _owner, _properties)) => {2579                let collection = <CollectionById<T>>::get(collection_id)?;25802581                // sponsor timeout2582                let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;25832584                let limit = collection.limits.sponsor_transfer_timeout;2585                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2586                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2587                    let limit_time = last_tx_block + limit.into();2588                    if block_number <= limit_time {2589                        return None;2590                    }2591                }2592                <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);25932594                // check free create limit2595                if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2596                    collection.sponsorship.sponsor()2597                        .cloned()2598                } else {2599                    None2600                }2601            }2602            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2603                let collection = <CollectionById<T>>::get(collection_id)?;2604                2605                let mut sponsor_transfer = false;2606                if collection.sponsorship.confirmed() {26072608                    let collection_limits = collection.limits;2609                    let collection_mode = collection.mode;2610    2611                    // sponsor timeout2612                    let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;2613                    sponsor_transfer = match collection_mode {2614                        CollectionMode::NFT => {2615    2616                            // get correct limit2617                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2618                                collection_limits.sponsor_transfer_timeout2619                            } else {2620                                ChainLimit::get().nft_sponsor_transfer_timeout2621                            };2622    2623                            let mut sponsored = true;2624                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2625                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2626                                let limit_time = last_tx_block + limit.into();2627                                if block_number <= limit_time {2628                                    sponsored = false;2629                                }2630                            }2631                            if sponsored {2632                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2633                            }26342635                            sponsored2636                        }2637                        CollectionMode::Fungible(_) => {2638    2639                            // get correct limit2640                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2641                                collection_limits.sponsor_transfer_timeout2642                            } else {2643                                ChainLimit::get().fungible_sponsor_transfer_timeout2644                            };2645    2646                            let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;2647                            let mut sponsored = true;2648                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2649                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2650                                let limit_time = last_tx_block + limit.into();2651                                if block_number <= limit_time {2652                                    sponsored = false;2653                                }2654                            }2655                            if sponsored {2656                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2657                            }26582659                            sponsored2660                        }2661                        CollectionMode::ReFungible => {2662    2663                            // get correct limit2664                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2665                                collection_limits.sponsor_transfer_timeout2666                            } else {2667                                ChainLimit::get().refungible_sponsor_transfer_timeout2668                            };2669    2670                            let mut sponsored = true;2671                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2672                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2673                                let limit_time = last_tx_block + limit.into();2674                                if block_number <= limit_time {2675                                    sponsored = false;2676                                }2677                            }2678                            if sponsored {2679                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2680                            }26812682                            sponsored2683                        }2684                        _ => {2685                            false2686                        },2687                    };2688                }26892690                if !sponsor_transfer {2691                    None2692                } else {2693                    collection.sponsorship.sponsor()2694                        .cloned()2695                }2696            }26972698            Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2699                let mut sponsor_metadata_changes = false;27002701                let collection = <CollectionById<T>>::get(collection_id)?;27022703                if2704                    collection.sponsorship.confirmed() &&2705                    // Can't sponsor fungible collection, this tx will be rejected2706                    // as invalid2707                    !matches!(collection.mode, CollectionMode::Fungible(_)) &&2708                    data.len() <= collection.limits.sponsored_data_size as usize2709                {2710                    if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2711                        let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;27122713                        if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2714                            .map(|last_block| block_number - last_block > rate_limit)2715                            .unwrap_or(true) 2716                        {2717                            sponsor_metadata_changes = true;2718                            <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2719                        }2720                    }2721                }27222723                if !sponsor_metadata_changes {2724                    None2725                } else {2726                    collection.sponsorship.sponsor().cloned()2727                }2728            }27292730            _ => None,2731        })();27322733        match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2734            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27352736                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27372738                let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2739                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2740                  2741                if !owned_contract && white_list_enabled {2742                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2743                        return Err(InvalidTransaction::Call.into());2744                    }2745                }2746            },2747            _ => {},2748        }27492750        // Sponsor smart contracts2751        sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27522753            // On instantiation: set the contract owner2754            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27552756                let new_contract_address = <pallet_contracts::Pallet<T>>::contract_address(2757                    &who,2758                    code_hash,2759                    salt,2760                );2761                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27622763                None2764            },27652766            // On instantiation with code: set the contract owner2767            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {27682769                let new_contract_address = <pallet_contracts::Pallet<T>>::contract_address(2770                    &who,2771                    &T::Hashing::hash(&_code),2772                    _salt,2773                );27742775                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27762777                None2778            }27792780            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2781            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27822783                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27842785                let mut sponsor_transfer = false;2786                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2787                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2788                    let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;2789                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2790                    let limit_time = last_tx_block + rate_limit;27912792                    if block_number >= limit_time {2793                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2794                        sponsor_transfer = true;2795                    }2796                } else {2797                    sponsor_transfer = false;2798                }2799               2800                if sponsor_transfer {2801                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2802                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2803                            return Some(called_contract);2804                        }2805                    }2806                }28072808                None2809            },28102811            _ => None,2812        });28132814        let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28152816		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2817			.map(|i| (fee, i))2818    }2819}282028212822impl<T: Config + Send + Sync> SignedExtension2823    for ChargeTransactionPayment<T>2824where2825    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2826    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2827    T::AccountId: AsRef<[u8]>,2828    T::AccountId: UncheckedFrom<T::Hash>,2829{2830    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2831    type AccountId = T::AccountId;2832    type Call = T::Call;2833    type AdditionalSigned = ();2834    type Pre = (2835        // tip2836        BalanceOf<T>,2837        // who pays fee2838        Self::AccountId,2839		// imbalance resulting from withdrawing the fee2840		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2841    );2842    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2843        Ok(())2844    }28452846    fn validate(2847        &self,2848        who: &Self::AccountId,2849        call: &Self::Call,2850        info: &DispatchInfoOf<Self::Call>,2851        len: usize,2852    ) -> TransactionValidity {2853		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2854		Ok(ValidTransaction {2855			priority: Self::get_priority(len, info, fee),2856			..Default::default()2857		})2858    }28592860    fn pre_dispatch(2861        self,2862        who: &Self::AccountId,2863        call: &Self::Call,2864        info: &DispatchInfoOf<Self::Call>,2865        len: usize,2866    ) -> Result<Self::Pre, TransactionValidityError> {2867        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2868        Ok((self.0, who.clone(), imbalance))2869    }28702871    fn post_dispatch(2872        pre: Self::Pre,2873        info: &DispatchInfoOf<Self::Call>,2874        post_info: &PostDispatchInfoOf<Self::Call>,2875        len: usize,2876        _result: &DispatchResult,2877    ) -> Result<(), TransactionValidityError> {2878		let (tip, who, imbalance) = pre;2879		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2880			len as u32,2881			info,2882			post_info,2883			tip,2884		);2885		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2886		Ok(())2887    }2888}28892890// #endregion