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

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 = T::CrossAccountId::from_sub(ensure_signed(origin)?);1184            let target_collection = Self::get_collection(collection_id)?;11851186            Self::burn_item_internal(&sender, &target_collection, item_id, value)?;11871188            Ok(())1189        }11901191        /// Change ownership of the token.1192        /// 1193        /// # Permissions1194        /// 1195        /// * Collection Owner1196        /// * Collection Admin1197        /// * Current NFT owner1198        ///1199        /// # Arguments1200        /// 1201        /// * recipient: Address of token recipient.1202        /// 1203        /// * collection_id.1204        /// 1205        /// * item_id: ID of the item1206        ///     * Non-Fungible Mode: Required.1207        ///     * Fungible Mode: Ignored.1208        ///     * Re-Fungible Mode: Required.1209        /// 1210        /// * value: Amount to transfer.1211        ///     * Non-Fungible Mode: Ignored1212        ///     * Fungible Mode: Must specify transferred amount1213        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1214        #[weight = <T as Config>::WeightInfo::transfer()]1215        #[transactional]1216        pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1217            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1218            let collection = Self::get_collection(collection_id)?;12191220            Self::transfer_internal(sender, recipient, &collection, item_id, value)?;12211222            Ok(())1223        }12241225        /// Set, change, or remove approved address to transfer the ownership of the NFT.1226        /// 1227        /// # Permissions1228        /// 1229        /// * Collection Owner1230        /// * Collection Admin1231        /// * Current NFT owner1232        /// 1233        /// # Arguments1234        /// 1235        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1236        /// 1237        /// * collection_id.1238        /// 1239        /// * item_id: ID of the item.1240        #[weight = <T as Config>::WeightInfo::approve()]1241        #[transactional]1242        pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12431244            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1245            let collection = Self::get_collection(collection_id)?;12461247            Self::approve_internal(sender, spender, &collection, item_id, amount)?;12481249            Ok(())1250        }1251        1252        /// 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.1253        /// 1254        /// # Permissions1255        /// * Collection Owner1256        /// * Collection Admin1257        /// * Current NFT owner1258        /// * Address approved by current NFT owner1259        /// 1260        /// # Arguments1261        /// 1262        /// * from: Address that owns token.1263        /// 1264        /// * recipient: Address of token recipient.1265        /// 1266        /// * collection_id.1267        /// 1268        /// * item_id: ID of the item.1269        /// 1270        /// * value: Amount to transfer.1271        #[weight = <T as Config>::WeightInfo::transfer_from()]1272        #[transactional]1273        pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12741275            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1276            let collection = Self::get_collection(collection_id)?;12771278            Self::transfer_from_internal(sender, from, recipient, &collection, item_id, value)?;12791280            Ok(())1281        }12821283        // #[weight = 0]1284        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {12851286        //     // let no_perm_mes = "You do not have permissions to modify this collection";1287        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1288        //     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1289        //     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);12901291        //     // // on_nft_received  call12921293        //     // Self::transfer(origin, collection_id, item_id, new_owner)?;12941295        //     Ok(())1296        // }12971298        /// Set off-chain data schema.1299        /// 1300        /// # Permissions1301        /// 1302        /// * Collection Owner1303        /// * Collection Admin1304        /// 1305        /// # Arguments1306        /// 1307        /// * collection_id.1308        /// 1309        /// * schema: String representing the offchain data schema.1310        #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1311        #[transactional]1312        pub fn set_variable_meta_data (1313            origin,1314            collection_id: CollectionId,1315            item_id: TokenId,1316            data: Vec<u8>1317        ) -> DispatchResult {1318            let sender = ensure_signed(origin)?;1319            1320            let target_collection = Self::get_collection(collection_id)?;1321            Self::token_exists(&target_collection, item_id)?;13221323            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13241325            // Modify permissions check1326            ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1327                Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1328                Error::<T>::NoPermission);13291330            match target_collection.mode1331            {1332                CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1333                CollectionMode::ReFungible  => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1334                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1335                _ => fail!(Error::<T>::UnexpectedCollectionType)1336            };13371338            Ok(())1339        }1340 1341        /// Set schema standard1342        /// ImageURL1343        /// Unique1344        /// 1345        /// # Permissions1346        /// 1347        /// * Collection Owner1348        /// * Collection Admin1349        /// 1350        /// # Arguments1351        /// 1352        /// * collection_id.1353        /// 1354        /// * schema: SchemaVersion: enum1355        #[weight = <T as Config>::WeightInfo::set_schema_version()]1356        #[transactional]1357        pub fn set_schema_version(1358            origin,1359            collection_id: CollectionId,1360            version: SchemaVersion1361        ) -> DispatchResult {1362            let sender = ensure_signed(origin)?;1363            let mut target_collection = Self::get_collection(collection_id)?;1364            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1365            target_collection.schema_version = version;1366            Self::save_collection(target_collection);13671368            Ok(())1369        }13701371        /// Set off-chain data schema.1372        /// 1373        /// # Permissions1374        /// 1375        /// * Collection Owner1376        /// * Collection Admin1377        /// 1378        /// # Arguments1379        /// 1380        /// * collection_id.1381        /// 1382        /// * schema: String representing the offchain data schema.1383        #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1384        #[transactional]1385        pub fn set_offchain_schema(1386            origin,1387            collection_id: CollectionId,1388            schema: Vec<u8>1389        ) -> DispatchResult {1390            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1391            let mut target_collection = Self::get_collection(collection_id)?;1392            Self::check_owner_or_admin_permissions(&target_collection, sender)?;13931394            // check schema limit1395            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");13961397            target_collection.offchain_schema = schema;1398            Self::save_collection(target_collection);13991400            Ok(())1401        }14021403        /// Set const on-chain data schema.1404        /// 1405        /// # Permissions1406        /// 1407        /// * Collection Owner1408        /// * Collection Admin1409        /// 1410        /// # Arguments1411        /// 1412        /// * collection_id.1413        /// 1414        /// * schema: String representing the const on-chain data schema.1415        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1416        #[transactional]1417        pub fn set_const_on_chain_schema (1418            origin,1419            collection_id: CollectionId,1420            schema: Vec<u8>1421        ) -> DispatchResult {1422            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1423            let mut target_collection = Self::get_collection(collection_id)?;1424            Self::check_owner_or_admin_permissions(&target_collection, sender)?;14251426            // check schema limit1427            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14281429            target_collection.const_on_chain_schema = schema;1430            Self::save_collection(target_collection);14311432            Ok(())1433        }14341435        /// Set variable on-chain data schema.1436        /// 1437        /// # Permissions1438        /// 1439        /// * Collection Owner1440        /// * Collection Admin1441        /// 1442        /// # Arguments1443        /// 1444        /// * collection_id.1445        /// 1446        /// * schema: String representing the variable on-chain data schema.1447        #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1448        #[transactional]1449        pub fn set_variable_on_chain_schema (1450            origin,1451            collection_id: CollectionId,1452            schema: Vec<u8>1453        ) -> DispatchResult {1454            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1455            let mut target_collection = Self::get_collection(collection_id)?;1456            Self::check_owner_or_admin_permissions(&target_collection, sender)?;14571458            // check schema limit1459            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14601461            target_collection.variable_on_chain_schema = schema;1462            Self::save_collection(target_collection);14631464            Ok(())1465        }14661467        // Sudo permissions function1468        #[weight = <T as Config>::WeightInfo::set_chain_limits()]1469        #[transactional]1470        pub fn set_chain_limits(1471            origin,1472            limits: ChainLimits1473        ) -> DispatchResult {14741475            #[cfg(not(feature = "runtime-benchmarks"))]1476            ensure_root(origin)?;14771478            <ChainLimit>::put(limits);1479            Ok(())1480        }14811482        /// Enable smart contract self-sponsoring.1483        /// 1484        /// # Permissions1485        /// 1486        /// * Contract Owner1487        /// 1488        /// # Arguments1489        /// 1490        /// * contract address1491        /// * enable flag1492        /// 1493        #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1494        #[transactional]1495        pub fn enable_contract_sponsoring(1496            origin,1497            contract_address: T::AccountId,1498            enable: bool1499        ) -> DispatchResult {15001501            let sender = ensure_signed(origin)?;15021503            #[cfg(feature = "runtime-benchmarks")]1504            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15051506            Self::ensure_contract_owned(sender, &contract_address)?;15071508            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1509            Ok(())1510        }15111512        /// Set the rate limit for contract sponsoring to specified number of blocks.1513        /// 1514        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1515        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1516        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1517        /// from contract endowment if there are at least B blocks between such transactions. 1518        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1519        /// 1520        /// # Permissions1521        /// 1522        /// * Contract Owner1523        /// 1524        /// # Arguments1525        /// 1526        /// -`contract_address`: Address of the contract to sponsor1527        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1528        /// 1529        #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1530        #[transactional]1531        pub fn set_contract_sponsoring_rate_limit(1532            origin,1533            contract_address: T::AccountId,1534            rate_limit: T::BlockNumber1535        ) -> DispatchResult {1536            let sender = ensure_signed(origin)?;15371538            #[cfg(feature = "runtime-benchmarks")]1539            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15401541            Self::ensure_contract_owned(sender, &contract_address)?;1542            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1543            Ok(())1544        }15451546        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1547        /// 1548        /// # Permissions1549        /// 1550        /// * Address that deployed smart contract.1551        /// 1552        /// # Arguments1553        /// 1554        /// -`contract_address`: Address of the contract.1555        /// 1556        /// - `enable`: .  1557        #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1558        #[transactional]1559        pub fn toggle_contract_white_list(1560            origin,1561            contract_address: T::AccountId,1562            enable: bool1563        ) -> DispatchResult {1564            let sender = ensure_signed(origin)?;15651566            #[cfg(feature = "runtime-benchmarks")]1567            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15681569            Self::ensure_contract_owned(sender, &contract_address)?;1570            if enable {1571                <ContractWhiteListEnabled<T>>::insert(contract_address, true);1572            } else {1573                <ContractWhiteListEnabled<T>>::remove(contract_address);1574            }1575            Ok(())1576        }1577        1578        /// Add an address to smart contract white list.1579        /// 1580        /// # Permissions1581        /// 1582        /// * Address that deployed smart contract.1583        /// 1584        /// # Arguments1585        /// 1586        /// -`contract_address`: Address of the contract.1587        ///1588        /// -`account_address`: Address to add.1589        #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1590        #[transactional]1591        pub fn add_to_contract_white_list(1592            origin,1593            contract_address: T::AccountId,1594            account_address: T::AccountId1595        ) -> DispatchResult {1596            let sender = ensure_signed(origin)?;15971598            #[cfg(feature = "runtime-benchmarks")]1599            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1600            1601            Self::ensure_contract_owned(sender, &contract_address)?;      1602            <ContractWhiteList<T>>::insert(contract_address, account_address, true);1603            Ok(())1604        }16051606        /// Remove an address from smart contract white list.1607        /// 1608        /// # Permissions1609        /// 1610        /// * Address that deployed smart contract.1611        /// 1612        /// # Arguments1613        /// 1614        /// -`contract_address`: Address of the contract.1615        ///1616        /// -`account_address`: Address to remove.1617        #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1618        #[transactional]1619        pub fn remove_from_contract_white_list(1620            origin,1621            contract_address: T::AccountId,1622            account_address: T::AccountId1623        ) -> DispatchResult {1624            let sender = ensure_signed(origin)?;16251626            #[cfg(feature = "runtime-benchmarks")]1627            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16281629            Self::ensure_contract_owned(sender, &contract_address)?;1630            <ContractWhiteList<T>>::remove(contract_address, account_address);1631            Ok(())1632        }16331634        #[weight = <T as Config>::WeightInfo::set_collection_limits()]1635        #[transactional]1636        pub fn set_collection_limits(1637            origin,1638            collection_id: u32,1639            new_limits: CollectionLimits<T::BlockNumber>,1640        ) -> DispatchResult {1641            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1642            let mut target_collection = Self::get_collection(collection_id)?;1643            Self::check_owner_permissions(&target_collection, sender.clone())?;1644            let old_limits = &target_collection.limits;1645            let chain_limits = ChainLimit::get();16461647            // collection bounds1648            ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1649                new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1650                new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1651                Error::<T>::CollectionLimitBoundsExceeded);16521653            // token_limit   check  prev1654            ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1655            ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16561657            ensure!(1658                (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1659                (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1660                Error::<T>::OwnerPermissionsCantBeReverted,1661            );16621663            target_collection.limits = new_limits;1664            Self::save_collection(target_collection);16651666            Ok(())1667        } 1668    }1669}16701671impl<T: Config> Module<T> {16721673    pub fn transfer_internal(sender: T::CrossAccountId, recipient: T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1674        // Limits check1675        Self::is_correct_transfer(target_collection, &recipient)?;16761677        // Transfer permissions check1678        ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1679            Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1680            Error::<T>::NoPermission);16811682        if target_collection.access == AccessMode::WhiteList {1683            Self::check_white_list(target_collection, &sender)?;1684            Self::check_white_list(target_collection, &recipient)?;1685        }16861687        match target_collection.mode1688        {1689            CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1690            CollectionMode::Fungible(_)  => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1691            CollectionMode::ReFungible  => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1692            _ => ()1693        };16941695        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));16961697        Ok(())1698    }16991700	pub fn approve_internal(1701		sender: T::CrossAccountId,1702		spender: T::CrossAccountId,1703		collection: &CollectionHandle<T>,1704		item_id: TokenId,1705		amount: u1281706	) -> DispatchResult {1707		Self::token_exists(&collection, item_id)?;17081709		// Transfer permissions check1710		let bypasses_limits = collection.limits.owner_can_transfer &&1711			Self::is_owner_or_admin_permissions(1712				&collection,1713				sender.clone(),1714			);17151716		let allowance_limit = if bypasses_limits {1717			None1718		} else if let Some(amount) = Self::owned_amount(1719			sender.clone(),1720			&collection,1721			item_id,1722		) {1723			Some(amount)1724		} else {1725			fail!(Error::<T>::NoPermission);1726		};17271728		if collection.access == AccessMode::WhiteList {1729			Self::check_white_list(&collection, &sender)?;1730			Self::check_white_list(&collection, &spender)?;1731		}17321733		let allowance: u128 = amount1734			.checked_add(<Allowances<T>>::get(collection.id, (item_id, sender.as_sub(), spender.as_sub())))1735			.ok_or(Error::<T>::NumOverflow)?;1736		if let Some(limit) = allowance_limit {1737			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1738		}1739		<Allowances<T>>::insert(collection.id, (item_id, sender.as_sub(), spender.as_sub()), allowance);174017411742		Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1743		Ok(())1744	}17451746	pub fn transfer_from_internal(1747		sender: T::CrossAccountId,1748		from: T::CrossAccountId,1749		recipient: T::CrossAccountId,1750		collection: &CollectionHandle<T>,1751		item_id: TokenId,1752		amount: u128,1753	) -> DispatchResult {1754		// Check approval1755		let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));17561757		// Limits check1758		Self::is_correct_transfer(&collection, &recipient)?;17591760		// Transfer permissions check1761		ensure!(1762			approval >= amount || 1763			(1764				collection.limits.owner_can_transfer &&1765				Self::is_owner_or_admin_permissions(&collection, sender.clone())1766			),1767			Error::<T>::NoPermission1768		);17691770		if collection.access == AccessMode::WhiteList {1771			Self::check_white_list(&collection, &sender)?;1772			Self::check_white_list(&collection, &recipient)?;1773		}17741775		// Reduce approval by transferred amount or remove if remaining approval drops to 01776		let allowance = approval.saturating_sub(amount);1777		if allowance > 0 {1778			<Allowances<T>>::insert(collection.id, (item_id, from.as_sub(), sender.as_sub()), allowance);1779		} else {1780			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1781		}17821783		match collection.mode {1784			CollectionMode::NFT => {1785				Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1786			}1787			CollectionMode::Fungible(_) => {1788				Self::transfer_fungible(&collection, amount, &from, &recipient)?1789			}1790			CollectionMode::ReFungible => {1791				Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1792			}1793			_ => ()1794		};17951796		Ok(())1797	}17981799    pub fn create_multiple_items_internal(1800        sender: T::CrossAccountId,1801        collection: &CollectionHandle<T>,1802        owner: T::CrossAccountId,1803        items_data: Vec<CreateItemData>,1804    ) -> DispatchResult {1805        Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18061807        for data in &items_data {1808            Self::validate_create_item_args(&collection, data)?;1809        }1810        for data in &items_data {1811            Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1812        }18131814        Ok(())1815    }18161817    pub fn burn_item_internal(1818        sender: &T::CrossAccountId,1819        collection: &CollectionHandle<T>,1820        item_id: TokenId,1821        value: u128,1822    ) -> DispatchResult {1823        ensure!(1824            Self::is_item_owner(sender.clone(), &collection, item_id) ||1825            (1826                collection.limits.owner_can_transfer &&1827                Self::is_owner_or_admin_permissions(&collection, sender.clone())1828            ),1829            Error::<T>::NoPermission1830        );18311832        if collection.access == AccessMode::WhiteList {1833            Self::check_white_list(&collection, &sender)?;1834        }18351836        match collection.mode1837        {1838            CollectionMode::NFT => Self::burn_nft_item(&collection, item_id)?,1839            CollectionMode::Fungible(_)  => Self::burn_fungible_item(&sender, &collection, value)?,1840            CollectionMode::ReFungible  => Self::burn_refungible_item(&collection, item_id, &sender)?,1841            _ => ()1842        };18431844        Ok(())1845    }18461847    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::CrossAccountId) -> DispatchResult {1848        let collection_id = collection.id;18491850        // check token limit and account token limit1851        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1852        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1853        1854        Ok(())1855    }18561857    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1858        let collection_id = collection.id;18591860        // check token limit and account token limit1861        let total_items: u32 = ItemListIndex::get(collection_id)1862            .checked_add(amount)1863            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1864        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1865            .checked_add(amount)1866            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1867        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1868        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);18691870        if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1871            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1872            Self::check_white_list(collection, owner)?;1873            Self::check_white_list(collection, sender)?;1874        }18751876        Ok(())1877    }18781879    fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1880        match target_collection.mode1881        {1882            CollectionMode::NFT => {1883                if let CreateItemData::NFT(data) = data {1884                    // check sizes1885                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1886                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1887                } else {1888                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1889                }1890            },1891            CollectionMode::Fungible(_) => {1892                if let CreateItemData::Fungible(_) = data {1893                } else {1894                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1895                }1896            },1897            CollectionMode::ReFungible => {1898                if let CreateItemData::ReFungible(data) = data {18991900                    // check sizes1901                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1902                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19031904                    // Check refungibility limits1905                    ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1906                    ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1907                } else {1908                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1909                }1910            },1911            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1912        };19131914        Ok(())1915    }19161917    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {1918        match data1919        {1920            CreateItemData::NFT(data) => {1921                let item = NftItemType {1922                    owner: owner.clone(),1923                    const_data: data.const_data,1924                    variable_data: data.variable_data1925                };19261927                Self::add_nft_item(collection, item)?;1928            },1929            CreateItemData::Fungible(data) => {1930                Self::add_fungible_item(collection, &owner, data.value)?;1931            },1932            CreateItemData::ReFungible(data) => {1933                let mut owner_list = Vec::new();1934                owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19351936                let item = ReFungibleItemType {1937                    owner: owner_list,1938                    const_data: data.const_data,1939                    variable_data: data.variable_data1940                };19411942                Self::add_refungible_item(collection, item)?;1943            }1944        };19451946        Ok(())1947    }19481949    fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, value: u128) -> DispatchResult {1950        let collection_id = collection.id;19511952        // Does new owner already have an account?1953        let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;19541955        // Mint 1956        let item = FungibleItemType {1957            value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1958        };1959        <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);19601961        // Update balance1962        let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1963            .checked_add(value)1964            .ok_or(Error::<T>::NumOverflow)?;1965        <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19661967        Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1968        Ok(())1969    }19701971    fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::CrossAccountId>) -> DispatchResult {1972        let collection_id = collection.id;19731974        let current_index = <ItemListIndex>::get(collection_id)1975            .checked_add(1)1976            .ok_or(Error::<T>::NumOverflow)?;1977        let itemcopy = item.clone();19781979        ensure!(1980            item.owner.len() == 1,1981            Error::<T>::BadCreateRefungibleCall,1982        );1983        let item_owner = item.owner.first().expect("only one owner is defined");19841985        let value = item_owner.fraction;1986        let owner = item_owner.owner.clone();19871988        Self::add_token_index(collection_id, current_index, &owner)?;19891990        <ItemListIndex>::insert(collection_id, current_index);1991        <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19921993        // Update balance1994        let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1995            .checked_add(value)1996            .ok_or(Error::<T>::NumOverflow)?;1997        <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19981999        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));2000        Ok(())2001    }20022003    fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::CrossAccountId>) -> DispatchResult {2004        let collection_id = collection.id;20052006        let current_index = <ItemListIndex>::get(collection_id)2007            .checked_add(1)2008            .ok_or(Error::<T>::NumOverflow)?;20092010        let item_owner = item.owner.clone();2011        Self::add_token_index(collection_id, current_index, &item.owner)?;20122013        <ItemListIndex>::insert(collection_id, current_index);2014        <NftItemList<T>>::insert(collection_id, current_index, item);20152016        // Update balance2017        let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())2018            .checked_add(1)2019            .ok_or(Error::<T>::NumOverflow)?;2020        <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);20212022        Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2023        Ok(())2024    }20252026    fn burn_refungible_item(2027        collection: &CollectionHandle<T>,2028        item_id: TokenId,2029        owner: &T::CrossAccountId,2030    ) -> DispatchResult {2031        let collection_id = collection.id;20322033        let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2034            .ok_or(Error::<T>::TokenNotFound)?;2035        let rft_balance = token2036            .owner2037            .iter()2038            .find(|&i| i.owner == *owner)2039            .ok_or(Error::<T>::TokenNotFound)?;2040        Self::remove_token_index(collection_id, item_id, owner)?;20412042        // update balance2043        let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())2044            .checked_sub(rft_balance.fraction)2045            .ok_or(Error::<T>::NumOverflow)?;2046        <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);20472048        // Re-create owners list with sender removed2049        let index = token2050            .owner2051            .iter()2052            .position(|i| i.owner == *owner)2053            .expect("owned item is exists");2054        token.owner.remove(index);2055        let owner_count = token.owner.len();20562057        // Burn the token completely if this was the last (only) owner2058        if owner_count == 0 {2059            <ReFungibleItemList<T>>::remove(collection_id, item_id);2060            <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2061        }2062        else {2063            <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2064        }20652066        Ok(())2067    }20682069    fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2070        let collection_id = collection.id;20712072        let item = <NftItemList<T>>::get(collection_id, item_id)2073            .ok_or(Error::<T>::TokenNotFound)?;2074        Self::remove_token_index(collection_id, item_id, &item.owner)?;20752076        // update balance2077        let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2078            .checked_sub(1)2079            .ok_or(Error::<T>::NumOverflow)?;2080        <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2081        <NftItemList<T>>::remove(collection_id, item_id);2082        <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20832084        Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));2085        Ok(())2086    }20872088    fn burn_fungible_item(owner: &T::CrossAccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2089        let collection_id = collection.id;20902091        let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2092        ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20932094        // update balance2095        let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2096            .checked_sub(value)2097            .ok_or(Error::<T>::NumOverflow)?;2098        <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20992100        if balance.value - value > 0 {2101            balance.value -= value;2102            <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2103        }2104        else {2105            <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2106        }21072108        Ok(())2109    }21102111    pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2112        Ok(<CollectionById<T>>::get(collection_id)2113            .map(|collection| CollectionHandle {2114                id: collection_id,2115                collection2116            })2117            .ok_or(Error::<T>::CollectionNotFound)?)2118    }21192120    fn save_collection(collection: CollectionHandle<T>) {2121        <CollectionById<T>>::insert(collection.id, collection.collection);2122    }21232124    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2125        ensure!(2126            subject == target_collection.owner,2127            Error::<T>::NoPermission2128        );21292130        Ok(())2131    }21322133    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2134        subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2135    }21362137    fn check_owner_or_admin_permissions(2138        collection: &CollectionHandle<T>,2139        subject: T::AccountId,2140    ) -> DispatchResult {2141        ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);21422143        Ok(())2144    }21452146    fn owned_amount(2147        subject: T::AccountId,2148        target_collection: &CollectionHandle<T>,2149        item_id: TokenId,2150    ) -> Option<u128> {2151        let collection_id = target_collection.id;21522153        match target_collection.mode {2154            CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2155                .then(|| 1),2156            CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2157                .value),2158            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2159                .owner2160                .iter()2161                .find(|i| i.owner == subject)2162                .map(|i| i.fraction),2163            CollectionMode::Invalid => None,2164        }2165    }21662167    fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2168        match target_collection.mode {2169            CollectionMode::Fungible(_) => true,2170            _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2171        }2172    }21732174    fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2175        let collection_id = collection.id;21762177        let mes = Error::<T>::AddresNotInWhiteList;2178        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21792180        Ok(())2181    }21822183    /// Check if token exists. In case of Fungible, check if there is an entry for 2184    /// the owner in fungible balances double map2185    fn token_exists(2186        target_collection: &CollectionHandle<T>,2187        item_id: TokenId,2188    ) -> DispatchResult {2189        let collection_id = target_collection.id;2190        let exists = match target_collection.mode2191        {2192            CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2193            CollectionMode::Fungible(_)  => true,2194            CollectionMode::ReFungible  => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2195            _ => false2196        };21972198        ensure!(exists == true, Error::<T>::TokenNotFound);2199        Ok(())2200    }22012202    fn transfer_fungible(2203        collection: &CollectionHandle<T>,2204        value: u128,2205        owner: &T::CrossAccountId,2206        recipient: &T::CrossAccountId,2207    ) -> DispatchResult {2208        let collection_id = collection.id;22092210        let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2211        ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22122213        // Send balance to recipient (updates balanceOf of recipient)2214        Self::add_fungible_item(collection, recipient, value)?;22152216        // update balanceOf of sender2217        <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);22182219        // Reduce or remove sender2220        if balance.value == value {2221            <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2222        }2223        else {2224            balance.value -= value;2225            <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2226        }22272228        Self::deposit_event(RawEvent::Transfer(collection.id, 1, owner.clone(), recipient.clone(), value));22292230        Ok(())2231    }22322233    fn transfer_refungible(2234        collection: &CollectionHandle<T>,2235        item_id: TokenId,2236        value: u128,2237        owner: T::CrossAccountId,2238        new_owner: T::CrossAccountId,2239    ) -> DispatchResult {2240        let collection_id = collection.id;2241        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2242            .ok_or(Error::<T>::TokenNotFound)?;22432244        let item = full_item2245            .owner2246            .iter()2247            .filter(|i| i.owner == owner)2248            .next()2249            .ok_or(Error::<T>::TokenNotFound)?;2250        let amount = item.fraction;22512252        ensure!(amount >= value, Error::<T>::TokenValueTooLow);22532254        // update balance2255        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2256            .checked_sub(value)2257            .ok_or(Error::<T>::NumOverflow)?;2258        <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22592260        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2261            .checked_add(value)2262            .ok_or(Error::<T>::NumOverflow)?;2263        <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22642265        let old_owner = item.owner.clone();2266        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22672268        // transfer2269        if amount == value && !new_owner_has_account {2270            // change owner2271            // new owner do not have account2272            let mut new_full_item = full_item.clone();2273            new_full_item2274                .owner2275                .iter_mut()2276                .find(|i| i.owner == owner)2277                .expect("old owner does present in refungible")2278                .owner = new_owner.clone();2279            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22802281            // update index collection2282            Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2283        } else {2284            let mut new_full_item = full_item.clone();2285            new_full_item2286                .owner2287                .iter_mut()2288                .find(|i| i.owner == owner)2289                .expect("old owner does present in refungible")2290                .fraction -= value;22912292            // separate amount2293            if new_owner_has_account {2294                // new owner has account2295                new_full_item2296                    .owner2297                    .iter_mut()2298                    .find(|i| i.owner == new_owner)2299                    .expect("new owner has account")2300                    .fraction += value;2301            } else {2302                // new owner do not have account2303                new_full_item.owner.push(Ownership {2304                    owner: new_owner.clone(),2305                    fraction: value,2306                });2307                Self::add_token_index(collection_id, item_id, &new_owner)?;2308            }23092310            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2311        }23122313        Self::deposit_event(RawEvent::Transfer(collection.id, item_id, owner, new_owner, amount));23142315        Ok(())2316    }23172318    fn transfer_nft(2319        collection: &CollectionHandle<T>,2320        item_id: TokenId,2321        sender: T::CrossAccountId,2322        new_owner: T::CrossAccountId,2323    ) -> DispatchResult {2324        let collection_id = collection.id;2325        let mut item = <NftItemList<T>>::get(collection_id, item_id)2326            .ok_or(Error::<T>::TokenNotFound)?;23272328        ensure!(2329            sender == item.owner,2330            Error::<T>::MustBeTokenOwner2331        );23322333        // update balance2334        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2335            .checked_sub(1)2336            .ok_or(Error::<T>::NumOverflow)?;2337        <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);23382339        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2340            .checked_add(1)2341            .ok_or(Error::<T>::NumOverflow)?;2342        <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);23432344        // change owner2345        let old_owner = item.owner.clone();2346        item.owner = new_owner.clone();2347        <NftItemList<T>>::insert(collection_id, item_id, item);23482349        // update index collection2350        Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23512352        Self::deposit_event(RawEvent::Transfer(collection.id, item_id, sender, new_owner, 1));23532354        Ok(())2355    }2356    2357    fn set_re_fungible_variable_data(2358        collection: &CollectionHandle<T>,2359        item_id: TokenId,2360        data: Vec<u8>2361    ) -> DispatchResult {2362        let collection_id = collection.id;2363        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2364            .ok_or(Error::<T>::TokenNotFound)?;23652366        item.variable_data = data;23672368        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23692370        Ok(())2371    }23722373    fn set_nft_variable_data(2374        collection: &CollectionHandle<T>,2375        item_id: TokenId,2376        data: Vec<u8>2377    ) -> DispatchResult {2378        let collection_id = collection.id;2379        let mut item = <NftItemList<T>>::get(collection_id, item_id)2380            .ok_or(Error::<T>::TokenNotFound)?;2381        2382        item.variable_data = data;23832384        <NftItemList<T>>::insert(collection_id, item_id, item);2385        2386        Ok(())2387    }23882389    fn init_collection(item: &Collection<T>) {2390        // check params2391        assert!(2392            item.decimal_points <= MAX_DECIMAL_POINTS,2393            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2394        );2395        assert!(2396            item.name.len() <= 64,2397            "Collection name can not be longer than 63 char"2398        );2399        assert!(2400            item.name.len() <= 256,2401            "Collection description can not be longer than 255 char"2402        );2403        assert!(2404            item.token_prefix.len() <= 16,2405            "Token prefix can not be longer than 15 char"2406        );24072408        // Generate next collection ID2409        let next_id = CreatedCollectionCount::get()2410            .checked_add(1)2411            .unwrap();24122413        CreatedCollectionCount::put(next_id);2414    }24152416    fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2417        let current_index = <ItemListIndex>::get(collection_id)2418            .checked_add(1)2419            .unwrap();24202421        let item_owner = item.owner.clone();2422        Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24232424        <ItemListIndex>::insert(collection_id, current_index);24252426        // Update balance2427        let new_balance = <Balance<T>>::get(collection_id, &item_owner)2428            .checked_add(1)2429            .unwrap();2430        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2431    }24322433    fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2434        let current_index = <ItemListIndex>::get(collection_id)2435            .checked_add(1)2436            .unwrap();24372438        Self::add_token_index(collection_id, current_index, owner).unwrap();24392440        <ItemListIndex>::insert(collection_id, current_index);24412442        // Update balance2443        let new_balance = <Balance<T>>::get(collection_id, owner)2444            .checked_add(item.value)2445            .unwrap();2446        <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2447    }24482449    fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2450        let current_index = <ItemListIndex>::get(collection_id)2451            .checked_add(1)2452            .unwrap();24532454        let value = item.owner.first().unwrap().fraction;2455        let owner = item.owner.first().unwrap().owner.clone();24562457        Self::add_token_index(collection_id, current_index, &owner).unwrap();24582459        <ItemListIndex>::insert(collection_id, current_index);24602461        // Update balance2462        let new_balance = <Balance<T>>::get(collection_id, &owner)2463            .checked_add(value)2464            .unwrap();2465        <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2466    }24672468    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2469        // add to account limit2470        if <AccountItemCount<T>>::contains_key(owner) {24712472            // bound Owned tokens by a single address2473            let count = <AccountItemCount<T>>::get(owner);2474            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24752476            <AccountItemCount<T>>::insert(owner.clone(), count2477                .checked_add(1)2478                .ok_or(Error::<T>::NumOverflow)?);2479        }2480        else {2481            <AccountItemCount<T>>::insert(owner.clone(), 1);2482        }24832484        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2485        if list_exists {2486            let mut list = <AddressTokens<T>>::get(collection_id, owner);2487            let item_contains = list.contains(&item_index.clone());24882489            if !item_contains {2490                list.push(item_index.clone());2491            }24922493            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2494        } else {2495            let mut itm = Vec::new();2496            itm.push(item_index.clone());2497            <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2498        }24992500        Ok(())2501    }25022503    fn remove_token_index(2504        collection_id: CollectionId,2505        item_index: TokenId,2506        owner: &T::AccountId,2507    ) -> DispatchResult {25082509        // update counter2510        <AccountItemCount<T>>::insert(owner.clone(), 2511            <AccountItemCount<T>>::get(owner)2512            .checked_sub(1)2513            .ok_or(Error::<T>::NumOverflow)?);251425152516        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2517        if list_exists {2518            let mut list = <AddressTokens<T>>::get(collection_id, owner);2519            let item_contains = list.contains(&item_index.clone());25202521            if item_contains {2522                list.retain(|&item| item != item_index);2523                <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2524            }2525        }25262527        Ok(())2528    }25292530    fn move_token_index(2531        collection_id: CollectionId,2532        item_index: TokenId,2533        old_owner: &T::AccountId,2534        new_owner: &T::AccountId,2535    ) -> DispatchResult {2536        Self::remove_token_index(collection_id, item_index, old_owner)?;2537        Self::add_token_index(collection_id, item_index, new_owner)?;25382539        Ok(())2540    }2541    2542    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2543        ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25442545        Ok(())2546    }2547}25482549////////////////////////////////////////////////////////////////////////////////////////////////////2550// Economic models2551// #region25522553/// Fee multiplier.2554pub type Multiplier = FixedU128;25552556type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25572558/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2559/// in the queue.2560#[derive(Encode, Decode, Clone, Eq, PartialEq)]2561pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25622563impl<T: Config + Send + Sync> sp_std::fmt::Debug 2564    for ChargeTransactionPayment<T>2565{2566	#[cfg(feature = "std")]2567	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2568		write!(f, "ChargeTransactionPayment<{:?}>", self.0)2569	}2570	#[cfg(not(feature = "std"))]2571	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2572		Ok(())2573	}2574}25752576impl<T: Config> ChargeTransactionPayment<T>2577where2578    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2579    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2580    T::AccountId: AsRef<[u8]>,2581    T::AccountId: UncheckedFrom<T::Hash>,2582{2583    fn traditional_fee(2584        len: usize,2585        info: &DispatchInfoOf<T::Call>,2586        tip: BalanceOf<T>,2587    ) -> BalanceOf<T>2588    where2589        T::Call: Dispatchable<Info = DispatchInfo>,2590    {2591        <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2592    }25932594	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2595        let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2596        let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2597        let len_saturation = max_block_length as u64 / (len as u64).max(1);2598        let coefficient: BalanceOf<T> = weight_saturation2599            .min(len_saturation)2600            .saturated_into::<BalanceOf<T>>();2601        final_fee2602            .saturating_mul(coefficient)2603            .saturated_into::<TransactionPriority>()2604    }26052606    fn withdraw_fee(2607        &self,2608        who: &T::AccountId,2609        call: &T::Call,2610        info: &DispatchInfoOf<T::Call>,2611        len: usize,2612	) -> Result<2613		(2614			BalanceOf<T>,2615			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2616		),2617		TransactionValidityError,2618	> {2619        let tip = self.0;26202621        let fee = Self::traditional_fee(len, info, tip);26222623        // Only mess with balances if fee is not zero.2624        if fee.is_zero() {2625            return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2626			.map(|i| (fee, i));2627        }26282629        // Determine who is paying transaction fee based on ecnomic model2630        // Parse call to extract collection ID and access collection sponsor2631        let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2632            Some(Call::create_item(collection_id, _owner, _properties)) => {2633                let collection = <CollectionById<T>>::get(collection_id)?;26342635                // sponsor timeout2636                let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26372638                let limit = collection.limits.sponsor_transfer_timeout;2639                if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2640                    let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2641                    let limit_time = last_tx_block + limit.into();2642                    if block_number <= limit_time {2643                        return None;2644                    }2645                }2646                <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26472648                // check free create limit2649                if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2650                    collection.sponsorship.sponsor()2651                        .cloned()2652                } else {2653                    None2654                }2655            }2656            Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2657                let collection = <CollectionById<T>>::get(collection_id)?;2658                2659                let mut sponsor_transfer = false;2660                if collection.sponsorship.confirmed() {26612662                    let collection_limits = collection.limits;2663                    let collection_mode = collection.mode;2664    2665                    // sponsor timeout2666                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2667                    sponsor_transfer = match collection_mode {2668                        CollectionMode::NFT => {2669    2670                            // get correct limit2671                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2672                                collection_limits.sponsor_transfer_timeout2673                            } else {2674                                ChainLimit::get().nft_sponsor_transfer_timeout2675                            };2676    2677                            let mut sponsored = true;2678                            if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2679                                let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2680                                let limit_time = last_tx_block + limit.into();2681                                if block_number <= limit_time {2682                                    sponsored = false;2683                                }2684                            }2685                            if sponsored {2686                                <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2687                            }26882689                            sponsored2690                        }2691                        CollectionMode::Fungible(_) => {2692    2693                            // get correct limit2694                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2695                                collection_limits.sponsor_transfer_timeout2696                            } else {2697                                ChainLimit::get().fungible_sponsor_transfer_timeout2698                            };2699    2700                            let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2701                            let mut sponsored = true;2702                            if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2703                                let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2704                                let limit_time = last_tx_block + limit.into();2705                                if block_number <= limit_time {2706                                    sponsored = false;2707                                }2708                            }2709                            if sponsored {2710                                <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2711                            }27122713                            sponsored2714                        }2715                        CollectionMode::ReFungible => {2716    2717                            // get correct limit2718                            let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2719                                collection_limits.sponsor_transfer_timeout2720                            } else {2721                                ChainLimit::get().refungible_sponsor_transfer_timeout2722                            };2723    2724                            let mut sponsored = true;2725                            if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2726                                let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2727                                let limit_time = last_tx_block + limit.into();2728                                if block_number <= limit_time {2729                                    sponsored = false;2730                                }2731                            }2732                            if sponsored {2733                                <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2734                            }27352736                            sponsored2737                        }2738                        _ => {2739                            false2740                        },2741                    };2742                }27432744                if !sponsor_transfer {2745                    None2746                } else {2747                    collection.sponsorship.sponsor()2748                        .cloned()2749                }2750            }27512752            Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2753                let mut sponsor_metadata_changes = false;27542755                let collection = <CollectionById<T>>::get(collection_id)?;27562757                if2758                    collection.sponsorship.confirmed() &&2759                    // Can't sponsor fungible collection, this tx will be rejected2760                    // as invalid2761                    !matches!(collection.mode, CollectionMode::Fungible(_)) &&2762                    data.len() <= collection.limits.sponsored_data_size as usize2763                {2764                    if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2765                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27662767                        if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2768                            .map(|last_block| block_number - last_block > rate_limit)2769                            .unwrap_or(true) 2770                        {2771                            sponsor_metadata_changes = true;2772                            <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2773                        }2774                    }2775                }27762777                if !sponsor_metadata_changes {2778                    None2779                } else {2780                    collection.sponsorship.sponsor().cloned()2781                }2782            }27832784            _ => None,2785        })();27862787        match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2788            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27892790                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27912792                let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2793                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2794                  2795                if !owned_contract && white_list_enabled {2796                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2797                        return Err(InvalidTransaction::Call.into());2798                    }2799                }2800            },2801            _ => {},2802        }28032804        // Sponsor smart contracts2805        sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28062807            // On instantiation: set the contract owner2808            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28092810                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2811                    &who,2812                    code_hash,2813                    salt,2814                );2815                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28162817                None2818            },28192820            // On instantiation with code: set the contract owner2821            Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt))  => {28222823                let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2824                    &who,2825                    &T::Hashing::hash(&_code),2826                    _salt,2827                );28282829                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28302831                None2832            }28332834            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2835            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28362837                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28382839                let mut sponsor_transfer = false;2840                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2841                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2842                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2843                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2844                    let limit_time = last_tx_block + rate_limit;28452846                    if block_number >= limit_time {2847                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2848                        sponsor_transfer = true;2849                    }2850                } else {2851                    sponsor_transfer = false;2852                }2853               2854                if sponsor_transfer {2855                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2856                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2857                            return Some(called_contract);2858                        }2859                    }2860                }28612862                None2863            },28642865            _ => None,2866        });28672868        let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28692870		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2871			.map(|i| (fee, i))2872    }2873}287428752876impl<T: Config + Send + Sync> SignedExtension2877    for ChargeTransactionPayment<T>2878where2879    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2880    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2881    T::AccountId: AsRef<[u8]>,2882    T::AccountId: UncheckedFrom<T::Hash>,2883{2884    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2885    type AccountId = T::AccountId;2886    type Call = T::Call;2887    type AdditionalSigned = ();2888    type Pre = (2889        // tip2890        BalanceOf<T>,2891        // who pays fee2892        Self::AccountId,2893		// imbalance resulting from withdrawing the fee2894		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2895    );2896    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2897        Ok(())2898    }28992900    fn validate(2901        &self,2902        who: &Self::AccountId,2903        call: &Self::Call,2904        info: &DispatchInfoOf<Self::Call>,2905        len: usize,2906    ) -> TransactionValidity {2907		let (fee, _) = self.withdraw_fee(who, call, info, len)?;2908		Ok(ValidTransaction {2909			priority: Self::get_priority(len, info, fee),2910			..Default::default()2911		})2912    }29132914    fn pre_dispatch(2915        self,2916        who: &Self::AccountId,2917        call: &Self::Call,2918        info: &DispatchInfoOf<Self::Call>,2919        len: usize,2920    ) -> Result<Self::Pre, TransactionValidityError> {2921        let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2922        Ok((self.0, who.clone(), imbalance))2923    }29242925    fn post_dispatch(2926        pre: Self::Pre,2927        info: &DispatchInfoOf<Self::Call>,2928        post_info: &PostDispatchInfoOf<Self::Call>,2929        len: usize,2930        _result: &DispatchResult,2931    ) -> Result<(), TransactionValidityError> {2932		let (tip, who, imbalance) = pre;2933		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2934			len as u32,2935			info,2936			post_info,2937			tip,2938		);2939		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2940		Ok(())2941    }2942}29432944// #endregion29452946sp_api::decl_runtime_apis! {2947    pub trait NftApi {2948        /// Used for ethereum integration2949        fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2950    }2951}