git.delta.rocks / unique-network / refs/commits / 03c27a6027ca

1#![cfg_attr(not(feature = "std"), no_std)]23#[cfg(feature = "std")]4pub use std::*;56#[cfg(feature = "std")]7pub use serde::*;89use codec::{Decode, Encode};10pub use frame_support::{11    construct_runtime, decl_event, decl_module, decl_storage, decl_error,12    dispatch::DispatchResult,13    ensure, fail, parameter_types,14    traits::{15        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,16        Randomness, WithdrawReason,17    },18    weights::{19        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},20        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,21        WeightToFeePolynomial,22    },23    IsSubType, StorageValue,24};2526use frame_system::{self as system, ensure_signed, ensure_root};27use sp_runtime::sp_std::prelude::Vec;28use sp_runtime::{29    traits::{30        DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SignedExtension, Zero,31    },32    transaction_validity::{33        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,34    },35    FixedPointOperand, FixedU128,36};37use pallet_contracts::ContractAddressFor;38use sp_runtime::traits::StaticLookup;3940#[cfg(test)]41mod mock;4243#[cfg(test)]44mod tests;4546mod default_weights;4748// Structs49// #region5051#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]52#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]53pub enum CollectionMode {54    Invalid,55    NFT,56    // decimal points57    Fungible(u32),58    // decimal points59    ReFungible(u32),60}6162impl Into<u8> for CollectionMode {63    fn into(self) -> u8 {64        match self {65            CollectionMode::Invalid => 0,66            CollectionMode::NFT => 1,67            CollectionMode::Fungible(_) => 2,68            CollectionMode::ReFungible(_) => 3,69        }70    }71}7273#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]74#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]75pub enum AccessMode {76    Normal,77    WhiteList,78}79impl Default for AccessMode {80    fn default() -> Self {81        Self::Normal82    }83}8485impl Default for CollectionMode {86    fn default() -> Self {87        Self::Invalid88    }89}9091#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]92#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]93pub struct Ownership<AccountId> {94    pub owner: AccountId,95    pub fraction: u128,96}9798#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]99#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]100pub struct CollectionType<AccountId> {101    pub owner: AccountId,102    pub mode: CollectionMode,103    pub access: AccessMode,104    pub decimal_points: u32,105    pub name: Vec<u16>,        // 64 include null escape char106    pub description: Vec<u16>, // 256 include null escape char107    pub token_prefix: Vec<u8>, // 16 include null escape char108    pub mint_mode: bool,109    pub offchain_schema: Vec<u8>,110    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender111    pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship112    pub variable_on_chain_schema: Vec<u8>, //113    pub const_on_chain_schema: Vec<u8>, //114}115116#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]117#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]118pub struct NftItemType<AccountId> {119    pub collection: u64,120    pub owner: AccountId,121    pub const_data: Vec<u8>,122    pub variable_data: Vec<u8>,123}124125#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]126#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]127pub struct FungibleItemType<AccountId> {128    pub collection: u64,129    pub owner: AccountId,130    pub value: u128,131}132133#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]134#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]135pub struct ReFungibleItemType<AccountId> {136    pub collection: u64,137    pub owner: Vec<Ownership<AccountId>>,138    pub const_data: Vec<u8>,139    pub variable_data: Vec<u8>,140}141142#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]143#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]144pub struct ApprovePermissions<AccountId> {145    pub approved: AccountId,146    pub amount: u64,147}148149#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]150#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]151pub struct VestingItem<AccountId, Moment> {152    pub sender: AccountId,153    pub recipient: AccountId,154    pub collection_id: u64,155    pub item_id: u64,156    pub amount: u64,157    pub vesting_date: Moment,158}159160#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]161#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]162pub struct BasketItem<AccountId, BlockNumber> {163    pub address: AccountId,164    pub start_block: BlockNumber,165}166167#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]168#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]169pub struct ChainLimits {170    pub collection_numbers_limit: u64,171    pub account_token_ownership_limit: u64,172    pub collections_admins_limit: u64,173    pub custom_data_limit: u32,174175    // Timeouts for item types in passed blocks176    pub nft_sponsor_transfer_timeout: u32,177    pub fungible_sponsor_transfer_timeout: u32,178    pub refungible_sponsor_transfer_timeout: u32,179}180181pub trait WeightInfo {182	fn create_collection() -> Weight;183	fn destroy_collection() -> Weight;184	fn add_to_white_list() -> Weight;185	fn remove_from_white_list() -> Weight;186    fn set_public_access_mode() -> Weight;187    fn set_mint_permission() -> Weight;188    fn change_collection_owner() -> Weight;189    fn add_collection_admin() -> Weight;190    fn remove_collection_admin() -> Weight;191    fn set_collection_sponsor() -> Weight;192    fn confirm_sponsorship() -> Weight;193    fn remove_collection_sponsor() -> Weight;194    fn create_item(s: usize) -> Weight;195    fn burn_item() -> Weight;196    fn transfer() -> Weight;197    fn approve() -> Weight;198    fn transfer_from() -> Weight;199    fn set_offchain_schema() -> Weight;200    fn set_const_on_chain_schema() -> Weight;201    fn set_variable_on_chain_schema() -> Weight;202    fn set_variable_meta_data() -> Weight;203    fn enable_contract_sponsoring() -> Weight;204}205206#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]207#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]208pub struct CreateNftData {209    pub const_data: Vec<u8>,210    pub variable_data: Vec<u8>,211}212213#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]214#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]215pub struct CreateFungibleData {216}217218#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct CreateReFungibleData {221    pub const_data: Vec<u8>,222    pub variable_data: Vec<u8>,223}224225#[derive(Encode, Decode, Debug, Clone, PartialEq)]226#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]227pub enum CreateItemData {228    NFT(CreateNftData),229    Fungible(CreateFungibleData),230    ReFungible(CreateReFungibleData)231}232233impl CreateItemData {234    pub fn len(&self) -> usize {235        let len = match self {236            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),237            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),238            _ => 0239        };240        241        return len;242    }243}244245impl From<CreateNftData> for CreateItemData {246    fn from(item: CreateNftData) -> Self {247        CreateItemData::NFT(item)248    }249}250251impl From<CreateReFungibleData> for CreateItemData {252    fn from(item: CreateReFungibleData) -> Self {253        CreateItemData::ReFungible(item)254    }255}256257impl From<CreateFungibleData> for CreateItemData {258    fn from(item: CreateFungibleData) -> Self {259        CreateItemData::Fungible(item)260    }261}262263264decl_error! {265	/// Error for non-fungible-token module.266	pub enum Error for Module<T: Trait> {267        /// Total collections bound exceeded268        TotalCollectionsLimitExceeded,269		/// Decimal_points parameter must be lower than 4270        CollectionDecimalPointLimitExceeded, 271        /// Collection name can not be longer than 63 char272        CollectionNameLimitExceeded, 273        /// Collection description can not be longer than 255 char274        CollectionDescriptionLimitExceeded, 275        /// Token prefix can not be longer than 15 char276        CollectionTokenPrefixLimitExceeded,277        /// This collection does not exist278        CollectionNotFound,279        /// Item not exists280        TokenNotFound,281        /// Arithmetic calculation overflow282        NumOverflow,       283        /// Account already has admin role284        AlreadyAdmin,  285        /// You do not own this collection286        NoPermission,287        /// This address is not set as sponsor, use setCollectionSponsor first288        ConfirmUnsetSponsorFail,289        /// Collection is not in mint mode290        PublicMintingNotAllowed,291        /// Sender parameter and item owner must be equal292        MustBeTokenOwner,293        /// Item balance not enouth294        TokenValueTooLow,295        /// Size of item is too large296        NftSizeLimitExceeded,297        /// Size of item must be 0 with fungible type298        FungibleUnexpectedParam,299        /// No approve found300        ApproveNotFound,301        /// Requested value more than approved302        TokenValueNotEnough,303        /// Only approved addresses can call this method304        ApproveRequired,305        /// Address is not in white list306        AddresNotInWhiteList,307        /// Number of collection admins bound exceeded308        CollectionAdminsLimitExceeded,309        /// Owned tokens by a single address bound exceeded310        AddressOwnershipLimitExceeded,311        /// Length of items properties must be greater than 0312        EmptyArgument,313	}314}315316pub trait Trait: system::Trait + Sized + transaction_payment::Trait + pallet_contracts::Trait {317    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;318319    /// Weight information for extrinsics in this pallet.320	type WeightInfo: WeightInfo;321}322323#[cfg(feature = "runtime-benchmarks")]324mod benchmarking;325326// #endregion327328decl_storage! {329    trait Store for Module<T: Trait> as Nft {330331        // Private members332        NextCollectionID: u64;333        CreatedCollectionCount: u64;334        ChainVersion: u64;335        ItemListIndex: map hasher(blake2_128_concat) u64 => u64;336337        // Chain limits struct338        pub ChainLimit get(fn chain_limit) config(): ChainLimits;339340        // Bound counters341        CollectionCount: u64;342        pub AccountItemCount get(fn account_item_count): map hasher(identity) T::AccountId => u64;343344        // Basic collections345        pub Collection get(fn collection) config(): map hasher(identity) u64 => CollectionType<T::AccountId>;346        pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;347        pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;348349        /// Balance owner per collection map350        pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;351352        /// second parameter: item id + owner account id353        pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;354355        /// Item collections356        pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;357        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;358        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;359360        /// Index list361        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;362363        /// Tokens transfer baskets364        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;365        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => Vec<BasketItem<T::AccountId, T::BlockNumber>>;366        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;367368        // Contract Sponsorship and Ownership369        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;370        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;371        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;372        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;373    }374    add_extra_genesis {375        build(|config: &GenesisConfig<T>| {376            // Modification of storage377            for (_num, _c) in &config.collection {378                <Module<T>>::init_collection(_c);379            }380381            for (_num, _q, _i) in &config.nft_item_id {382                <Module<T>>::init_nft_token(_i);383            }384385            for (_num, _q, _i) in &config.fungible_item_id {386                <Module<T>>::init_fungible_token(_i);387            }388389            for (_num, _q, _i) in &config.refungible_item_id {390                <Module<T>>::init_refungible_token(_i);391            }392        })393    }394}395396decl_event!(397    pub enum Event<T>398    where399        AccountId = <T as system::Trait>::AccountId,400    {401        /// New collection was created402        /// 403        /// # Arguments404        /// 405        /// * collection_id: Globally unique identifier of newly created collection.406        /// 407        /// * mode: [CollectionMode] converted into u8.408        /// 409        /// * account_id: Collection owner.410        Created(u64, u8, AccountId),411412        /// New item was created.413        /// 414        /// # Arguments415        /// 416        /// * collection_id: Id of the collection where item was created.417        /// 418        /// * item_id: Id of an item. Unique within the collection.419        ItemCreated(u64, u64),420421        /// Collection item was burned.422        /// 423        /// # Arguments424        /// 425        /// collection_id.426        /// 427        /// item_id: Identifier of burned NFT.428        ItemDestroyed(u64, u64),429    }430);431432decl_module! {433    pub struct Module<T: Trait> for enum Call where origin: T::Origin {434435        fn deposit_event() = default;436        type Error = Error<T>;437438        fn on_initialize(now: T::BlockNumber) -> Weight {439440            if ChainVersion::get() < 2441            {442                let value = NextCollectionID::get();443                CreatedCollectionCount::put(value);444                ChainVersion::put(2);445            }446447            0448        }449450        /// 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.451        /// 452        /// # Permissions453        /// 454        /// * Anyone.455        /// 456        /// # Arguments457        /// 458        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.459        /// 460        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.461        /// 462        /// * token_prefix: UTF-8 string with token prefix.463        /// 464        /// * mode: [CollectionMode] collection type and type dependent data.465        // returns collection ID466        #[weight = T::WeightInfo::create_collection()]467        pub fn create_collection(origin,468                                 collection_name: Vec<u16>,469                                 collection_description: Vec<u16>,470                                 token_prefix: Vec<u8>,471                                 mode: CollectionMode) -> DispatchResult {472473            // Anyone can create a collection474            let who = ensure_signed(origin)?;475476            let decimal_points = match mode {477                CollectionMode::Fungible(points) => points,478                CollectionMode::ReFungible(points) => points,479                _ => 0480            };481482            // bound Total number of collections483            ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);484485            // check params486            ensure!(decimal_points <= 4, Error::<T>::CollectionDecimalPointLimitExceeded);487488            let mut name = collection_name.to_vec();489            name.push(0);490            ensure!(name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);491492            let mut description = collection_description.to_vec();493            description.push(0);494            ensure!(name.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);495496            let mut prefix = token_prefix.to_vec();497            prefix.push(0);498            ensure!(prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);499500            // Generate next collection ID501            let next_id = CreatedCollectionCount::get()502                .checked_add(1)503                .ok_or(Error::<T>::NumOverflow)?;504505            // bound counter506            let total = CollectionCount::get()507                .checked_add(1)508                .ok_or(Error::<T>::NumOverflow)?;509510            CreatedCollectionCount::put(next_id);511            CollectionCount::put(total);512513            // Create new collection514            let new_collection = CollectionType {515                owner: who.clone(),516                name: name,517                mode: mode.clone(),518                mint_mode: false,519                access: AccessMode::Normal,520                description: description,521                decimal_points: decimal_points,522                token_prefix: prefix,523                offchain_schema: Vec::new(),524                sponsor: T::AccountId::default(),525                unconfirmed_sponsor: T::AccountId::default(),526                variable_on_chain_schema: Vec::new(),527                const_on_chain_schema: Vec::new(),528            };529530            // Add new collection to map531            <Collection<T>>::insert(next_id, new_collection);532533            // call event534            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));535536            Ok(())537        }538539        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.540        /// 541        /// # Permissions542        /// 543        /// * Collection Owner.544        /// 545        /// # Arguments546        /// 547        /// * collection_id: collection to destroy.548        #[weight = T::WeightInfo::destroy_collection()]549        pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {550551            let sender = ensure_signed(origin)?;552            Self::check_owner_permissions(collection_id, sender)?;553554            <AddressTokens<T>>::remove_prefix(collection_id);555            <ApprovedList<T>>::remove_prefix(collection_id);556            <Balance<T>>::remove_prefix(collection_id);557            <ItemListIndex>::remove(collection_id);558            <AdminList<T>>::remove(collection_id);559            <Collection<T>>::remove(collection_id);560            <WhiteList<T>>::remove(collection_id);561562            <NftItemList<T>>::remove_prefix(collection_id);563            <FungibleItemList<T>>::remove_prefix(collection_id);564            <ReFungibleItemList<T>>::remove_prefix(collection_id);565566            <NftTransferBasket<T>>::remove_prefix(collection_id);567            <FungibleTransferBasket<T>>::remove_prefix(collection_id);568            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);569570            if CollectionCount::get() > 0571            {572                // bound couter573                let total = CollectionCount::get()574                    .checked_sub(1)575                    .ok_or(Error::<T>::NumOverflow)?;576577                CollectionCount::put(total);578            }579580            Ok(())581        }582583        /// Add an address to white list.584        /// 585        /// # Permissions586        /// 587        /// * Collection Owner588        /// * Collection Admin589        /// 590        /// # Arguments591        /// 592        /// * collection_id.593        /// 594        /// * address.595        #[weight = T::WeightInfo::add_to_white_list()]596        pub fn add_to_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{597598            let sender = ensure_signed(origin)?;599            Self::check_owner_or_admin_permissions(collection_id, sender)?;600601            let mut white_list_collection: Vec<T::AccountId>;602            if <WhiteList<T>>::contains_key(collection_id) {603                white_list_collection = <WhiteList<T>>::get(collection_id);604                if !white_list_collection.contains(&address.clone())605                {606                    white_list_collection.push(address.clone());607                }608            }609            else {610                white_list_collection = Vec::new();611                white_list_collection.push(address.clone());612            }613614            <WhiteList<T>>::insert(collection_id, white_list_collection);615            Ok(())616        }617618        /// Remove an address from white list.619        /// 620        /// # Permissions621        /// 622        /// * Collection Owner623        /// * Collection Admin624        /// 625        /// # Arguments626        /// 627        /// * collection_id.628        /// 629        /// * address.630        #[weight = T::WeightInfo::remove_from_white_list()]631        pub fn remove_from_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{632633            let sender = ensure_signed(origin)?;634            Self::check_owner_or_admin_permissions(collection_id, sender)?;635636            if <WhiteList<T>>::contains_key(collection_id) {637                let mut white_list_collection = <WhiteList<T>>::get(collection_id);638                if white_list_collection.contains(&address.clone())639                {640                    white_list_collection.retain(|i| *i != address.clone());641                    <WhiteList<T>>::insert(collection_id, white_list_collection);642                }643            }644645            Ok(())646        }647648        /// Toggle between normal and white list access for the methods with access for `Anyone`.649        /// 650        /// # Permissions651        /// 652        /// * Collection Owner.653        /// 654        /// # Arguments655        /// 656        /// * collection_id.657        /// 658        /// * mode: [AccessMode]659        #[weight = T::WeightInfo::set_public_access_mode()]660        pub fn set_public_access_mode(origin, collection_id: u64, mode: AccessMode) -> DispatchResult661        {662            let sender = ensure_signed(origin)?;663664            Self::check_owner_permissions(collection_id, sender)?;665            let mut target_collection = <Collection<T>>::get(collection_id);666            target_collection.access = mode;667            <Collection<T>>::insert(collection_id, target_collection);668669            Ok(())670        }671672        /// Allows Anyone to create tokens if:673        /// * White List is enabled, and674        /// * Address is added to white list, and675        /// * This method was called with True parameter676        /// 677        /// # Permissions678        /// * Collection Owner679        ///680        /// # Arguments681        /// 682        /// * collection_id.683        /// 684        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.685        #[weight = T::WeightInfo::set_mint_permission()]686        pub fn set_mint_permission(origin, collection_id: u64, mint_permission: bool) -> DispatchResult687        {688            let sender = ensure_signed(origin)?;689690            Self::check_owner_permissions(collection_id, sender)?;691            let mut target_collection = <Collection<T>>::get(collection_id);692            target_collection.mint_mode = mint_permission;693            <Collection<T>>::insert(collection_id, target_collection);694695            Ok(())696        }697698        /// Change the owner of the collection.699        /// 700        /// # Permissions701        /// 702        /// * Collection Owner.703        /// 704        /// # Arguments705        /// 706        /// * collection_id.707        /// 708        /// * new_owner.709        #[weight = T::WeightInfo::change_collection_owner()]710        pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {711712            let sender = ensure_signed(origin)?;713            Self::check_owner_permissions(collection_id, sender)?;714            let mut target_collection = <Collection<T>>::get(collection_id);715            target_collection.owner = new_owner;716            <Collection<T>>::insert(collection_id, target_collection);717718            Ok(())719        }720721        /// Adds an admin of the Collection.722        /// 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. 723        /// 724        /// # Permissions725        /// 726        /// * Collection Owner.727        /// * Collection Admin.728        /// 729        /// # Arguments730        /// 731        /// * collection_id: ID of the Collection to add admin for.732        /// 733        /// * new_admin_id: Address of new admin to add.734        #[weight = T::WeightInfo::add_collection_admin()]735        pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {736737            let sender = ensure_signed(origin)?;738            Self::check_owner_or_admin_permissions(collection_id, sender)?;739            let mut admin_arr: Vec<T::AccountId> = Vec::new();740741            if <AdminList<T>>::contains_key(collection_id)742            {743                admin_arr = <AdminList<T>>::get(collection_id);744                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);745            }746747            // Number of collection admins748            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);749750            admin_arr.push(new_admin_id);751            <AdminList<T>>::insert(collection_id, admin_arr);752753            Ok(())754        }755756        /// 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.757        ///758        /// # Permissions759        /// 760        /// * Collection Owner.761        /// * Collection Admin.762        /// 763        /// # Arguments764        /// 765        /// * collection_id: ID of the Collection to remove admin for.766        /// 767        /// * account_id: Address of admin to remove.768        #[weight = T::WeightInfo::remove_collection_admin()]769        pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {770771            let sender = ensure_signed(origin)?;772            Self::check_owner_or_admin_permissions(collection_id, sender)?;773774            if <AdminList<T>>::contains_key(collection_id)775            {776                let mut admin_arr = <AdminList<T>>::get(collection_id);777                admin_arr.retain(|i| *i != account_id);778                <AdminList<T>>::insert(collection_id, admin_arr);779            }780781            Ok(())782        }783784        /// # Permissions785        /// 786        /// * Collection Owner787        /// 788        /// # Arguments789        /// 790        /// * collection_id.791        /// 792        /// * new_sponsor.793        #[weight = T::WeightInfo::set_collection_sponsor()]794        pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {795796            let sender = ensure_signed(origin)?;797            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);798799            let mut target_collection = <Collection<T>>::get(collection_id);800            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);801802            target_collection.unconfirmed_sponsor = new_sponsor;803            <Collection<T>>::insert(collection_id, target_collection);804805            Ok(())806        }807808        /// # Permissions809        /// 810        /// * Sponsor.811        /// 812        /// # Arguments813        /// 814        /// * collection_id.815        #[weight = T::WeightInfo::confirm_sponsorship()]816        pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {817818            let sender = ensure_signed(origin)?;819            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);820821            let mut target_collection = <Collection<T>>::get(collection_id);822            ensure!(sender == target_collection.unconfirmed_sponsor, Error::<T>::ConfirmUnsetSponsorFail);823824            target_collection.sponsor = target_collection.unconfirmed_sponsor;825            target_collection.unconfirmed_sponsor = T::AccountId::default();826            <Collection<T>>::insert(collection_id, target_collection);827828            Ok(())829        }830831        /// Switch back to pay-per-own-transaction model.832        ///833        /// # Permissions834        ///835        /// * Collection owner.836        /// 837        /// # Arguments838        /// 839        /// * collection_id.840        #[weight = T::WeightInfo::remove_collection_sponsor()]841        pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {842843            let sender = ensure_signed(origin)?;844            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);845846            let mut target_collection = <Collection<T>>::get(collection_id);847            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);848849            target_collection.sponsor = T::AccountId::default();850            <Collection<T>>::insert(collection_id, target_collection);851852            Ok(())853        }854855        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.856        /// 857        /// # Permissions858        /// 859        /// * Collection Owner.860        /// * Collection Admin.861        /// * Anyone if862        ///     * White List is enabled, and863        ///     * Address is added to white list, and864        ///     * MintPermission is enabled (see SetMintPermission method)865        /// 866        /// # Arguments867        /// 868        /// * collection_id: ID of the collection.869        /// 870        /// * owner: Address, initial owner of the NFT.871        ///872        /// * data: Token data to store on chain.873        // #[weight =874        // (130_000_000 as Weight)875        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))876        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))877        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]878879        #[weight = T::WeightInfo::create_item(data.len())]880        pub fn create_item(origin, collection_id: u64, owner: T::AccountId, data: CreateItemData) -> DispatchResult {881882            let sender = ensure_signed(origin)?;883884            Self::collection_exists(collection_id)?;885886            let target_collection = <Collection<T>>::get(collection_id);887888            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;889            Self::validate_create_item_args(&target_collection, &data)?;890            Self::create_item_no_validation(collection_id, &target_collection, owner, data)?;891892            Ok(())893        }894895        /// This method creates multiple instances of NFT Collection created with CreateCollection method.896        /// 897        /// # Permissions898        /// 899        /// * Collection Owner.900        /// * Collection Admin.901        /// * Anyone if902        ///     * White List is enabled, and903        ///     * Address is added to white list, and904        ///     * MintPermission is enabled (see SetMintPermission method)905        /// 906        /// # Arguments907        /// 908        /// * collection_id: ID of the collection.909        /// 910        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].911        /// 912        /// * owner: Address, initial owner of the NFT.913        #[weight = T::WeightInfo::create_item(items_data.into_iter()914                               .map(|data| { data.len() })915                               .sum())]916        pub fn create_multiple_items(origin, collection_id: u64, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {917918            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);919            let sender = ensure_signed(origin)?;920921            Self::collection_exists(collection_id)?;922            let target_collection = <Collection<T>>::get(collection_id);923924            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;925926            for data in &items_data {927                Self::validate_create_item_args(&target_collection, data)?;928            }929            for data in &items_data {930                Self::create_item_no_validation(collection_id, &target_collection, owner.clone(), data.clone())?;931            }932933            Ok(())934        }935936        /// Destroys a concrete instance of NFT.937        /// 938        /// # Permissions939        /// 940        /// * Collection Owner.941        /// * Collection Admin.942        /// * Current NFT Owner.943        /// 944        /// # Arguments945        /// 946        /// * collection_id: ID of the collection.947        /// 948        /// * item_id: ID of NFT to burn.949        #[weight = T::WeightInfo::burn_item()]950        pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {951952            let sender = ensure_signed(origin)?;953            Self::collection_exists(collection_id)?;954955            // Transfer permissions check956            let target_collection = <Collection<T>>::get(collection_id);957            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||958                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),959                Error::<T>::NoPermission);960961            if target_collection.access == AccessMode::WhiteList {962                Self::check_white_list(collection_id, &sender)?;963            }964965            match target_collection.mode966            {967                CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,968                CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,969                CollectionMode::ReFungible(_)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,970                _ => ()971            };972973            // call event974            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));975976            Ok(())977        }978979        /// Change ownership of the token.980        /// 981        /// # Permissions982        /// 983        /// * Collection Owner984        /// * Collection Admin985        /// * Current NFT owner986        ///987        /// # Arguments988        /// 989        /// * recipient: Address of token recipient.990        /// 991        /// * collection_id.992        /// 993        /// * item_id: ID of the item994        ///     * Non-Fungible Mode: Required.995        ///     * Fungible Mode: Ignored.996        ///     * Re-Fungible Mode: Required.997        /// 998        /// * value: Amount to transfer.999        ///     * Non-Fungible Mode: Ignored1000        ///     * Fungible Mode: Must specify transferred amount1001        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1002        #[weight = T::WeightInfo::transfer()]1003        pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {10041005            let sender = ensure_signed(origin)?;10061007            // Transfer permissions check1008            let target_collection = <Collection<T>>::get(collection_id);1009            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1010                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1011                Error::<T>::NoPermission);10121013            if target_collection.access == AccessMode::WhiteList {1014                Self::check_white_list(collection_id, &sender)?;1015                Self::check_white_list(collection_id, &recipient)?;1016            }10171018            match target_collection.mode1019            {1020                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,1021                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,1022                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,1023                _ => ()1024            };10251026            Ok(())1027        }10281029        /// Set, change, or remove approved address to transfer the ownership of the NFT.1030        /// 1031        /// # Permissions1032        /// 1033        /// * Collection Owner1034        /// * Collection Admin1035        /// * Current NFT owner1036        /// 1037        /// # Arguments1038        /// 1039        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1040        /// 1041        /// * collection_id.1042        /// 1043        /// * item_id: ID of the item.1044        #[weight = T::WeightInfo::approve()]1045        pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {10461047            let sender = ensure_signed(origin)?;10481049            // Transfer permissions check1050            let target_collection = <Collection<T>>::get(collection_id);1051            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1052                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1053                Error::<T>::NoPermission);10541055            if target_collection.access == AccessMode::WhiteList {1056                Self::check_white_list(collection_id, &sender)?;1057                Self::check_white_list(collection_id, &approved)?;1058            }10591060            // amount param stub1061            let amount = 100000000;10621063            let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));1064            if list_exists {10651066                let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));1067                let item_contains = list.iter().any(|i| i.approved == approved);10681069                if !item_contains {1070                    list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1071                    <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1072                }1073            } else {10741075                let mut list = Vec::new();1076                list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1077                <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1078            }10791080            Ok(())1081        }1082        1083        /// 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.1084        /// 1085        /// # Permissions1086        /// * Collection Owner1087        /// * Collection Admin1088        /// * Current NFT owner1089        /// * Address approved by current NFT owner1090        /// 1091        /// # Arguments1092        /// 1093        /// * from: Address that owns token.1094        /// 1095        /// * recipient: Address of token recipient.1096        /// 1097        /// * collection_id.1098        /// 1099        /// * item_id: ID of the item.1100        /// 1101        /// * value: Amount to transfer.1102        #[weight = T::WeightInfo::transfer_from()]1103        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {11041105            let sender = ensure_signed(origin)?;1106            let mut appoved_transfer = false;11071108            // Check approve1109            if <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone())) {1110                let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));1111                let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());1112                if opt_item.is_some()1113                {1114                    appoved_transfer = true;1115                    ensure!(opt_item.unwrap().amount >= value, Error::<T>::TokenValueNotEnough);1116                }1117            }11181119            // Transfer permissions check1120            let target_collection = <Collection<T>>::get(collection_id);1121                ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1122                Error::<T>::NoPermission);11231124            if target_collection.access == AccessMode::WhiteList {1125                Self::check_white_list(collection_id, &sender)?;1126                Self::check_white_list(collection_id, &recipient)?;1127            }11281129            // remove approve1130            let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))1131                .into_iter().filter(|i| i.approved != sender.clone()).collect();1132            <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);113311341135            match target_collection.mode1136            {1137                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1138                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,1139                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1140                _ => ()1141            };11421143            Ok(())1144        }11451146        ///1147        #[weight = 0]1148        pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {11491150            // let no_perm_mes = "You do not have permissions to modify this collection";1151            // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1152            // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1153            // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);11541155            // // on_nft_received  call11561157            // Self::transfer(origin, collection_id, item_id, new_owner)?;11581159            Ok(())1160        }11611162        /// Set off-chain data schema.1163        /// 1164        /// # Permissions1165        /// 1166        /// * Collection Owner1167        /// * Collection Admin1168        /// 1169        /// # Arguments1170        /// 1171        /// * collection_id.1172        /// 1173        /// * schema: String representing the offchain data schema.1174        #[weight = T::WeightInfo::set_variable_meta_data()]1175        pub fn set_variable_meta_data (1176            origin,1177            collection_id: u64,1178            item_id: u64,1179            data: Vec<u8>1180        ) -> DispatchResult {1181            let sender = ensure_signed(origin)?;1182            1183            Self::collection_exists(collection_id)?;11841185            // Modify permissions check1186            let target_collection = <Collection<T>>::get(collection_id);1187            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1188                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1189                Error::<T>::NoPermission);11901191            Self::item_exists(collection_id, item_id, &target_collection.mode)?;11921193            match target_collection.mode1194            {1195                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1196                CollectionMode::ReFungible(_)  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1197                _ => ()1198            };11991200            Ok(())1201        }1202        12031204        /// Set off-chain data schema.1205        /// 1206        /// # Permissions1207        /// 1208        /// * Collection Owner1209        /// * Collection Admin1210        /// 1211        /// # Arguments1212        /// 1213        /// * collection_id.1214        /// 1215        /// * schema: String representing the offchain data schema.1216        #[weight = T::WeightInfo::set_offchain_schema()]1217        pub fn set_offchain_schema(1218            origin,1219            collection_id: u64,1220            schema: Vec<u8>1221        ) -> DispatchResult {1222            let sender = ensure_signed(origin)?;1223            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12241225            let mut target_collection = <Collection<T>>::get(collection_id);1226            target_collection.offchain_schema = schema;1227            <Collection<T>>::insert(collection_id, target_collection);12281229            Ok(())1230        }12311232        /// Set const on-chain data schema.1233        /// 1234        /// # Permissions1235        /// 1236        /// * Collection Owner1237        /// * Collection Admin1238        /// 1239        /// # Arguments1240        /// 1241        /// * collection_id.1242        /// 1243        /// * schema: String representing the const on-chain data schema.1244        #[weight = T::WeightInfo::set_const_on_chain_schema()]1245        pub fn set_const_on_chain_schema (1246            origin,1247            collection_id: u64,1248            schema: Vec<u8>1249        ) -> DispatchResult {1250            let sender = ensure_signed(origin)?;1251            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12521253            let mut target_collection = <Collection<T>>::get(collection_id);1254            target_collection.const_on_chain_schema = schema;1255            <Collection<T>>::insert(collection_id, target_collection);12561257            Ok(())1258        }12591260        /// Set variable on-chain data schema.1261        /// 1262        /// # Permissions1263        /// 1264        /// * Collection Owner1265        /// * Collection Admin1266        /// 1267        /// # Arguments1268        /// 1269        /// * collection_id.1270        /// 1271        /// * schema: String representing the variable on-chain data schema.1272        #[weight = T::WeightInfo::set_const_on_chain_schema()]1273        pub fn set_variable_on_chain_schema (1274            origin,1275            collection_id: u64,1276            schema: Vec<u8>1277        ) -> DispatchResult {1278            let sender = ensure_signed(origin)?;1279            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12801281            let mut target_collection = <Collection<T>>::get(collection_id);1282            target_collection.variable_on_chain_schema = schema;1283            <Collection<T>>::insert(collection_id, target_collection);12841285            Ok(())1286        }12871288        // Sudo permissions function1289        #[weight = 0]1290        pub fn set_chain_limits(1291            origin,1292            limits: ChainLimits1293        ) -> DispatchResult {1294            ensure_root(origin)?;1295            <ChainLimit>::put(limits);1296            Ok(())1297        }12981299        /// Enable smart contract self-sponsoring.1300        /// 1301        /// # Permissions1302        /// 1303        /// * Contract Owner1304        /// 1305        /// # Arguments1306        /// 1307        /// * contract address1308        /// * enable flag1309        /// 1310        #[weight = T::WeightInfo::enable_contract_sponsoring()]1311        pub fn enable_contract_sponsoring(1312            origin,1313            contract_address: T::AccountId,1314            enable: bool1315        ) -> DispatchResult {1316            let sender = ensure_signed(origin)?;1317            let mut is_owner = false;1318            if <ContractOwner<T>>::contains_key(contract_address.clone()) {1319                let owner = <ContractOwner<T>>::get(&contract_address);1320                is_owner = sender == owner;1321            }1322            ensure!(is_owner, Error::<T>::NoPermission);13231324            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1325            Ok(())1326        }13271328        /// Set the rate limit for contract sponsoring to specified number of blocks.1329        /// 1330        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1331        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1332        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1333        /// from contract endowment if there are at least B blocks between such transactions. 1334        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1335        /// 1336        /// # Permissions1337        /// 1338        /// * Contract Owner1339        /// 1340        /// # Arguments1341        /// 1342        /// -`contract_address`: Address of the contract to sponsor1343        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1344        /// 1345        #[weight = 0]1346        pub fn set_contract_sponsoring_rate_limit(1347            origin,1348            contract_address: T::AccountId,1349            rate_limit: T::BlockNumber1350        ) -> DispatchResult {1351            let sender = ensure_signed(origin)?;1352            let mut is_owner = false;1353            if <ContractOwner<T>>::contains_key(contract_address.clone()) {1354                let owner = <ContractOwner<T>>::get(&contract_address);1355                is_owner = sender == owner;1356            }1357            ensure!(is_owner, Error::<T>::NoPermission);13581359            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1360            Ok(())1361        }13621363    }1364}13651366impl<T: Trait> Module<T> {13671368    fn can_create_items_in_collection(collection_id: u64, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {13691370        if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1371            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1372            Self::check_white_list(collection_id, owner)?;1373            Self::check_white_list(collection_id, sender)?;1374        }13751376        Ok(())1377    }13781379    fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1380        match target_collection.mode1381        {1382            CollectionMode::NFT => {1383                if let CreateItemData::NFT(data) = data {1384                    // check sizes1385                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");1386                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");1387                } else {1388                    fail!("Not NFT item data used to mint in NFT collection.");1389                }1390            },1391            CollectionMode::Fungible(_) => {1392                if let CreateItemData::Fungible(_) = data {1393                } else {1394                    fail!("Not Fungible item data used to mint in Fungible collection.");1395                }1396            },1397            CollectionMode::ReFungible(_) => {1398                if let CreateItemData::ReFungible(data) = data {13991400                    // check sizes1401                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");1402                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");1403                } else {1404                    fail!("Not Re Fungible item data used to mint in Re Fungible collection.");1405                }1406            },1407            _ => { fail!("Unexpected collection type."); }1408        };14091410        Ok(())1411    }14121413    fn create_item_no_validation(collection_id: u64, collection: &CollectionType<T::AccountId>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1414        match data1415        {1416            CreateItemData::NFT(data) => {1417                let item = NftItemType {1418                    collection: collection_id,1419                    owner,1420                    const_data: data.const_data,1421                    variable_data: data.variable_data1422                };14231424                Self::add_nft_item(item)?;1425            },1426            CreateItemData::Fungible(_) => {1427                let item = FungibleItemType {1428                    collection: collection_id,1429                    owner,1430                    value: (10 as u128).pow(collection.decimal_points)1431                };14321433                Self::add_fungible_item(item)?;1434            },1435            CreateItemData::ReFungible(data) => {1436                let mut owner_list = Vec::new();1437                let value = (10 as u128).pow(collection.decimal_points);1438                owner_list.push(Ownership {owner: owner.clone(), fraction: value});14391440                let item = ReFungibleItemType {1441                    collection: collection_id,1442                    owner: owner_list,1443                    const_data: data.const_data,1444                    variable_data: data.variable_data1445                };14461447                Self::add_refungible_item(item)?;1448            }1449        };145014511452        // call event1453        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));14541455        Ok(())1456    }14571458    fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {1459        let current_index = <ItemListIndex>::get(item.collection)1460            .checked_add(1)1461            .ok_or(Error::<T>::NumOverflow)?;1462        let itemcopy = item.clone();1463        let owner = item.owner.clone();1464        let value = item.value as u64;14651466        Self::add_token_index(item.collection, current_index, owner.clone())?;14671468        <ItemListIndex>::insert(item.collection, current_index);1469        <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);14701471        // Add current block1472        let v: Vec<BasketItem<T::AccountId, T::BlockNumber>> = Vec::new();1473        <FungibleTransferBasket<T>>::insert(item.collection, current_index, v);1474        1475        // Update balance1476        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1477            .checked_add(value)1478            .ok_or(Error::<T>::NumOverflow)?;1479        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);14801481        Ok(())1482    }14831484    fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1485        let current_index = <ItemListIndex>::get(item.collection)1486            .checked_add(1)1487            .ok_or(Error::<T>::NumOverflow)?;1488        let itemcopy = item.clone();14891490        let value = item.owner.first().unwrap().fraction as u64;1491        let owner = item.owner.first().unwrap().owner.clone();14921493        Self::add_token_index(item.collection, current_index, owner.clone())?;14941495        <ItemListIndex>::insert(item.collection, current_index);1496        <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);14971498        // Add current block1499        let block_number: T::BlockNumber = 0.into();1500        <ReFungibleTransferBasket<T>>::insert(item.collection, current_index, block_number);15011502        // Update balance1503        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1504            .checked_add(value)1505            .ok_or(Error::<T>::NumOverflow)?;1506        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);15071508        Ok(())1509    }15101511    fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {1512        let current_index = <ItemListIndex>::get(item.collection)1513            .checked_add(1)1514            .ok_or(Error::<T>::NumOverflow)?;15151516        let item_owner = item.owner.clone();1517        let collection_id = item.collection.clone();1518        Self::add_token_index(collection_id, current_index, item.owner.clone())?;15191520        <ItemListIndex>::insert(collection_id, current_index);1521        <NftItemList<T>>::insert(collection_id, current_index, item);15221523        // Add current block1524        let block_number: T::BlockNumber = 0.into();1525        <NftTransferBasket<T>>::insert(collection_id, current_index, block_number);15261527        // Update balance1528        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1529            .checked_add(1)1530            .ok_or(Error::<T>::NumOverflow)?;1531        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);15321533        Ok(())1534    }15351536    fn burn_refungible_item(1537        collection_id: u64,1538        item_id: u64,1539        owner: T::AccountId,1540    ) -> DispatchResult {1541        ensure!(1542            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1543            Error::<T>::TokenNotFound1544        );1545        let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);1546        let item = collection1547            .owner1548            .iter()1549            .filter(|&i| i.owner == owner)1550            .next()1551            .unwrap();1552        Self::remove_token_index(collection_id, item_id, owner.clone())?;15531554        // remove approve list1555        <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));15561557        // update balance1558        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1559            .checked_sub(item.fraction as u64)1560            .ok_or(Error::<T>::NumOverflow)?;1561        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);15621563        <ReFungibleItemList<T>>::remove(collection_id, item_id);15641565        Ok(())1566    }15671568    fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {1569        ensure!(1570            <NftItemList<T>>::contains_key(collection_id, item_id),1571            Error::<T>::TokenNotFound1572        );1573        let item = <NftItemList<T>>::get(collection_id, item_id);1574        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;15751576        // remove approve list1577        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));15781579        // update balance1580        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1581            .checked_sub(1)1582            .ok_or(Error::<T>::NumOverflow)?;1583        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1584        <NftItemList<T>>::remove(collection_id, item_id);15851586        Ok(())1587    }15881589    fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {1590        ensure!(1591            <FungibleItemList<T>>::contains_key(collection_id, item_id),1592            Error::<T>::TokenNotFound1593        );1594        let item = <FungibleItemList<T>>::get(collection_id, item_id);1595        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;15961597        // remove approve list1598        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));15991600        // update balance1601        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1602            .checked_sub(item.value as u64)1603            .ok_or(Error::<T>::NumOverflow)?;1604        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);16051606        <FungibleItemList<T>>::remove(collection_id, item_id);16071608        Ok(())1609    }16101611    fn collection_exists(collection_id: u64) -> DispatchResult {1612        ensure!(1613            <Collection<T>>::contains_key(collection_id),1614            Error::<T>::CollectionNotFound1615        );1616        Ok(())1617    }16181619    fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {1620        Self::collection_exists(collection_id)?;16211622        let target_collection = <Collection<T>>::get(collection_id);1623        ensure!(1624            subject == target_collection.owner,1625            Error::<T>::NoPermission1626        );16271628        Ok(())1629    }16301631    fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {1632        let target_collection = <Collection<T>>::get(collection_id);1633        let mut result: bool = subject == target_collection.owner;1634        let exists = <AdminList<T>>::contains_key(collection_id);16351636        if !result & exists {1637            if <AdminList<T>>::get(collection_id).contains(&subject) {1638                result = true1639            }1640        }16411642        result1643    }16441645    fn check_owner_or_admin_permissions(1646        collection_id: u64,1647        subject: T::AccountId,1648    ) -> DispatchResult {1649        Self::collection_exists(collection_id)?;1650        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());16511652        ensure!(1653            result,1654            Error::<T>::NoPermission1655        );1656        Ok(())1657    }16581659    fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {1660        let target_collection = <Collection<T>>::get(collection_id);16611662        match target_collection.mode {1663            CollectionMode::NFT => {1664                <NftItemList<T>>::get(collection_id, item_id).owner == subject1665            }1666            CollectionMode::Fungible(_) => {1667                <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1668            }1669            CollectionMode::ReFungible(_) => {1670                <ReFungibleItemList<T>>::get(collection_id, item_id)1671                    .owner1672                    .iter()1673                    .any(|i| i.owner == subject)1674            }1675            CollectionMode::Invalid => false,1676        }1677    }16781679    fn check_white_list(collection_id: u64, address: &T::AccountId) -> DispatchResult {1680        let mes = Error::<T>::AddresNotInWhiteList;1681        ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1682        let wl = <WhiteList<T>>::get(collection_id);1683        ensure!(wl.contains(address), mes);16841685        Ok(())1686    }16871688    fn transfer_fungible(1689        collection_id: u64,1690        item_id: u64,1691        value: u64,1692        owner: T::AccountId,1693        new_owner: T::AccountId,1694    ) -> DispatchResult {1695        ensure!(1696            <FungibleItemList<T>>::contains_key(collection_id, item_id),1697            Error::<T>::TokenNotFound1698        );16991700        let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1701        let amount = full_item.value;17021703        ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);17041705        // update balance1706        let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1707            .checked_sub(value)1708            .ok_or(Error::<T>::NumOverflow)?;1709        <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);17101711        let mut new_owner_account_id = 0;1712        let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());1713        if new_owner_items.len() > 0 {1714            new_owner_account_id = new_owner_items[0];1715        }17161717        let val64 = value.into();17181719        // transfer1720        if amount == val64 && new_owner_account_id == 0 {1721            // change owner1722            // new owner do not have account1723            let mut new_full_item = full_item.clone();1724            new_full_item.owner = new_owner.clone();1725            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);17261727            // update balance1728            let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1729                .checked_add(value)1730                .ok_or(Error::<T>::NumOverflow)?;1731            <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17321733            // update index collection1734            Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1735        } else {1736            let mut new_full_item = full_item.clone();1737            new_full_item.value -= val64;17381739            // separate amount1740            if new_owner_account_id > 0 {1741                // new owner has account1742                let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1743                item.value += val64;17441745                // update balance1746                let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1747                    .checked_add(value)1748                    .ok_or(Error::<T>::NumOverflow)?;1749                <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17501751                <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);1752            } else {1753                // new owner do not have account1754                let item = FungibleItemType {1755                    collection: collection_id,1756                    owner: new_owner.clone(),1757                    value: val64,1758                };17591760                Self::add_fungible_item(item)?;1761            }17621763            if amount == val64 {1764                Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;17651766                // remove approve list1767                <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));1768                <FungibleItemList<T>>::remove(collection_id, item_id);1769            }17701771            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1772        }17731774        Ok(())1775    }17761777    fn transfer_refungible(1778        collection_id: u64,1779        item_id: u64,1780        value: u64,1781        owner: T::AccountId,1782        new_owner: T::AccountId,1783    ) -> DispatchResult {1784        ensure!(1785            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1786            Error::<T>::TokenNotFound1787        );17881789        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1790        let item = full_item1791            .owner1792            .iter()1793            .filter(|i| i.owner == owner)1794            .next()1795            .ok_or(Error::<T>::NumOverflow)?;1796        let amount = item.fraction;17971798        ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);17991800        // update balance1801        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1802            .checked_sub(value)1803            .ok_or(Error::<T>::NumOverflow)?;1804        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);18051806        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1807            .checked_add(value)1808            .ok_or(Error::<T>::NumOverflow)?;1809        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18101811        let old_owner = item.owner.clone();1812        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);1813        let val64 = value.into();18141815        // transfer1816        if amount == val64 && !new_owner_has_account {1817            // change owner1818            // new owner do not have account1819            let mut new_full_item = full_item.clone();1820            new_full_item1821                .owner1822                .iter_mut()1823                .find(|i| i.owner == owner)1824                .unwrap()1825                .owner = new_owner.clone();1826            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);18271828            // update index collection1829            Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1830        } else {1831            let mut new_full_item = full_item.clone();1832            new_full_item1833                .owner1834                .iter_mut()1835                .find(|i| i.owner == owner)1836                .unwrap()1837                .fraction -= val64;18381839            // separate amount1840            if new_owner_has_account {1841                // new owner has account1842                new_full_item1843                    .owner1844                    .iter_mut()1845                    .find(|i| i.owner == new_owner)1846                    .unwrap()1847                    .fraction += val64;1848            } else {1849                // new owner do not have account1850                new_full_item.owner.push(Ownership {1851                    owner: new_owner.clone(),1852                    fraction: val64,1853                });1854                Self::add_token_index(collection_id, item_id, new_owner.clone())?;1855            }18561857            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1858        }18591860        Ok(())1861    }18621863    fn transfer_nft(1864        collection_id: u64,1865        item_id: u64,1866        sender: T::AccountId,1867        new_owner: T::AccountId,1868    ) -> DispatchResult {1869        ensure!(1870            <NftItemList<T>>::contains_key(collection_id, item_id),1871            Error::<T>::TokenNotFound1872        );18731874        let mut item = <NftItemList<T>>::get(collection_id, item_id);18751876        ensure!(1877            sender == item.owner,1878            Error::<T>::MustBeTokenOwner1879        );18801881        // update balance1882        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1883            .checked_sub(1)1884            .ok_or(Error::<T>::NumOverflow)?;1885        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);18861887        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1888            .checked_add(1)1889            .ok_or(Error::<T>::NumOverflow)?;1890        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18911892        // change owner1893        let old_owner = item.owner.clone();1894        item.owner = new_owner.clone();1895        <NftItemList<T>>::insert(collection_id, item_id, item);18961897        // update index collection1898        Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;18991900        // reset approved list1901        <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1902        Ok(())1903    }1904    1905    fn item_exists(1906        collection_id: u64,1907        item_id: u64,1908        mode: &CollectionMode1909    ) -> DispatchResult {1910        match mode {1911            CollectionMode::NFT => ensure!(<NftItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1912            CollectionMode::ReFungible(_) => ensure!(<ReFungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1913            CollectionMode::Fungible(_) => ensure!(<FungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1914            _ => ()1915        };1916        1917        Ok(())1918    }19191920    fn set_re_fungible_variable_data(1921        collection_id: u64,1922        item_id: u64,1923        data: Vec<u8>1924    ) -> DispatchResult {1925        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);19261927        item.variable_data = data;19281929        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);19301931        Ok(())1932    }19331934    fn set_nft_variable_data(1935        collection_id: u64,1936        item_id: u64,1937        data: Vec<u8>1938    ) -> DispatchResult {1939        let mut item = <NftItemList<T>>::get(collection_id, item_id);1940        1941        item.variable_data = data;19421943        <NftItemList<T>>::insert(collection_id, item_id, item);1944        1945        Ok(())1946    }19471948    fn init_collection(item: &CollectionType<T::AccountId>) {1949        // check params1950        assert!(1951            item.decimal_points <= 4,1952            "decimal_points parameter must be lower than 4"1953        );1954        assert!(1955            item.name.len() <= 64,1956            "Collection name can not be longer than 63 char"1957        );1958        assert!(1959            item.name.len() <= 256,1960            "Collection description can not be longer than 255 char"1961        );1962        assert!(1963            item.token_prefix.len() <= 16,1964            "Token prefix can not be longer than 15 char"1965        );19661967        // Generate next collection ID1968        let next_id = CreatedCollectionCount::get()1969            .checked_add(1)1970            .unwrap();19711972        CreatedCollectionCount::put(next_id);1973    }19741975    fn init_nft_token(item: &NftItemType<T::AccountId>) {1976        let current_index = <ItemListIndex>::get(item.collection)1977            .checked_add(1)1978            .unwrap();19791980        let item_owner = item.owner.clone();1981        let collection_id = item.collection.clone();1982        Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();19831984        <ItemListIndex>::insert(collection_id, current_index);19851986        // Update balance1987        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1988            .checked_add(1)1989            .unwrap();1990        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);1991    }19921993    fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {1994        let current_index = <ItemListIndex>::get(item.collection)1995            .checked_add(1)1996            .unwrap();1997        let owner = item.owner.clone();1998        let value = item.value as u64;19992000        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();20012002        <ItemListIndex>::insert(item.collection, current_index);20032004        // Update balance2005        let new_balance = <Balance<T>>::get(item.collection, owner.clone())2006            .checked_add(value)2007            .unwrap();2008        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2009    }20102011    fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {2012        let current_index = <ItemListIndex>::get(item.collection)2013            .checked_add(1)2014            .unwrap();20152016        let value = item.owner.first().unwrap().fraction as u64;2017        let owner = item.owner.first().unwrap().owner.clone();20182019        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();20202021        <ItemListIndex>::insert(item.collection, current_index);20222023        // Update balance2024        let new_balance = <Balance<T>>::get(item.collection, owner.clone())2025            .checked_add(value)2026            .unwrap();2027        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2028    }20292030    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {20312032        // add to account limit2033        if <AccountItemCount<T>>::contains_key(owner.clone()) {20342035            // bound Owned tokens by a single address2036            let count = <AccountItemCount<T>>::get(owner.clone());2037            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);20382039            <AccountItemCount<T>>::insert(owner.clone(), count2040                .checked_add(1)2041                .ok_or(Error::<T>::NumOverflow)?);2042        }2043        else {2044            <AccountItemCount<T>>::insert(owner.clone(), 1);2045        }20462047        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2048        if list_exists {2049            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2050            let item_contains = list.contains(&item_index.clone());20512052            if !item_contains {2053                list.push(item_index.clone());2054            }20552056            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2057        } else {2058            let mut itm = Vec::new();2059            itm.push(item_index.clone());2060            <AddressTokens<T>>::insert(collection_id, owner, itm);2061            2062        }20632064        Ok(())2065    }20662067    fn remove_token_index(2068        collection_id: u64,2069        item_index: u64,2070        owner: T::AccountId,2071    ) -> DispatchResult {20722073        // update counter2074        <AccountItemCount<T>>::insert(owner.clone(), 2075            <AccountItemCount<T>>::get(owner.clone())2076            .checked_sub(1)2077            .ok_or(Error::<T>::NumOverflow)?);207820792080        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2081        if list_exists {2082            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2083            let item_contains = list.contains(&item_index.clone());20842085            if item_contains {2086                list.retain(|&item| item != item_index);2087                <AddressTokens<T>>::insert(collection_id, owner, list);2088            }2089        }20902091        Ok(())2092    }20932094    fn move_token_index(2095        collection_id: u64,2096        item_index: u64,2097        old_owner: T::AccountId,2098        new_owner: T::AccountId,2099    ) -> DispatchResult {2100        Self::remove_token_index(collection_id, item_index, old_owner)?;2101        Self::add_token_index(collection_id, item_index, new_owner)?;21022103        Ok(())2104    }2105}21062107////////////////////////////////////////////////////////////////////////////////////////////////////2108// Economic models2109// #region21102111/// Fee multiplier.2112pub type Multiplier = FixedU128;21132114type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2115    <T as system::Trait>::AccountId,2116>>::Balance;2117type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2118    <T as system::Trait>::AccountId,2119>>::NegativeImbalance;21202121/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2122/// in the queue.2123#[derive(Encode, Decode, Clone, Eq, PartialEq)]2124pub struct ChargeTransactionPayment<T: Trait + Send + Sync>(2125    #[codec(compact)] BalanceOf<T>2126);21272128impl<T: Trait + Send + Sync> sp_std::fmt::Debug2129    for ChargeTransactionPayment<T>2130{2131    #[cfg(feature = "std")]2132    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2133        write!(f, "ChargeTransactionPayment<{:?}>", self.0)2134    }2135    #[cfg(not(feature = "std"))]2136    fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2137        Ok(())2138    }2139}21402141impl<T: Trait + Send + Sync> ChargeTransactionPayment<T>2142where2143    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2144    BalanceOf<T>: Send + Sync + FixedPointOperand,2145{2146    /// utility constructor. Used only in client/factory code.2147    pub fn from(fee: BalanceOf<T>) -> Self {2148        Self(fee)2149    }21502151    pub fn traditional_fee(2152        len: usize,2153        info: &DispatchInfoOf<T::Call>,2154        tip: BalanceOf<T>,2155    ) -> BalanceOf<T>2156    where2157        T::Call: Dispatchable<Info = DispatchInfo>,2158    {2159        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2160    }21612162    fn withdraw_fee(2163        &self,2164        who: &T::AccountId,2165        call: &T::Call,2166        info: &DispatchInfoOf<T::Call>,2167        len: usize,2168    ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {2169        let tip = self.0;21702171        // Set fee based on call type. Creating collection costs 1 Unique.2172        // All other transactions have traditional fees so far2173        // let fee = match call.is_sub_type() {2174        //     Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2175        //     _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2176        //                                                 // _ => <BalanceOf<T>>::from(100)2177        // };2178        let fee = Self::traditional_fee(len, info, tip);21792180        // Determine who is paying transaction fee based on ecnomic model2181        // Parse call to extract collection ID and access collection sponsor2182        let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2183            Some(Call::create_item(collection_id, _properties, _owner)) => {2184                <Collection<T>>::get(collection_id).sponsor2185            }2186            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {2187                let _collection_mode = <Collection<T>>::get(collection_id).mode;21882189                // sponsor timeout2190                let sponsor_transfer = match _collection_mode {2191                    CollectionMode::NFT => {2192                        let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);2193                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2194                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2195                        if block_number >= limit_time {2196                            <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);2197                            true2198                        }2199                        else {2200                            false2201                        }2202                    }2203                    CollectionMode::Fungible(_) => {2204                        let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);2205                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2206                        if basket.iter().any(|i| i.address == _new_owner.clone())2207                        {2208                            let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();2209                            let limit_time = item.start_block + ChainLimit::get().fungible_sponsor_transfer_timeout.into();2210                            if block_number >= limit_time {2211                                basket.retain(|x| x.address == item.address);2212                                basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });2213                                <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);2214                                true2215                            }2216                            else {2217                                false2218                            }2219                        }2220                        else {2221                            basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});2222                            true2223                        }2224                    }2225                    CollectionMode::ReFungible(_) => {2226                        let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);2227                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2228                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2229                        if block_number >= limit_time {2230                            <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);2231                            true2232                        } else {2233                            false2234                        }2235                    }2236                    _ => {2237                        false2238                    },2239                };22402241                if !sponsor_transfer {2242                    T::AccountId::default()2243                } else {2244                    <Collection<T>>::get(collection_id).sponsor2245                }2246            }22472248            _ => T::AccountId::default(),2249        };22502251        // Sponsor smart contracts2252        sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {22532254            // On instantiation: set the contract owner2255            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, data)) => {22562257                let new_contract_address = <T as pallet_contracts::Trait>::DetermineContractAddress::contract_address_for(2258                    code_hash,2259                    &data,2260                    &who,2261                );2262                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());22632264                T::AccountId::default()2265            },22662267            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2268            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {22692270                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());22712272                let mut sponsor_transfer = false;2273                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2274                    let last_tx_block = <ContractSponsorBasket<T>>::get(&called_contract);2275                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2276                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2277                    let limit_time = last_tx_block + rate_limit;22782279                    if block_number >= limit_time {2280                        <ContractSponsorBasket<T>>::insert(called_contract.clone(), block_number);2281                        sponsor_transfer = true;2282                    }2283                } else {2284                    sponsor_transfer = false;2285                }2286               2287                2288                let mut sp = T::AccountId::default();2289                if sponsor_transfer {2290                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2291                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2292                            sp = called_contract;2293                        }2294                    }2295                }22962297                sp2298            },22992300            _ => sponsor,2301        };23022303        let mut who_pays_fee: T::AccountId = sponsor.clone();2304        if sponsor == T::AccountId::default() {2305            who_pays_fee = who.clone();2306        }23072308        // Only mess with balances if fee is not zero.2309        if fee.is_zero() {2310            return Ok((fee, None));2311        }23122313        match <T as transaction_payment::Trait>::Currency::withdraw(2314            &who_pays_fee,2315            fee,2316            if tip.is_zero() {2317                WithdrawReason::TransactionPayment.into()2318            } else {2319                WithdrawReason::TransactionPayment | WithdrawReason::Tip2320            },2321            ExistenceRequirement::KeepAlive,2322        ) {2323            Ok(imbalance) => Ok((fee, Some(imbalance))),2324            Err(_) => Err(InvalidTransaction::Payment.into()),2325        }2326    }2327}232823292330impl<T: Trait + Send + Sync> SignedExtension2331    for ChargeTransactionPayment<T>2332where2333    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2334    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2335{2336    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2337    type AccountId = T::AccountId;2338    type Call = T::Call;2339    type AdditionalSigned = ();2340    type Pre = (2341        BalanceOf<T>,2342        Self::AccountId,2343        Option<NegativeImbalanceOf<T>>,2344        BalanceOf<T>,2345    );2346    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2347        Ok(())2348    }23492350    fn validate(2351        &self,2352        _who: &Self::AccountId,2353        _call: &Self::Call,2354        _info: &DispatchInfoOf<Self::Call>,2355        _len: usize,2356    ) -> TransactionValidity {2357        Ok(ValidTransaction::default())2358    }23592360    fn pre_dispatch(2361        self,2362        who: &Self::AccountId,2363        call: &Self::Call,2364        info: &DispatchInfoOf<Self::Call>,2365        len: usize,2366    ) -> Result<Self::Pre, TransactionValidityError> {2367        let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2368        Ok((self.0, who.clone(), imbalance, fee))2369    }23702371    fn post_dispatch(2372        pre: Self::Pre,2373        info: &DispatchInfoOf<Self::Call>,2374        post_info: &PostDispatchInfoOf<Self::Call>,2375        len: usize,2376        _result: &DispatchResult,2377    ) -> Result<(), TransactionValidityError> {2378        let (tip, who, imbalance, fee) = pre;2379        if let Some(payed) = imbalance {2380            let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(2381                len as u32, info, post_info, tip,2382            );2383            let refund = fee.saturating_sub(actual_fee);2384            let actual_payment =2385                match <T as transaction_payment::Trait>::Currency::deposit_into_existing(2386                    &who, refund,2387                ) {2388                    Ok(refund_imbalance) => {2389                        // The refund cannot be larger than the up front payed max weight.2390                        // `PostDispatchInfo::calc_unspent` guards against such a case.2391                        match payed.offset(refund_imbalance) {2392                            Ok(actual_payment) => actual_payment,2393                            Err(_) => return Err(InvalidTransaction::Payment.into()),2394                        }2395                    }2396                    // We do not recreate the account using the refund. The up front payment2397                    // is gone in that case.2398                    Err(_) => payed,2399                };2400            let imbalances = actual_payment.split(tip);2401            <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(2402                Some(imbalances.0).into_iter().chain(Some(imbalances.1)),2403            );2404        }2405        Ok(())2406    }2407}24082409// #endregion