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::CrossAccountId, data: CreateItemData) -> DispatchResult {11211122            let sender = T::CrossAccountId::from_sub(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::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11561157            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1158            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1159            let collection = Self::get_collection(collection_id)?;11601161            Self::create_multiple_items_internal(sender, &collection, owner, items_data)?;11621163            Ok(())1164        }11651166        /// Destroys a concrete instance of NFT.1167        /// 1168        /// # Permissions1169        /// 1170        /// * Collection Owner.1171        /// * Collection Admin.1172        /// * Current NFT Owner.1173        /// 1174        /// # Arguments1175        /// 1176        /// * collection_id: ID of the collection.1177        /// 1178        /// * item_id: ID of NFT to burn.1179        #[weight = <T as Config>::WeightInfo::burn_item()]1180        #[transactional]1181        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11821183            let sender = ensure_signed(origin)?;11841185            // Transfer permissions check1186            let target_collection = Self::get_collection(collection_id)?;1187            ensure!(1188                Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1189                (1190                    target_collection.limits.owner_can_transfer &&1191                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1192                ),1193                Error::<T>::NoPermission1194            );11951196            if target_collection.access == AccessMode::WhiteList {1197                Self::check_white_list(&target_collection, &sender)?;1198            }11991200            match target_collection.mode1201            {1202                CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1203                CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, &target_collection, value)?,1204                CollectionMode::ReFungible  => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1205                _ => ()1206            };12071208            // call event1209            Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12101211            Ok(())1212        }12131214        /// Change ownership of the token.1215        /// 1216        /// # Permissions1217        /// 1218        /// * Collection Owner1219        /// * Collection Admin1220        /// * Current NFT owner1221        ///1222        /// # Arguments1223        /// 1224        /// * recipient: Address of token recipient.1225        /// 1226        /// * collection_id.1227        /// 1228        /// * item_id: ID of the item1229        ///     * Non-Fungible Mode: Required.1230        ///     * Fungible Mode: Ignored.1231        ///     * Re-Fungible Mode: Required.1232        /// 1233        /// * value: Amount to transfer.1234        ///     * Non-Fungible Mode: Ignored1235        ///     * Fungible Mode: Must specify transferred amount1236        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1237        #[weight = <T as Config>::WeightInfo::transfer()]1238        #[transactional]1239        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1240            let sender = ensure_signed(origin)?;1241            let collection = Self::get_collection(collection_id)?;12421243            Self::transfer_internal(sender, recipient, &collection, item_id, value)1244        }12451246        /// Set, change, or remove approved address to transfer the ownership of the NFT.1247        /// 1248        /// # Permissions1249        /// 1250        /// * Collection Owner1251        /// * Collection Admin1252        /// * Current NFT owner1253        /// 1254        /// # Arguments1255        /// 1256        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1257        /// 1258        /// * collection_id.1259        /// 1260        /// * item_id: ID of the item.1261        #[weight = <T as Config>::WeightInfo::approve()]1262        #[transactional]1263        pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12641265            let sender = ensure_signed(origin)?;1266            let target_collection = Self::get_collection(collection_id)?;12671268            Self::token_exists(&target_collection, item_id)?;12691270            // Transfer permissions check1271            let bypasses_limits = target_collection.limits.owner_can_transfer &&1272                Self::is_owner_or_admin_permissions(1273                    &target_collection,1274                    sender.clone(),1275                );12761277            let allowance_limit = if bypasses_limits {1278                None1279            } else if let Some(amount) = Self::owned_amount(1280                sender.clone(),1281                &target_collection,1282                item_id,1283            ) {1284                Some(amount)1285            } else {1286                fail!(Error::<T>::NoPermission);1287            };12881289            if target_collection.access == AccessMode::WhiteList {1290                Self::check_white_list(&target_collection, &sender)?;1291                Self::check_white_list(&target_collection, &spender)?;1292            }12931294            let allowance: u128 = amount1295                .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1296                .ok_or(Error::<T>::NumOverflow)?;1297            if let Some(limit) = allowance_limit {1298                ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1299            }1300            <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13011302            Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1303            Ok(())1304        }1305        1306        /// 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.1307        /// 1308        /// # Permissions1309        /// * Collection Owner1310        /// * Collection Admin1311        /// * Current NFT owner1312        /// * Address approved by current NFT owner1313        /// 1314        /// # Arguments1315        /// 1316        /// * from: Address that owns token.1317        /// 1318        /// * recipient: Address of token recipient.1319        /// 1320        /// * collection_id.1321        /// 1322        /// * item_id: ID of the item.1323        /// 1324        /// * value: Amount to transfer.1325        #[weight = <T as Config>::WeightInfo::transfer_from()]1326        #[transactional]1327        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13281329            let sender = ensure_signed(origin)?;1330            let target_collection = Self::get_collection(collection_id)?;13311332            // Check approval1333            let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13341335            // Limits check1336            Self::is_correct_transfer(&target_collection, &recipient)?;13371338            // Transfer permissions check         1339            ensure!(1340                approval >= value || 1341                (1342                    target_collection.limits.owner_can_transfer &&1343                    Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1344                ),1345                Error::<T>::NoPermission1346            );13471348            if target_collection.access == AccessMode::WhiteList {1349                Self::check_white_list(&target_collection, &sender)?;1350                Self::check_white_list(&target_collection, &recipient)?;1351            }13521353            // Reduce approval by transferred amount or remove if remaining approval drops to 01354            if approval.saturating_sub(value) > 0 {1355                <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1356            }1357            else {1358                <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1359            }13601361            match target_collection.mode1362            {1363                CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1364                CollectionMode::Fungible(_)  => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1365                CollectionMode::ReFungible  => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1366                _ => ()1367            };13681369            Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1370            Ok(())1371        }13721373        // #[weight = 0]1374        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13751376        //     // let no_perm_mes = "You do not have permissions to modify this collection";1377        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1378        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1379        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13801381        //     // // on_nft_received  call13821383        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;13841385        //     Ok(())1386        // }13871388        /// Set off-chain data schema.1389        /// 1390        /// # Permissions1391        /// 1392        /// * Collection Owner1393        /// * Collection Admin1394        /// 1395        /// # Arguments1396        /// 1397        /// * collection_id.1398        /// 1399        /// * schema: String representing the offchain data schema.1400        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1401        #[transactional]1402        pub fn set_variable_meta_data (1403            origin,1404            collection_id: CollectionId,1405            item_id: TokenId,1406            data: Vec<u8>1407        ) -> DispatchResult {1408            let sender = ensure_signed(origin)?;1409            1410            let target_collection = Self::get_collection(collection_id)?;1411            Self::token_exists(&target_collection, item_id)?;14121413            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14141415            // Modify permissions check1416            ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1417                Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1418                Error::<T>::NoPermission);14191420            match target_collection.mode1421            {1422                CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1423                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1424                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1425                _ => fail!(Error::<T>::UnexpectedCollectionType)1426            };14271428            Ok(())1429        }1430 1431        /// Set schema standard1432        /// ImageURL1433        /// Unique1434        /// 1435        /// # Permissions1436        /// 1437        /// * Collection Owner1438        /// * Collection Admin1439        /// 1440        /// # Arguments1441        /// 1442        /// * collection_id.1443        /// 1444        /// * schema: SchemaVersion: enum1445        #[weight = <T as Config>::WeightInfo::set_schema_version()]1446        #[transactional]1447        pub fn set_schema_version(1448            origin,1449            collection_id: CollectionId,1450            version: SchemaVersion1451        ) -> DispatchResult {1452            let sender = ensure_signed(origin)?;1453            let mut target_collection = Self::get_collection(collection_id)?;1454            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1455            target_collection.schema_version = version;1456            Self::save_collection(target_collection);14571458            Ok(())1459        }14601461        /// Set off-chain data schema.1462        /// 1463        /// # Permissions1464        /// 1465        /// * Collection Owner1466        /// * Collection Admin1467        /// 1468        /// # Arguments1469        /// 1470        /// * collection_id.1471        /// 1472        /// * schema: String representing the offchain data schema.1473        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1474        #[transactional]1475        pub fn set_offchain_schema(1476            origin,1477            collection_id: CollectionId,1478            schema: Vec<u8>1479        ) -> DispatchResult {1480            let sender = ensure_signed(origin)?;1481            let mut target_collection = Self::get_collection(collection_id)?;1482            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14831484            // check schema limit1485            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14861487            target_collection.offchain_schema = schema;1488            Self::save_collection(target_collection);14891490            Ok(())1491        }14921493        /// Set const on-chain data schema.1494        /// 1495        /// # Permissions1496        /// 1497        /// * Collection Owner1498        /// * Collection Admin1499        /// 1500        /// # Arguments1501        /// 1502        /// * collection_id.1503        /// 1504        /// * schema: String representing the const on-chain data schema.1505        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1506        #[transactional]1507        pub fn set_const_on_chain_schema (1508            origin,1509            collection_id: CollectionId,1510            schema: Vec<u8>1511        ) -> DispatchResult {1512            let sender = ensure_signed(origin)?;1513            let mut target_collection = Self::get_collection(collection_id)?;1514            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15151516            // check schema limit1517            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15181519            target_collection.const_on_chain_schema = schema;1520            Self::save_collection(target_collection);15211522            Ok(())1523        }15241525        /// Set variable on-chain data schema.1526        /// 1527        /// # Permissions1528        /// 1529        /// * Collection Owner1530        /// * Collection Admin1531        /// 1532        /// # Arguments1533        /// 1534        /// * collection_id.1535        /// 1536        /// * schema: String representing the variable on-chain data schema.1537        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1538        #[transactional]1539        pub fn set_variable_on_chain_schema (1540            origin,1541            collection_id: CollectionId,1542            schema: Vec<u8>1543        ) -> DispatchResult {1544            let sender = ensure_signed(origin)?;1545            let mut target_collection = Self::get_collection(collection_id)?;1546            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15471548            // check schema limit1549            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15501551            target_collection.variable_on_chain_schema = schema;1552            Self::save_collection(target_collection);15531554            Ok(())1555        }15561557        // Sudo permissions function1558        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1559        #[transactional]1560        pub fn set_chain_limits(1561            origin,1562            limits: ChainLimits1563        ) -> DispatchResult {15641565            #[cfg(not(feature = "runtime-benchmarks"))]1566            ensure_root(origin)?;15671568            <ChainLimit>::put(limits);1569            Ok(())1570        }15711572        /// Enable smart contract self-sponsoring.1573        /// 1574        /// # Permissions1575        /// 1576        /// * Contract Owner1577        /// 1578        /// # Arguments1579        /// 1580        /// * contract address1581        /// * enable flag1582        /// 1583        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1584        #[transactional]1585        pub fn enable_contract_sponsoring(1586            origin,1587            contract_address: T::AccountId,1588            enable: bool1589        ) -> DispatchResult {15901591            let sender = ensure_signed(origin)?;15921593            #[cfg(feature = "runtime-benchmarks")]1594            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15951596            Self::ensure_contract_owned(sender, &contract_address)?;15971598            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1599            Ok(())1600        }16011602        /// Set the rate limit for contract sponsoring to specified number of blocks.1603        /// 1604        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1605        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1606        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1607        /// from contract endowment if there are at least B blocks between such transactions. 1608        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1609        /// 1610        /// # Permissions1611        /// 1612        /// * Contract Owner1613        /// 1614        /// # Arguments1615        /// 1616        /// -`contract_address`: Address of the contract to sponsor1617        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1618        /// 1619        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1620        #[transactional]1621        pub fn set_contract_sponsoring_rate_limit(1622            origin,1623            contract_address: T::AccountId,1624            rate_limit: T::BlockNumber1625        ) -> DispatchResult {1626            let sender = ensure_signed(origin)?;16271628            #[cfg(feature = "runtime-benchmarks")]1629            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16301631            Self::ensure_contract_owned(sender, &contract_address)?;1632            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1633            Ok(())1634        }16351636        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1637        /// 1638        /// # Permissions1639        /// 1640        /// * Address that deployed smart contract.1641        /// 1642        /// # Arguments1643        /// 1644        /// -`contract_address`: Address of the contract.1645        /// 1646        /// - `enable`: .  1647        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1648        #[transactional]1649        pub fn toggle_contract_white_list(1650            origin,1651            contract_address: T::AccountId,1652            enable: bool1653        ) -> DispatchResult {1654            let sender = ensure_signed(origin)?;16551656            #[cfg(feature = "runtime-benchmarks")]1657            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16581659            Self::ensure_contract_owned(sender, &contract_address)?;1660            if enable {1661                <ContractWhiteListEnabled<T>>::insert(contract_address, true);1662            } else {1663                <ContractWhiteListEnabled<T>>::remove(contract_address);1664            }1665            Ok(())1666        }1667        1668        /// Add an address to smart contract white list.1669        /// 1670        /// # Permissions1671        /// 1672        /// * Address that deployed smart contract.1673        /// 1674        /// # Arguments1675        /// 1676        /// -`contract_address`: Address of the contract.1677        ///1678        /// -`account_address`: Address to add.1679        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1680        #[transactional]1681        pub fn add_to_contract_white_list(1682            origin,1683            contract_address: T::AccountId,1684            account_address: T::AccountId1685        ) -> DispatchResult {1686            let sender = ensure_signed(origin)?;16871688            #[cfg(feature = "runtime-benchmarks")]1689            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1690            1691            Self::ensure_contract_owned(sender, &contract_address)?;      1692            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1693            Ok(())1694        }16951696        /// Remove an address from smart contract white list.1697        /// 1698        /// # Permissions1699        /// 1700        /// * Address that deployed smart contract.1701        /// 1702        /// # Arguments1703        /// 1704        /// -`contract_address`: Address of the contract.1705        ///1706        /// -`account_address`: Address to remove.1707        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1708        #[transactional]1709        pub fn remove_from_contract_white_list(1710            origin,1711            contract_address: T::AccountId,1712            account_address: T::AccountId1713        ) -> DispatchResult {1714            let sender = ensure_signed(origin)?;17151716            #[cfg(feature = "runtime-benchmarks")]1717            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17181719            Self::ensure_contract_owned(sender, &contract_address)?;1720            <ContractWhiteList<T>>::remove(contract_address, account_address);1721            Ok(())1722        }17231724        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1725        #[transactional]1726        pub fn set_collection_limits(1727            origin,1728            collection_id: u32,1729            new_limits: CollectionLimits<T::BlockNumber>,1730        ) -> DispatchResult {1731            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1732            let mut target_collection = Self::get_collection(collection_id)?;1733            Self::check_owner_permissions(&target_collection, sender.clone())?;1734            let old_limits = &target_collection.limits;1735            let chain_limits = ChainLimit::get();17361737            // collection bounds1738            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1739                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1740                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1741                Error::<T>::CollectionLimitBoundsExceeded);17421743            // token_limit   check  prev1744            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1745            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17461747            ensure!(1748                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1749                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1750                Error::<T>::OwnerPermissionsCantBeReverted,1751            );17521753            target_collection.limits = new_limits;1754            Self::save_collection(target_collection);17551756            Ok(())1757        } 1758    }1759}17601761impl<T: Config> Module<T> {17621763    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1764        // Limits check1765        Self::is_correct_transfer(target_collection, &recipient)?;17661767        // Transfer permissions check1768        ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1769            Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1770            Error::<T>::NoPermission);17711772        if target_collection.access == AccessMode::WhiteList {1773            Self::check_white_list(target_collection, &sender)?;1774            Self::check_white_list(target_collection, &recipient)?;1775        }17761777        match target_collection.mode1778        {1779            CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1780            CollectionMode::Fungible(_)  => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1781            CollectionMode::ReFungible  => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1782            _ => ()1783        };17841785        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17861787        Ok(())1788    }17891790	pub fn approve_internal(1791		sender: T::AccountId,1792		spender: T::AccountId,1793		collection: &CollectionHandle<T>,1794		item_id: TokenId,1795		amount: u1281796	) -> DispatchResult {1797		Self::token_exists(&collection, item_id)?;17981799		// Transfer permissions check1800		let bypasses_limits = collection.limits.owner_can_transfer &&1801			Self::is_owner_or_admin_permissions(1802				&collection,1803				sender.clone(),1804			);18051806		let allowance_limit = if bypasses_limits {1807			None1808		} else if let Some(amount) = Self::owned_amount(1809			sender.clone(),1810			&collection,1811			item_id,1812		) {1813			Some(amount)1814		} else {1815			fail!(Error::<T>::NoPermission);1816		};18171818		if collection.access == AccessMode::WhiteList {1819			Self::check_white_list(&collection, &sender)?;1820			Self::check_white_list(&collection, &spender)?;1821		}18221823		let allowance: u128 = amount1824			.checked_add(<Allowances<T>>::get(collection.id, (item_id, &sender, &spender)))1825			.ok_or(Error::<T>::NumOverflow)?;1826		if let Some(limit) = allowance_limit {1827			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1828		}1829		<Allowances<T>>::insert(collection.id, (item_id, sender.clone(), spender.clone()), allowance);18301831		Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1832		Ok(())1833	}18341835	pub fn transfer_from_internal(1836		sender: T::AccountId,1837		from: T::AccountId,1838		recipient: T::AccountId,1839		collection: &CollectionHandle<T>,1840		item_id: TokenId,1841		amount: u128,1842	) -> DispatchResult {1843		// Check approval1844		let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, &from, &sender));18451846		// Limits check1847		Self::is_correct_transfer(&collection, &recipient)?;18481849		// Transfer permissions check1850		ensure!(1851			approval >= amount || 1852			(1853				collection.limits.owner_can_transfer &&1854				Self::is_owner_or_admin_permissions(&collection, sender.clone())1855			),1856			Error::<T>::NoPermission1857		);18581859		if collection.access == AccessMode::WhiteList {1860			Self::check_white_list(&collection, &sender)?;1861			Self::check_white_list(&collection, &recipient)?;1862		}18631864		// Reduce approval by transferred amount or remove if remaining approval drops to 01865		if approval.saturating_sub(amount) > 0 {1866			<Allowances<T>>::insert(collection.id, (item_id, &from, &sender), approval - amount);1867		} else {1868			<Allowances<T>>::remove(collection.id, (item_id, &from, &sender));1869		}18701871		match collection.mode {1872			CollectionMode::NFT => {1873				Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1874			}1875			CollectionMode::Fungible(_) => {1876				Self::transfer_fungible(&collection, amount, &from, &recipient)?1877			}1878			CollectionMode::ReFungible => {1879				Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1880			}1881			_ => ()1882		};18831884    pub fn create_multiple_items_internal(1885        sender: T::CrossAccountId,1886        collection: &CollectionHandle<T>,1887        owner: T::CrossAccountId,1888        items_data: Vec<CreateItemData>,1889    ) -> DispatchResult {1890        Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18911892        for data in &items_data {1893            Self::validate_create_item_args(&collection, data)?;1894        }1895        for data in &items_data {1896            Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1897        }18981899        Ok(())1900    }19011902    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1903        let collection_id = collection.id;19041905        // check token limit and account token limit1906        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1907        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1908        1909        Ok(())1910    }19111912    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1913        let collection_id = collection.id;19141915        // check token limit and account token limit1916        let total_items: u32 = ItemListIndex::get(collection_id)1917            .checked_add(amount)1918            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1919        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1920            .checked_add(amount)1921            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1922        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1923        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);19241925        if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1926            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1927            Self::check_white_list(collection, owner)?;1928            Self::check_white_list(collection, sender)?;1929        }19301931        Ok(())1932    }19331934    fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1935        match target_collection.mode1936        {1937            CollectionMode::NFT => {1938                if let CreateItemData::NFT(data) = data {1939                    // check sizes1940                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1941                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1942                } else {1943                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1944                }1945            },1946            CollectionMode::Fungible(_) => {1947                if let CreateItemData::Fungible(_) = data {1948                } else {1949                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1950                }1951            },1952            CollectionMode::ReFungible => {1953                if let CreateItemData::ReFungible(data) = data {19541955                    // check sizes1956                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1957                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19581959                    // Check refungibility limits1960                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1961                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1962                } else {1963                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1964                }1965            },1966            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1967        };19681969        Ok(())1970    }19711972    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {1973        match data1974        {1975            CreateItemData::NFT(data) => {1976                let item = NftItemType {1977                    owner: owner.clone(),1978                    const_data: data.const_data,1979                    variable_data: data.variable_data1980                };19811982                Self::add_nft_item(collection, item)?;1983            },1984            CreateItemData::Fungible(data) => {1985                Self::add_fungible_item(collection, &owner, data.value)?;1986            },1987            CreateItemData::ReFungible(data) => {1988                let mut owner_list = Vec::new();1989                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19901991                let item = ReFungibleItemType {1992                    owner: owner_list,1993                    const_data: data.const_data,1994                    variable_data: data.variable_data1995                };19961997                Self::add_refungible_item(collection, item)?;1998            }1999        };20002001        Ok(())2002    }20032004    fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, value: u128) -> DispatchResult {2005        let collection_id = collection.id;20062007        // Does new owner already have an account?2008        let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;20092010        // Mint 2011        let item = FungibleItemType {2012            value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,2013        };2014        <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);20152016        // Update balance2017        let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2018            .checked_add(value)2019            .ok_or(Error::<T>::NumOverflow)?;2020        <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20212022        Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));2023        Ok(())2024    }20252026    fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::CrossAccountId>) -> DispatchResult {2027        let collection_id = collection.id;20282029        let current_index = <ItemListIndex>::get(collection_id)2030            .checked_add(1)2031            .ok_or(Error::<T>::NumOverflow)?;2032        let itemcopy = item.clone();20332034        ensure!(2035            item.owner.len() == 1,2036            Error::<T>::BadCreateRefungibleCall,2037        );2038        let item_owner = item.owner.first().expect("only one owner is defined");20392040        let value = item_owner.fraction;2041        let owner = item_owner.owner.clone();20422043        Self::add_token_index(collection_id, current_index, &owner)?;20442045        <ItemListIndex>::insert(collection_id, current_index);2046        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);20472048        // Update balance2049        let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2050            .checked_add(value)2051            .ok_or(Error::<T>::NumOverflow)?;2052        <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20532054        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));2055        Ok(())2056    }20572058    fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::CrossAccountId>) -> DispatchResult {2059        let collection_id = collection.id;20602061        let current_index = <ItemListIndex>::get(collection_id)2062            .checked_add(1)2063            .ok_or(Error::<T>::NumOverflow)?;20642065        let item_owner = item.owner.clone();2066        Self::add_token_index(collection_id, current_index, &item.owner)?;20672068        <ItemListIndex>::insert(collection_id, current_index);2069        <NftItemList<T>>::insert(collection_id, current_index, item);20702071        // Update balance2072        let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())2073            .checked_add(1)2074            .ok_or(Error::<T>::NumOverflow)?;2075        <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);20762077        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2078        Ok(())2079    }20802081    fn burn_refungible_item(2082        collection: &CollectionHandle<T>,2083        item_id: TokenId,2084        owner: &T::AccountId,2085    ) -> DispatchResult {2086        let collection_id = collection.id;20872088        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2089            .ok_or(Error::<T>::TokenNotFound)?;2090        let rft_balance = token2091            .owner2092            .iter()2093            .find(|&i| i.owner == *owner)2094            .ok_or(Error::<T>::TokenNotFound)?;2095        Self::remove_token_index(collection_id, item_id, owner)?;20962097        // update balance2098        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2099            .checked_sub(rft_balance.fraction)2100            .ok_or(Error::<T>::NumOverflow)?;2101        <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);21022103        // Re-create owners list with sender removed2104        let index = token2105            .owner2106            .iter()2107            .position(|i| i.owner == *owner)2108            .expect("owned item is exists");2109        token.owner.remove(index);2110        let owner_count = token.owner.len();21112112        // Burn the token completely if this was the last (only) owner2113        if owner_count == 0 {2114            <ReFungibleItemList<T>>::remove(collection_id, item_id);2115            <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2116        }2117        else {2118            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2119        }21202121        Ok(())2122    }21232124    fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2125        let collection_id = collection.id;21262127        let item = <NftItemList<T>>::get(collection_id, item_id)2128            .ok_or(Error::<T>::TokenNotFound)?;2129        Self::remove_token_index(collection_id, item_id, &item.owner)?;21302131        // update balance2132        let new_balance = <Balance<T>>::get(collection_id, &item.owner)2133            .checked_sub(1)2134            .ok_or(Error::<T>::NumOverflow)?;2135        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2136        <NftItemList<T>>::remove(collection_id, item_id);2137        <VariableMetaDataBasket<T>>::remove(collection_id, item_id);21382139        Ok(())2140    }21412142    fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2143        let collection_id = collection.id;21442145        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2146        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);21472148        // update balance2149        let new_balance = <Balance<T>>::get(collection_id, owner)2150            .checked_sub(value)2151            .ok_or(Error::<T>::NumOverflow)?;2152        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);21532154        if balance.value - value > 0 {2155            balance.value -= value;2156            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2157        }2158        else {2159            <FungibleItemList<T>>::remove(collection_id, owner);2160        }21612162        Ok(())2163    }21642165    pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2166        Ok(<CollectionById<T>>::get(collection_id)2167            .map(|collection| CollectionHandle {2168                id: collection_id,2169                collection2170            })2171            .ok_or(Error::<T>::CollectionNotFound)?)2172    }21732174    fn save_collection(collection: CollectionHandle<T>) {2175        <CollectionById<T>>::insert(collection.id, collection.collection);2176    }21772178    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2179        ensure!(2180            subject == target_collection.owner,2181            Error::<T>::NoPermission2182        );21832184        Ok(())2185    }21862187    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2188        subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2189    }21902191    fn check_owner_or_admin_permissions(2192        collection: &CollectionHandle<T>,2193        subject: T::AccountId,2194    ) -> DispatchResult {2195        ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);21962197        Ok(())2198    }21992200    fn owned_amount(2201        subject: T::AccountId,2202        target_collection: &CollectionHandle<T>,2203        item_id: TokenId,2204    ) -> Option<u128> {2205        let collection_id = target_collection.id;22062207        match target_collection.mode {2208            CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2209                .then(|| 1),2210            CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2211                .value),2212            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2213                .owner2214                .iter()2215                .find(|i| i.owner == subject)2216                .map(|i| i.fraction),2217            CollectionMode::Invalid => None,2218        }2219    }22202221    fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2222        match target_collection.mode {2223            CollectionMode::Fungible(_) => true,2224            _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2225        }2226    }22272228    fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2229        let collection_id = collection.id;22302231        let mes = Error::<T>::AddresNotInWhiteList;2232        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);22332234        Ok(())2235    }22362237    /// Check if token exists. In case of Fungible, check if there is an entry for 2238    /// the owner in fungible balances double map2239    fn token_exists(2240        target_collection: &CollectionHandle<T>,2241        item_id: TokenId,2242    ) -> DispatchResult {2243        let collection_id = target_collection.id;2244        let exists = match target_collection.mode2245        {2246            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2247            CollectionMode::Fungible(_)  => true,2248            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2249            _ => false2250        };22512252        ensure!(exists == true, Error::<T>::TokenNotFound);2253        Ok(())2254    }22552256    fn transfer_fungible(2257        collection: &CollectionHandle<T>,2258        value: u128,2259        owner: &T::AccountId,2260        recipient: &T::AccountId,2261    ) -> DispatchResult {2262        let collection_id = collection.id;22632264        let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2265        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22662267        // Send balance to recipient (updates balanceOf of recipient)2268        Self::add_fungible_item(collection, recipient, value)?;22692270        // update balanceOf of sender2271        <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22722273        // Reduce or remove sender2274        if balance.value == value {2275            <FungibleItemList<T>>::remove(collection_id, owner);2276        }2277        else {2278            balance.value -= value;2279            <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2280        }22812282        Ok(())2283    }22842285    fn transfer_refungible(2286        collection: &CollectionHandle<T>,2287        item_id: TokenId,2288        value: u128,2289        owner: T::AccountId,2290        new_owner: T::AccountId,2291    ) -> DispatchResult {2292        let collection_id = collection.id;2293        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2294            .ok_or(Error::<T>::TokenNotFound)?;22952296        let item = full_item2297            .owner2298            .iter()2299            .filter(|i| i.owner == owner)2300            .next()2301            .ok_or(Error::<T>::TokenNotFound)?;2302        let amount = item.fraction;23032304        ensure!(amount >= value, Error::<T>::TokenValueTooLow);23052306        // update balance2307        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2308            .checked_sub(value)2309            .ok_or(Error::<T>::NumOverflow)?;2310        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23112312        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2313            .checked_add(value)2314            .ok_or(Error::<T>::NumOverflow)?;2315        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);23162317        let old_owner = item.owner.clone();2318        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);23192320        // transfer2321        if amount == value && !new_owner_has_account {2322            // change owner2323            // new owner do not have account2324            let mut new_full_item = full_item.clone();2325            new_full_item2326                .owner2327                .iter_mut()2328                .find(|i| i.owner == owner)2329                .expect("old owner does present in refungible")2330                .owner = new_owner.clone();2331            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);23322333            // update index collection2334            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2335        } else {2336            let mut new_full_item = full_item.clone();2337            new_full_item2338                .owner2339                .iter_mut()2340                .find(|i| i.owner == owner)2341                .expect("old owner does present in refungible")2342                .fraction -= value;23432344            // separate amount2345            if new_owner_has_account {2346                // new owner has account2347                new_full_item2348                    .owner2349                    .iter_mut()2350                    .find(|i| i.owner == new_owner)2351                    .expect("new owner has account")2352                    .fraction += value;2353            } else {2354                // new owner do not have account2355                new_full_item.owner.push(Ownership {2356                    owner: new_owner.clone(),2357                    fraction: value,2358                });2359                Self::add_token_index(collection_id, item_id, &new_owner)?;2360            }23612362            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2363        }23642365        Ok(())2366    }23672368    fn transfer_nft(2369        collection: &CollectionHandle<T>,2370        item_id: TokenId,2371        sender: T::AccountId,2372        new_owner: T::AccountId,2373    ) -> DispatchResult {2374        let collection_id = collection.id;2375        let mut item = <NftItemList<T>>::get(collection_id, item_id)2376            .ok_or(Error::<T>::TokenNotFound)?;23772378        ensure!(2379            sender == item.owner,2380            Error::<T>::MustBeTokenOwner2381        );23822383        // update balance2384        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2385            .checked_sub(1)2386            .ok_or(Error::<T>::NumOverflow)?;2387        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23882389        let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2390            .checked_add(1)2391            .ok_or(Error::<T>::NumOverflow)?;2392        <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23932394        // change owner2395        let old_owner = item.owner.clone();2396        item.owner = new_owner.clone();2397        <NftItemList<T>>::insert(collection_id, item_id, item);23982399        // update index collection2400        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;24012402        Ok(())2403    }2404    2405    fn set_re_fungible_variable_data(2406        collection: &CollectionHandle<T>,2407        item_id: TokenId,2408        data: Vec<u8>2409    ) -> DispatchResult {2410        let collection_id = collection.id;2411        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2412            .ok_or(Error::<T>::TokenNotFound)?;24132414        item.variable_data = data;24152416        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);24172418        Ok(())2419    }24202421    fn set_nft_variable_data(2422        collection: &CollectionHandle<T>,2423        item_id: TokenId,2424        data: Vec<u8>2425    ) -> DispatchResult {2426        let collection_id = collection.id;2427        let mut item = <NftItemList<T>>::get(collection_id, item_id)2428            .ok_or(Error::<T>::TokenNotFound)?;2429        2430        item.variable_data = data;24312432        <NftItemList<T>>::insert(collection_id, item_id, item);2433        2434        Ok(())2435    }24362437    fn init_collection(item: &Collection<T>) {2438        // check params2439        assert!(2440            item.decimal_points <= MAX_DECIMAL_POINTS,2441            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2442        );2443        assert!(2444            item.name.len() <= 64,2445            "Collection name can not be longer than 63 char"2446        );2447        assert!(2448            item.name.len() <= 256,2449            "Collection description can not be longer than 255 char"2450        );2451        assert!(2452            item.token_prefix.len() <= 16,2453            "Token prefix can not be longer than 15 char"2454        );24552456        // Generate next collection ID2457        let next_id = CreatedCollectionCount::get()2458            .checked_add(1)2459            .unwrap();24602461        CreatedCollectionCount::put(next_id);2462    }24632464    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2465        let current_index = <ItemListIndex>::get(collection_id)2466            .checked_add(1)2467            .unwrap();24682469        let item_owner = item.owner.clone();2470        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24712472        <ItemListIndex>::insert(collection_id, current_index);24732474        // Update balance2475        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2476            .checked_add(1)2477            .unwrap();2478        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2479    }24802481    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2482        let current_index = <ItemListIndex>::get(collection_id)2483            .checked_add(1)2484            .unwrap();24852486        Self::add_token_index(collection_id, current_index, owner).unwrap();24872488        <ItemListIndex>::insert(collection_id, current_index);24892490        // Update balance2491        let new_balance = <Balance<T>>::get(collection_id, owner)2492            .checked_add(item.value)2493            .unwrap();2494        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2495    }24962497    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2498        let current_index = <ItemListIndex>::get(collection_id)2499            .checked_add(1)2500            .unwrap();25012502        let value = item.owner.first().unwrap().fraction;2503        let owner = item.owner.first().unwrap().owner.clone();25042505        Self::add_token_index(collection_id, current_index, &owner).unwrap();25062507        <ItemListIndex>::insert(collection_id, current_index);25082509        // Update balance2510        let new_balance = <Balance<T>>::get(collection_id, &owner)2511            .checked_add(value)2512            .unwrap();2513        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2514    }25152516    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2517        // add to account limit2518        if <AccountItemCount<T>>::contains_key(owner) {25192520            // bound Owned tokens by a single address2521            let count = <AccountItemCount<T>>::get(owner);2522            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);25232524            <AccountItemCount<T>>::insert(owner.clone(), count2525                .checked_add(1)2526                .ok_or(Error::<T>::NumOverflow)?);2527        }2528        else {2529            <AccountItemCount<T>>::insert(owner.clone(), 1);2530        }25312532        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2533        if list_exists {2534            let mut list = <AddressTokens<T>>::get(collection_id, owner);2535            let item_contains = list.contains(&item_index.clone());25362537            if !item_contains {2538                list.push(item_index.clone());2539            }25402541            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2542        } else {2543            let mut itm = Vec::new();2544            itm.push(item_index.clone());2545            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2546        }25472548        Ok(())2549    }25502551    fn remove_token_index(2552        collection_id: CollectionId,2553        item_index: TokenId,2554        owner: &T::AccountId,2555    ) -> DispatchResult {25562557        // update counter2558        <AccountItemCount<T>>::insert(owner.clone(), 2559            <AccountItemCount<T>>::get(owner)2560            .checked_sub(1)2561            .ok_or(Error::<T>::NumOverflow)?);256225632564        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2565        if list_exists {2566            let mut list = <AddressTokens<T>>::get(collection_id, owner);2567            let item_contains = list.contains(&item_index.clone());25682569            if item_contains {2570                list.retain(|&item| item != item_index);2571                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2572            }2573        }25742575        Ok(())2576    }25772578    fn move_token_index(2579        collection_id: CollectionId,2580        item_index: TokenId,2581        old_owner: &T::AccountId,2582        new_owner: &T::AccountId,2583    ) -> DispatchResult {2584        Self::remove_token_index(collection_id, item_index, old_owner)?;2585        Self::add_token_index(collection_id, item_index, new_owner)?;25862587        Ok(())2588    }2589    2590    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2591        ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25922593        Ok(())2594    }2595}25962597////////////////////////////////////////////////////////////////////////////////////////////////////2598// Economic models2599// #region26002601/// Fee multiplier.2602pub type Multiplier = FixedU128;26032604type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;26052606/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2607/// in the queue.2608#[derive(Encode, Decode, Clone, Eq, PartialEq)]2609pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);26102611impl<T: Config + Send + Sync> sp_std::fmt::Debug 2612    for ChargeTransactionPayment<T>2613{2614	#[cfg(feature = "std")]2615	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2616		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2617	}2618	#[cfg(not(feature = "std"))]2619	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2620		Ok(())2621	}2622}26232624impl<T: Config> ChargeTransactionPayment<T>2625where2626    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2627    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2628    T::AccountId: AsRef<[u8]>,2629    T::AccountId: UncheckedFrom<T::Hash>,2630{2631    fn traditional_fee(2632        len: usize,2633        info: &DispatchInfoOf<T::Call>,2634        tip: BalanceOf<T>,2635    ) -> BalanceOf<T>2636    where2637        T::Call: Dispatchable<Info = DispatchInfo>,2638    {2639        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2640    }26412642	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2643        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2644        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2645        let len_saturation = max_block_length as u64 / (len as u64).max(1);2646        let coefficient: BalanceOf<T> = weight_saturation2647            .min(len_saturation)2648            .saturated_into::<BalanceOf<T>>();2649        final_fee2650            .saturating_mul(coefficient)2651            .saturated_into::<TransactionPriority>()2652    }26532654    fn withdraw_fee(2655        &self,2656        who: &T::AccountId,2657        call: &T::Call,2658        info: &DispatchInfoOf<T::Call>,2659        len: usize,2660	) -> Result<2661		(2662			BalanceOf<T>,2663			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2664		),2665		TransactionValidityError,2666	> {2667        let tip = self.0;26682669        let fee = Self::traditional_fee(len, info, tip);26702671        // Only mess with balances if fee is not zero.2672        if fee.is_zero() {2673            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2674			.map(|i| (fee, i));2675        }26762677        // Determine who is paying transaction fee based on ecnomic model2678        // Parse call to extract collection ID and access collection sponsor2679        let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2680            Some(Call::create_item(collection_id, _owner, _properties)) => {2681                let collection = <CollectionById<T>>::get(collection_id)?;26822683                // sponsor timeout2684                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26852686                let limit = collection.limits.sponsor_transfer_timeout;2687                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2688                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2689                    let limit_time = last_tx_block + limit.into();2690                    if block_number <= limit_time {2691                        return None;2692                    }2693                }2694                <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26952696                // check free create limit2697                if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2698                    collection.sponsorship.sponsor()2699                        .cloned()2700                } else {2701                    None2702                }2703            }2704            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2705                let collection = <CollectionById<T>>::get(collection_id)?;2706                2707                let mut sponsor_transfer = false;2708                if collection.sponsorship.confirmed() {27092710                    let collection_limits = collection.limits;2711                    let collection_mode = collection.mode;2712    2713                    // sponsor timeout2714                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2715                    sponsor_transfer = match collection_mode {2716                        CollectionMode::NFT => {2717    2718                            // get correct limit2719                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2720                                collection_limits.sponsor_transfer_timeout2721                            } else {2722                                ChainLimit::get().nft_sponsor_transfer_timeout2723                            };2724    2725                            let mut sponsored = true;2726                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2727                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2728                                let limit_time = last_tx_block + limit.into();2729                                if block_number <= limit_time {2730                                    sponsored = false;2731                                }2732                            }2733                            if sponsored {2734                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2735                            }27362737                            sponsored2738                        }2739                        CollectionMode::Fungible(_) => {2740    2741                            // get correct limit2742                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2743                                collection_limits.sponsor_transfer_timeout2744                            } else {2745                                ChainLimit::get().fungible_sponsor_transfer_timeout2746                            };2747    2748                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2749                            let mut sponsored = true;2750                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2751                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2752                                let limit_time = last_tx_block + limit.into();2753                                if block_number <= limit_time {2754                                    sponsored = false;2755                                }2756                            }2757                            if sponsored {2758                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2759                            }27602761                            sponsored2762                        }2763                        CollectionMode::ReFungible => {2764    2765                            // get correct limit2766                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2767                                collection_limits.sponsor_transfer_timeout2768                            } else {2769                                ChainLimit::get().refungible_sponsor_transfer_timeout2770                            };2771    2772                            let mut sponsored = true;2773                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2774                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2775                                let limit_time = last_tx_block + limit.into();2776                                if block_number <= limit_time {2777                                    sponsored = false;2778                                }2779                            }2780                            if sponsored {2781                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2782                            }27832784                            sponsored2785                        }2786                        _ => {2787                            false2788                        },2789                    };2790                }27912792                if !sponsor_transfer {2793                    None2794                } else {2795                    collection.sponsorship.sponsor()2796                        .cloned()2797                }2798            }27992800            Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2801                let mut sponsor_metadata_changes = false;28022803                let collection = <CollectionById<T>>::get(collection_id)?;28042805                if2806                    collection.sponsorship.confirmed() &&2807                    // Can't sponsor fungible collection, this tx will be rejected2808                    // as invalid2809                    !matches!(collection.mode, CollectionMode::Fungible(_)) &&2810                    data.len() <= collection.limits.sponsored_data_size as usize2811                {2812                    if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2813                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;28142815                        if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2816                            .map(|last_block| block_number - last_block > rate_limit)2817                            .unwrap_or(true) 2818                        {2819                            sponsor_metadata_changes = true;2820                            <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2821                        }2822                    }2823                }28242825                if !sponsor_metadata_changes {2826                    None2827                } else {2828                    collection.sponsorship.sponsor().cloned()2829                }2830            }28312832            _ => None,2833        })();28342835        match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2836            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28372838                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28392840                let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2841                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2842                  2843                if !owned_contract && white_list_enabled {2844                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2845                        return Err(InvalidTransaction::Call.into());2846                    }2847                }2848            },2849            _ => {},2850        }28512852        // Sponsor smart contracts2853        sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28542855            // On instantiation: set the contract owner2856            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28572858                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2859                    &who,2860                    code_hash,2861                    salt,2862                );2863                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28642865                None2866            },28672868            // On instantiation with code: set the contract owner2869            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {28702871                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2872                    &who,2873                    &T::Hashing::hash(&_code),2874                    _salt,2875                );28762877                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28782879                None2880            }28812882            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2883            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28842885                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28862887                let mut sponsor_transfer = false;2888                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2889                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2890                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2891                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2892                    let limit_time = last_tx_block + rate_limit;28932894                    if block_number >= limit_time {2895                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2896                        sponsor_transfer = true;2897                    }2898                } else {2899                    sponsor_transfer = false;2900                }2901               2902                if sponsor_transfer {2903                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2904                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2905                            return Some(called_contract);2906                        }2907                    }2908                }29092910                None2911            },29122913            _ => None,2914        });29152916        let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());29172918		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2919			.map(|i| (fee, i))2920    }2921}292229232924impl<T: Config + Send + Sync> SignedExtension2925    for ChargeTransactionPayment<T>2926where2927    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2928    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2929    T::AccountId: AsRef<[u8]>,2930    T::AccountId: UncheckedFrom<T::Hash>,2931{2932    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2933    type AccountId = T::AccountId;2934    type Call = T::Call;2935    type AdditionalSigned = ();2936    type Pre = (2937        // tip2938        BalanceOf<T>,2939        // who pays fee2940        Self::AccountId,2941		// imbalance resulting from withdrawing the fee2942		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2943    );2944    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2945        Ok(())2946    }29472948    fn validate(2949        &self,2950        who: &Self::AccountId,2951        call: &Self::Call,2952        info: &DispatchInfoOf<Self::Call>,2953        len: usize,2954    ) -> TransactionValidity {2955		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2956		Ok(ValidTransaction {2957			priority: Self::get_priority(len, info, fee),2958			..Default::default()2959		})2960    }29612962    fn pre_dispatch(2963        self,2964        who: &Self::AccountId,2965        call: &Self::Call,2966        info: &DispatchInfoOf<Self::Call>,2967        len: usize,2968    ) -> Result<Self::Pre, TransactionValidityError> {2969        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2970        Ok((self.0, who.clone(), imbalance))2971    }29722973    fn post_dispatch(2974        pre: Self::Pre,2975        info: &DispatchInfoOf<Self::Call>,2976        post_info: &PostDispatchInfoOf<Self::Call>,2977        len: usize,2978        _result: &DispatchResult,2979    ) -> Result<(), TransactionValidityError> {2980		let (tip, who, imbalance) = pre;2981		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2982			len as u32,2983			info,2984			post_info,2985			tip,2986		);2987		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2988		Ok(())2989    }2990}29912992// #endregion29932994sp_api::decl_runtime_apis! {2995    pub trait NftApi {2996        /// Used for ethereum integration2997        fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2998    }2999}