git.delta.rocks / unique-network / refs/commits / 3bcc5aae8f54

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 {11171118            let sender = ensure_signed(origin)?;11191120            let target_collection = Self::get_collection(collection_id)?;11211122            Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1123            Self::validate_create_item_args(&target_collection, &data)?;1124            Self::create_item_no_validation(&target_collection, owner, data)?;11251126            Ok(())1127        }11281129        /// This method creates multiple items in a collection created with CreateCollection method.1130        /// 1131        /// # Permissions1132        /// 1133        /// * Collection Owner.1134        /// * Collection Admin.1135        /// * Anyone if1136        ///     * White List is enabled, and1137        ///     * Address is added to white list, and1138        ///     * MintPermission is enabled (see SetMintPermission method)1139        /// 1140        /// # Arguments1141        /// 1142        /// * collection_id: ID of the collection.1143        /// 1144        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1145        /// 1146        /// * owner: Address, initial owner of the NFT.1147        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1148                               .map(|data| { data.len() })1149                               .sum())]1150        #[transactional]1151        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11521153            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1154            let sender = ensure_signed(origin)?;11551156            let target_collection = Self::get_collection(collection_id)?;11571158            Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11591160            for data in &items_data {1161                Self::validate_create_item_args(&target_collection, data)?;1162            }1163            for data in &items_data {1164                Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1165            }11661167            Ok(())1168        }11691170        /// Destroys a concrete instance of NFT.1171        /// 1172        /// # Permissions1173        /// 1174        /// * Collection Owner.1175        /// * Collection Admin.1176        /// * Current NFT Owner.1177        /// 1178        /// # Arguments1179        /// 1180        /// * collection_id: ID of the collection.1181        /// 1182        /// * item_id: ID of NFT to burn.1183        #[weight = <T as Config>::WeightInfo::burn_item()]1184        #[transactional]1185        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11861187            let sender = ensure_signed(origin)?;11881189            // Transfer permissions check1190            let target_collection = Self::get_collection(collection_id)?;1191            ensure!(1192                Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1193                (1194                    target_collection.limits.owner_can_transfer &&1195                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1196                ),1197                Error::<T>::NoPermission1198            );11991200            if target_collection.access == AccessMode::WhiteList {1201                Self::check_white_list(&target_collection, &sender)?;1202            }12031204            match target_collection.mode1205            {1206                CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1207                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, &target_collection, value)?,1208                CollectionMode::ReFungible  => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1209                _ => ()1210            };12111212            // call event1213            Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12141215            Ok(())1216        }12171218        /// Change ownership of the token.1219        /// 1220        /// # Permissions1221        /// 1222        /// * Collection Owner1223        /// * Collection Admin1224        /// * Current NFT owner1225        ///1226        /// # Arguments1227        /// 1228        /// * recipient: Address of token recipient.1229        /// 1230        /// * collection_id.1231        /// 1232        /// * item_id: ID of the item1233        ///     * Non-Fungible Mode: Required.1234        ///     * Fungible Mode: Ignored.1235        ///     * Re-Fungible Mode: Required.1236        /// 1237        /// * value: Amount to transfer.1238        ///     * Non-Fungible Mode: Ignored1239        ///     * Fungible Mode: Must specify transferred amount1240        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1241        #[weight = <T as Config>::WeightInfo::transfer()]1242        #[transactional]1243        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1244            let sender = ensure_signed(origin)?;1245            let collection = Self::get_collection(collection_id)?;12461247            Self::transfer_internal(sender, recipient, &collection, item_id, value)1248        }12491250        /// Set, change, or remove approved address to transfer the ownership of the NFT.1251        /// 1252        /// # Permissions1253        /// 1254        /// * Collection Owner1255        /// * Collection Admin1256        /// * Current NFT owner1257        /// 1258        /// # Arguments1259        /// 1260        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1261        /// 1262        /// * collection_id.1263        /// 1264        /// * item_id: ID of the item.1265        #[weight = <T as Config>::WeightInfo::approve()]1266        #[transactional]1267        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12681269            let sender = ensure_signed(origin)?;1270            let target_collection = Self::get_collection(collection_id)?;12711272            Self::token_exists(&target_collection, item_id)?;12731274            // Transfer permissions check1275            let bypasses_limits = target_collection.limits.owner_can_transfer &&1276                Self::is_owner_or_admin_permissions(1277                    &target_collection,1278                    sender.clone(),1279                );12801281            let allowance_limit = if bypasses_limits {1282                None1283            } else if let Some(amount) = Self::owned_amount(1284                sender.clone(),1285                &target_collection,1286                item_id,1287            ) {1288                Some(amount)1289            } else {1290                fail!(Error::<T>::NoPermission);1291            };12921293            if target_collection.access == AccessMode::WhiteList {1294                Self::check_white_list(&target_collection, &sender)?;1295                Self::check_white_list(&target_collection, &spender)?;1296            }12971298            let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1299            let mut allowance: u128 = amount;1300            if allowance_exists {1301                allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1302            }1303            if let Some(limit) = allowance_limit {1304                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1305            }1306            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13071308            Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1309            Ok(())1310        }1311        1312        /// 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.1313        /// 1314        /// # Permissions1315        /// * Collection Owner1316        /// * Collection Admin1317        /// * Current NFT owner1318        /// * Address approved by current NFT owner1319        /// 1320        /// # Arguments1321        /// 1322        /// * from: Address that owns token.1323        /// 1324        /// * recipient: Address of token recipient.1325        /// 1326        /// * collection_id.1327        /// 1328        /// * item_id: ID of the item.1329        /// 1330        /// * value: Amount to transfer.1331        #[weight = <T as Config>::WeightInfo::transfer_from()]1332        #[transactional]1333        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13341335            let sender = ensure_signed(origin)?;1336            let target_collection = Self::get_collection(collection_id)?;13371338            let mut appoved_transfer = false;13391340            // Check approval1341            let mut approval: u128 = 0;1342            if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1343                approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1344                ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1345                appoved_transfer = true;1346            }13471348            // Limits check1349            Self::is_correct_transfer(&target_collection, &recipient)?;13501351            // Transfer permissions check         1352            ensure!(1353                appoved_transfer || 1354                (1355                    target_collection.limits.owner_can_transfer &&1356                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1357                ),1358                Error::<T>::NoPermission1359            );13601361            if target_collection.access == AccessMode::WhiteList {1362                Self::check_white_list(&target_collection, &sender)?;1363                Self::check_white_list(&target_collection, &recipient)?;1364            }13651366            // Reduce approval by transferred amount or remove if remaining approval drops to 01367            if approval.saturating_sub(value) > 0 {1368                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1369            }1370            else {1371                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1372            }13731374            match target_collection.mode1375            {1376                CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1377                CollectionMode::Fungible(_)  => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1378                CollectionMode::ReFungible  => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1379                _ => ()1380            };13811382            Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1383            Ok(())1384        }13851386        // #[weight = 0]1387        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13881389        //     // let no_perm_mes = "You do not have permissions to modify this collection";1390        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1391        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1392        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13931394        //     // // on_nft_received  call13951396        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;13971398        //     Ok(())1399        // }14001401        /// Set off-chain data schema.1402        /// 1403        /// # Permissions1404        /// 1405        /// * Collection Owner1406        /// * Collection Admin1407        /// 1408        /// # Arguments1409        /// 1410        /// * collection_id.1411        /// 1412        /// * schema: String representing the offchain data schema.1413        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1414        #[transactional]1415        pub fn set_variable_meta_data (1416            origin,1417            collection_id: CollectionId,1418            item_id: TokenId,1419            data: Vec<u8>1420        ) -> DispatchResult {1421            let sender = ensure_signed(origin)?;1422            1423            let target_collection = Self::get_collection(collection_id)?;1424            Self::token_exists(&target_collection, item_id)?;14251426            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14271428            // Modify permissions check1429            ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1430                Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1431                Error::<T>::NoPermission);14321433            match target_collection.mode1434            {1435                CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1436                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1437                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1438                _ => fail!(Error::<T>::UnexpectedCollectionType)1439            };14401441            Ok(())1442        }1443 1444        /// Set schema standard1445        /// ImageURL1446        /// Unique1447        /// 1448        /// # Permissions1449        /// 1450        /// * Collection Owner1451        /// * Collection Admin1452        /// 1453        /// # Arguments1454        /// 1455        /// * collection_id.1456        /// 1457        /// * schema: SchemaVersion: enum1458        #[weight = <T as Config>::WeightInfo::set_schema_version()]1459        #[transactional]1460        pub fn set_schema_version(1461            origin,1462            collection_id: CollectionId,1463            version: SchemaVersion1464        ) -> DispatchResult {1465            let sender = ensure_signed(origin)?;1466            let mut target_collection = Self::get_collection(collection_id)?;1467            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1468            target_collection.schema_version = version;1469            Self::save_collection(target_collection);14701471            Ok(())1472        }14731474        /// Set off-chain data schema.1475        /// 1476        /// # Permissions1477        /// 1478        /// * Collection Owner1479        /// * Collection Admin1480        /// 1481        /// # Arguments1482        /// 1483        /// * collection_id.1484        /// 1485        /// * schema: String representing the offchain data schema.1486        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1487        #[transactional]1488        pub fn set_offchain_schema(1489            origin,1490            collection_id: CollectionId,1491            schema: Vec<u8>1492        ) -> DispatchResult {1493            let sender = ensure_signed(origin)?;1494            let mut target_collection = Self::get_collection(collection_id)?;1495            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14961497            // check schema limit1498            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14991500            target_collection.offchain_schema = schema;1501            Self::save_collection(target_collection);15021503            Ok(())1504        }15051506        /// Set const on-chain data schema.1507        /// 1508        /// # Permissions1509        /// 1510        /// * Collection Owner1511        /// * Collection Admin1512        /// 1513        /// # Arguments1514        /// 1515        /// * collection_id.1516        /// 1517        /// * schema: String representing the const on-chain data schema.1518        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1519        #[transactional]1520        pub fn set_const_on_chain_schema (1521            origin,1522            collection_id: CollectionId,1523            schema: Vec<u8>1524        ) -> DispatchResult {1525            let sender = ensure_signed(origin)?;1526            let mut target_collection = Self::get_collection(collection_id)?;1527            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15281529            // check schema limit1530            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15311532            target_collection.const_on_chain_schema = schema;1533            Self::save_collection(target_collection);15341535            Ok(())1536        }15371538        /// Set variable on-chain data schema.1539        /// 1540        /// # Permissions1541        /// 1542        /// * Collection Owner1543        /// * Collection Admin1544        /// 1545        /// # Arguments1546        /// 1547        /// * collection_id.1548        /// 1549        /// * schema: String representing the variable on-chain data schema.1550        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1551        #[transactional]1552        pub fn set_variable_on_chain_schema (1553            origin,1554            collection_id: CollectionId,1555            schema: Vec<u8>1556        ) -> DispatchResult {1557            let sender = ensure_signed(origin)?;1558            let mut target_collection = Self::get_collection(collection_id)?;1559            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15601561            // check schema limit1562            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15631564            target_collection.variable_on_chain_schema = schema;1565            Self::save_collection(target_collection);15661567            Ok(())1568        }15691570        // Sudo permissions function1571        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1572        #[transactional]1573        pub fn set_chain_limits(1574            origin,1575            limits: ChainLimits1576        ) -> DispatchResult {15771578            #[cfg(not(feature = "runtime-benchmarks"))]1579            ensure_root(origin)?;15801581            <ChainLimit>::put(limits);1582            Ok(())1583        }15841585        /// Enable smart contract self-sponsoring.1586        /// 1587        /// # Permissions1588        /// 1589        /// * Contract Owner1590        /// 1591        /// # Arguments1592        /// 1593        /// * contract address1594        /// * enable flag1595        /// 1596        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1597        #[transactional]1598        pub fn enable_contract_sponsoring(1599            origin,1600            contract_address: T::AccountId,1601            enable: bool1602        ) -> DispatchResult {16031604            let sender = ensure_signed(origin)?;16051606            #[cfg(feature = "runtime-benchmarks")]1607            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16081609            Self::ensure_contract_owned(sender, &contract_address)?;16101611            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1612            Ok(())1613        }16141615        /// Set the rate limit for contract sponsoring to specified number of blocks.1616        /// 1617        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1618        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1619        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1620        /// from contract endowment if there are at least B blocks between such transactions. 1621        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1622        /// 1623        /// # Permissions1624        /// 1625        /// * Contract Owner1626        /// 1627        /// # Arguments1628        /// 1629        /// -`contract_address`: Address of the contract to sponsor1630        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1631        /// 1632        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1633        #[transactional]1634        pub fn set_contract_sponsoring_rate_limit(1635            origin,1636            contract_address: T::AccountId,1637            rate_limit: T::BlockNumber1638        ) -> DispatchResult {1639            let sender = ensure_signed(origin)?;16401641            #[cfg(feature = "runtime-benchmarks")]1642            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16431644            Self::ensure_contract_owned(sender, &contract_address)?;1645            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1646            Ok(())1647        }16481649        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1650        /// 1651        /// # Permissions1652        /// 1653        /// * Address that deployed smart contract.1654        /// 1655        /// # Arguments1656        /// 1657        /// -`contract_address`: Address of the contract.1658        /// 1659        /// - `enable`: .  1660        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1661        #[transactional]1662        pub fn toggle_contract_white_list(1663            origin,1664            contract_address: T::AccountId,1665            enable: bool1666        ) -> DispatchResult {1667            let sender = ensure_signed(origin)?;16681669            #[cfg(feature = "runtime-benchmarks")]1670            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16711672            Self::ensure_contract_owned(sender, &contract_address)?;1673            if enable {1674                <ContractWhiteListEnabled<T>>::insert(contract_address, true);1675            } else {1676                <ContractWhiteListEnabled<T>>::remove(contract_address);1677            }1678            Ok(())1679        }1680        1681        /// Add an address to smart contract white list.1682        /// 1683        /// # Permissions1684        /// 1685        /// * Address that deployed smart contract.1686        /// 1687        /// # Arguments1688        /// 1689        /// -`contract_address`: Address of the contract.1690        ///1691        /// -`account_address`: Address to add.1692        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1693        #[transactional]1694        pub fn add_to_contract_white_list(1695            origin,1696            contract_address: T::AccountId,1697            account_address: T::AccountId1698        ) -> DispatchResult {1699            let sender = ensure_signed(origin)?;17001701            #[cfg(feature = "runtime-benchmarks")]1702            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1703            1704            Self::ensure_contract_owned(sender, &contract_address)?;      1705            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1706            Ok(())1707        }17081709        /// Remove an address from smart contract white list.1710        /// 1711        /// # Permissions1712        /// 1713        /// * Address that deployed smart contract.1714        /// 1715        /// # Arguments1716        /// 1717        /// -`contract_address`: Address of the contract.1718        ///1719        /// -`account_address`: Address to remove.1720        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1721        #[transactional]1722        pub fn remove_from_contract_white_list(1723            origin,1724            contract_address: T::AccountId,1725            account_address: T::AccountId1726        ) -> DispatchResult {1727            let sender = ensure_signed(origin)?;17281729            #[cfg(feature = "runtime-benchmarks")]1730            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17311732            Self::ensure_contract_owned(sender, &contract_address)?;1733            <ContractWhiteList<T>>::remove(contract_address, account_address);1734            Ok(())1735        }17361737        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1738        #[transactional]1739        pub fn set_collection_limits(1740            origin,1741            collection_id: u32,1742            new_limits: CollectionLimits<T::BlockNumber>,1743        ) -> DispatchResult {1744            let sender = ensure_signed(origin)?;1745            let mut target_collection = Self::get_collection(collection_id)?;1746            Self::check_owner_permissions(&target_collection, sender.clone())?;1747            let old_limits = &target_collection.limits;1748            let chain_limits = ChainLimit::get();17491750            // collection bounds1751            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1752                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1753                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1754                Error::<T>::CollectionLimitBoundsExceeded);17551756            // token_limit   check  prev1757            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1758            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17591760            ensure!(1761                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1762                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1763                Error::<T>::OwnerPermissionsCantBeReverted,1764            );17651766            target_collection.limits = new_limits;1767            Self::save_collection(target_collection);17681769            Ok(())1770        } 1771    }1772}17731774impl<T: Config> Module<T> {17751776    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1777        // Limits check1778        Self::is_correct_transfer(target_collection, &recipient)?;17791780        // Transfer permissions check1781        ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1782            Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1783            Error::<T>::NoPermission);17841785        if target_collection.access == AccessMode::WhiteList {1786            Self::check_white_list(target_collection, &sender)?;1787            Self::check_white_list(target_collection, &recipient)?;1788        }17891790        match target_collection.mode1791        {1792            CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1793            CollectionMode::Fungible(_)  => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1794            CollectionMode::ReFungible  => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1795            _ => ()1796        };17971798        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17991800        Ok(())1801    }180218031804    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1805        let collection_id = collection.id;18061807        // check token limit and account token limit1808        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1809        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1810        1811        Ok(())1812    }18131814    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1815        let collection_id = collection.id;18161817        // check token limit and account token limit1818        let total_items: u32 = ItemListIndex::get(collection_id)1819            .checked_add(amount)1820            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1821        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1822            .checked_add(amount)1823            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1824        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1825        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);18261827        if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1828            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1829            Self::check_white_list(collection, owner)?;1830            Self::check_white_list(collection, sender)?;1831        }18321833        Ok(())1834    }18351836    fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1837        match target_collection.mode1838        {1839            CollectionMode::NFT => {1840                if let CreateItemData::NFT(data) = data {1841                    // check sizes1842                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1843                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1844                } else {1845                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1846                }1847            },1848            CollectionMode::Fungible(_) => {1849                if let CreateItemData::Fungible(_) = data {1850                } else {1851                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1852                }1853            },1854            CollectionMode::ReFungible => {1855                if let CreateItemData::ReFungible(data) = data {18561857                    // check sizes1858                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1859                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18601861                    // Check refungibility limits1862                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1863                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1864                } else {1865                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1866                }1867            },1868            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1869        };18701871        Ok(())1872    }18731874    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1875        match data1876        {1877            CreateItemData::NFT(data) => {1878                let item = NftItemType {1879                    owner: owner.clone(),1880                    const_data: data.const_data,1881                    variable_data: data.variable_data1882                };18831884                Self::add_nft_item(collection, item)?;1885            },1886            CreateItemData::Fungible(data) => {1887                Self::add_fungible_item(collection, &owner, data.value)?;1888            },1889            CreateItemData::ReFungible(data) => {1890                let mut owner_list = Vec::new();1891                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18921893                let item = ReFungibleItemType {1894                    owner: owner_list,1895                    const_data: data.const_data,1896                    variable_data: data.variable_data1897                };18981899                Self::add_refungible_item(collection, item)?;1900            }1901        };19021903        Ok(())1904    }19051906    fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1907        let collection_id = collection.id;19081909        // Does new owner already have an account?1910        let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19111912        // Mint 1913        let item = FungibleItemType {1914            value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1915        };1916        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19171918        // Update balance1919        let new_balance = <Balance<T>>::get(collection_id, owner)1920            .checked_add(value)1921            .ok_or(Error::<T>::NumOverflow)?;1922        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19231924        Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1925        Ok(())1926    }19271928    fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1929        let collection_id = collection.id;19301931        let current_index = <ItemListIndex>::get(collection_id)1932            .checked_add(1)1933            .ok_or(Error::<T>::NumOverflow)?;1934        let itemcopy = item.clone();19351936        ensure!(1937            item.owner.len() == 1,1938            Error::<T>::BadCreateRefungibleCall,1939        );1940        let item_owner = item.owner.first().expect("only one owner is defined");19411942        let value = item_owner.fraction;1943        let owner = item_owner.owner.clone();19441945        Self::add_token_index(collection_id, current_index, &owner)?;19461947        <ItemListIndex>::insert(collection_id, current_index);1948        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19491950        // Update balance1951        let new_balance = <Balance<T>>::get(collection_id, &owner)1952            .checked_add(value)1953            .ok_or(Error::<T>::NumOverflow)?;1954        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19551956        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1957        Ok(())1958    }19591960    fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1961        let collection_id = collection.id;19621963        let current_index = <ItemListIndex>::get(collection_id)1964            .checked_add(1)1965            .ok_or(Error::<T>::NumOverflow)?;19661967        let item_owner = item.owner.clone();1968        Self::add_token_index(collection_id, current_index, &item.owner)?;19691970        <ItemListIndex>::insert(collection_id, current_index);1971        <NftItemList<T>>::insert(collection_id, current_index, item);19721973        // Update balance1974        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1975            .checked_add(1)1976            .ok_or(Error::<T>::NumOverflow)?;1977        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19781979        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1980        Ok(())1981    }19821983    fn burn_refungible_item(1984        collection: &CollectionHandle<T>,1985        item_id: TokenId,1986        owner: &T::AccountId,1987    ) -> DispatchResult {1988        let collection_id = collection.id;19891990        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1991            .ok_or(Error::<T>::TokenNotFound)?;1992        let rft_balance = token1993            .owner1994            .iter()1995            .find(|&i| i.owner == *owner)1996            .ok_or(Error::<T>::TokenNotFound)?;1997        Self::remove_token_index(collection_id, item_id, owner)?;19981999        // update balance2000        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2001            .checked_sub(rft_balance.fraction)2002            .ok_or(Error::<T>::NumOverflow)?;2003        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20042005        // Re-create owners list with sender removed2006        let index = token2007            .owner2008            .iter()2009            .position(|i| i.owner == *owner)2010            .expect("owned item is exists");2011        token.owner.remove(index);2012        let owner_count = token.owner.len();20132014        // Burn the token completely if this was the last (only) owner2015        if owner_count == 0 {2016            <ReFungibleItemList<T>>::remove(collection_id, item_id);2017            <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2018        }2019        else {2020            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2021        }20222023        Ok(())2024    }20252026    fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2027        let collection_id = collection.id;20282029        let item = <NftItemList<T>>::get(collection_id, item_id)2030            .ok_or(Error::<T>::TokenNotFound)?;2031        Self::remove_token_index(collection_id, item_id, &item.owner)?;20322033        // update balance2034        let new_balance = <Balance<T>>::get(collection_id, &item.owner)2035            .checked_sub(1)2036            .ok_or(Error::<T>::NumOverflow)?;2037        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2038        <NftItemList<T>>::remove(collection_id, item_id);2039        <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20402041        Ok(())2042    }20432044    fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2045        let collection_id = collection.id;20462047        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2048        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20492050        // update balance2051        let new_balance = <Balance<T>>::get(collection_id, owner)2052            .checked_sub(value)2053            .ok_or(Error::<T>::NumOverflow)?;2054        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20552056        if balance.value - value > 0 {2057            balance.value -= value;2058            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2059        }2060        else {2061            <FungibleItemList<T>>::remove(collection_id, owner);2062        }20632064        Ok(())2065    }20662067    pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2068        Ok(<CollectionById<T>>::get(collection_id)2069            .map(|collection| CollectionHandle {2070                id: collection_id,2071                collection2072            })2073            .ok_or(Error::<T>::CollectionNotFound)?)2074    }20752076    fn save_collection(collection: CollectionHandle<T>) {2077        <CollectionById<T>>::insert(collection.id, collection.collection);2078    }20792080    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2081        ensure!(2082            subject == target_collection.owner,2083            Error::<T>::NoPermission2084        );20852086        Ok(())2087    }20882089    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2090        subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2091    }20922093    fn check_owner_or_admin_permissions(2094        collection: &CollectionHandle<T>,2095        subject: T::AccountId,2096    ) -> DispatchResult {2097        ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);20982099        Ok(())2100    }21012102    fn owned_amount(2103        subject: T::AccountId,2104        target_collection: &CollectionHandle<T>,2105        item_id: TokenId,2106    ) -> Option<u128> {2107        let collection_id = target_collection.id;21082109        match target_collection.mode {2110            CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2111                .then(|| 1),2112            CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2113                .value),2114            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2115                .owner2116                .iter()2117                .find(|i| i.owner == subject)2118                .map(|i| i.fraction),2119            CollectionMode::Invalid => None,2120        }2121    }21222123    fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2124        match target_collection.mode {2125            CollectionMode::Fungible(_) => true,2126            _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2127        }2128    }21292130    fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2131        let collection_id = collection.id;21322133        let mes = Error::<T>::AddresNotInWhiteList;2134        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21352136        Ok(())2137    }21382139    /// Check if token exists. In case of Fungible, check if there is an entry for 2140    /// the owner in fungible balances double map2141    fn token_exists(2142        target_collection: &CollectionHandle<T>,2143        item_id: TokenId,2144    ) -> DispatchResult {2145        let collection_id = target_collection.id;2146        let exists = match target_collection.mode2147        {2148            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2149            CollectionMode::Fungible(_)  => true,2150            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2151            _ => false2152        };21532154        ensure!(exists == true, Error::<T>::TokenNotFound);2155        Ok(())2156    }21572158    fn transfer_fungible(2159        collection: &CollectionHandle<T>,2160        value: u128,2161        owner: &T::AccountId,2162        recipient: &T::AccountId,2163    ) -> DispatchResult {2164        let collection_id = collection.id;21652166        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2167        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21682169        // Send balance to recipient (updates balanceOf of recipient)2170        Self::add_fungible_item(collection, recipient, value)?;21712172        // update balanceOf of sender2173        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21742175        // Reduce or remove sender2176        if balance.value == value {2177            <FungibleItemList<T>>::remove(collection_id, owner);2178        }2179        else {2180            balance.value -= value;2181            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2182        }21832184        Ok(())2185    }21862187    fn transfer_refungible(2188        collection: &CollectionHandle<T>,2189        item_id: TokenId,2190        value: u128,2191        owner: T::AccountId,2192        new_owner: T::AccountId,2193    ) -> DispatchResult {2194        let collection_id = collection.id;2195        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2196            .ok_or(Error::<T>::TokenNotFound)?;21972198        let item = full_item2199            .owner2200            .iter()2201            .filter(|i| i.owner == owner)2202            .next()2203            .ok_or(Error::<T>::TokenNotFound)?;2204        let amount = item.fraction;22052206        ensure!(amount >= value, Error::<T>::TokenValueTooLow);22072208        // update balance2209        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2210            .checked_sub(value)2211            .ok_or(Error::<T>::NumOverflow)?;2212        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22132214        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2215            .checked_add(value)2216            .ok_or(Error::<T>::NumOverflow)?;2217        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22182219        let old_owner = item.owner.clone();2220        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22212222        // transfer2223        if amount == value && !new_owner_has_account {2224            // change owner2225            // new owner do not have account2226            let mut new_full_item = full_item.clone();2227            new_full_item2228                .owner2229                .iter_mut()2230                .find(|i| i.owner == owner)2231                .expect("old owner does present in refungible")2232                .owner = new_owner.clone();2233            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22342235            // update index collection2236            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2237        } else {2238            let mut new_full_item = full_item.clone();2239            new_full_item2240                .owner2241                .iter_mut()2242                .find(|i| i.owner == owner)2243                .expect("old owner does present in refungible")2244                .fraction -= value;22452246            // separate amount2247            if new_owner_has_account {2248                // new owner has account2249                new_full_item2250                    .owner2251                    .iter_mut()2252                    .find(|i| i.owner == new_owner)2253                    .expect("new owner has account")2254                    .fraction += value;2255            } else {2256                // new owner do not have account2257                new_full_item.owner.push(Ownership {2258                    owner: new_owner.clone(),2259                    fraction: value,2260                });2261                Self::add_token_index(collection_id, item_id, &new_owner)?;2262            }22632264            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2265        }22662267        Ok(())2268    }22692270    fn transfer_nft(2271        collection: &CollectionHandle<T>,2272        item_id: TokenId,2273        sender: T::AccountId,2274        new_owner: T::AccountId,2275    ) -> DispatchResult {2276        let collection_id = collection.id;2277        let mut item = <NftItemList<T>>::get(collection_id, item_id)2278            .ok_or(Error::<T>::TokenNotFound)?;22792280        ensure!(2281            sender == item.owner,2282            Error::<T>::MustBeTokenOwner2283        );22842285        // update balance2286        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2287            .checked_sub(1)2288            .ok_or(Error::<T>::NumOverflow)?;2289        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22902291        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2292            .checked_add(1)2293            .ok_or(Error::<T>::NumOverflow)?;2294        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22952296        // change owner2297        let old_owner = item.owner.clone();2298        item.owner = new_owner.clone();2299        <NftItemList<T>>::insert(collection_id, item_id, item);23002301        // update index collection2302        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23032304        Ok(())2305    }2306    2307    fn set_re_fungible_variable_data(2308        collection: &CollectionHandle<T>,2309        item_id: TokenId,2310        data: Vec<u8>2311    ) -> DispatchResult {2312        let collection_id = collection.id;2313        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2314            .ok_or(Error::<T>::TokenNotFound)?;23152316        item.variable_data = data;23172318        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23192320        Ok(())2321    }23222323    fn set_nft_variable_data(2324        collection: &CollectionHandle<T>,2325        item_id: TokenId,2326        data: Vec<u8>2327    ) -> DispatchResult {2328        let collection_id = collection.id;2329        let mut item = <NftItemList<T>>::get(collection_id, item_id)2330            .ok_or(Error::<T>::TokenNotFound)?;2331        2332        item.variable_data = data;23332334        <NftItemList<T>>::insert(collection_id, item_id, item);2335        2336        Ok(())2337    }23382339    fn init_collection(item: &Collection<T>) {2340        // check params2341        assert!(2342            item.decimal_points <= MAX_DECIMAL_POINTS,2343            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2344        );2345        assert!(2346            item.name.len() <= 64,2347            "Collection name can not be longer than 63 char"2348        );2349        assert!(2350            item.name.len() <= 256,2351            "Collection description can not be longer than 255 char"2352        );2353        assert!(2354            item.token_prefix.len() <= 16,2355            "Token prefix can not be longer than 15 char"2356        );23572358        // Generate next collection ID2359        let next_id = CreatedCollectionCount::get()2360            .checked_add(1)2361            .unwrap();23622363        CreatedCollectionCount::put(next_id);2364    }23652366    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2367        let current_index = <ItemListIndex>::get(collection_id)2368            .checked_add(1)2369            .unwrap();23702371        let item_owner = item.owner.clone();2372        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23732374        <ItemListIndex>::insert(collection_id, current_index);23752376        // Update balance2377        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2378            .checked_add(1)2379            .unwrap();2380        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2381    }23822383    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2384        let current_index = <ItemListIndex>::get(collection_id)2385            .checked_add(1)2386            .unwrap();23872388        Self::add_token_index(collection_id, current_index, owner).unwrap();23892390        <ItemListIndex>::insert(collection_id, current_index);23912392        // Update balance2393        let new_balance = <Balance<T>>::get(collection_id, owner)2394            .checked_add(item.value)2395            .unwrap();2396        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2397    }23982399    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2400        let current_index = <ItemListIndex>::get(collection_id)2401            .checked_add(1)2402            .unwrap();24032404        let value = item.owner.first().unwrap().fraction;2405        let owner = item.owner.first().unwrap().owner.clone();24062407        Self::add_token_index(collection_id, current_index, &owner).unwrap();24082409        <ItemListIndex>::insert(collection_id, current_index);24102411        // Update balance2412        let new_balance = <Balance<T>>::get(collection_id, &owner)2413            .checked_add(value)2414            .unwrap();2415        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2416    }24172418    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2419        // add to account limit2420        if <AccountItemCount<T>>::contains_key(owner) {24212422            // bound Owned tokens by a single address2423            let count = <AccountItemCount<T>>::get(owner);2424            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24252426            <AccountItemCount<T>>::insert(owner.clone(), count2427                .checked_add(1)2428                .ok_or(Error::<T>::NumOverflow)?);2429        }2430        else {2431            <AccountItemCount<T>>::insert(owner.clone(), 1);2432        }24332434        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2435        if list_exists {2436            let mut list = <AddressTokens<T>>::get(collection_id, owner);2437            let item_contains = list.contains(&item_index.clone());24382439            if !item_contains {2440                list.push(item_index.clone());2441            }24422443            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2444        } else {2445            let mut itm = Vec::new();2446            itm.push(item_index.clone());2447            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2448        }24492450        Ok(())2451    }24522453    fn remove_token_index(2454        collection_id: CollectionId,2455        item_index: TokenId,2456        owner: &T::AccountId,2457    ) -> DispatchResult {24582459        // update counter2460        <AccountItemCount<T>>::insert(owner.clone(), 2461            <AccountItemCount<T>>::get(owner)2462            .checked_sub(1)2463            .ok_or(Error::<T>::NumOverflow)?);246424652466        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2467        if list_exists {2468            let mut list = <AddressTokens<T>>::get(collection_id, owner);2469            let item_contains = list.contains(&item_index.clone());24702471            if item_contains {2472                list.retain(|&item| item != item_index);2473                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2474            }2475        }24762477        Ok(())2478    }24792480    fn move_token_index(2481        collection_id: CollectionId,2482        item_index: TokenId,2483        old_owner: &T::AccountId,2484        new_owner: &T::AccountId,2485    ) -> DispatchResult {2486        Self::remove_token_index(collection_id, item_index, old_owner)?;2487        Self::add_token_index(collection_id, item_index, new_owner)?;24882489        Ok(())2490    }2491    2492    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2493        ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);24942495        Ok(())2496    }2497}24982499////////////////////////////////////////////////////////////////////////////////////////////////////2500// Economic models2501// #region25022503/// Fee multiplier.2504pub type Multiplier = FixedU128;25052506type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25072508/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2509/// in the queue.2510#[derive(Encode, Decode, Clone, Eq, PartialEq)]2511pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25122513impl<T: Config + Send + Sync> sp_std::fmt::Debug 2514    for ChargeTransactionPayment<T>2515{2516	#[cfg(feature = "std")]2517	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2518		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2519	}2520	#[cfg(not(feature = "std"))]2521	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2522		Ok(())2523	}2524}25252526impl<T: Config> ChargeTransactionPayment<T>2527where2528    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2529    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2530    T::AccountId: AsRef<[u8]>,2531    T::AccountId: UncheckedFrom<T::Hash>,2532{2533    fn traditional_fee(2534        len: usize,2535        info: &DispatchInfoOf<T::Call>,2536        tip: BalanceOf<T>,2537    ) -> BalanceOf<T>2538    where2539        T::Call: Dispatchable<Info = DispatchInfo>,2540    {2541        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2542    }25432544	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2545        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2546        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2547        let len_saturation = max_block_length as u64 / (len as u64).max(1);2548        let coefficient: BalanceOf<T> = weight_saturation2549            .min(len_saturation)2550            .saturated_into::<BalanceOf<T>>();2551        final_fee2552            .saturating_mul(coefficient)2553            .saturated_into::<TransactionPriority>()2554    }25552556    fn withdraw_fee(2557        &self,2558        who: &T::AccountId,2559        call: &T::Call,2560        info: &DispatchInfoOf<T::Call>,2561        len: usize,2562	) -> Result<2563		(2564			BalanceOf<T>,2565			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2566		),2567		TransactionValidityError,2568	> {2569        let tip = self.0;25702571        let fee = Self::traditional_fee(len, info, tip);25722573        // Only mess with balances if fee is not zero.2574        if fee.is_zero() {2575            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2576			.map(|i| (fee, i));2577        }25782579        // Determine who is paying transaction fee based on ecnomic model2580        // Parse call to extract collection ID and access collection sponsor2581        let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2582            Some(Call::create_item(collection_id, _owner, _properties)) => {2583                let collection = <CollectionById<T>>::get(collection_id)?;25842585                // sponsor timeout2586                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25872588                let limit = collection.limits.sponsor_transfer_timeout;2589                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2590                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2591                    let limit_time = last_tx_block + limit.into();2592                    if block_number <= limit_time {2593                        return None;2594                    }2595                }2596                <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);25972598                // check free create limit2599                if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2600                    collection.sponsorship.sponsor()2601                        .cloned()2602                } else {2603                    None2604                }2605            }2606            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2607                let collection = <CollectionById<T>>::get(collection_id)?;2608                2609                let mut sponsor_transfer = false;2610                if collection.sponsorship.confirmed() {26112612                    let collection_limits = collection.limits;2613                    let collection_mode = collection.mode;2614    2615                    // sponsor timeout2616                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2617                    sponsor_transfer = match collection_mode {2618                        CollectionMode::NFT => {2619    2620                            // get correct limit2621                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2622                                collection_limits.sponsor_transfer_timeout2623                            } else {2624                                ChainLimit::get().nft_sponsor_transfer_timeout2625                            };2626    2627                            let mut sponsored = true;2628                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2629                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2630                                let limit_time = last_tx_block + limit.into();2631                                if block_number <= limit_time {2632                                    sponsored = false;2633                                }2634                            }2635                            if sponsored {2636                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2637                            }26382639                            sponsored2640                        }2641                        CollectionMode::Fungible(_) => {2642    2643                            // get correct limit2644                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2645                                collection_limits.sponsor_transfer_timeout2646                            } else {2647                                ChainLimit::get().fungible_sponsor_transfer_timeout2648                            };2649    2650                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2651                            let mut sponsored = true;2652                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2653                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2654                                let limit_time = last_tx_block + limit.into();2655                                if block_number <= limit_time {2656                                    sponsored = false;2657                                }2658                            }2659                            if sponsored {2660                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2661                            }26622663                            sponsored2664                        }2665                        CollectionMode::ReFungible => {2666    2667                            // get correct limit2668                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2669                                collection_limits.sponsor_transfer_timeout2670                            } else {2671                                ChainLimit::get().refungible_sponsor_transfer_timeout2672                            };2673    2674                            let mut sponsored = true;2675                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2676                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2677                                let limit_time = last_tx_block + limit.into();2678                                if block_number <= limit_time {2679                                    sponsored = false;2680                                }2681                            }2682                            if sponsored {2683                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2684                            }26852686                            sponsored2687                        }2688                        _ => {2689                            false2690                        },2691                    };2692                }26932694                if !sponsor_transfer {2695                    None2696                } else {2697                    collection.sponsorship.sponsor()2698                        .cloned()2699                }2700            }27012702            Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2703                let mut sponsor_metadata_changes = false;27042705                let collection = <CollectionById<T>>::get(collection_id)?;27062707                if2708                    collection.sponsorship.confirmed() &&2709                    // Can't sponsor fungible collection, this tx will be rejected2710                    // as invalid2711                    !matches!(collection.mode, CollectionMode::Fungible(_)) &&2712                    data.len() <= collection.limits.sponsored_data_size as usize2713                {2714                    if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2715                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27162717                        if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2718                            .map(|last_block| block_number - last_block > rate_limit)2719                            .unwrap_or(true) 2720                        {2721                            sponsor_metadata_changes = true;2722                            <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2723                        }2724                    }2725                }27262727                if !sponsor_metadata_changes {2728                    None2729                } else {2730                    collection.sponsorship.sponsor().cloned()2731                }2732            }27332734            _ => None,2735        })();27362737        match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2738            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27392740                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27412742                let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2743                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2744                  2745                if !owned_contract && white_list_enabled {2746                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2747                        return Err(InvalidTransaction::Call.into());2748                    }2749                }2750            },2751            _ => {},2752        }27532754        // Sponsor smart contracts2755        sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27562757            // On instantiation: set the contract owner2758            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27592760                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2761                    &who,2762                    code_hash,2763                    salt,2764                );2765                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27662767                None2768            },27692770            // On instantiation with code: set the contract owner2771            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {27722773                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2774                    &who,2775                    &T::Hashing::hash(&_code),2776                    _salt,2777                );27782779                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27802781                None2782            }27832784            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2785            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27862787                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27882789                let mut sponsor_transfer = false;2790                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2791                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2792                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2793                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2794                    let limit_time = last_tx_block + rate_limit;27952796                    if block_number >= limit_time {2797                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2798                        sponsor_transfer = true;2799                    }2800                } else {2801                    sponsor_transfer = false;2802                }2803               2804                if sponsor_transfer {2805                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2806                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2807                            return Some(called_contract);2808                        }2809                    }2810                }28112812                None2813            },28142815            _ => None,2816        });28172818        let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28192820		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2821			.map(|i| (fee, i))2822    }2823}282428252826impl<T: Config + Send + Sync> SignedExtension2827    for ChargeTransactionPayment<T>2828where2829    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2830    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2831    T::AccountId: AsRef<[u8]>,2832    T::AccountId: UncheckedFrom<T::Hash>,2833{2834    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2835    type AccountId = T::AccountId;2836    type Call = T::Call;2837    type AdditionalSigned = ();2838    type Pre = (2839        // tip2840        BalanceOf<T>,2841        // who pays fee2842        Self::AccountId,2843		// imbalance resulting from withdrawing the fee2844		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2845    );2846    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2847        Ok(())2848    }28492850    fn validate(2851        &self,2852        who: &Self::AccountId,2853        call: &Self::Call,2854        info: &DispatchInfoOf<Self::Call>,2855        len: usize,2856    ) -> TransactionValidity {2857		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2858		Ok(ValidTransaction {2859			priority: Self::get_priority(len, info, fee),2860			..Default::default()2861		})2862    }28632864    fn pre_dispatch(2865        self,2866        who: &Self::AccountId,2867        call: &Self::Call,2868        info: &DispatchInfoOf<Self::Call>,2869        len: usize,2870    ) -> Result<Self::Pre, TransactionValidityError> {2871        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2872        Ok((self.0, who.clone(), imbalance))2873    }28742875    fn post_dispatch(2876        pre: Self::Pre,2877        info: &DispatchInfoOf<Self::Call>,2878        post_info: &PostDispatchInfoOf<Self::Call>,2879        len: usize,2880        _result: &DispatchResult,2881    ) -> Result<(), TransactionValidityError> {2882		let (tip, who, imbalance) = pre;2883		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2884			len as u32,2885			info,2886			post_info,2887			tip,2888		);2889		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2890		Ok(())2891    }2892}28932894// #endregion