git.delta.rocks / unique-network / refs/commits / 24bc802b4d0c

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 serde::*;1213use core::ops::{Deref, DerefMut};14use codec::{Decode, Encode};15pub use frame_support::{16    construct_runtime, decl_event, decl_module, decl_storage, decl_error,17    dispatch::DispatchResult,18    ensure, fail, parameter_types,19    traits::{20        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,21        Randomness, IsSubType, WithdrawReasons,22    },23    weights::{24        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},25        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,26        WeightToFeePolynomial, DispatchClass,27    },28    StorageValue,29    transactional,30};3132use frame_system::{self as system, ensure_signed, ensure_root};33use sp_core::{H160, H256};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36    traits::{37        Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38    },39    transaction_validity::{40        TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41    },42    FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_evm::AddressMapping;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;56mod eth;5758pub use eth::account::*;5960pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;61pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;62pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;63pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6465// Structs66// #region6768pub type CollectionId = u32;69pub type TokenId = u32;70pub type DecimalPoints = u8;7172#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]73#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]74pub enum CollectionMode {75    Invalid,76    NFT,77    // decimal points78    Fungible(DecimalPoints),79    ReFungible,80}8182impl Default for CollectionMode {83    fn default() -> Self {84        Self::Invalid85    }86}8788impl Into<u8> for CollectionMode {89    fn into(self) -> u8 {90        match self {91            CollectionMode::Invalid => 0,92            CollectionMode::NFT => 1,93            CollectionMode::Fungible(_) => 2,94            CollectionMode::ReFungible => 3,95        }96    }97}9899#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]100#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]101pub enum AccessMode {102    Normal,103    WhiteList,104}105impl Default for AccessMode {106    fn default() -> Self {107        Self::Normal108    }109}110111#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]112#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]113pub enum SchemaVersion {114    ImageURL,115    Unique,116}117impl Default for SchemaVersion {118    fn default() -> Self {119        Self::ImageURL120    }121}122123#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]124#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]125pub struct Ownership<AccountId> {126    pub owner: AccountId,127    pub fraction: u128,128}129130#[derive(Encode, Decode, Debug, Clone, PartialEq)]131#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]132pub enum SponsorshipState<AccountId> {133    /// The fees are applied to the transaction sender134    Disabled,135    Unconfirmed(AccountId),136    /// Transactions are sponsored by specified account137    Confirmed(AccountId),138}139140impl<AccountId> SponsorshipState<AccountId> {141    fn sponsor(&self) -> Option<&AccountId> {142        match self {143            Self::Confirmed(sponsor) => Some(sponsor),144            _ => None,145        }146    }147148    fn pending_sponsor(&self) -> Option<&AccountId> {149        match self {150            Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),151            _ => None,152        }153    }154155    fn confirmed(&self) -> bool {156        matches!(self, Self::Confirmed(_))157    }158}159160impl<T> Default for SponsorshipState<T> {161    fn default() -> Self {162        Self::Disabled163    }164}165166#[derive(Encode, Decode, Clone, PartialEq)]167#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]168pub struct Collection<T: Config> {169    pub owner: T::CrossAccountId,170    pub mode: CollectionMode,171    pub access: AccessMode,172    pub decimal_points: DecimalPoints,173    pub name: Vec<u16>,        // 64 include null escape char174    pub description: Vec<u16>, // 256 include null escape char175    pub token_prefix: Vec<u8>, // 16 include null escape char176    pub mint_mode: bool,177    pub offchain_schema: Vec<u8>,178    pub schema_version: SchemaVersion,179    pub sponsorship: SponsorshipState<T::AccountId>,180    pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 181    pub variable_on_chain_schema: Vec<u8>, //182    pub const_on_chain_schema: Vec<u8>, //183}184185pub struct CollectionHandle<T: Config> {186    pub id: CollectionId,187    collection: Collection<T>,188}189190impl<T: Config> Deref for CollectionHandle<T> {191    type Target = Collection<T>;192193    fn deref(&self) -> &Self::Target {194        &self.collection195    }196}197198impl<T: Config> DerefMut for CollectionHandle<T> {199    fn deref_mut(&mut self) -> &mut Self::Target {200        &mut self.collection201    }202}203204#[derive(Encode, Decode, Debug, Clone, PartialEq)]205#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]206pub struct NftItemType<AccountId> {207    pub owner: AccountId,208    pub const_data: Vec<u8>,209    pub variable_data: Vec<u8>,210}211212#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]213#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]214pub struct FungibleItemType {215    pub value: u128,216}217218#[derive(Encode, Decode, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct ReFungibleItemType<AccountId> {221    pub owner: Vec<Ownership<AccountId>>,222    pub const_data: Vec<u8>,223    pub variable_data: Vec<u8>,224}225226// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]227// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]228// pub struct VestingItem<AccountId, Moment> {229//     pub sender: AccountId,230//     pub recipient: AccountId,231//     pub collection_id: CollectionId,232//     pub item_id: TokenId,233//     pub amount: u64,234//     pub vesting_date: Moment,235// }236237#[derive(Encode, Decode, Debug, Clone, PartialEq)]238#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]239pub struct CollectionLimits<BlockNumber: Encode + Decode> {240    pub account_token_ownership_limit: u32,241    pub sponsored_data_size: u32,242    /// None - setVariableMetadata is not sponsored243    /// Some(v) - setVariableMetadata is sponsored 244    ///           if there is v block between txs245    pub sponsored_data_rate_limit: Option<BlockNumber>,246    pub token_limit: u32,247248    // Timeouts for item types in passed blocks249    pub sponsor_transfer_timeout: u32,250    pub owner_can_transfer: bool,251    pub owner_can_destroy: bool,252}253254impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {255    fn default() -> Self {256        Self { 257            account_token_ownership_limit: 10_000_000, 258            token_limit: u32::max_value(),259            sponsored_data_size: u32::MAX, 260            sponsored_data_rate_limit: None,261            sponsor_transfer_timeout: 14400,262            owner_can_transfer: true,263            owner_can_destroy: true264        }265    }266}267268#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]269#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]270pub struct ChainLimits {271    pub collection_numbers_limit: u32,272    pub account_token_ownership_limit: u32,273    pub collections_admins_limit: u64,274    pub custom_data_limit: u32,275276    // Timeouts for item types in passed blocks277    pub nft_sponsor_transfer_timeout: u32,278    pub fungible_sponsor_transfer_timeout: u32,279    pub refungible_sponsor_transfer_timeout: u32,280281    // Schema limits282    pub offchain_schema_limit: u32,283    pub variable_on_chain_schema_limit: u32,284    pub const_on_chain_schema_limit: u32,285}286287pub trait WeightInfo {288	fn create_collection() -> Weight;289	fn destroy_collection() -> Weight;290	fn add_to_white_list() -> Weight;291	fn remove_from_white_list() -> Weight;292    fn set_public_access_mode() -> Weight;293    fn set_mint_permission() -> Weight;294    fn change_collection_owner() -> Weight;295    fn add_collection_admin() -> Weight;296    fn remove_collection_admin() -> Weight;297    fn set_collection_sponsor() -> Weight;298    fn confirm_sponsorship() -> Weight;299    fn remove_collection_sponsor() -> Weight;300    fn create_item(s: usize) -> Weight;301    fn burn_item() -> Weight;302    fn transfer() -> Weight;303    fn approve() -> Weight;304    fn transfer_from() -> Weight;305    fn set_offchain_schema() -> Weight;306    fn set_const_on_chain_schema() -> Weight;307    fn set_variable_on_chain_schema() -> Weight;308    fn set_variable_meta_data() -> Weight;309    fn enable_contract_sponsoring() -> Weight;310    fn set_schema_version() -> Weight;311    fn set_chain_limits() -> Weight;312    fn set_contract_sponsoring_rate_limit() -> Weight;313    fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;314    fn toggle_contract_white_list() -> Weight;315    fn add_to_contract_white_list() -> Weight;316    fn remove_from_contract_white_list() -> Weight;317    fn set_collection_limits() -> Weight;318}319320#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]321#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]322pub struct CreateNftData {323    pub const_data: Vec<u8>,324    pub variable_data: Vec<u8>,325}326327#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]328#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]329pub struct CreateFungibleData {330    pub value: u128,331}332333#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]334#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]335pub struct CreateReFungibleData {336    pub const_data: Vec<u8>,337    pub variable_data: Vec<u8>,338    pub pieces: u128,339}340341#[derive(Encode, Decode, Debug, Clone, PartialEq)]342#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]343pub enum CreateItemData {344    NFT(CreateNftData),345    Fungible(CreateFungibleData),346    ReFungible(CreateReFungibleData),347}348349impl CreateItemData {350    pub fn len(&self) -> usize {351        let len = match self {352            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),353            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),354            _ => 0355        };356        357        return len;358    }359}360361impl From<CreateNftData> for CreateItemData {362    fn from(item: CreateNftData) -> Self {363        CreateItemData::NFT(item)364    }365}366367impl From<CreateReFungibleData> for CreateItemData {368    fn from(item: CreateReFungibleData) -> Self {369        CreateItemData::ReFungible(item)370    }371}372373impl From<CreateFungibleData> for CreateItemData {374    fn from(item: CreateFungibleData) -> Self {375        CreateItemData::Fungible(item)376    }377}378379380decl_error! {381	/// Error for non-fungible-token module.382	pub enum Error for Module<T: Config> {383        /// Total collections bound exceeded.384        TotalCollectionsLimitExceeded,385		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.386        CollectionDecimalPointLimitExceeded, 387        /// Collection name can not be longer than 63 char.388        CollectionNameLimitExceeded, 389        /// Collection description can not be longer than 255 char.390        CollectionDescriptionLimitExceeded, 391        /// Token prefix can not be longer than 15 char.392        CollectionTokenPrefixLimitExceeded,393        /// This collection does not exist.394        CollectionNotFound,395        /// Item not exists.396        TokenNotFound,397        /// Admin not found398        AdminNotFound,399        /// Arithmetic calculation overflow.400        NumOverflow,       401        /// Account already has admin role.402        AlreadyAdmin,  403        /// You do not own this collection.404        NoPermission,405        /// This address is not set as sponsor, use setCollectionSponsor first.406        ConfirmUnsetSponsorFail,407        /// Collection is not in mint mode.408        PublicMintingNotAllowed,409        /// Sender parameter and item owner must be equal.410        MustBeTokenOwner,411        /// Item balance not enough.412        TokenValueTooLow,413        /// Size of item is too large.414        NftSizeLimitExceeded,415        /// No approve found416        ApproveNotFound,417        /// Requested value more than approved.418        TokenValueNotEnough,419        /// Only approved addresses can call this method.420        ApproveRequired,421        /// Address is not in white list.422        AddresNotInWhiteList,423        /// Number of collection admins bound exceeded.424        CollectionAdminsLimitExceeded,425        /// Owned tokens by a single address bound exceeded.426        AddressOwnershipLimitExceeded,427        /// Length of items properties must be greater than 0.428        EmptyArgument,429        /// const_data exceeded data limit.430        TokenConstDataLimitExceeded,431        /// variable_data exceeded data limit.432        TokenVariableDataLimitExceeded,433        /// Not NFT item data used to mint in NFT collection.434        NotNftDataUsedToMintNftCollectionToken,435        /// Not Fungible item data used to mint in Fungible collection.436        NotFungibleDataUsedToMintFungibleCollectionToken,437        /// Not Re Fungible item data used to mint in Re Fungible collection.438        NotReFungibleDataUsedToMintReFungibleCollectionToken,439        /// Unexpected collection type.440        UnexpectedCollectionType,441        /// Can't store metadata in fungible tokens.442        CantStoreMetadataInFungibleTokens,443        /// Collection token limit exceeded444        CollectionTokenLimitExceeded,445        /// Account token limit exceeded per collection446        AccountTokenLimitExceeded,447        /// Collection limit bounds per collection exceeded448        CollectionLimitBoundsExceeded,449        /// Tried to enable permissions which are only permitted to be disabled450        OwnerPermissionsCantBeReverted,451        /// Schema data size limit bound exceeded452        SchemaDataLimitExceeded,453        /// Maximum refungibility exceeded454        WrongRefungiblePieces,455        /// createRefungible should be called with one owner456        BadCreateRefungibleCall,457	}458}459460pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {461    type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;462463    /// Weight information for extrinsics in this pallet.464	type WeightInfo: WeightInfo;465466    type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;467    type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;468    type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;469470	type CrossAccountId: CrossAccountId<Self::AccountId>;471    type Currency: Currency<Self::AccountId>;472    type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;473    type TreasuryAccountId: Get<Self::AccountId>;474}475476#[cfg(feature = "runtime-benchmarks")]477mod benchmarking;478479// #endregion480481// # Used definitions482//483// ## User control levels484//485// chain-controlled - key is uncontrolled by user486//                    i.e autoincrementing index487//                    can use non-cryptographic hash488// real - key is controlled by user489//        but it is hard to generate enough colliding values, i.e owner of signed txs490//        can use non-cryptographic hash491// controlled - key is completly controlled by users492//              i.e maps with mutable keys493//              should use cryptographic hash494//495// ## User control level downgrade reasons496//497// ?1 - chain-controlled -> controlled498//      collections/tokens can be destroyed, resulting in massive holes499// ?2 - chain-controlled -> controlled500//      same as ?1, but can be only added, resulting in easier exploitation501// ?3 - real -> controlled502//      no confirmation required, so addresses can be easily generated503decl_storage! {504    trait Store for Module<T: Config> as Nft {505506        //#region Private members507        /// Id of next collection508        CreatedCollectionCount: u32;509        /// Used for migrations510        ChainVersion: u64;511        /// Id of last collection token512        /// Collection id (controlled?1)513        ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;514        //#endregion515516        //#region Chain limits struct517        pub ChainLimit get(fn chain_limit) config(): ChainLimits;518        //#endregion519520        //#region Bound counters521        /// Amount of collections destroyed, used for total amount tracking with522        /// CreatedCollectionCount523        DestroyedCollectionCount: u32;524        /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)525        /// Account id (real)526        pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;527        //#endregion528529        //#region Basic collections530        /// Collection info531        /// Collection id (controlled?1)532        pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;533        /// List of collection admins534        /// Collection id (controlled?2)535        pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;536        /// Whitelisted collection users537        /// Collection id (controlled?2), user id (controlled?3)538        pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;539        //#endregion540541        /// How many of collection items user have542        /// Collection id (controlled?2), account id (real)543        pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;544545        /// Amount of items which spender can transfer out of owners account (via transferFrom)546        /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))547        /// TODO: Off chain worker should remove from this map when token gets removed548        pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;549550        //#region Item collections551        /// Collection id (controlled?2), token id (controlled?1)552        pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;553        /// Collection id (controlled?2), owner (controlled?2)554        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;555        /// Collection id (controlled?2), token id (controlled?1)556        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;557        //#endregion558559        //#region Index list560        /// Collection id (controlled?2), tokens owner (controlled?2)561        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;562        //#endregion563564        //#region Tokens transfer rate limit baskets565        /// (Collection id (controlled?2), who created (real))566        /// TODO: Off chain worker should remove from this map when collection gets removed567        pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;568        /// Collection id (controlled?2), token id (controlled?2)569        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;570        /// Collection id (controlled?2), owning user (real)571        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;572        /// Collection id (controlled?2), token id (controlled?2)573        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;574        //#endregion575576        /// Variable metadata sponsoring577        /// Collection id (controlled?2), token id (controlled?2)578        pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;579      580        //#region Contract Sponsorship and Ownership581        /// Contract address (real)582        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;583        /// Contract address (real)584        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;585        /// (Contract address(real), caller (real))586        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;587        /// Contract address (real)588        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;589        /// Contract address (real)590        pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 591        /// Contract address (real) => Whitelisted user (controlled?3)592        pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 593        //#endregion594    }595    add_extra_genesis {596        build(|config: &GenesisConfig<T>| {597            // Modification of storage598            for (_num, _c) in &config.collection_id {599                <Module<T>>::init_collection(_c);600            }601602            for (_num, _c, _i) in &config.nft_item_id {603                <Module<T>>::init_nft_token(*_c, _i);604            }605606            for (collection_id, account_id, fungible_item) in &config.fungible_item_id {607                <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);608            }609610            for (_num, _c, _i) in &config.refungible_item_id {611                <Module<T>>::init_refungible_token(*_c, _i);612            }613        })614    }615}616617decl_event!(618    pub enum Event<T>619    where620        CrossAccountId = <T as Config>::CrossAccountId,621    {622        /// New collection was created623        /// 624        /// # Arguments625        /// 626        /// * collection_id: Globally unique identifier of newly created collection.627        /// 628        /// * mode: [CollectionMode] converted into u8.629        /// 630        /// * account_id: Collection owner.631        CollectionCreated(CollectionId, u8, CrossAccountId),632633        /// New item was created.634        /// 635        /// # Arguments636        /// 637        /// * collection_id: Id of the collection where item was created.638        /// 639        /// * item_id: Id of an item. Unique within the collection.640        ///641        /// * recipient: Owner of newly created item 642        ItemCreated(CollectionId, TokenId, CrossAccountId),643644        /// Collection item was burned.645        /// 646        /// # Arguments647        /// 648        /// collection_id.649        /// 650        /// item_id: Identifier of burned NFT.651        ItemDestroyed(CollectionId, TokenId),652653        /// Item was transferred654        ///655        /// * collection_id: Id of collection to which item is belong656        ///657        /// * item_id: Id of an item658        ///659        /// * sender: Original owner of item660        ///661        /// * recipient: New owner of item662        ///663        /// * amount: Always 1 for NFT664        Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),665666        /// * collection_id667        ///668        /// * item_id669        ///670        /// * sender671        ///672        /// * spender673        ///674        /// * amount675        Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),676    }677);678679decl_module! {680    pub struct Module<T: Config> for enum Call 681    where 682        origin: T::Origin683    {684        fn deposit_event() = default;685        type Error = Error<T>;686687        fn on_initialize(now: T::BlockNumber) -> Weight {688            0689        }690691        /// 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.692        /// 693        /// # Permissions694        /// 695        /// * Anyone.696        /// 697        /// # Arguments698        /// 699        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.700        /// 701        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.702        /// 703        /// * token_prefix: UTF-8 string with token prefix.704        /// 705        /// * mode: [CollectionMode] collection type and type dependent data.706        // returns collection ID707        #[weight = <T as Config>::WeightInfo::create_collection()]708        #[transactional]709        pub fn create_collection(origin,710                                 collection_name: Vec<u16>,711                                 collection_description: Vec<u16>,712                                 token_prefix: Vec<u8>,713                                 mode: CollectionMode) -> DispatchResult {714715            // Anyone can create a collection716            let who = T::CrossAccountId::from_sub(ensure_signed(origin)?);717718            // Take a (non-refundable) deposit of collection creation719            let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();720            imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(721                &T::TreasuryAccountId::get(),722                T::CollectionCreationPrice::get(),723            ));724            <T as Config>::Currency::settle(725                who.as_sub(),726                imbalance,727                WithdrawReasons::TRANSFER,728                ExistenceRequirement::KeepAlive,729            ).map_err(|_| Error::<T>::NoPermission)?;730731            let decimal_points = match mode {732                CollectionMode::Fungible(points) => points,733                _ => 0734            };735736            let chain_limit = ChainLimit::get();737738            let created_count = CreatedCollectionCount::get();739            let destroyed_count = DestroyedCollectionCount::get();740741            // bound Total number of collections742            ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);743744            // check params745            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);746            ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);747            ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);748            ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);749750            // Generate next collection ID751            let next_id = created_count752                .checked_add(1)753                .ok_or(Error::<T>::NumOverflow)?;754755            CreatedCollectionCount::put(next_id);756757            let limits = CollectionLimits {758                sponsored_data_size: chain_limit.custom_data_limit,759                ..Default::default()760            };761762            // Create new collection763            let new_collection = Collection {764                owner: who.clone(),765                name: collection_name,766                mode: mode.clone(),767                mint_mode: false,768                access: AccessMode::Normal,769                description: collection_description,770                decimal_points: decimal_points,771                token_prefix: token_prefix,772                offchain_schema: Vec::new(),773                schema_version: SchemaVersion::ImageURL,774                sponsorship: SponsorshipState::Disabled,775                variable_on_chain_schema: Vec::new(),776                const_on_chain_schema: Vec::new(),777                limits,778            };779780            // Add new collection to map781            <CollectionById<T>>::insert(next_id, new_collection);782783            // call event784            Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who));785786            Ok(())787        }788789        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.790        /// 791        /// # Permissions792        /// 793        /// * Collection Owner.794        /// 795        /// # Arguments796        /// 797        /// * collection_id: collection to destroy.798        #[weight = <T as Config>::WeightInfo::destroy_collection()]799        #[transactional]800        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {801802            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);803            let collection = Self::get_collection(collection_id)?;804            Self::check_owner_permissions(&collection, sender)?;805            if !collection.limits.owner_can_destroy {806                fail!(Error::<T>::NoPermission);807            }808809            <AddressTokens<T>>::remove_prefix(collection_id);810            <Allowances<T>>::remove_prefix(collection_id);811            <Balance<T>>::remove_prefix(collection_id);812            <ItemListIndex>::remove(collection_id);813            <AdminList<T>>::remove(collection_id);814            <CollectionById<T>>::remove(collection_id);815            <WhiteList<T>>::remove_prefix(collection_id);816817            <NftItemList<T>>::remove_prefix(collection_id);818            <FungibleItemList<T>>::remove_prefix(collection_id);819            <ReFungibleItemList<T>>::remove_prefix(collection_id);820821            <NftTransferBasket<T>>::remove_prefix(collection_id);822            <FungibleTransferBasket<T>>::remove_prefix(collection_id);823            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);824825            <VariableMetaDataBasket<T>>::remove_prefix(collection_id);826827            DestroyedCollectionCount::put(DestroyedCollectionCount::get()828                .checked_add(1)829                .ok_or(Error::<T>::NumOverflow)?);830831            Ok(())832        }833834        /// Add an address to white list.835        /// 836        /// # Permissions837        /// 838        /// * Collection Owner839        /// * Collection Admin840        /// 841        /// # Arguments842        /// 843        /// * collection_id.844        /// 845        /// * address.846        #[weight = <T as Config>::WeightInfo::add_to_white_list()]847        #[transactional]848        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{849850            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);851            let collection = Self::get_collection(collection_id)?;852            Self::check_owner_or_admin_permissions(&collection, sender)?;853854            <WhiteList<T>>::insert(collection_id, address.as_sub(), true);855            856            Ok(())857        }858859        /// Remove an address from white list.860        /// 861        /// # Permissions862        /// 863        /// * Collection Owner864        /// * Collection Admin865        /// 866        /// # Arguments867        /// 868        /// * collection_id.869        /// 870        /// * address.871        #[weight = <T as Config>::WeightInfo::remove_from_white_list()]872        #[transactional]873        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{874875            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);876            let collection = Self::get_collection(collection_id)?;877            Self::check_owner_or_admin_permissions(&collection, sender)?;878879            <WhiteList<T>>::remove(collection_id, address.as_sub());880881            Ok(())882        }883884        /// Toggle between normal and white list access for the methods with access for `Anyone`.885        /// 886        /// # Permissions887        /// 888        /// * Collection Owner.889        /// 890        /// # Arguments891        /// 892        /// * collection_id.893        /// 894        /// * mode: [AccessMode]895        #[weight = <T as Config>::WeightInfo::set_public_access_mode()]896        #[transactional]897        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult898        {899            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);900901            let mut target_collection = Self::get_collection(collection_id)?;902            Self::check_owner_permissions(&target_collection, sender)?;903            target_collection.access = mode;904            Self::save_collection(target_collection);905906            Ok(())907        }908909        /// Allows Anyone to create tokens if:910        /// * White List is enabled, and911        /// * Address is added to white list, and912        /// * This method was called with True parameter913        /// 914        /// # Permissions915        /// * Collection Owner916        ///917        /// # Arguments918        /// 919        /// * collection_id.920        /// 921        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.922        #[weight = <T as Config>::WeightInfo::set_mint_permission()]923        #[transactional]924        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult925        {926            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);927928            let mut target_collection = Self::get_collection(collection_id)?;929            Self::check_owner_permissions(&target_collection, sender)?;930            target_collection.mint_mode = mint_permission;931            Self::save_collection(target_collection);932933            Ok(())934        }935936        /// Change the owner of the collection.937        /// 938        /// # Permissions939        /// 940        /// * Collection Owner.941        /// 942        /// # Arguments943        /// 944        /// * collection_id.945        /// 946        /// * new_owner.947        #[weight = <T as Config>::WeightInfo::change_collection_owner()]948        #[transactional]949        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::CrossAccountId) -> DispatchResult {950951            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);952            let mut target_collection = Self::get_collection(collection_id)?;953            Self::check_owner_permissions(&target_collection, sender)?;954            target_collection.owner = new_owner;955            Self::save_collection(target_collection);956957            Ok(())958        }959960        /// Adds an admin of the Collection.961        /// 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. 962        /// 963        /// # Permissions964        /// 965        /// * Collection Owner.966        /// * Collection Admin.967        /// 968        /// # Arguments969        /// 970        /// * collection_id: ID of the Collection to add admin for.971        /// 972        /// * new_admin_id: Address of new admin to add.973        #[weight = <T as Config>::WeightInfo::add_collection_admin()]974        #[transactional]975        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {976977            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);978            let collection = Self::get_collection(collection_id)?;979            Self::check_owner_or_admin_permissions(&collection, sender)?;980            let mut admin_arr = <AdminList<T>>::get(collection_id);981982            match admin_arr.binary_search(&new_admin_id) {983                Ok(_) => {},984                Err(idx) => {985                    let limits = ChainLimit::get();986                    ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);987                    admin_arr.insert(idx, new_admin_id);988                    <AdminList<T>>::insert(collection_id, admin_arr);989                }990            }991            Ok(())992        }993994        /// 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.995        ///996        /// # Permissions997        /// 998        /// * Collection Owner.999        /// * Collection Admin.1000        /// 1001        /// # Arguments1002        /// 1003        /// * collection_id: ID of the Collection to remove admin for.1004        /// 1005        /// * account_id: Address of admin to remove.1006        #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1007        #[transactional]1008        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {10091010            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1011            let collection = Self::get_collection(collection_id)?;1012            Self::check_owner_or_admin_permissions(&collection, sender)?;1013            let mut admin_arr = <AdminList<T>>::get(collection_id);10141015            match admin_arr.binary_search(&account_id) {1016                Ok(idx) => {1017                    admin_arr.remove(idx);1018                    <AdminList<T>>::insert(collection_id, admin_arr);1019                },1020                Err(_) => {}1021            }1022            Ok(())1023        }10241025        /// # Permissions1026        /// 1027        /// * Collection Owner1028        /// 1029        /// # Arguments1030        /// 1031        /// * collection_id.1032        /// 1033        /// * new_sponsor.1034        #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1035        #[transactional]1036        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {1037            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1038            let mut target_collection = Self::get_collection(collection_id)?;1039            Self::check_owner_permissions(&target_collection, &sender)?;10401041            target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1042            Self::save_collection(target_collection);10431044            Ok(())1045        }10461047        /// # Permissions1048        /// 1049        /// * Sponsor.1050        /// 1051        /// # Arguments1052        /// 1053        /// * collection_id.1054        #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1055        #[transactional]1056        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {1057            let sender = ensure_signed(origin)?;10581059            let mut target_collection = Self::get_collection(collection_id)?;1060            ensure!(1061                target_collection.sponsorship.pending_sponsor() == Some(&sender),1062                Error::<T>::ConfirmUnsetSponsorFail1063            );10641065            target_collection.sponsorship = SponsorshipState::Confirmed(sender);1066            Self::save_collection(target_collection);10671068            Ok(())1069        }10701071        /// Switch back to pay-per-own-transaction model.1072        ///1073        /// # Permissions1074        ///1075        /// * Collection owner.1076        /// 1077        /// # Arguments1078        /// 1079        /// * collection_id.1080        #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1081        #[transactional]1082        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {1083            let sender = ensure_signed(origin)?;10841085            let mut target_collection = Self::get_collection(collection_id)?;1086            Self::check_owner_permissions(&target_collection, sender)?;10871088            target_collection.sponsorship = SponsorshipState::Disabled;1089            Self::save_collection(target_collection);10901091            Ok(())1092        }10931094        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1095        /// 1096        /// # Permissions1097        /// 1098        /// * Collection Owner.1099        /// * Collection Admin.1100        /// * Anyone if1101        ///     * White List is enabled, and1102        ///     * Address is added to white list, and1103        ///     * MintPermission is enabled (see SetMintPermission method)1104        /// 1105        /// # Arguments1106        /// 1107        /// * collection_id: ID of the collection.1108        /// 1109        /// * owner: Address, initial owner of the NFT.1110        ///1111        /// * data: Token data to store on chain.1112        // #[weight =1113        // (130_000_000 as Weight)1114        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1115        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1116        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11171118        #[weight = <T as Config>::WeightInfo::create_item(data.len())]1119        #[transactional]1120        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11211122            let sender = ensure_signed(origin)?;11231124            let target_collection = Self::get_collection(collection_id)?;11251126            Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1127            Self::validate_create_item_args(&target_collection, &data)?;1128            Self::create_item_no_validation(&target_collection, owner, data)?;11291130            Ok(())1131        }11321133        /// This method creates multiple items in a collection created with CreateCollection method.1134        /// 1135        /// # Permissions1136        /// 1137        /// * Collection Owner.1138        /// * Collection Admin.1139        /// * Anyone if1140        ///     * White List is enabled, and1141        ///     * Address is added to white list, and1142        ///     * MintPermission is enabled (see SetMintPermission method)1143        /// 1144        /// # Arguments1145        /// 1146        /// * collection_id: ID of the collection.1147        /// 1148        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1149        /// 1150        /// * owner: Address, initial owner of the NFT.1151        #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1152                               .map(|data| { data.len() })1153                               .sum())]1154        #[transactional]1155        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11561157            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1158            let sender = ensure_signed(origin)?;11591160            let target_collection = Self::get_collection(collection_id)?;11611162            Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11631164            for data in &items_data {1165                Self::validate_create_item_args(&target_collection, data)?;1166            }1167            for data in &items_data {1168                Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1169            }11701171            Ok(())1172        }11731174        /// Destroys a concrete instance of NFT.1175        /// 1176        /// # Permissions1177        /// 1178        /// * Collection Owner.1179        /// * Collection Admin.1180        /// * Current NFT Owner.1181        /// 1182        /// # Arguments1183        /// 1184        /// * collection_id: ID of the collection.1185        /// 1186        /// * item_id: ID of NFT to burn.1187        #[weight = <T as Config>::WeightInfo::burn_item()]1188        #[transactional]1189        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11901191            let sender = ensure_signed(origin)?;11921193            // Transfer permissions check1194            let target_collection = Self::get_collection(collection_id)?;1195            ensure!(1196                Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1197                (1198                    target_collection.limits.owner_can_transfer &&1199                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1200                ),1201                Error::<T>::NoPermission1202            );12031204            if target_collection.access == AccessMode::WhiteList {1205                Self::check_white_list(&target_collection, &sender)?;1206            }12071208            match target_collection.mode1209            {1210                CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1211                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, &target_collection, value)?,1212                CollectionMode::ReFungible  => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1213                _ => ()1214            };12151216            // call event1217            Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12181219            Ok(())1220        }12211222        /// Change ownership of the token.1223        /// 1224        /// # Permissions1225        /// 1226        /// * Collection Owner1227        /// * Collection Admin1228        /// * Current NFT owner1229        ///1230        /// # Arguments1231        /// 1232        /// * recipient: Address of token recipient.1233        /// 1234        /// * collection_id.1235        /// 1236        /// * item_id: ID of the item1237        ///     * Non-Fungible Mode: Required.1238        ///     * Fungible Mode: Ignored.1239        ///     * Re-Fungible Mode: Required.1240        /// 1241        /// * value: Amount to transfer.1242        ///     * Non-Fungible Mode: Ignored1243        ///     * Fungible Mode: Must specify transferred amount1244        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1245        #[weight = <T as Config>::WeightInfo::transfer()]1246        #[transactional]1247        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1248            let sender = ensure_signed(origin)?;1249            let collection = Self::get_collection(collection_id)?;12501251            Self::transfer_internal(sender, recipient, &collection, item_id, value)1252        }12531254        /// Set, change, or remove approved address to transfer the ownership of the NFT.1255        /// 1256        /// # Permissions1257        /// 1258        /// * Collection Owner1259        /// * Collection Admin1260        /// * Current NFT owner1261        /// 1262        /// # Arguments1263        /// 1264        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1265        /// 1266        /// * collection_id.1267        /// 1268        /// * item_id: ID of the item.1269        #[weight = <T as Config>::WeightInfo::approve()]1270        #[transactional]1271        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12721273            let sender = ensure_signed(origin)?;1274            let target_collection = Self::get_collection(collection_id)?;12751276            Self::token_exists(&target_collection, item_id)?;12771278            // Transfer permissions check1279            let bypasses_limits = target_collection.limits.owner_can_transfer &&1280                Self::is_owner_or_admin_permissions(1281                    &target_collection,1282                    sender.clone(),1283                );12841285            let allowance_limit = if bypasses_limits {1286                None1287            } else if let Some(amount) = Self::owned_amount(1288                sender.clone(),1289                &target_collection,1290                item_id,1291            ) {1292                Some(amount)1293            } else {1294                fail!(Error::<T>::NoPermission);1295            };12961297            if target_collection.access == AccessMode::WhiteList {1298                Self::check_white_list(&target_collection, &sender)?;1299                Self::check_white_list(&target_collection, &spender)?;1300            }13011302            let allowance: u128 = amount1303                .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1304                .ok_or(Error::<T>::NumOverflow)?;1305            if let Some(limit) = allowance_limit {1306                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1307            }1308            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13091310            Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1311            Ok(())1312        }1313        1314        /// 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.1315        /// 1316        /// # Permissions1317        /// * Collection Owner1318        /// * Collection Admin1319        /// * Current NFT owner1320        /// * Address approved by current NFT owner1321        /// 1322        /// # Arguments1323        /// 1324        /// * from: Address that owns token.1325        /// 1326        /// * recipient: Address of token recipient.1327        /// 1328        /// * collection_id.1329        /// 1330        /// * item_id: ID of the item.1331        /// 1332        /// * value: Amount to transfer.1333        #[weight = <T as Config>::WeightInfo::transfer_from()]1334        #[transactional]1335        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13361337            let sender = ensure_signed(origin)?;1338            let target_collection = Self::get_collection(collection_id)?;13391340            // Check approval1341            let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13421343            // Limits check1344            Self::is_correct_transfer(&target_collection, &recipient)?;13451346            // Transfer permissions check         1347            ensure!(1348                approval >= value || 1349                (1350                    target_collection.limits.owner_can_transfer &&1351                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1352                ),1353                Error::<T>::NoPermission1354            );13551356            if target_collection.access == AccessMode::WhiteList {1357                Self::check_white_list(&target_collection, &sender)?;1358                Self::check_white_list(&target_collection, &recipient)?;1359            }13601361            // Reduce approval by transferred amount or remove if remaining approval drops to 01362            if approval.saturating_sub(value) > 0 {1363                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1364            }1365            else {1366                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1367            }13681369            match target_collection.mode1370            {1371                CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1372                CollectionMode::Fungible(_)  => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1373                CollectionMode::ReFungible  => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1374                _ => ()1375            };13761377            Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1378            Ok(())1379        }13801381        // #[weight = 0]1382        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13831384        //     // let no_perm_mes = "You do not have permissions to modify this collection";1385        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1386        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1387        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13881389        //     // // on_nft_received  call13901391        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;13921393        //     Ok(())1394        // }13951396        /// Set off-chain data schema.1397        /// 1398        /// # Permissions1399        /// 1400        /// * Collection Owner1401        /// * Collection Admin1402        /// 1403        /// # Arguments1404        /// 1405        /// * collection_id.1406        /// 1407        /// * schema: String representing the offchain data schema.1408        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1409        #[transactional]1410        pub fn set_variable_meta_data (1411            origin,1412            collection_id: CollectionId,1413            item_id: TokenId,1414            data: Vec<u8>1415        ) -> DispatchResult {1416            let sender = ensure_signed(origin)?;1417            1418            let target_collection = Self::get_collection(collection_id)?;1419            Self::token_exists(&target_collection, item_id)?;14201421            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14221423            // Modify permissions check1424            ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1425                Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1426                Error::<T>::NoPermission);14271428            match target_collection.mode1429            {1430                CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1431                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1432                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1433                _ => fail!(Error::<T>::UnexpectedCollectionType)1434            };14351436            Ok(())1437        }1438 1439        /// Set schema standard1440        /// ImageURL1441        /// Unique1442        /// 1443        /// # Permissions1444        /// 1445        /// * Collection Owner1446        /// * Collection Admin1447        /// 1448        /// # Arguments1449        /// 1450        /// * collection_id.1451        /// 1452        /// * schema: SchemaVersion: enum1453        #[weight = <T as Config>::WeightInfo::set_schema_version()]1454        #[transactional]1455        pub fn set_schema_version(1456            origin,1457            collection_id: CollectionId,1458            version: SchemaVersion1459        ) -> DispatchResult {1460            let sender = ensure_signed(origin)?;1461            let mut target_collection = Self::get_collection(collection_id)?;1462            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1463            target_collection.schema_version = version;1464            Self::save_collection(target_collection);14651466            Ok(())1467        }14681469        /// Set off-chain data schema.1470        /// 1471        /// # Permissions1472        /// 1473        /// * Collection Owner1474        /// * Collection Admin1475        /// 1476        /// # Arguments1477        /// 1478        /// * collection_id.1479        /// 1480        /// * schema: String representing the offchain data schema.1481        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1482        #[transactional]1483        pub fn set_offchain_schema(1484            origin,1485            collection_id: CollectionId,1486            schema: Vec<u8>1487        ) -> DispatchResult {1488            let sender = ensure_signed(origin)?;1489            let mut target_collection = Self::get_collection(collection_id)?;1490            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14911492            // check schema limit1493            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14941495            target_collection.offchain_schema = schema;1496            Self::save_collection(target_collection);14971498            Ok(())1499        }15001501        /// Set const on-chain data schema.1502        /// 1503        /// # Permissions1504        /// 1505        /// * Collection Owner1506        /// * Collection Admin1507        /// 1508        /// # Arguments1509        /// 1510        /// * collection_id.1511        /// 1512        /// * schema: String representing the const on-chain data schema.1513        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1514        #[transactional]1515        pub fn set_const_on_chain_schema (1516            origin,1517            collection_id: CollectionId,1518            schema: Vec<u8>1519        ) -> DispatchResult {1520            let sender = ensure_signed(origin)?;1521            let mut target_collection = Self::get_collection(collection_id)?;1522            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15231524            // check schema limit1525            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15261527            target_collection.const_on_chain_schema = schema;1528            Self::save_collection(target_collection);15291530            Ok(())1531        }15321533        /// Set variable on-chain data schema.1534        /// 1535        /// # Permissions1536        /// 1537        /// * Collection Owner1538        /// * Collection Admin1539        /// 1540        /// # Arguments1541        /// 1542        /// * collection_id.1543        /// 1544        /// * schema: String representing the variable on-chain data schema.1545        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1546        #[transactional]1547        pub fn set_variable_on_chain_schema (1548            origin,1549            collection_id: CollectionId,1550            schema: Vec<u8>1551        ) -> DispatchResult {1552            let sender = ensure_signed(origin)?;1553            let mut target_collection = Self::get_collection(collection_id)?;1554            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15551556            // check schema limit1557            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15581559            target_collection.variable_on_chain_schema = schema;1560            Self::save_collection(target_collection);15611562            Ok(())1563        }15641565        // Sudo permissions function1566        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1567        #[transactional]1568        pub fn set_chain_limits(1569            origin,1570            limits: ChainLimits1571        ) -> DispatchResult {15721573            #[cfg(not(feature = "runtime-benchmarks"))]1574            ensure_root(origin)?;15751576            <ChainLimit>::put(limits);1577            Ok(())1578        }15791580        /// Enable smart contract self-sponsoring.1581        /// 1582        /// # Permissions1583        /// 1584        /// * Contract Owner1585        /// 1586        /// # Arguments1587        /// 1588        /// * contract address1589        /// * enable flag1590        /// 1591        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1592        #[transactional]1593        pub fn enable_contract_sponsoring(1594            origin,1595            contract_address: T::AccountId,1596            enable: bool1597        ) -> DispatchResult {15981599            let sender = ensure_signed(origin)?;16001601            #[cfg(feature = "runtime-benchmarks")]1602            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16031604            Self::ensure_contract_owned(sender, &contract_address)?;16051606            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1607            Ok(())1608        }16091610        /// Set the rate limit for contract sponsoring to specified number of blocks.1611        /// 1612        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1613        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1614        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1615        /// from contract endowment if there are at least B blocks between such transactions. 1616        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1617        /// 1618        /// # Permissions1619        /// 1620        /// * Contract Owner1621        /// 1622        /// # Arguments1623        /// 1624        /// -`contract_address`: Address of the contract to sponsor1625        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1626        /// 1627        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1628        #[transactional]1629        pub fn set_contract_sponsoring_rate_limit(1630            origin,1631            contract_address: T::AccountId,1632            rate_limit: T::BlockNumber1633        ) -> DispatchResult {1634            let sender = ensure_signed(origin)?;16351636            #[cfg(feature = "runtime-benchmarks")]1637            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16381639            Self::ensure_contract_owned(sender, &contract_address)?;1640            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1641            Ok(())1642        }16431644        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1645        /// 1646        /// # Permissions1647        /// 1648        /// * Address that deployed smart contract.1649        /// 1650        /// # Arguments1651        /// 1652        /// -`contract_address`: Address of the contract.1653        /// 1654        /// - `enable`: .  1655        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1656        #[transactional]1657        pub fn toggle_contract_white_list(1658            origin,1659            contract_address: T::AccountId,1660            enable: bool1661        ) -> DispatchResult {1662            let sender = ensure_signed(origin)?;16631664            #[cfg(feature = "runtime-benchmarks")]1665            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16661667            Self::ensure_contract_owned(sender, &contract_address)?;1668            if enable {1669                <ContractWhiteListEnabled<T>>::insert(contract_address, true);1670            } else {1671                <ContractWhiteListEnabled<T>>::remove(contract_address);1672            }1673            Ok(())1674        }1675        1676        /// Add an address to smart contract white list.1677        /// 1678        /// # Permissions1679        /// 1680        /// * Address that deployed smart contract.1681        /// 1682        /// # Arguments1683        /// 1684        /// -`contract_address`: Address of the contract.1685        ///1686        /// -`account_address`: Address to add.1687        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1688        #[transactional]1689        pub fn add_to_contract_white_list(1690            origin,1691            contract_address: T::AccountId,1692            account_address: T::AccountId1693        ) -> DispatchResult {1694            let sender = ensure_signed(origin)?;16951696            #[cfg(feature = "runtime-benchmarks")]1697            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1698            1699            Self::ensure_contract_owned(sender, &contract_address)?;      1700            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1701            Ok(())1702        }17031704        /// Remove an address from smart contract white list.1705        /// 1706        /// # Permissions1707        /// 1708        /// * Address that deployed smart contract.1709        /// 1710        /// # Arguments1711        /// 1712        /// -`contract_address`: Address of the contract.1713        ///1714        /// -`account_address`: Address to remove.1715        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1716        #[transactional]1717        pub fn remove_from_contract_white_list(1718            origin,1719            contract_address: T::AccountId,1720            account_address: T::AccountId1721        ) -> DispatchResult {1722            let sender = ensure_signed(origin)?;17231724            #[cfg(feature = "runtime-benchmarks")]1725            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17261727            Self::ensure_contract_owned(sender, &contract_address)?;1728            <ContractWhiteList<T>>::remove(contract_address, account_address);1729            Ok(())1730        }17311732        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1733        #[transactional]1734        pub fn set_collection_limits(1735            origin,1736            collection_id: u32,1737            new_limits: CollectionLimits<T::BlockNumber>,1738        ) -> DispatchResult {1739            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1740            let mut target_collection = Self::get_collection(collection_id)?;1741            Self::check_owner_permissions(&target_collection, sender.clone())?;1742            let old_limits = &target_collection.limits;1743            let chain_limits = ChainLimit::get();17441745            // collection bounds1746            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1747                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1748                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1749                Error::<T>::CollectionLimitBoundsExceeded);17501751            // token_limit   check  prev1752            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1753            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17541755            ensure!(1756                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1757                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1758                Error::<T>::OwnerPermissionsCantBeReverted,1759            );17601761            target_collection.limits = new_limits;1762            Self::save_collection(target_collection);17631764            Ok(())1765        } 1766    }1767}17681769impl<T: Config> Module<T> {17701771    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1772        // Limits check1773        Self::is_correct_transfer(target_collection, &recipient)?;17741775        // Transfer permissions check1776        ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1777            Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1778            Error::<T>::NoPermission);17791780        if target_collection.access == AccessMode::WhiteList {1781            Self::check_white_list(target_collection, &sender)?;1782            Self::check_white_list(target_collection, &recipient)?;1783        }17841785        match target_collection.mode1786        {1787            CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1788            CollectionMode::Fungible(_)  => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1789            CollectionMode::ReFungible  => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1790            _ => ()1791        };17921793        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17941795        Ok(())1796    }179717981799    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1800        let collection_id = collection.id;18011802        // check token limit and account token limit1803        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1804        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1805        1806        Ok(())1807    }18081809    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1810        let collection_id = collection.id;18111812        // check token limit and account token limit1813        let total_items: u32 = ItemListIndex::get(collection_id)1814            .checked_add(amount)1815            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1816        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1817            .checked_add(amount)1818            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1819        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1820        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);18211822        if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1823            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1824            Self::check_white_list(collection, owner)?;1825            Self::check_white_list(collection, sender)?;1826        }18271828        Ok(())1829    }18301831    fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1832        match target_collection.mode1833        {1834            CollectionMode::NFT => {1835                if let CreateItemData::NFT(data) = data {1836                    // check sizes1837                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1838                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1839                } else {1840                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1841                }1842            },1843            CollectionMode::Fungible(_) => {1844                if let CreateItemData::Fungible(_) = data {1845                } else {1846                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1847                }1848            },1849            CollectionMode::ReFungible => {1850                if let CreateItemData::ReFungible(data) = data {18511852                    // check sizes1853                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1854                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18551856                    // Check refungibility limits1857                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1858                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1859                } else {1860                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1861                }1862            },1863            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1864        };18651866        Ok(())1867    }18681869    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1870        match data1871        {1872            CreateItemData::NFT(data) => {1873                let item = NftItemType {1874                    owner: owner.clone(),1875                    const_data: data.const_data,1876                    variable_data: data.variable_data1877                };18781879                Self::add_nft_item(collection, item)?;1880            },1881            CreateItemData::Fungible(data) => {1882                Self::add_fungible_item(collection, &owner, data.value)?;1883            },1884            CreateItemData::ReFungible(data) => {1885                let mut owner_list = Vec::new();1886                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18871888                let item = ReFungibleItemType {1889                    owner: owner_list,1890                    const_data: data.const_data,1891                    variable_data: data.variable_data1892                };18931894                Self::add_refungible_item(collection, item)?;1895            }1896        };18971898        Ok(())1899    }19001901    fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1902        let collection_id = collection.id;19031904        // Does new owner already have an account?1905        let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19061907        // Mint 1908        let item = FungibleItemType {1909            value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1910        };1911        <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19121913        // Update balance1914        let new_balance = <Balance<T>>::get(collection_id, owner)1915            .checked_add(value)1916            .ok_or(Error::<T>::NumOverflow)?;1917        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19181919        Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1920        Ok(())1921    }19221923    fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1924        let collection_id = collection.id;19251926        let current_index = <ItemListIndex>::get(collection_id)1927            .checked_add(1)1928            .ok_or(Error::<T>::NumOverflow)?;1929        let itemcopy = item.clone();19301931        ensure!(1932            item.owner.len() == 1,1933            Error::<T>::BadCreateRefungibleCall,1934        );1935        let item_owner = item.owner.first().expect("only one owner is defined");19361937        let value = item_owner.fraction;1938        let owner = item_owner.owner.clone();19391940        Self::add_token_index(collection_id, current_index, &owner)?;19411942        <ItemListIndex>::insert(collection_id, current_index);1943        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19441945        // Update balance1946        let new_balance = <Balance<T>>::get(collection_id, &owner)1947            .checked_add(value)1948            .ok_or(Error::<T>::NumOverflow)?;1949        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19501951        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1952        Ok(())1953    }19541955    fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1956        let collection_id = collection.id;19571958        let current_index = <ItemListIndex>::get(collection_id)1959            .checked_add(1)1960            .ok_or(Error::<T>::NumOverflow)?;19611962        let item_owner = item.owner.clone();1963        Self::add_token_index(collection_id, current_index, &item.owner)?;19641965        <ItemListIndex>::insert(collection_id, current_index);1966        <NftItemList<T>>::insert(collection_id, current_index, item);19671968        // Update balance1969        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1970            .checked_add(1)1971            .ok_or(Error::<T>::NumOverflow)?;1972        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19731974        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1975        Ok(())1976    }19771978    fn burn_refungible_item(1979        collection: &CollectionHandle<T>,1980        item_id: TokenId,1981        owner: &T::AccountId,1982    ) -> DispatchResult {1983        let collection_id = collection.id;19841985        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1986            .ok_or(Error::<T>::TokenNotFound)?;1987        let rft_balance = token1988            .owner1989            .iter()1990            .find(|&i| i.owner == *owner)1991            .ok_or(Error::<T>::TokenNotFound)?;1992        Self::remove_token_index(collection_id, item_id, owner)?;19931994        // update balance1995        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1996            .checked_sub(rft_balance.fraction)1997            .ok_or(Error::<T>::NumOverflow)?;1998        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19992000        // Re-create owners list with sender removed2001        let index = token2002            .owner2003            .iter()2004            .position(|i| i.owner == *owner)2005            .expect("owned item is exists");2006        token.owner.remove(index);2007        let owner_count = token.owner.len();20082009        // Burn the token completely if this was the last (only) owner2010        if owner_count == 0 {2011            <ReFungibleItemList<T>>::remove(collection_id, item_id);2012            <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2013        }2014        else {2015            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2016        }20172018        Ok(())2019    }20202021    fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2022        let collection_id = collection.id;20232024        let item = <NftItemList<T>>::get(collection_id, item_id)2025            .ok_or(Error::<T>::TokenNotFound)?;2026        Self::remove_token_index(collection_id, item_id, &item.owner)?;20272028        // update balance2029        let new_balance = <Balance<T>>::get(collection_id, &item.owner)2030            .checked_sub(1)2031            .ok_or(Error::<T>::NumOverflow)?;2032        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2033        <NftItemList<T>>::remove(collection_id, item_id);2034        <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20352036        Ok(())2037    }20382039    fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2040        let collection_id = collection.id;20412042        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2043        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20442045        // update balance2046        let new_balance = <Balance<T>>::get(collection_id, owner)2047            .checked_sub(value)2048            .ok_or(Error::<T>::NumOverflow)?;2049        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20502051        if balance.value - value > 0 {2052            balance.value -= value;2053            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2054        }2055        else {2056            <FungibleItemList<T>>::remove(collection_id, owner);2057        }20582059        Ok(())2060    }20612062    pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2063        Ok(<CollectionById<T>>::get(collection_id)2064            .map(|collection| CollectionHandle {2065                id: collection_id,2066                collection2067            })2068            .ok_or(Error::<T>::CollectionNotFound)?)2069    }20702071    fn save_collection(collection: CollectionHandle<T>) {2072        <CollectionById<T>>::insert(collection.id, collection.collection);2073    }20742075    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2076        ensure!(2077            subject == target_collection.owner,2078            Error::<T>::NoPermission2079        );20802081        Ok(())2082    }20832084    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2085        subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2086    }20872088    fn check_owner_or_admin_permissions(2089        collection: &CollectionHandle<T>,2090        subject: T::AccountId,2091    ) -> DispatchResult {2092        ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);20932094        Ok(())2095    }20962097    fn owned_amount(2098        subject: T::AccountId,2099        target_collection: &CollectionHandle<T>,2100        item_id: TokenId,2101    ) -> Option<u128> {2102        let collection_id = target_collection.id;21032104        match target_collection.mode {2105            CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2106                .then(|| 1),2107            CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2108                .value),2109            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2110                .owner2111                .iter()2112                .find(|i| i.owner == subject)2113                .map(|i| i.fraction),2114            CollectionMode::Invalid => None,2115        }2116    }21172118    fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2119        match target_collection.mode {2120            CollectionMode::Fungible(_) => true,2121            _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2122        }2123    }21242125    fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2126        let collection_id = collection.id;21272128        let mes = Error::<T>::AddresNotInWhiteList;2129        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21302131        Ok(())2132    }21332134    /// Check if token exists. In case of Fungible, check if there is an entry for 2135    /// the owner in fungible balances double map2136    fn token_exists(2137        target_collection: &CollectionHandle<T>,2138        item_id: TokenId,2139    ) -> DispatchResult {2140        let collection_id = target_collection.id;2141        let exists = match target_collection.mode2142        {2143            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2144            CollectionMode::Fungible(_)  => true,2145            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2146            _ => false2147        };21482149        ensure!(exists == true, Error::<T>::TokenNotFound);2150        Ok(())2151    }21522153    fn transfer_fungible(2154        collection: &CollectionHandle<T>,2155        value: u128,2156        owner: &T::AccountId,2157        recipient: &T::AccountId,2158    ) -> DispatchResult {2159        let collection_id = collection.id;21602161        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2162        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21632164        // Send balance to recipient (updates balanceOf of recipient)2165        Self::add_fungible_item(collection, recipient, value)?;21662167        // update balanceOf of sender2168        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21692170        // Reduce or remove sender2171        if balance.value == value {2172            <FungibleItemList<T>>::remove(collection_id, owner);2173        }2174        else {2175            balance.value -= value;2176            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2177        }21782179        Ok(())2180    }21812182    fn transfer_refungible(2183        collection: &CollectionHandle<T>,2184        item_id: TokenId,2185        value: u128,2186        owner: T::AccountId,2187        new_owner: T::AccountId,2188    ) -> DispatchResult {2189        let collection_id = collection.id;2190        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2191            .ok_or(Error::<T>::TokenNotFound)?;21922193        let item = full_item2194            .owner2195            .iter()2196            .filter(|i| i.owner == owner)2197            .next()2198            .ok_or(Error::<T>::TokenNotFound)?;2199        let amount = item.fraction;22002201        ensure!(amount >= value, Error::<T>::TokenValueTooLow);22022203        // update balance2204        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2205            .checked_sub(value)2206            .ok_or(Error::<T>::NumOverflow)?;2207        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22082209        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2210            .checked_add(value)2211            .ok_or(Error::<T>::NumOverflow)?;2212        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22132214        let old_owner = item.owner.clone();2215        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22162217        // transfer2218        if amount == value && !new_owner_has_account {2219            // change owner2220            // new owner do not have account2221            let mut new_full_item = full_item.clone();2222            new_full_item2223                .owner2224                .iter_mut()2225                .find(|i| i.owner == owner)2226                .expect("old owner does present in refungible")2227                .owner = new_owner.clone();2228            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22292230            // update index collection2231            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2232        } else {2233            let mut new_full_item = full_item.clone();2234            new_full_item2235                .owner2236                .iter_mut()2237                .find(|i| i.owner == owner)2238                .expect("old owner does present in refungible")2239                .fraction -= value;22402241            // separate amount2242            if new_owner_has_account {2243                // new owner has account2244                new_full_item2245                    .owner2246                    .iter_mut()2247                    .find(|i| i.owner == new_owner)2248                    .expect("new owner has account")2249                    .fraction += value;2250            } else {2251                // new owner do not have account2252                new_full_item.owner.push(Ownership {2253                    owner: new_owner.clone(),2254                    fraction: value,2255                });2256                Self::add_token_index(collection_id, item_id, &new_owner)?;2257            }22582259            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2260        }22612262        Ok(())2263    }22642265    fn transfer_nft(2266        collection: &CollectionHandle<T>,2267        item_id: TokenId,2268        sender: T::AccountId,2269        new_owner: T::AccountId,2270    ) -> DispatchResult {2271        let collection_id = collection.id;2272        let mut item = <NftItemList<T>>::get(collection_id, item_id)2273            .ok_or(Error::<T>::TokenNotFound)?;22742275        ensure!(2276            sender == item.owner,2277            Error::<T>::MustBeTokenOwner2278        );22792280        // update balance2281        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2282            .checked_sub(1)2283            .ok_or(Error::<T>::NumOverflow)?;2284        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22852286        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2287            .checked_add(1)2288            .ok_or(Error::<T>::NumOverflow)?;2289        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22902291        // change owner2292        let old_owner = item.owner.clone();2293        item.owner = new_owner.clone();2294        <NftItemList<T>>::insert(collection_id, item_id, item);22952296        // update index collection2297        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22982299        Ok(())2300    }2301    2302    fn set_re_fungible_variable_data(2303        collection: &CollectionHandle<T>,2304        item_id: TokenId,2305        data: Vec<u8>2306    ) -> DispatchResult {2307        let collection_id = collection.id;2308        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2309            .ok_or(Error::<T>::TokenNotFound)?;23102311        item.variable_data = data;23122313        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23142315        Ok(())2316    }23172318    fn set_nft_variable_data(2319        collection: &CollectionHandle<T>,2320        item_id: TokenId,2321        data: Vec<u8>2322    ) -> DispatchResult {2323        let collection_id = collection.id;2324        let mut item = <NftItemList<T>>::get(collection_id, item_id)2325            .ok_or(Error::<T>::TokenNotFound)?;2326        2327        item.variable_data = data;23282329        <NftItemList<T>>::insert(collection_id, item_id, item);2330        2331        Ok(())2332    }23332334    fn init_collection(item: &Collection<T>) {2335        // check params2336        assert!(2337            item.decimal_points <= MAX_DECIMAL_POINTS,2338            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2339        );2340        assert!(2341            item.name.len() <= 64,2342            "Collection name can not be longer than 63 char"2343        );2344        assert!(2345            item.name.len() <= 256,2346            "Collection description can not be longer than 255 char"2347        );2348        assert!(2349            item.token_prefix.len() <= 16,2350            "Token prefix can not be longer than 15 char"2351        );23522353        // Generate next collection ID2354        let next_id = CreatedCollectionCount::get()2355            .checked_add(1)2356            .unwrap();23572358        CreatedCollectionCount::put(next_id);2359    }23602361    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2362        let current_index = <ItemListIndex>::get(collection_id)2363            .checked_add(1)2364            .unwrap();23652366        let item_owner = item.owner.clone();2367        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23682369        <ItemListIndex>::insert(collection_id, current_index);23702371        // Update balance2372        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2373            .checked_add(1)2374            .unwrap();2375        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2376    }23772378    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2379        let current_index = <ItemListIndex>::get(collection_id)2380            .checked_add(1)2381            .unwrap();23822383        Self::add_token_index(collection_id, current_index, owner).unwrap();23842385        <ItemListIndex>::insert(collection_id, current_index);23862387        // Update balance2388        let new_balance = <Balance<T>>::get(collection_id, owner)2389            .checked_add(item.value)2390            .unwrap();2391        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2392    }23932394    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2395        let current_index = <ItemListIndex>::get(collection_id)2396            .checked_add(1)2397            .unwrap();23982399        let value = item.owner.first().unwrap().fraction;2400        let owner = item.owner.first().unwrap().owner.clone();24012402        Self::add_token_index(collection_id, current_index, &owner).unwrap();24032404        <ItemListIndex>::insert(collection_id, current_index);24052406        // Update balance2407        let new_balance = <Balance<T>>::get(collection_id, &owner)2408            .checked_add(value)2409            .unwrap();2410        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2411    }24122413    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2414        // add to account limit2415        if <AccountItemCount<T>>::contains_key(owner) {24162417            // bound Owned tokens by a single address2418            let count = <AccountItemCount<T>>::get(owner);2419            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24202421            <AccountItemCount<T>>::insert(owner.clone(), count2422                .checked_add(1)2423                .ok_or(Error::<T>::NumOverflow)?);2424        }2425        else {2426            <AccountItemCount<T>>::insert(owner.clone(), 1);2427        }24282429        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2430        if list_exists {2431            let mut list = <AddressTokens<T>>::get(collection_id, owner);2432            let item_contains = list.contains(&item_index.clone());24332434            if !item_contains {2435                list.push(item_index.clone());2436            }24372438            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2439        } else {2440            let mut itm = Vec::new();2441            itm.push(item_index.clone());2442            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2443        }24442445        Ok(())2446    }24472448    fn remove_token_index(2449        collection_id: CollectionId,2450        item_index: TokenId,2451        owner: &T::AccountId,2452    ) -> DispatchResult {24532454        // update counter2455        <AccountItemCount<T>>::insert(owner.clone(), 2456            <AccountItemCount<T>>::get(owner)2457            .checked_sub(1)2458            .ok_or(Error::<T>::NumOverflow)?);245924602461        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2462        if list_exists {2463            let mut list = <AddressTokens<T>>::get(collection_id, owner);2464            let item_contains = list.contains(&item_index.clone());24652466            if item_contains {2467                list.retain(|&item| item != item_index);2468                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2469            }2470        }24712472        Ok(())2473    }24742475    fn move_token_index(2476        collection_id: CollectionId,2477        item_index: TokenId,2478        old_owner: &T::AccountId,2479        new_owner: &T::AccountId,2480    ) -> DispatchResult {2481        Self::remove_token_index(collection_id, item_index, old_owner)?;2482        Self::add_token_index(collection_id, item_index, new_owner)?;24832484        Ok(())2485    }2486    2487    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2488        ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);24892490        Ok(())2491    }2492}24932494////////////////////////////////////////////////////////////////////////////////////////////////////2495// Economic models2496// #region24972498/// Fee multiplier.2499pub type Multiplier = FixedU128;25002501type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25022503/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2504/// in the queue.2505#[derive(Encode, Decode, Clone, Eq, PartialEq)]2506pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25072508impl<T: Config + Send + Sync> sp_std::fmt::Debug 2509    for ChargeTransactionPayment<T>2510{2511	#[cfg(feature = "std")]2512	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2513		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2514	}2515	#[cfg(not(feature = "std"))]2516	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2517		Ok(())2518	}2519}25202521impl<T: Config> ChargeTransactionPayment<T>2522where2523    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2524    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2525    T::AccountId: AsRef<[u8]>,2526    T::AccountId: UncheckedFrom<T::Hash>,2527{2528    fn traditional_fee(2529        len: usize,2530        info: &DispatchInfoOf<T::Call>,2531        tip: BalanceOf<T>,2532    ) -> BalanceOf<T>2533    where2534        T::Call: Dispatchable<Info = DispatchInfo>,2535    {2536        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2537    }25382539	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2540        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2541        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2542        let len_saturation = max_block_length as u64 / (len as u64).max(1);2543        let coefficient: BalanceOf<T> = weight_saturation2544            .min(len_saturation)2545            .saturated_into::<BalanceOf<T>>();2546        final_fee2547            .saturating_mul(coefficient)2548            .saturated_into::<TransactionPriority>()2549    }25502551    fn withdraw_fee(2552        &self,2553        who: &T::AccountId,2554        call: &T::Call,2555        info: &DispatchInfoOf<T::Call>,2556        len: usize,2557	) -> Result<2558		(2559			BalanceOf<T>,2560			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2561		),2562		TransactionValidityError,2563	> {2564        let tip = self.0;25652566        let fee = Self::traditional_fee(len, info, tip);25672568        // Only mess with balances if fee is not zero.2569        if fee.is_zero() {2570            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2571			.map(|i| (fee, i));2572        }25732574        // Determine who is paying transaction fee based on ecnomic model2575        // Parse call to extract collection ID and access collection sponsor2576        let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2577            Some(Call::create_item(collection_id, _owner, _properties)) => {2578                let collection = <CollectionById<T>>::get(collection_id)?;25792580                // sponsor timeout2581                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25822583                let limit = collection.limits.sponsor_transfer_timeout;2584                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2585                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2586                    let limit_time = last_tx_block + limit.into();2587                    if block_number <= limit_time {2588                        return None;2589                    }2590                }2591                <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);25922593                // check free create limit2594                if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2595                    collection.sponsorship.sponsor()2596                        .cloned()2597                } else {2598                    None2599                }2600            }2601            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2602                let collection = <CollectionById<T>>::get(collection_id)?;2603                2604                let mut sponsor_transfer = false;2605                if collection.sponsorship.confirmed() {26062607                    let collection_limits = collection.limits;2608                    let collection_mode = collection.mode;2609    2610                    // sponsor timeout2611                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2612                    sponsor_transfer = match collection_mode {2613                        CollectionMode::NFT => {2614    2615                            // get correct limit2616                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2617                                collection_limits.sponsor_transfer_timeout2618                            } else {2619                                ChainLimit::get().nft_sponsor_transfer_timeout2620                            };2621    2622                            let mut sponsored = true;2623                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2624                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2625                                let limit_time = last_tx_block + limit.into();2626                                if block_number <= limit_time {2627                                    sponsored = false;2628                                }2629                            }2630                            if sponsored {2631                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2632                            }26332634                            sponsored2635                        }2636                        CollectionMode::Fungible(_) => {2637    2638                            // get correct limit2639                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2640                                collection_limits.sponsor_transfer_timeout2641                            } else {2642                                ChainLimit::get().fungible_sponsor_transfer_timeout2643                            };2644    2645                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2646                            let mut sponsored = true;2647                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2648                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2649                                let limit_time = last_tx_block + limit.into();2650                                if block_number <= limit_time {2651                                    sponsored = false;2652                                }2653                            }2654                            if sponsored {2655                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2656                            }26572658                            sponsored2659                        }2660                        CollectionMode::ReFungible => {2661    2662                            // get correct limit2663                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2664                                collection_limits.sponsor_transfer_timeout2665                            } else {2666                                ChainLimit::get().refungible_sponsor_transfer_timeout2667                            };2668    2669                            let mut sponsored = true;2670                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2671                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2672                                let limit_time = last_tx_block + limit.into();2673                                if block_number <= limit_time {2674                                    sponsored = false;2675                                }2676                            }2677                            if sponsored {2678                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2679                            }26802681                            sponsored2682                        }2683                        _ => {2684                            false2685                        },2686                    };2687                }26882689                if !sponsor_transfer {2690                    None2691                } else {2692                    collection.sponsorship.sponsor()2693                        .cloned()2694                }2695            }26962697            Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2698                let mut sponsor_metadata_changes = false;26992700                let collection = <CollectionById<T>>::get(collection_id)?;27012702                if2703                    collection.sponsorship.confirmed() &&2704                    // Can't sponsor fungible collection, this tx will be rejected2705                    // as invalid2706                    !matches!(collection.mode, CollectionMode::Fungible(_)) &&2707                    data.len() <= collection.limits.sponsored_data_size as usize2708                {2709                    if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2710                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27112712                        if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2713                            .map(|last_block| block_number - last_block > rate_limit)2714                            .unwrap_or(true) 2715                        {2716                            sponsor_metadata_changes = true;2717                            <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2718                        }2719                    }2720                }27212722                if !sponsor_metadata_changes {2723                    None2724                } else {2725                    collection.sponsorship.sponsor().cloned()2726                }2727            }27282729            _ => None,2730        })();27312732        match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2733            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27342735                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27362737                let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2738                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2739                  2740                if !owned_contract && white_list_enabled {2741                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2742                        return Err(InvalidTransaction::Call.into());2743                    }2744                }2745            },2746            _ => {},2747        }27482749        // Sponsor smart contracts2750        sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27512752            // On instantiation: set the contract owner2753            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27542755                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2756                    &who,2757                    code_hash,2758                    salt,2759                );2760                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27612762                None2763            },27642765            // On instantiation with code: set the contract owner2766            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {27672768                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2769                    &who,2770                    &T::Hashing::hash(&_code),2771                    _salt,2772                );27732774                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27752776                None2777            }27782779            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2780            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27812782                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27832784                let mut sponsor_transfer = false;2785                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2786                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2787                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2788                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2789                    let limit_time = last_tx_block + rate_limit;27902791                    if block_number >= limit_time {2792                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2793                        sponsor_transfer = true;2794                    }2795                } else {2796                    sponsor_transfer = false;2797                }2798               2799                if sponsor_transfer {2800                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2801                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2802                            return Some(called_contract);2803                        }2804                    }2805                }28062807                None2808            },28092810            _ => None,2811        });28122813        let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28142815		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2816			.map(|i| (fee, i))2817    }2818}281928202821impl<T: Config + Send + Sync> SignedExtension2822    for ChargeTransactionPayment<T>2823where2824    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2825    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2826    T::AccountId: AsRef<[u8]>,2827    T::AccountId: UncheckedFrom<T::Hash>,2828{2829    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2830    type AccountId = T::AccountId;2831    type Call = T::Call;2832    type AdditionalSigned = ();2833    type Pre = (2834        // tip2835        BalanceOf<T>,2836        // who pays fee2837        Self::AccountId,2838		// imbalance resulting from withdrawing the fee2839		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2840    );2841    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2842        Ok(())2843    }28442845    fn validate(2846        &self,2847        who: &Self::AccountId,2848        call: &Self::Call,2849        info: &DispatchInfoOf<Self::Call>,2850        len: usize,2851    ) -> TransactionValidity {2852		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2853		Ok(ValidTransaction {2854			priority: Self::get_priority(len, info, fee),2855			..Default::default()2856		})2857    }28582859    fn pre_dispatch(2860        self,2861        who: &Self::AccountId,2862        call: &Self::Call,2863        info: &DispatchInfoOf<Self::Call>,2864        len: usize,2865    ) -> Result<Self::Pre, TransactionValidityError> {2866        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2867        Ok((self.0, who.clone(), imbalance))2868    }28692870    fn post_dispatch(2871        pre: Self::Pre,2872        info: &DispatchInfoOf<Self::Call>,2873        post_info: &PostDispatchInfoOf<Self::Call>,2874        len: usize,2875        _result: &DispatchResult,2876    ) -> Result<(), TransactionValidityError> {2877		let (tip, who, imbalance) = pre;2878		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2879			len as u32,2880			info,2881			post_info,2882			tip,2883		);2884		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2885		Ok(())2886    }2887}28882889// #endregion28902891sp_api::decl_runtime_apis! {2892    pub trait NftApi {2893        /// Used for ethereum integration2894        fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2895    }2896}