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

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 collection = Self::get_collection(collection_id)?;12631264            Self::approve_internal(sender, spender, &collection, item_id, amount)?;12651266            Ok(())1267        }1268        1269        /// 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.1270        /// 1271        /// # Permissions1272        /// * Collection Owner1273        /// * Collection Admin1274        /// * Current NFT owner1275        /// * Address approved by current NFT owner1276        /// 1277        /// # Arguments1278        /// 1279        /// * from: Address that owns token.1280        /// 1281        /// * recipient: Address of token recipient.1282        /// 1283        /// * collection_id.1284        /// 1285        /// * item_id: ID of the item.1286        /// 1287        /// * value: Amount to transfer.1288        #[weight = <T as Config>::WeightInfo::transfer_from()]1289        #[transactional]1290        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12911292            let sender = ensure_signed(origin)?;1293            let collection = Self::get_collection(collection_id)?;12941295            Self::transfer_from_internal(sender, from, recipient, &collection, item_id, value)?;12961297            Ok(())1298        }12991300        // #[weight = 0]1301        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13021303        //     // let no_perm_mes = "You do not have permissions to modify this collection";1304        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1305        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1306        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13071308        //     // // on_nft_received  call13091310        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;13111312        //     Ok(())1313        // }13141315        /// Set off-chain data schema.1316        /// 1317        /// # Permissions1318        /// 1319        /// * Collection Owner1320        /// * Collection Admin1321        /// 1322        /// # Arguments1323        /// 1324        /// * collection_id.1325        /// 1326        /// * schema: String representing the offchain data schema.1327        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1328        #[transactional]1329        pub fn set_variable_meta_data (1330            origin,1331            collection_id: CollectionId,1332            item_id: TokenId,1333            data: Vec<u8>1334        ) -> DispatchResult {1335            let sender = ensure_signed(origin)?;1336            1337            let collection = Self::get_collection(collection_id)?;13381339            Self::set_variable_meta_data_internal(sender, &collection, item_id, data)?;13401341            Ok(())1342        }1343 1344        /// Set schema standard1345        /// ImageURL1346        /// Unique1347        /// 1348        /// # Permissions1349        /// 1350        /// * Collection Owner1351        /// * Collection Admin1352        /// 1353        /// # Arguments1354        /// 1355        /// * collection_id.1356        /// 1357        /// * schema: SchemaVersion: enum1358        #[weight = <T as Config>::WeightInfo::set_schema_version()]1359        #[transactional]1360        pub fn set_schema_version(1361            origin,1362            collection_id: CollectionId,1363            version: SchemaVersion1364        ) -> DispatchResult {1365            let sender = ensure_signed(origin)?;1366            let mut target_collection = Self::get_collection(collection_id)?;1367            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1368            target_collection.schema_version = version;1369            Self::save_collection(target_collection);13701371            Ok(())1372        }13731374        /// Set off-chain data schema.1375        /// 1376        /// # Permissions1377        /// 1378        /// * Collection Owner1379        /// * Collection Admin1380        /// 1381        /// # Arguments1382        /// 1383        /// * collection_id.1384        /// 1385        /// * schema: String representing the offchain data schema.1386        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1387        #[transactional]1388        pub fn set_offchain_schema(1389            origin,1390            collection_id: CollectionId,1391            schema: Vec<u8>1392        ) -> DispatchResult {1393            let sender = ensure_signed(origin)?;1394            let mut target_collection = Self::get_collection(collection_id)?;1395            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;13961397            // check schema limit1398            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");13991400            target_collection.offchain_schema = schema;1401            Self::save_collection(target_collection);14021403            Ok(())1404        }14051406        /// Set const on-chain data schema.1407        /// 1408        /// # Permissions1409        /// 1410        /// * Collection Owner1411        /// * Collection Admin1412        /// 1413        /// # Arguments1414        /// 1415        /// * collection_id.1416        /// 1417        /// * schema: String representing the const on-chain data schema.1418        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1419        #[transactional]1420        pub fn set_const_on_chain_schema (1421            origin,1422            collection_id: CollectionId,1423            schema: Vec<u8>1424        ) -> DispatchResult {1425            let sender = ensure_signed(origin)?;1426            let mut target_collection = Self::get_collection(collection_id)?;1427            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14281429            // check schema limit1430            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14311432            target_collection.const_on_chain_schema = schema;1433            Self::save_collection(target_collection);14341435            Ok(())1436        }14371438        /// Set variable on-chain data schema.1439        /// 1440        /// # Permissions1441        /// 1442        /// * Collection Owner1443        /// * Collection Admin1444        /// 1445        /// # Arguments1446        /// 1447        /// * collection_id.1448        /// 1449        /// * schema: String representing the variable on-chain data schema.1450        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1451        #[transactional]1452        pub fn set_variable_on_chain_schema (1453            origin,1454            collection_id: CollectionId,1455            schema: Vec<u8>1456        ) -> DispatchResult {1457            let sender = ensure_signed(origin)?;1458            let mut target_collection = Self::get_collection(collection_id)?;1459            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14601461            // check schema limit1462            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14631464            target_collection.variable_on_chain_schema = schema;1465            Self::save_collection(target_collection);14661467            Ok(())1468        }14691470        // Sudo permissions function1471        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1472        #[transactional]1473        pub fn set_chain_limits(1474            origin,1475            limits: ChainLimits1476        ) -> DispatchResult {14771478            #[cfg(not(feature = "runtime-benchmarks"))]1479            ensure_root(origin)?;14801481            <ChainLimit>::put(limits);1482            Ok(())1483        }14841485        /// Enable smart contract self-sponsoring.1486        /// 1487        /// # Permissions1488        /// 1489        /// * Contract Owner1490        /// 1491        /// # Arguments1492        /// 1493        /// * contract address1494        /// * enable flag1495        /// 1496        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1497        #[transactional]1498        pub fn enable_contract_sponsoring(1499            origin,1500            contract_address: T::AccountId,1501            enable: bool1502        ) -> DispatchResult {15031504            let sender = ensure_signed(origin)?;15051506            #[cfg(feature = "runtime-benchmarks")]1507            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15081509            Self::ensure_contract_owned(sender, &contract_address)?;15101511            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1512            Ok(())1513        }15141515        /// Set the rate limit for contract sponsoring to specified number of blocks.1516        /// 1517        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1518        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1519        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1520        /// from contract endowment if there are at least B blocks between such transactions. 1521        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1522        /// 1523        /// # Permissions1524        /// 1525        /// * Contract Owner1526        /// 1527        /// # Arguments1528        /// 1529        /// -`contract_address`: Address of the contract to sponsor1530        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1531        /// 1532        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1533        #[transactional]1534        pub fn set_contract_sponsoring_rate_limit(1535            origin,1536            contract_address: T::AccountId,1537            rate_limit: T::BlockNumber1538        ) -> DispatchResult {1539            let sender = ensure_signed(origin)?;15401541            #[cfg(feature = "runtime-benchmarks")]1542            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15431544            Self::ensure_contract_owned(sender, &contract_address)?;1545            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1546            Ok(())1547        }15481549        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1550        /// 1551        /// # Permissions1552        /// 1553        /// * Address that deployed smart contract.1554        /// 1555        /// # Arguments1556        /// 1557        /// -`contract_address`: Address of the contract.1558        /// 1559        /// - `enable`: .  1560        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1561        #[transactional]1562        pub fn toggle_contract_white_list(1563            origin,1564            contract_address: T::AccountId,1565            enable: bool1566        ) -> DispatchResult {1567            let sender = ensure_signed(origin)?;15681569            #[cfg(feature = "runtime-benchmarks")]1570            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15711572            Self::ensure_contract_owned(sender, &contract_address)?;1573            if enable {1574                <ContractWhiteListEnabled<T>>::insert(contract_address, true);1575            } else {1576                <ContractWhiteListEnabled<T>>::remove(contract_address);1577            }1578            Ok(())1579        }1580        1581        /// Add an address to smart contract white list.1582        /// 1583        /// # Permissions1584        /// 1585        /// * Address that deployed smart contract.1586        /// 1587        /// # Arguments1588        /// 1589        /// -`contract_address`: Address of the contract.1590        ///1591        /// -`account_address`: Address to add.1592        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1593        #[transactional]1594        pub fn add_to_contract_white_list(1595            origin,1596            contract_address: T::AccountId,1597            account_address: T::AccountId1598        ) -> DispatchResult {1599            let sender = ensure_signed(origin)?;16001601            #[cfg(feature = "runtime-benchmarks")]1602            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1603            1604            Self::ensure_contract_owned(sender, &contract_address)?;      1605            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1606            Ok(())1607        }16081609        /// Remove an address from smart contract white list.1610        /// 1611        /// # Permissions1612        /// 1613        /// * Address that deployed smart contract.1614        /// 1615        /// # Arguments1616        /// 1617        /// -`contract_address`: Address of the contract.1618        ///1619        /// -`account_address`: Address to remove.1620        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1621        #[transactional]1622        pub fn remove_from_contract_white_list(1623            origin,1624            contract_address: T::AccountId,1625            account_address: T::AccountId1626        ) -> DispatchResult {1627            let sender = ensure_signed(origin)?;16281629            #[cfg(feature = "runtime-benchmarks")]1630            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16311632            Self::ensure_contract_owned(sender, &contract_address)?;1633            <ContractWhiteList<T>>::remove(contract_address, account_address);1634            Ok(())1635        }16361637        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1638        #[transactional]1639        pub fn set_collection_limits(1640            origin,1641            collection_id: u32,1642            new_limits: CollectionLimits<T::BlockNumber>,1643        ) -> DispatchResult {1644            let sender = ensure_signed(origin)?;1645            let mut target_collection = Self::get_collection(collection_id)?;1646            Self::check_owner_permissions(&target_collection, sender.clone())?;1647            let old_limits = &target_collection.limits;1648            let chain_limits = ChainLimit::get();16491650            // collection bounds1651            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1652                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1653                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1654                Error::<T>::CollectionLimitBoundsExceeded);16551656            // token_limit   check  prev1657            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1658            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16591660            ensure!(1661                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1662                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1663                Error::<T>::OwnerPermissionsCantBeReverted,1664            );16651666            target_collection.limits = new_limits;1667            Self::save_collection(target_collection);16681669            Ok(())1670        } 1671    }1672}16731674impl<T: Config> Module<T> {1675    pub fn create_item_internal(sender: T::AccountId, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1676        let target_collection = Self::get_collection(collection_id)?;16771678        Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1679        Self::validate_create_item_args(&target_collection, &data)?;1680        Self::create_item_no_validation(&target_collection, owner, data)?;16811682        Ok(())1683    }16841685    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1686        // Limits check1687        Self::is_correct_transfer(target_collection, &recipient)?;16881689        // Transfer permissions check1690        ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1691            Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1692            Error::<T>::NoPermission);16931694        if target_collection.access == AccessMode::WhiteList {1695            Self::check_white_list(target_collection, &sender)?;1696            Self::check_white_list(target_collection, &recipient)?;1697        }16981699        match target_collection.mode1700        {1701            CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1702            CollectionMode::Fungible(_)  => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1703            CollectionMode::ReFungible  => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1704            _ => ()1705        };17061707        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17081709        Ok(())1710    }17111712	pub fn approve_internal(1713		sender: T::AccountId,1714		spender: T::AccountId,1715		collection: &CollectionHandle<T>,1716		item_id: TokenId,1717		amount: u128,1718	) -> DispatchResult {1719		Self::token_exists(&collection, item_id)?;17201721		// Transfer permissions check1722		let bypasses_limits = collection.limits.owner_can_transfer &&1723			Self::is_owner_or_admin_permissions(1724				&collection,1725				sender.clone(),1726			);17271728		let allowance_limit = if bypasses_limits {1729			None1730		} else if let Some(amount) = Self::owned_amount(1731			sender.clone(),1732			&collection,1733			item_id,1734		) {1735			Some(amount)1736		} else {1737			fail!(Error::<T>::NoPermission);1738		};17391740		if collection.access == AccessMode::WhiteList {1741			Self::check_white_list(&collection, &sender)?;1742			Self::check_white_list(&collection, &spender)?;1743		}17441745		let allowance: u128 = amount1746			.checked_add(<Allowances<T>>::get(collection.id, (item_id, &sender, &spender)))1747			.ok_or(Error::<T>::NumOverflow)?;1748		if let Some(limit) = allowance_limit {1749			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1750		}1751		<Allowances<T>>::insert(collection.id, (item_id, &sender, &spender), allowance);17521753		Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1754		Ok(())1755	}17561757	pub fn transfer_from_internal(1758		sender: T::AccountId,1759		from: T::AccountId,1760		recipient: T::AccountId,1761		collection: &CollectionHandle<T>,1762		item_id: TokenId,1763		amount: u128,1764	) -> DispatchResult {1765		// Check approval1766		let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, &from, &sender));17671768		// Limits check1769		Self::is_correct_transfer(&collection, &recipient)?;17701771		// Transfer permissions check1772		ensure!(1773			approval >= amount || 1774			(1775				collection.limits.owner_can_transfer &&1776				Self::is_owner_or_admin_permissions(&collection, sender.clone())1777			),1778			Error::<T>::NoPermission1779		);17801781		if collection.access == AccessMode::WhiteList {1782			Self::check_white_list(&collection, &sender)?;1783			Self::check_white_list(&collection, &recipient)?;1784		}17851786		// Reduce approval by transferred amount or remove if remaining approval drops to 01787		let allowance = approval.saturating_sub(amount);1788		if allowance > 0 {1789			<Allowances<T>>::insert(collection.id, (item_id, &from, &sender), allowance);1790		} else {1791			<Allowances<T>>::remove(collection.id, (item_id, &from, &sender));1792		}17931794		match collection.mode {1795			CollectionMode::NFT => {1796				Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1797			}1798			CollectionMode::Fungible(_) => {1799				Self::transfer_fungible(&collection, amount, &from, &recipient)?1800			}1801			CollectionMode::ReFungible => {1802				Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1803			}1804			_ => ()1805		};18061807		Ok(())1808	}18091810    pub fn set_variable_meta_data_internal(1811        sender: T::AccountId,1812        collection: &CollectionHandle<T>, 1813        item_id: TokenId,1814        data: Vec<u8>,1815    ) -> DispatchResult {1816        Self::token_exists(&collection, item_id)?;18171818        ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18191820        // Modify permissions check1821        ensure!(Self::is_item_owner(sender.clone(), &collection, item_id) ||1822            Self::is_owner_or_admin_permissions(&collection, sender.clone()),1823            Error::<T>::NoPermission);18241825        match collection.mode1826        {1827            CollectionMode::NFT => Self::set_nft_variable_data(&collection, item_id, data)?,1828            CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(&collection, item_id, data)?,1829            CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1830            _ => fail!(Error::<T>::UnexpectedCollectionType)1831        };18321833        Ok(())1834    }18351836    pub fn create_multiple_items_internal(1837        sender: T::AccountId,1838        collection: &CollectionHandle<T>,1839        owner: T::AccountId,1840        items_data: Vec<CreateItemData>,1841    ) -> DispatchResult {1842        Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18431844        for data in &items_data {1845            Self::validate_create_item_args(&collection, data)?;1846        }1847        for data in &items_data {1848            Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1849        }18501851        Ok(())1852    }18531854    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1855        let collection_id = collection.id;18561857        // check token limit and account token limit1858        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1859        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1860        1861        Ok(())1862    }18631864    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1865        let collection_id = collection.id;18661867        // check token limit and account token limit1868        let total_items: u32 = ItemListIndex::get(collection_id)1869            .checked_add(amount)1870            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1871        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1872            .checked_add(amount)1873            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1874        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1875        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);18761877        if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1878            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1879            Self::check_white_list(collection, owner)?;1880            Self::check_white_list(collection, sender)?;1881        }18821883        Ok(())1884    }18851886    fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1887        match target_collection.mode1888        {1889            CollectionMode::NFT => {1890                if let CreateItemData::NFT(data) = data {1891                    // check sizes1892                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1893                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1894                } else {1895                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1896                }1897            },1898            CollectionMode::Fungible(_) => {1899                if let CreateItemData::Fungible(_) = data {1900                } else {1901                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1902                }1903            },1904            CollectionMode::ReFungible => {1905                if let CreateItemData::ReFungible(data) = data {19061907                    // check sizes1908                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1909                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19101911                    // Check refungibility limits1912                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1913                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1914                } else {1915                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1916                }1917            },1918            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1919        };19201921        Ok(())1922    }19231924    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1925        match data1926        {1927            CreateItemData::NFT(data) => {1928                let item = NftItemType {1929                    owner: owner.clone(),1930                    const_data: data.const_data,1931                    variable_data: data.variable_data1932                };19331934                Self::add_nft_item(collection, item)?;1935            },1936            CreateItemData::Fungible(data) => {1937                Self::add_fungible_item(collection, &owner, data.value)?;1938            },1939            CreateItemData::ReFungible(data) => {1940                let mut owner_list = Vec::new();1941                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19421943                let item = ReFungibleItemType {1944                    owner: owner_list,1945                    const_data: data.const_data,1946                    variable_data: data.variable_data1947                };19481949                Self::add_refungible_item(collection, item)?;1950            }1951        };19521953        Ok(())1954    }19551956    fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1957        let collection_id = collection.id;19581959        // Does new owner already have an account?1960        let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19611962        // Mint 1963        let item = FungibleItemType {1964            value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1965        };1966        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19671968        // Update balance1969        let new_balance = <Balance<T>>::get(collection_id, owner)1970            .checked_add(value)1971            .ok_or(Error::<T>::NumOverflow)?;1972        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19731974        Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1975        Ok(())1976    }19771978    fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1979        let collection_id = collection.id;19801981        let current_index = <ItemListIndex>::get(collection_id)1982            .checked_add(1)1983            .ok_or(Error::<T>::NumOverflow)?;1984        let itemcopy = item.clone();19851986        ensure!(1987            item.owner.len() == 1,1988            Error::<T>::BadCreateRefungibleCall,1989        );1990        let item_owner = item.owner.first().expect("only one owner is defined");19911992        let value = item_owner.fraction;1993        let owner = item_owner.owner.clone();19941995        Self::add_token_index(collection_id, current_index, &owner)?;19961997        <ItemListIndex>::insert(collection_id, current_index);1998        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19992000        // Update balance2001        let new_balance = <Balance<T>>::get(collection_id, &owner)2002            .checked_add(value)2003            .ok_or(Error::<T>::NumOverflow)?;2004        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);20052006        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));2007        Ok(())2008    }20092010    fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {2011        let collection_id = collection.id;20122013        let current_index = <ItemListIndex>::get(collection_id)2014            .checked_add(1)2015            .ok_or(Error::<T>::NumOverflow)?;20162017        let item_owner = item.owner.clone();2018        Self::add_token_index(collection_id, current_index, &item.owner)?;20192020        <ItemListIndex>::insert(collection_id, current_index);2021        <NftItemList<T>>::insert(collection_id, current_index, item);20222023        // Update balance2024        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())2025            .checked_add(1)2026            .ok_or(Error::<T>::NumOverflow)?;2027        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);20282029        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2030        Ok(())2031    }20322033    fn burn_refungible_item(2034        collection: &CollectionHandle<T>,2035        item_id: TokenId,2036        owner: &T::AccountId,2037    ) -> DispatchResult {2038        let collection_id = collection.id;20392040        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2041            .ok_or(Error::<T>::TokenNotFound)?;2042        let rft_balance = token2043            .owner2044            .iter()2045            .find(|&i| i.owner == *owner)2046            .ok_or(Error::<T>::TokenNotFound)?;2047        Self::remove_token_index(collection_id, item_id, owner)?;20482049        // update balance2050        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2051            .checked_sub(rft_balance.fraction)2052            .ok_or(Error::<T>::NumOverflow)?;2053        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20542055        // Re-create owners list with sender removed2056        let index = token2057            .owner2058            .iter()2059            .position(|i| i.owner == *owner)2060            .expect("owned item is exists");2061        token.owner.remove(index);2062        let owner_count = token.owner.len();20632064        // Burn the token completely if this was the last (only) owner2065        if owner_count == 0 {2066            <ReFungibleItemList<T>>::remove(collection_id, item_id);2067            <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2068        }2069        else {2070            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2071        }20722073        Ok(())2074    }20752076    fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2077        let collection_id = collection.id;20782079        let item = <NftItemList<T>>::get(collection_id, item_id)2080            .ok_or(Error::<T>::TokenNotFound)?;2081        Self::remove_token_index(collection_id, item_id, &item.owner)?;20822083        // update balance2084        let new_balance = <Balance<T>>::get(collection_id, &item.owner)2085            .checked_sub(1)2086            .ok_or(Error::<T>::NumOverflow)?;2087        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2088        <NftItemList<T>>::remove(collection_id, item_id);2089        <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20902091        Ok(())2092    }20932094    fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2095        let collection_id = collection.id;20962097        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2098        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20992100        // update balance2101        let new_balance = <Balance<T>>::get(collection_id, owner)2102            .checked_sub(value)2103            .ok_or(Error::<T>::NumOverflow)?;2104        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);21052106        if balance.value - value > 0 {2107            balance.value -= value;2108            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2109        }2110        else {2111            <FungibleItemList<T>>::remove(collection_id, owner);2112        }21132114        Ok(())2115    }21162117    pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2118        Ok(<CollectionById<T>>::get(collection_id)2119            .map(|collection| CollectionHandle {2120                id: collection_id,2121                collection2122            })2123            .ok_or(Error::<T>::CollectionNotFound)?)2124    }21252126    fn save_collection(collection: CollectionHandle<T>) {2127        <CollectionById<T>>::insert(collection.id, collection.collection);2128    }21292130    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2131        ensure!(2132            subject == target_collection.owner,2133            Error::<T>::NoPermission2134        );21352136        Ok(())2137    }21382139    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2140        subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2141    }21422143    fn check_owner_or_admin_permissions(2144        collection: &CollectionHandle<T>,2145        subject: T::AccountId,2146    ) -> DispatchResult {2147        ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);21482149        Ok(())2150    }21512152    fn owned_amount(2153        subject: T::AccountId,2154        target_collection: &CollectionHandle<T>,2155        item_id: TokenId,2156    ) -> Option<u128> {2157        let collection_id = target_collection.id;21582159        match target_collection.mode {2160            CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2161                .then(|| 1),2162            CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2163                .value),2164            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2165                .owner2166                .iter()2167                .find(|i| i.owner == subject)2168                .map(|i| i.fraction),2169            CollectionMode::Invalid => None,2170        }2171    }21722173    fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2174        match target_collection.mode {2175            CollectionMode::Fungible(_) => true,2176            _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2177        }2178    }21792180    fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2181        let collection_id = collection.id;21822183        let mes = Error::<T>::AddresNotInWhiteList;2184        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21852186        Ok(())2187    }21882189    /// Check if token exists. In case of Fungible, check if there is an entry for 2190    /// the owner in fungible balances double map2191    fn token_exists(2192        target_collection: &CollectionHandle<T>,2193        item_id: TokenId,2194    ) -> DispatchResult {2195        let collection_id = target_collection.id;2196        let exists = match target_collection.mode2197        {2198            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2199            CollectionMode::Fungible(_)  => true,2200            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2201            _ => false2202        };22032204        ensure!(exists == true, Error::<T>::TokenNotFound);2205        Ok(())2206    }22072208    fn transfer_fungible(2209        collection: &CollectionHandle<T>,2210        value: u128,2211        owner: &T::AccountId,2212        recipient: &T::AccountId,2213    ) -> DispatchResult {2214        let collection_id = collection.id;22152216        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2217        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22182219        // Send balance to recipient (updates balanceOf of recipient)2220        Self::add_fungible_item(collection, recipient, value)?;22212222        // update balanceOf of sender2223        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22242225        // Reduce or remove sender2226        if balance.value == value {2227            <FungibleItemList<T>>::remove(collection_id, owner);2228        }2229        else {2230            balance.value -= value;2231            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2232        }22332234        Ok(())2235    }22362237    fn transfer_refungible(2238        collection: &CollectionHandle<T>,2239        item_id: TokenId,2240        value: u128,2241        owner: T::AccountId,2242        new_owner: T::AccountId,2243    ) -> DispatchResult {2244        let collection_id = collection.id;2245        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2246            .ok_or(Error::<T>::TokenNotFound)?;22472248        let item = full_item2249            .owner2250            .iter()2251            .filter(|i| i.owner == owner)2252            .next()2253            .ok_or(Error::<T>::TokenNotFound)?;2254        let amount = item.fraction;22552256        ensure!(amount >= value, Error::<T>::TokenValueTooLow);22572258        // update balance2259        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2260            .checked_sub(value)2261            .ok_or(Error::<T>::NumOverflow)?;2262        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22632264        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2265            .checked_add(value)2266            .ok_or(Error::<T>::NumOverflow)?;2267        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22682269        let old_owner = item.owner.clone();2270        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22712272        // transfer2273        if amount == value && !new_owner_has_account {2274            // change owner2275            // new owner do not have account2276            let mut new_full_item = full_item.clone();2277            new_full_item2278                .owner2279                .iter_mut()2280                .find(|i| i.owner == owner)2281                .expect("old owner does present in refungible")2282                .owner = new_owner.clone();2283            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22842285            // update index collection2286            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2287        } else {2288            let mut new_full_item = full_item.clone();2289            new_full_item2290                .owner2291                .iter_mut()2292                .find(|i| i.owner == owner)2293                .expect("old owner does present in refungible")2294                .fraction -= value;22952296            // separate amount2297            if new_owner_has_account {2298                // new owner has account2299                new_full_item2300                    .owner2301                    .iter_mut()2302                    .find(|i| i.owner == new_owner)2303                    .expect("new owner has account")2304                    .fraction += value;2305            } else {2306                // new owner do not have account2307                new_full_item.owner.push(Ownership {2308                    owner: new_owner.clone(),2309                    fraction: value,2310                });2311                Self::add_token_index(collection_id, item_id, &new_owner)?;2312            }23132314            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2315        }23162317        Ok(())2318    }23192320    fn transfer_nft(2321        collection: &CollectionHandle<T>,2322        item_id: TokenId,2323        sender: T::AccountId,2324        new_owner: T::AccountId,2325    ) -> DispatchResult {2326        let collection_id = collection.id;2327        let mut item = <NftItemList<T>>::get(collection_id, item_id)2328            .ok_or(Error::<T>::TokenNotFound)?;23292330        ensure!(2331            sender == item.owner,2332            Error::<T>::MustBeTokenOwner2333        );23342335        // update balance2336        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2337            .checked_sub(1)2338            .ok_or(Error::<T>::NumOverflow)?;2339        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23402341        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2342            .checked_add(1)2343            .ok_or(Error::<T>::NumOverflow)?;2344        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23452346        // change owner2347        let old_owner = item.owner.clone();2348        item.owner = new_owner.clone();2349        <NftItemList<T>>::insert(collection_id, item_id, item);23502351        // update index collection2352        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23532354        Ok(())2355    }2356    2357    fn set_re_fungible_variable_data(2358        collection: &CollectionHandle<T>,2359        item_id: TokenId,2360        data: Vec<u8>2361    ) -> DispatchResult {2362        let collection_id = collection.id;2363        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2364            .ok_or(Error::<T>::TokenNotFound)?;23652366        item.variable_data = data;23672368        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23692370        Ok(())2371    }23722373    fn set_nft_variable_data(2374        collection: &CollectionHandle<T>,2375        item_id: TokenId,2376        data: Vec<u8>2377    ) -> DispatchResult {2378        let collection_id = collection.id;2379        let mut item = <NftItemList<T>>::get(collection_id, item_id)2380            .ok_or(Error::<T>::TokenNotFound)?;2381        2382        item.variable_data = data;23832384        <NftItemList<T>>::insert(collection_id, item_id, item);2385        2386        Ok(())2387    }23882389    fn init_collection(item: &Collection<T>) {2390        // check params2391        assert!(2392            item.decimal_points <= MAX_DECIMAL_POINTS,2393            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2394        );2395        assert!(2396            item.name.len() <= 64,2397            "Collection name can not be longer than 63 char"2398        );2399        assert!(2400            item.name.len() <= 256,2401            "Collection description can not be longer than 255 char"2402        );2403        assert!(2404            item.token_prefix.len() <= 16,2405            "Token prefix can not be longer than 15 char"2406        );24072408        // Generate next collection ID2409        let next_id = CreatedCollectionCount::get()2410            .checked_add(1)2411            .unwrap();24122413        CreatedCollectionCount::put(next_id);2414    }24152416    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2417        let current_index = <ItemListIndex>::get(collection_id)2418            .checked_add(1)2419            .unwrap();24202421        let item_owner = item.owner.clone();2422        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24232424        <ItemListIndex>::insert(collection_id, current_index);24252426        // Update balance2427        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2428            .checked_add(1)2429            .unwrap();2430        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2431    }24322433    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2434        let current_index = <ItemListIndex>::get(collection_id)2435            .checked_add(1)2436            .unwrap();24372438        Self::add_token_index(collection_id, current_index, owner).unwrap();24392440        <ItemListIndex>::insert(collection_id, current_index);24412442        // Update balance2443        let new_balance = <Balance<T>>::get(collection_id, owner)2444            .checked_add(item.value)2445            .unwrap();2446        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2447    }24482449    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2450        let current_index = <ItemListIndex>::get(collection_id)2451            .checked_add(1)2452            .unwrap();24532454        let value = item.owner.first().unwrap().fraction;2455        let owner = item.owner.first().unwrap().owner.clone();24562457        Self::add_token_index(collection_id, current_index, &owner).unwrap();24582459        <ItemListIndex>::insert(collection_id, current_index);24602461        // Update balance2462        let new_balance = <Balance<T>>::get(collection_id, &owner)2463            .checked_add(value)2464            .unwrap();2465        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2466    }24672468    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2469        // add to account limit2470        if <AccountItemCount<T>>::contains_key(owner) {24712472            // bound Owned tokens by a single address2473            let count = <AccountItemCount<T>>::get(owner);2474            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24752476            <AccountItemCount<T>>::insert(owner.clone(), count2477                .checked_add(1)2478                .ok_or(Error::<T>::NumOverflow)?);2479        }2480        else {2481            <AccountItemCount<T>>::insert(owner.clone(), 1);2482        }24832484        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2485        if list_exists {2486            let mut list = <AddressTokens<T>>::get(collection_id, owner);2487            let item_contains = list.contains(&item_index.clone());24882489            if !item_contains {2490                list.push(item_index.clone());2491            }24922493            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2494        } else {2495            let mut itm = Vec::new();2496            itm.push(item_index.clone());2497            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2498        }24992500        Ok(())2501    }25022503    fn remove_token_index(2504        collection_id: CollectionId,2505        item_index: TokenId,2506        owner: &T::AccountId,2507    ) -> DispatchResult {25082509        // update counter2510        <AccountItemCount<T>>::insert(owner.clone(), 2511            <AccountItemCount<T>>::get(owner)2512            .checked_sub(1)2513            .ok_or(Error::<T>::NumOverflow)?);251425152516        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2517        if list_exists {2518            let mut list = <AddressTokens<T>>::get(collection_id, owner);2519            let item_contains = list.contains(&item_index.clone());25202521            if item_contains {2522                list.retain(|&item| item != item_index);2523                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2524            }2525        }25262527        Ok(())2528    }25292530    fn move_token_index(2531        collection_id: CollectionId,2532        item_index: TokenId,2533        old_owner: &T::AccountId,2534        new_owner: &T::AccountId,2535    ) -> DispatchResult {2536        Self::remove_token_index(collection_id, item_index, old_owner)?;2537        Self::add_token_index(collection_id, item_index, new_owner)?;25382539        Ok(())2540    }2541    2542    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2543        ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25442545        Ok(())2546    }2547}25482549////////////////////////////////////////////////////////////////////////////////////////////////////2550// Economic models2551// #region25522553/// Fee multiplier.2554pub type Multiplier = FixedU128;25552556type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25572558/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2559/// in the queue.2560#[derive(Encode, Decode, Clone, Eq, PartialEq)]2561pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25622563impl<T: Config + Send + Sync> sp_std::fmt::Debug 2564    for ChargeTransactionPayment<T>2565{2566	#[cfg(feature = "std")]2567	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2568		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2569	}2570	#[cfg(not(feature = "std"))]2571	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2572		Ok(())2573	}2574}25752576impl<T: Config> ChargeTransactionPayment<T>2577where2578    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2579    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2580    T::AccountId: AsRef<[u8]>,2581    T::AccountId: UncheckedFrom<T::Hash>,2582{2583    fn traditional_fee(2584        len: usize,2585        info: &DispatchInfoOf<T::Call>,2586        tip: BalanceOf<T>,2587    ) -> BalanceOf<T>2588    where2589        T::Call: Dispatchable<Info = DispatchInfo>,2590    {2591        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2592    }25932594	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2595        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2596        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2597        let len_saturation = max_block_length as u64 / (len as u64).max(1);2598        let coefficient: BalanceOf<T> = weight_saturation2599            .min(len_saturation)2600            .saturated_into::<BalanceOf<T>>();2601        final_fee2602            .saturating_mul(coefficient)2603            .saturated_into::<TransactionPriority>()2604    }26052606    fn withdraw_fee(2607        &self,2608        who: &T::AccountId,2609        call: &T::Call,2610        info: &DispatchInfoOf<T::Call>,2611        len: usize,2612	) -> Result<2613		(2614			BalanceOf<T>,2615			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2616		),2617		TransactionValidityError,2618	> {2619        let tip = self.0;26202621        let fee = Self::traditional_fee(len, info, tip);26222623        // Only mess with balances if fee is not zero.2624        if fee.is_zero() {2625            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2626			.map(|i| (fee, i));2627        }26282629        // Determine who is paying transaction fee based on ecnomic model2630        // Parse call to extract collection ID and access collection sponsor2631        let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2632            Some(Call::create_item(collection_id, _owner, _properties)) => {2633                let collection = <CollectionById<T>>::get(collection_id)?;26342635                // sponsor timeout2636                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26372638                let limit = collection.limits.sponsor_transfer_timeout;2639                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2640                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2641                    let limit_time = last_tx_block + limit.into();2642                    if block_number <= limit_time {2643                        return None;2644                    }2645                }2646                <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26472648                // check free create limit2649                if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2650                    collection.sponsorship.sponsor()2651                        .cloned()2652                } else {2653                    None2654                }2655            }2656            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2657                let collection = <CollectionById<T>>::get(collection_id)?;2658                2659                let mut sponsor_transfer = false;2660                if collection.sponsorship.confirmed() {26612662                    let collection_limits = collection.limits;2663                    let collection_mode = collection.mode;2664    2665                    // sponsor timeout2666                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2667                    sponsor_transfer = match collection_mode {2668                        CollectionMode::NFT => {2669    2670                            // get correct limit2671                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2672                                collection_limits.sponsor_transfer_timeout2673                            } else {2674                                ChainLimit::get().nft_sponsor_transfer_timeout2675                            };2676    2677                            let mut sponsored = true;2678                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2679                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2680                                let limit_time = last_tx_block + limit.into();2681                                if block_number <= limit_time {2682                                    sponsored = false;2683                                }2684                            }2685                            if sponsored {2686                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2687                            }26882689                            sponsored2690                        }2691                        CollectionMode::Fungible(_) => {2692    2693                            // get correct limit2694                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2695                                collection_limits.sponsor_transfer_timeout2696                            } else {2697                                ChainLimit::get().fungible_sponsor_transfer_timeout2698                            };2699    2700                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2701                            let mut sponsored = true;2702                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2703                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2704                                let limit_time = last_tx_block + limit.into();2705                                if block_number <= limit_time {2706                                    sponsored = false;2707                                }2708                            }2709                            if sponsored {2710                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2711                            }27122713                            sponsored2714                        }2715                        CollectionMode::ReFungible => {2716    2717                            // get correct limit2718                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2719                                collection_limits.sponsor_transfer_timeout2720                            } else {2721                                ChainLimit::get().refungible_sponsor_transfer_timeout2722                            };2723    2724                            let mut sponsored = true;2725                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2726                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2727                                let limit_time = last_tx_block + limit.into();2728                                if block_number <= limit_time {2729                                    sponsored = false;2730                                }2731                            }2732                            if sponsored {2733                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2734                            }27352736                            sponsored2737                        }2738                        _ => {2739                            false2740                        },2741                    };2742                }27432744                if !sponsor_transfer {2745                    None2746                } else {2747                    collection.sponsorship.sponsor()2748                        .cloned()2749                }2750            }27512752            Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2753                let mut sponsor_metadata_changes = false;27542755                let collection = <CollectionById<T>>::get(collection_id)?;27562757                if2758                    collection.sponsorship.confirmed() &&2759                    // Can't sponsor fungible collection, this tx will be rejected2760                    // as invalid2761                    !matches!(collection.mode, CollectionMode::Fungible(_)) &&2762                    data.len() <= collection.limits.sponsored_data_size as usize2763                {2764                    if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2765                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27662767                        if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2768                            .map(|last_block| block_number - last_block > rate_limit)2769                            .unwrap_or(true) 2770                        {2771                            sponsor_metadata_changes = true;2772                            <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2773                        }2774                    }2775                }27762777                if !sponsor_metadata_changes {2778                    None2779                } else {2780                    collection.sponsorship.sponsor().cloned()2781                }2782            }27832784            _ => None,2785        })();27862787        match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2788            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27892790                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27912792                let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2793                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2794                  2795                if !owned_contract && white_list_enabled {2796                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2797                        return Err(InvalidTransaction::Call.into());2798                    }2799                }2800            },2801            _ => {},2802        }28032804        // Sponsor smart contracts2805        sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28062807            // On instantiation: set the contract owner2808            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28092810                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2811                    &who,2812                    code_hash,2813                    salt,2814                );2815                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28162817                None2818            },28192820            // On instantiation with code: set the contract owner2821            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {28222823                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2824                    &who,2825                    &T::Hashing::hash(&_code),2826                    _salt,2827                );28282829                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28302831                None2832            }28332834            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2835            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28362837                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28382839                let mut sponsor_transfer = false;2840                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2841                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2842                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2843                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2844                    let limit_time = last_tx_block + rate_limit;28452846                    if block_number >= limit_time {2847                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2848                        sponsor_transfer = true;2849                    }2850                } else {2851                    sponsor_transfer = false;2852                }2853               2854                if sponsor_transfer {2855                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2856                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2857                            return Some(called_contract);2858                        }2859                    }2860                }28612862                None2863            },28642865            _ => None,2866        });28672868        let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28692870		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2871			.map(|i| (fee, i))2872    }2873}287428752876impl<T: Config + Send + Sync> SignedExtension2877    for ChargeTransactionPayment<T>2878where2879    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2880    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2881    T::AccountId: AsRef<[u8]>,2882    T::AccountId: UncheckedFrom<T::Hash>,2883{2884    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2885    type AccountId = T::AccountId;2886    type Call = T::Call;2887    type AdditionalSigned = ();2888    type Pre = (2889        // tip2890        BalanceOf<T>,2891        // who pays fee2892        Self::AccountId,2893		// imbalance resulting from withdrawing the fee2894		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2895    );2896    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2897        Ok(())2898    }28992900    fn validate(2901        &self,2902        who: &Self::AccountId,2903        call: &Self::Call,2904        info: &DispatchInfoOf<Self::Call>,2905        len: usize,2906    ) -> TransactionValidity {2907		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2908		Ok(ValidTransaction {2909			priority: Self::get_priority(len, info, fee),2910			..Default::default()2911		})2912    }29132914    fn pre_dispatch(2915        self,2916        who: &Self::AccountId,2917        call: &Self::Call,2918        info: &DispatchInfoOf<Self::Call>,2919        len: usize,2920    ) -> Result<Self::Pre, TransactionValidityError> {2921        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2922        Ok((self.0, who.clone(), imbalance))2923    }29242925    fn post_dispatch(2926        pre: Self::Pre,2927        info: &DispatchInfoOf<Self::Call>,2928        post_info: &PostDispatchInfoOf<Self::Call>,2929        len: usize,2930        _result: &DispatchResult,2931    ) -> Result<(), TransactionValidityError> {2932		let (tip, who, imbalance) = pre;2933		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2934			len as u32,2935			info,2936			post_info,2937			tip,2938		);2939		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2940		Ok(())2941    }2942}29432944// #endregion