git.delta.rocks / unique-network / refs/commits / 82ca9c1be6da

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(identity) T::AccountId => T::AccountId;370        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(identity) T::AccountId => bool;371    }372    add_extra_genesis {373        build(|config: &GenesisConfig<T>| {374            // Modification of storage375            for (_num, _c) in &config.collection {376                <Module<T>>::init_collection(_c);377            }378379            for (_num, _q, _i) in &config.nft_item_id {380                <Module<T>>::init_nft_token(_i);381            }382383            for (_num, _q, _i) in &config.fungible_item_id {384                <Module<T>>::init_fungible_token(_i);385            }386387            for (_num, _q, _i) in &config.refungible_item_id {388                <Module<T>>::init_refungible_token(_i);389            }390        })391    }392}393394decl_event!(395    pub enum Event<T>396    where397        AccountId = <T as system::Trait>::AccountId,398    {399        /// New collection was created400        /// 401        /// # Arguments402        /// 403        /// * collection_id: Globally unique identifier of newly created collection.404        /// 405        /// * mode: [CollectionMode] converted into u8.406        /// 407        /// * account_id: Collection owner.408        Created(u64, u8, AccountId),409410        /// New item was created.411        /// 412        /// # Arguments413        /// 414        /// * collection_id: Id of the collection where item was created.415        /// 416        /// * item_id: Id of an item. Unique within the collection.417        ItemCreated(u64, u64),418419        /// Collection item was burned.420        /// 421        /// # Arguments422        /// 423        /// collection_id.424        /// 425        /// item_id: Identifier of burned NFT.426        ItemDestroyed(u64, u64),427    }428);429430decl_module! {431    pub struct Module<T: Trait> for enum Call where origin: T::Origin {432433        fn deposit_event() = default;434        type Error = Error<T>;435436        fn on_initialize(now: T::BlockNumber) -> Weight {437438            if ChainVersion::get() < 2439            {440                let value = NextCollectionID::get();441                CreatedCollectionCount::put(value);442                ChainVersion::put(2);443            }444445            0446        }447448        /// 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.449        /// 450        /// # Permissions451        /// 452        /// * Anyone.453        /// 454        /// # Arguments455        /// 456        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.457        /// 458        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.459        /// 460        /// * token_prefix: UTF-8 string with token prefix.461        /// 462        /// * mode: [CollectionMode] collection type and type dependent data.463        // returns collection ID464        #[weight = T::WeightInfo::create_collection()]465        pub fn create_collection(origin,466                                 collection_name: Vec<u16>,467                                 collection_description: Vec<u16>,468                                 token_prefix: Vec<u8>,469                                 mode: CollectionMode) -> DispatchResult {470471            // Anyone can create a collection472            let who = ensure_signed(origin)?;473474            let decimal_points = match mode {475                CollectionMode::Fungible(points) => points,476                CollectionMode::ReFungible(points) => points,477                _ => 0478            };479480            // bound Total number of collections481            ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);482483            // check params484            ensure!(decimal_points <= 4, Error::<T>::CollectionDecimalPointLimitExceeded);485486            let mut name = collection_name.to_vec();487            name.push(0);488            ensure!(name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);489490            let mut description = collection_description.to_vec();491            description.push(0);492            ensure!(name.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);493494            let mut prefix = token_prefix.to_vec();495            prefix.push(0);496            ensure!(prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);497498            // Generate next collection ID499            let next_id = CreatedCollectionCount::get()500                .checked_add(1)501                .ok_or(Error::<T>::NumOverflow)?;502503            // bound counter504            let total = CollectionCount::get()505                .checked_add(1)506                .ok_or(Error::<T>::NumOverflow)?;507508            CreatedCollectionCount::put(next_id);509            CollectionCount::put(total);510511            // Create new collection512            let new_collection = CollectionType {513                owner: who.clone(),514                name: name,515                mode: mode.clone(),516                mint_mode: false,517                access: AccessMode::Normal,518                description: description,519                decimal_points: decimal_points,520                token_prefix: prefix,521                offchain_schema: Vec::new(),522                sponsor: T::AccountId::default(),523                unconfirmed_sponsor: T::AccountId::default(),524                variable_on_chain_schema: Vec::new(),525                const_on_chain_schema: Vec::new(),526            };527528            // Add new collection to map529            <Collection<T>>::insert(next_id, new_collection);530531            // call event532            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));533534            Ok(())535        }536537        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.538        /// 539        /// # Permissions540        /// 541        /// * Collection Owner.542        /// 543        /// # Arguments544        /// 545        /// * collection_id: collection to destroy.546        #[weight = T::WeightInfo::destroy_collection()]547        pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {548549            let sender = ensure_signed(origin)?;550            Self::check_owner_permissions(collection_id, sender)?;551552            <AddressTokens<T>>::remove_prefix(collection_id);553            <ApprovedList<T>>::remove_prefix(collection_id);554            <Balance<T>>::remove_prefix(collection_id);555            <ItemListIndex>::remove(collection_id);556            <AdminList<T>>::remove(collection_id);557            <Collection<T>>::remove(collection_id);558            <WhiteList<T>>::remove(collection_id);559560            <NftItemList<T>>::remove_prefix(collection_id);561            <FungibleItemList<T>>::remove_prefix(collection_id);562            <ReFungibleItemList<T>>::remove_prefix(collection_id);563564            <NftTransferBasket<T>>::remove_prefix(collection_id);565            <FungibleTransferBasket<T>>::remove_prefix(collection_id);566            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);567568            if CollectionCount::get() > 0569            {570                // bound couter571                let total = CollectionCount::get()572                    .checked_sub(1)573                    .ok_or(Error::<T>::NumOverflow)?;574575                CollectionCount::put(total);576            }577578            Ok(())579        }580581        /// Add an address to white list.582        /// 583        /// # Permissions584        /// 585        /// * Collection Owner586        /// * Collection Admin587        /// 588        /// # Arguments589        /// 590        /// * collection_id.591        /// 592        /// * address.593        #[weight = T::WeightInfo::add_to_white_list()]594        pub fn add_to_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{595596            let sender = ensure_signed(origin)?;597            Self::check_owner_or_admin_permissions(collection_id, sender)?;598599            let mut white_list_collection: Vec<T::AccountId>;600            if <WhiteList<T>>::contains_key(collection_id) {601                white_list_collection = <WhiteList<T>>::get(collection_id);602                if !white_list_collection.contains(&address.clone())603                {604                    white_list_collection.push(address.clone());605                }606            }607            else {608                white_list_collection = Vec::new();609                white_list_collection.push(address.clone());610            }611612            <WhiteList<T>>::insert(collection_id, white_list_collection);613            Ok(())614        }615616        /// Remove an address from white list.617        /// 618        /// # Permissions619        /// 620        /// * Collection Owner621        /// * Collection Admin622        /// 623        /// # Arguments624        /// 625        /// * collection_id.626        /// 627        /// * address.628        #[weight = T::WeightInfo::remove_from_white_list()]629        pub fn remove_from_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{630631            let sender = ensure_signed(origin)?;632            Self::check_owner_or_admin_permissions(collection_id, sender)?;633634            if <WhiteList<T>>::contains_key(collection_id) {635                let mut white_list_collection = <WhiteList<T>>::get(collection_id);636                if white_list_collection.contains(&address.clone())637                {638                    white_list_collection.retain(|i| *i != address.clone());639                    <WhiteList<T>>::insert(collection_id, white_list_collection);640                }641            }642643            Ok(())644        }645646        /// Toggle between normal and white list access for the methods with access for `Anyone`.647        /// 648        /// # Permissions649        /// 650        /// * Collection Owner.651        /// 652        /// # Arguments653        /// 654        /// * collection_id.655        /// 656        /// * mode: [AccessMode]657        #[weight = T::WeightInfo::set_public_access_mode()]658        pub fn set_public_access_mode(origin, collection_id: u64, mode: AccessMode) -> DispatchResult659        {660            let sender = ensure_signed(origin)?;661662            Self::check_owner_permissions(collection_id, sender)?;663            let mut target_collection = <Collection<T>>::get(collection_id);664            target_collection.access = mode;665            <Collection<T>>::insert(collection_id, target_collection);666667            Ok(())668        }669670        /// Allows Anyone to create tokens if:671        /// * White List is enabled, and672        /// * Address is added to white list, and673        /// * This method was called with True parameter674        /// 675        /// # Permissions676        /// * Collection Owner677        ///678        /// # Arguments679        /// 680        /// * collection_id.681        /// 682        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.683        #[weight = T::WeightInfo::set_mint_permission()]684        pub fn set_mint_permission(origin, collection_id: u64, mint_permission: bool) -> DispatchResult685        {686            let sender = ensure_signed(origin)?;687688            Self::check_owner_permissions(collection_id, sender)?;689            let mut target_collection = <Collection<T>>::get(collection_id);690            target_collection.mint_mode = mint_permission;691            <Collection<T>>::insert(collection_id, target_collection);692693            Ok(())694        }695696        /// Change the owner of the collection.697        /// 698        /// # Permissions699        /// 700        /// * Collection Owner.701        /// 702        /// # Arguments703        /// 704        /// * collection_id.705        /// 706        /// * new_owner.707        #[weight = T::WeightInfo::change_collection_owner()]708        pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {709710            let sender = ensure_signed(origin)?;711            Self::check_owner_permissions(collection_id, sender)?;712            let mut target_collection = <Collection<T>>::get(collection_id);713            target_collection.owner = new_owner;714            <Collection<T>>::insert(collection_id, target_collection);715716            Ok(())717        }718719        /// Adds an admin of the Collection.720        /// 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. 721        /// 722        /// # Permissions723        /// 724        /// * Collection Owner.725        /// * Collection Admin.726        /// 727        /// # Arguments728        /// 729        /// * collection_id: ID of the Collection to add admin for.730        /// 731        /// * new_admin_id: Address of new admin to add.732        #[weight = T::WeightInfo::add_collection_admin()]733        pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {734735            let sender = ensure_signed(origin)?;736            Self::check_owner_or_admin_permissions(collection_id, sender)?;737            let mut admin_arr: Vec<T::AccountId> = Vec::new();738739            if <AdminList<T>>::contains_key(collection_id)740            {741                admin_arr = <AdminList<T>>::get(collection_id);742                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);743            }744745            // Number of collection admins746            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);747748            admin_arr.push(new_admin_id);749            <AdminList<T>>::insert(collection_id, admin_arr);750751            Ok(())752        }753754        /// 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.755        ///756        /// # Permissions757        /// 758        /// * Collection Owner.759        /// * Collection Admin.760        /// 761        /// # Arguments762        /// 763        /// * collection_id: ID of the Collection to remove admin for.764        /// 765        /// * account_id: Address of admin to remove.766        #[weight = T::WeightInfo::remove_collection_admin()]767        pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {768769            let sender = ensure_signed(origin)?;770            Self::check_owner_or_admin_permissions(collection_id, sender)?;771772            if <AdminList<T>>::contains_key(collection_id)773            {774                let mut admin_arr = <AdminList<T>>::get(collection_id);775                admin_arr.retain(|i| *i != account_id);776                <AdminList<T>>::insert(collection_id, admin_arr);777            }778779            Ok(())780        }781782        /// # Permissions783        /// 784        /// * Collection Owner785        /// 786        /// # Arguments787        /// 788        /// * collection_id.789        /// 790        /// * new_sponsor.791        #[weight = T::WeightInfo::set_collection_sponsor()]792        pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {793794            let sender = ensure_signed(origin)?;795            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);796797            let mut target_collection = <Collection<T>>::get(collection_id);798            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);799800            target_collection.unconfirmed_sponsor = new_sponsor;801            <Collection<T>>::insert(collection_id, target_collection);802803            Ok(())804        }805806        /// # Permissions807        /// 808        /// * Sponsor.809        /// 810        /// # Arguments811        /// 812        /// * collection_id.813        #[weight = T::WeightInfo::confirm_sponsorship()]814        pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {815816            let sender = ensure_signed(origin)?;817            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);818819            let mut target_collection = <Collection<T>>::get(collection_id);820            ensure!(sender == target_collection.unconfirmed_sponsor, Error::<T>::ConfirmUnsetSponsorFail);821822            target_collection.sponsor = target_collection.unconfirmed_sponsor;823            target_collection.unconfirmed_sponsor = T::AccountId::default();824            <Collection<T>>::insert(collection_id, target_collection);825826            Ok(())827        }828829        /// Switch back to pay-per-own-transaction model.830        ///831        /// # Permissions832        ///833        /// * Collection owner.834        /// 835        /// # Arguments836        /// 837        /// * collection_id.838        #[weight = T::WeightInfo::remove_collection_sponsor()]839        pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {840841            let sender = ensure_signed(origin)?;842            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);843844            let mut target_collection = <Collection<T>>::get(collection_id);845            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);846847            target_collection.sponsor = T::AccountId::default();848            <Collection<T>>::insert(collection_id, target_collection);849850            Ok(())851        }852853        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.854        /// 855        /// # Permissions856        /// 857        /// * Collection Owner.858        /// * Collection Admin.859        /// * Anyone if860        ///     * White List is enabled, and861        ///     * Address is added to white list, and862        ///     * MintPermission is enabled (see SetMintPermission method)863        /// 864        /// # Arguments865        /// 866        /// * collection_id: ID of the collection.867        /// 868        /// * owner: Address, initial owner of the NFT.869        ///870        /// * data: Token data to store on chain.871        // #[weight =872        // (130_000_000 as Weight)873        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))874        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))875        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]876877        #[weight = T::WeightInfo::create_item(data.len())]878        pub fn create_item(origin, collection_id: u64, owner: T::AccountId, data: CreateItemData) -> DispatchResult {879880            let sender = ensure_signed(origin)?;881882            Self::collection_exists(collection_id)?;883884            let target_collection = <Collection<T>>::get(collection_id);885886            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;887            Self::validate_create_item_args(&target_collection, &data)?;888            Self::create_item_no_validation(collection_id, &target_collection, owner, data)?;889890            Ok(())891        }892893        /// This method creates multiple instances of NFT Collection created with CreateCollection method.894        /// 895        /// # Permissions896        /// 897        /// * Collection Owner.898        /// * Collection Admin.899        /// * Anyone if900        ///     * White List is enabled, and901        ///     * Address is added to white list, and902        ///     * MintPermission is enabled (see SetMintPermission method)903        /// 904        /// # Arguments905        /// 906        /// * collection_id: ID of the collection.907        /// 908        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].909        /// 910        /// * owner: Address, initial owner of the NFT.911        #[weight = T::WeightInfo::create_item(items_data.into_iter()912                               .map(|data| { data.len() })913                               .sum())]914        pub fn create_multiple_items(origin, collection_id: u64, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {915916            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);917            let sender = ensure_signed(origin)?;918919            Self::collection_exists(collection_id)?;920            let target_collection = <Collection<T>>::get(collection_id);921922            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;923924            for data in &items_data {925                Self::validate_create_item_args(&target_collection, data)?;926            }927            for data in &items_data {928                Self::create_item_no_validation(collection_id, &target_collection, owner.clone(), data.clone())?;929            }930931            Ok(())932        }933934        /// Destroys a concrete instance of NFT.935        /// 936        /// # Permissions937        /// 938        /// * Collection Owner.939        /// * Collection Admin.940        /// * Current NFT Owner.941        /// 942        /// # Arguments943        /// 944        /// * collection_id: ID of the collection.945        /// 946        /// * item_id: ID of NFT to burn.947        #[weight = T::WeightInfo::burn_item()]948        pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {949950            let sender = ensure_signed(origin)?;951            Self::collection_exists(collection_id)?;952953            // Transfer permissions check954            let target_collection = <Collection<T>>::get(collection_id);955            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||956                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),957                Error::<T>::NoPermission);958959            if target_collection.access == AccessMode::WhiteList {960                Self::check_white_list(collection_id, &sender)?;961            }962963            match target_collection.mode964            {965                CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,966                CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,967                CollectionMode::ReFungible(_)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,968                _ => ()969            };970971            // call event972            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));973974            Ok(())975        }976977        /// Change ownership of the token.978        /// 979        /// # Permissions980        /// 981        /// * Collection Owner982        /// * Collection Admin983        /// * Current NFT owner984        ///985        /// # Arguments986        /// 987        /// * recipient: Address of token recipient.988        /// 989        /// * collection_id.990        /// 991        /// * item_id: ID of the item992        ///     * Non-Fungible Mode: Required.993        ///     * Fungible Mode: Ignored.994        ///     * Re-Fungible Mode: Required.995        /// 996        /// * value: Amount to transfer.997        ///     * Non-Fungible Mode: Ignored998        ///     * Fungible Mode: Must specify transferred amount999        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1000        #[weight = T::WeightInfo::transfer()]1001        pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {10021003            let sender = ensure_signed(origin)?;10041005            // Transfer permissions check1006            let target_collection = <Collection<T>>::get(collection_id);1007            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1008                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1009                Error::<T>::NoPermission);10101011            if target_collection.access == AccessMode::WhiteList {1012                Self::check_white_list(collection_id, &sender)?;1013                Self::check_white_list(collection_id, &recipient)?;1014            }10151016            match target_collection.mode1017            {1018                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,1019                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,1020                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,1021                _ => ()1022            };10231024            Ok(())1025        }10261027        /// Set, change, or remove approved address to transfer the ownership of the NFT.1028        /// 1029        /// # Permissions1030        /// 1031        /// * Collection Owner1032        /// * Collection Admin1033        /// * Current NFT owner1034        /// 1035        /// # Arguments1036        /// 1037        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1038        /// 1039        /// * collection_id.1040        /// 1041        /// * item_id: ID of the item.1042        #[weight = T::WeightInfo::approve()]1043        pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {10441045            let sender = ensure_signed(origin)?;10461047            // Transfer permissions check1048            let target_collection = <Collection<T>>::get(collection_id);1049            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1050                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1051                Error::<T>::NoPermission);10521053            if target_collection.access == AccessMode::WhiteList {1054                Self::check_white_list(collection_id, &sender)?;1055                Self::check_white_list(collection_id, &approved)?;1056            }10571058            // amount param stub1059            let amount = 100000000;10601061            let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));1062            if list_exists {10631064                let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));1065                let item_contains = list.iter().any(|i| i.approved == approved);10661067                if !item_contains {1068                    list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1069                    <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1070                }1071            } else {10721073                let mut list = Vec::new();1074                list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1075                <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1076            }10771078            Ok(())1079        }1080        1081        /// 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.1082        /// 1083        /// # Permissions1084        /// * Collection Owner1085        /// * Collection Admin1086        /// * Current NFT owner1087        /// * Address approved by current NFT owner1088        /// 1089        /// # Arguments1090        /// 1091        /// * from: Address that owns token.1092        /// 1093        /// * recipient: Address of token recipient.1094        /// 1095        /// * collection_id.1096        /// 1097        /// * item_id: ID of the item.1098        /// 1099        /// * value: Amount to transfer.1100        #[weight = T::WeightInfo::transfer_from()]1101        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {11021103            let sender = ensure_signed(origin)?;1104            let mut appoved_transfer = false;11051106            // Check approve1107            if <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone())) {1108                let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));1109                let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());1110                if opt_item.is_some()1111                {1112                    appoved_transfer = true;1113                    ensure!(opt_item.unwrap().amount >= value, Error::<T>::TokenValueNotEnough);1114                }1115            }11161117            // Transfer permissions check1118            let target_collection = <Collection<T>>::get(collection_id);1119                ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1120                Error::<T>::NoPermission);11211122            if target_collection.access == AccessMode::WhiteList {1123                Self::check_white_list(collection_id, &sender)?;1124                Self::check_white_list(collection_id, &recipient)?;1125            }11261127            // remove approve1128            let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))1129                .into_iter().filter(|i| i.approved != sender.clone()).collect();1130            <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);113111321133            match target_collection.mode1134            {1135                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1136                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,1137                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1138                _ => ()1139            };11401141            Ok(())1142        }11431144        ///1145        #[weight = 0]1146        pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {11471148            // let no_perm_mes = "You do not have permissions to modify this collection";1149            // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1150            // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1151            // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);11521153            // // on_nft_received  call11541155            // Self::transfer(origin, collection_id, item_id, new_owner)?;11561157            Ok(())1158        }11591160        /// Set off-chain data schema.1161        /// 1162        /// # Permissions1163        /// 1164        /// * Collection Owner1165        /// * Collection Admin1166        /// 1167        /// # Arguments1168        /// 1169        /// * collection_id.1170        /// 1171        /// * schema: String representing the offchain data schema.1172        #[weight = T::WeightInfo::set_variable_meta_data()]1173        pub fn set_variable_meta_data (1174            origin,1175            collection_id: u64,1176            item_id: u64,1177            data: Vec<u8>1178        ) -> DispatchResult {1179            let sender = ensure_signed(origin)?;1180            1181            Self::collection_exists(collection_id)?;11821183            // Modify permissions check1184            let target_collection = <Collection<T>>::get(collection_id);1185            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1186                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1187                Error::<T>::NoPermission);11881189            Self::item_exists(collection_id, item_id, &target_collection.mode)?;11901191            match target_collection.mode1192            {1193                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1194                CollectionMode::ReFungible(_)  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1195                _ => ()1196            };11971198            Ok(())1199        }1200        12011202        /// Set off-chain data schema.1203        /// 1204        /// # Permissions1205        /// 1206        /// * Collection Owner1207        /// * Collection Admin1208        /// 1209        /// # Arguments1210        /// 1211        /// * collection_id.1212        /// 1213        /// * schema: String representing the offchain data schema.1214        #[weight = T::WeightInfo::set_offchain_schema()]1215        pub fn set_offchain_schema(1216            origin,1217            collection_id: u64,1218            schema: Vec<u8>1219        ) -> DispatchResult {1220            let sender = ensure_signed(origin)?;1221            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12221223            let mut target_collection = <Collection<T>>::get(collection_id);1224            target_collection.offchain_schema = schema;1225            <Collection<T>>::insert(collection_id, target_collection);12261227            Ok(())1228        }12291230        /// Set const on-chain data schema.1231        /// 1232        /// # Permissions1233        /// 1234        /// * Collection Owner1235        /// * Collection Admin1236        /// 1237        /// # Arguments1238        /// 1239        /// * collection_id.1240        /// 1241        /// * schema: String representing the const on-chain data schema.1242        #[weight = T::WeightInfo::set_const_on_chain_schema()]1243        pub fn set_const_on_chain_schema (1244            origin,1245            collection_id: u64,1246            schema: Vec<u8>1247        ) -> DispatchResult {1248            let sender = ensure_signed(origin)?;1249            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12501251            let mut target_collection = <Collection<T>>::get(collection_id);1252            target_collection.const_on_chain_schema = schema;1253            <Collection<T>>::insert(collection_id, target_collection);12541255            Ok(())1256        }12571258        /// Set variable on-chain data schema.1259        /// 1260        /// # Permissions1261        /// 1262        /// * Collection Owner1263        /// * Collection Admin1264        /// 1265        /// # Arguments1266        /// 1267        /// * collection_id.1268        /// 1269        /// * schema: String representing the variable on-chain data schema.1270        #[weight = T::WeightInfo::set_const_on_chain_schema()]1271        pub fn set_variable_on_chain_schema (1272            origin,1273            collection_id: u64,1274            schema: Vec<u8>1275        ) -> DispatchResult {1276            let sender = ensure_signed(origin)?;1277            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12781279            let mut target_collection = <Collection<T>>::get(collection_id);1280            target_collection.variable_on_chain_schema = schema;1281            <Collection<T>>::insert(collection_id, target_collection);12821283            Ok(())1284        }12851286        // Sudo permissions function1287        #[weight = 0]1288        pub fn set_chain_limits(1289            origin,1290            limits: ChainLimits1291        ) -> DispatchResult {1292            ensure_root(origin)?;1293            <ChainLimit>::put(limits);1294            Ok(())1295        }12961297        /// Enable smart contract self-sponsoring.1298        /// 1299        /// # Permissions1300        /// 1301        /// * Contract Owner1302        /// 1303        /// # Arguments1304        /// 1305        /// * contract address1306        /// * enable flag1307        /// 1308        #[weight = 0]1309        pub fn enable_contract_sponsoring(1310            origin,1311            contract_address: T::AccountId,1312            enable: bool1313        ) -> DispatchResult {1314            let sender = ensure_signed(origin)?;1315            let mut is_owner = false;1316            if <ContractOwner<T>>::contains_key(contract_address.clone()) {1317                let owner = <ContractOwner<T>>::get(&contract_address);1318                is_owner = sender == owner;1319            }1320            ensure!(is_owner, Error::<T>::NoPermission);13211322            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1323            Ok(())1324        }13251326    }1327}13281329impl<T: Trait> Module<T> {13301331    fn can_create_items_in_collection(collection_id: u64, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {13321333        if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1334            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1335            Self::check_white_list(collection_id, owner)?;1336            Self::check_white_list(collection_id, sender)?;1337        }13381339        Ok(())1340    }13411342    fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1343        match target_collection.mode1344        {1345            CollectionMode::NFT => {1346                if let CreateItemData::NFT(data) = data {1347                    // check sizes1348                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");1349                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");1350                } else {1351                    fail!("Not NFT item data used to mint in NFT collection.");1352                }1353            },1354            CollectionMode::Fungible(_) => {1355                if let CreateItemData::Fungible(_) = data {1356                } else {1357                    fail!("Not Fungible item data used to mint in Fungible collection.");1358                }1359            },1360            CollectionMode::ReFungible(_) => {1361                if let CreateItemData::ReFungible(data) = data {13621363                    // check sizes1364                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");1365                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");1366                } else {1367                    fail!("Not Re Fungible item data used to mint in Re Fungible collection.");1368                }1369            },1370            _ => { fail!("Unexpected collection type."); }1371        };13721373        Ok(())1374    }13751376    fn create_item_no_validation(collection_id: u64, collection: &CollectionType<T::AccountId>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1377        match data1378        {1379            CreateItemData::NFT(data) => {1380                let item = NftItemType {1381                    collection: collection_id,1382                    owner,1383                    const_data: data.const_data,1384                    variable_data: data.variable_data1385                };13861387                Self::add_nft_item(item)?;1388            },1389            CreateItemData::Fungible(_) => {1390                let item = FungibleItemType {1391                    collection: collection_id,1392                    owner,1393                    value: (10 as u128).pow(collection.decimal_points)1394                };13951396                Self::add_fungible_item(item)?;1397            },1398            CreateItemData::ReFungible(data) => {1399                let mut owner_list = Vec::new();1400                let value = (10 as u128).pow(collection.decimal_points);1401                owner_list.push(Ownership {owner: owner.clone(), fraction: value});14021403                let item = ReFungibleItemType {1404                    collection: collection_id,1405                    owner: owner_list,1406                    const_data: data.const_data,1407                    variable_data: data.variable_data1408                };14091410                Self::add_refungible_item(item)?;1411            }1412        };141314141415        // call event1416        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));14171418        Ok(())1419    }14201421    fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {1422        let current_index = <ItemListIndex>::get(item.collection)1423            .checked_add(1)1424            .ok_or(Error::<T>::NumOverflow)?;1425        let itemcopy = item.clone();1426        let owner = item.owner.clone();1427        let value = item.value as u64;14281429        Self::add_token_index(item.collection, current_index, owner.clone())?;14301431        <ItemListIndex>::insert(item.collection, current_index);1432        <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);14331434        // Add current block1435        let v: Vec<BasketItem<T::AccountId, T::BlockNumber>> = Vec::new();1436        <FungibleTransferBasket<T>>::insert(item.collection, current_index, v);1437        1438        // Update balance1439        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1440            .checked_add(value)1441            .ok_or(Error::<T>::NumOverflow)?;1442        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);14431444        Ok(())1445    }14461447    fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1448        let current_index = <ItemListIndex>::get(item.collection)1449            .checked_add(1)1450            .ok_or(Error::<T>::NumOverflow)?;1451        let itemcopy = item.clone();14521453        let value = item.owner.first().unwrap().fraction as u64;1454        let owner = item.owner.first().unwrap().owner.clone();14551456        Self::add_token_index(item.collection, current_index, owner.clone())?;14571458        <ItemListIndex>::insert(item.collection, current_index);1459        <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);14601461        // Add current block1462        let block_number: T::BlockNumber = 0.into();1463        <ReFungibleTransferBasket<T>>::insert(item.collection, current_index, block_number);14641465        // Update balance1466        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1467            .checked_add(value)1468            .ok_or(Error::<T>::NumOverflow)?;1469        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);14701471        Ok(())1472    }14731474    fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {1475        let current_index = <ItemListIndex>::get(item.collection)1476            .checked_add(1)1477            .ok_or(Error::<T>::NumOverflow)?;14781479        let item_owner = item.owner.clone();1480        let collection_id = item.collection.clone();1481        Self::add_token_index(collection_id, current_index, item.owner.clone())?;14821483        <ItemListIndex>::insert(collection_id, current_index);1484        <NftItemList<T>>::insert(collection_id, current_index, item);14851486        // Add current block1487        let block_number: T::BlockNumber = 0.into();1488        <NftTransferBasket<T>>::insert(collection_id, current_index, block_number);14891490        // Update balance1491        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1492            .checked_add(1)1493            .ok_or(Error::<T>::NumOverflow)?;1494        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);14951496        Ok(())1497    }14981499    fn burn_refungible_item(1500        collection_id: u64,1501        item_id: u64,1502        owner: T::AccountId,1503    ) -> DispatchResult {1504        ensure!(1505            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1506            Error::<T>::TokenNotFound1507        );1508        let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);1509        let item = collection1510            .owner1511            .iter()1512            .filter(|&i| i.owner == owner)1513            .next()1514            .unwrap();1515        Self::remove_token_index(collection_id, item_id, owner.clone())?;15161517        // remove approve list1518        <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));15191520        // update balance1521        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1522            .checked_sub(item.fraction as u64)1523            .ok_or(Error::<T>::NumOverflow)?;1524        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);15251526        <ReFungibleItemList<T>>::remove(collection_id, item_id);15271528        Ok(())1529    }15301531    fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {1532        ensure!(1533            <NftItemList<T>>::contains_key(collection_id, item_id),1534            Error::<T>::TokenNotFound1535        );1536        let item = <NftItemList<T>>::get(collection_id, item_id);1537        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;15381539        // remove approve list1540        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));15411542        // update balance1543        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1544            .checked_sub(1)1545            .ok_or(Error::<T>::NumOverflow)?;1546        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1547        <NftItemList<T>>::remove(collection_id, item_id);15481549        Ok(())1550    }15511552    fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {1553        ensure!(1554            <FungibleItemList<T>>::contains_key(collection_id, item_id),1555            Error::<T>::TokenNotFound1556        );1557        let item = <FungibleItemList<T>>::get(collection_id, item_id);1558        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;15591560        // remove approve list1561        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));15621563        // update balance1564        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1565            .checked_sub(item.value as u64)1566            .ok_or(Error::<T>::NumOverflow)?;1567        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);15681569        <FungibleItemList<T>>::remove(collection_id, item_id);15701571        Ok(())1572    }15731574    fn collection_exists(collection_id: u64) -> DispatchResult {1575        ensure!(1576            <Collection<T>>::contains_key(collection_id),1577            Error::<T>::CollectionNotFound1578        );1579        Ok(())1580    }15811582    fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {1583        Self::collection_exists(collection_id)?;15841585        let target_collection = <Collection<T>>::get(collection_id);1586        ensure!(1587            subject == target_collection.owner,1588            Error::<T>::NoPermission1589        );15901591        Ok(())1592    }15931594    fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {1595        let target_collection = <Collection<T>>::get(collection_id);1596        let mut result: bool = subject == target_collection.owner;1597        let exists = <AdminList<T>>::contains_key(collection_id);15981599        if !result & exists {1600            if <AdminList<T>>::get(collection_id).contains(&subject) {1601                result = true1602            }1603        }16041605        result1606    }16071608    fn check_owner_or_admin_permissions(1609        collection_id: u64,1610        subject: T::AccountId,1611    ) -> DispatchResult {1612        Self::collection_exists(collection_id)?;1613        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());16141615        ensure!(1616            result,1617            Error::<T>::NoPermission1618        );1619        Ok(())1620    }16211622    fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {1623        let target_collection = <Collection<T>>::get(collection_id);16241625        match target_collection.mode {1626            CollectionMode::NFT => {1627                <NftItemList<T>>::get(collection_id, item_id).owner == subject1628            }1629            CollectionMode::Fungible(_) => {1630                <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1631            }1632            CollectionMode::ReFungible(_) => {1633                <ReFungibleItemList<T>>::get(collection_id, item_id)1634                    .owner1635                    .iter()1636                    .any(|i| i.owner == subject)1637            }1638            CollectionMode::Invalid => false,1639        }1640    }16411642    fn check_white_list(collection_id: u64, address: &T::AccountId) -> DispatchResult {1643        let mes = Error::<T>::AddresNotInWhiteList;1644        ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1645        let wl = <WhiteList<T>>::get(collection_id);1646        ensure!(wl.contains(address), mes);16471648        Ok(())1649    }16501651    fn transfer_fungible(1652        collection_id: u64,1653        item_id: u64,1654        value: u64,1655        owner: T::AccountId,1656        new_owner: T::AccountId,1657    ) -> DispatchResult {1658        ensure!(1659            <FungibleItemList<T>>::contains_key(collection_id, item_id),1660            Error::<T>::TokenNotFound1661        );16621663        let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1664        let amount = full_item.value;16651666        ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);16671668        // update balance1669        let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1670            .checked_sub(value)1671            .ok_or(Error::<T>::NumOverflow)?;1672        <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);16731674        let mut new_owner_account_id = 0;1675        let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());1676        if new_owner_items.len() > 0 {1677            new_owner_account_id = new_owner_items[0];1678        }16791680        let val64 = value.into();16811682        // transfer1683        if amount == val64 && new_owner_account_id == 0 {1684            // change owner1685            // new owner do not have account1686            let mut new_full_item = full_item.clone();1687            new_full_item.owner = new_owner.clone();1688            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);16891690            // update balance1691            let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1692                .checked_add(value)1693                .ok_or(Error::<T>::NumOverflow)?;1694            <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);16951696            // update index collection1697            Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1698        } else {1699            let mut new_full_item = full_item.clone();1700            new_full_item.value -= val64;17011702            // separate amount1703            if new_owner_account_id > 0 {1704                // new owner has account1705                let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1706                item.value += val64;17071708                // update balance1709                let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1710                    .checked_add(value)1711                    .ok_or(Error::<T>::NumOverflow)?;1712                <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17131714                <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);1715            } else {1716                // new owner do not have account1717                let item = FungibleItemType {1718                    collection: collection_id,1719                    owner: new_owner.clone(),1720                    value: val64,1721                };17221723                Self::add_fungible_item(item)?;1724            }17251726            if amount == val64 {1727                Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;17281729                // remove approve list1730                <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));1731                <FungibleItemList<T>>::remove(collection_id, item_id);1732            }17331734            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1735        }17361737        Ok(())1738    }17391740    fn transfer_refungible(1741        collection_id: u64,1742        item_id: u64,1743        value: u64,1744        owner: T::AccountId,1745        new_owner: T::AccountId,1746    ) -> DispatchResult {1747        ensure!(1748            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1749            Error::<T>::TokenNotFound1750        );17511752        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1753        let item = full_item1754            .owner1755            .iter()1756            .filter(|i| i.owner == owner)1757            .next()1758            .ok_or(Error::<T>::NumOverflow)?;1759        let amount = item.fraction;17601761        ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);17621763        // update balance1764        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1765            .checked_sub(value)1766            .ok_or(Error::<T>::NumOverflow)?;1767        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);17681769        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1770            .checked_add(value)1771            .ok_or(Error::<T>::NumOverflow)?;1772        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17731774        let old_owner = item.owner.clone();1775        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);1776        let val64 = value.into();17771778        // transfer1779        if amount == val64 && !new_owner_has_account {1780            // change owner1781            // new owner do not have account1782            let mut new_full_item = full_item.clone();1783            new_full_item1784                .owner1785                .iter_mut()1786                .find(|i| i.owner == owner)1787                .unwrap()1788                .owner = new_owner.clone();1789            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);17901791            // update index collection1792            Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1793        } else {1794            let mut new_full_item = full_item.clone();1795            new_full_item1796                .owner1797                .iter_mut()1798                .find(|i| i.owner == owner)1799                .unwrap()1800                .fraction -= val64;18011802            // separate amount1803            if new_owner_has_account {1804                // new owner has account1805                new_full_item1806                    .owner1807                    .iter_mut()1808                    .find(|i| i.owner == new_owner)1809                    .unwrap()1810                    .fraction += val64;1811            } else {1812                // new owner do not have account1813                new_full_item.owner.push(Ownership {1814                    owner: new_owner.clone(),1815                    fraction: val64,1816                });1817                Self::add_token_index(collection_id, item_id, new_owner.clone())?;1818            }18191820            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1821        }18221823        Ok(())1824    }18251826    fn transfer_nft(1827        collection_id: u64,1828        item_id: u64,1829        sender: T::AccountId,1830        new_owner: T::AccountId,1831    ) -> DispatchResult {1832        ensure!(1833            <NftItemList<T>>::contains_key(collection_id, item_id),1834            Error::<T>::TokenNotFound1835        );18361837        let mut item = <NftItemList<T>>::get(collection_id, item_id);18381839        ensure!(1840            sender == item.owner,1841            Error::<T>::MustBeTokenOwner1842        );18431844        // update balance1845        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1846            .checked_sub(1)1847            .ok_or(Error::<T>::NumOverflow)?;1848        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);18491850        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1851            .checked_add(1)1852            .ok_or(Error::<T>::NumOverflow)?;1853        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18541855        // change owner1856        let old_owner = item.owner.clone();1857        item.owner = new_owner.clone();1858        <NftItemList<T>>::insert(collection_id, item_id, item);18591860        // update index collection1861        Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;18621863        // reset approved list1864        <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1865        Ok(())1866    }1867    1868    fn item_exists(1869        collection_id: u64,1870        item_id: u64,1871        mode: &CollectionMode1872    ) -> DispatchResult {1873        match mode {1874            CollectionMode::NFT => ensure!(<NftItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1875            CollectionMode::ReFungible(_) => ensure!(<ReFungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1876            CollectionMode::Fungible(_) => ensure!(<FungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1877            _ => ()1878        };1879        1880        Ok(())1881    }18821883    fn set_re_fungible_variable_data(1884        collection_id: u64,1885        item_id: u64,1886        data: Vec<u8>1887    ) -> DispatchResult {1888        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);18891890        item.variable_data = data;18911892        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);18931894        Ok(())1895    }18961897    fn set_nft_variable_data(1898        collection_id: u64,1899        item_id: u64,1900        data: Vec<u8>1901    ) -> DispatchResult {1902        let mut item = <NftItemList<T>>::get(collection_id, item_id);1903        1904        item.variable_data = data;19051906        <NftItemList<T>>::insert(collection_id, item_id, item);1907        1908        Ok(())1909    }19101911    fn init_collection(item: &CollectionType<T::AccountId>) {1912        // check params1913        assert!(1914            item.decimal_points <= 4,1915            "decimal_points parameter must be lower than 4"1916        );1917        assert!(1918            item.name.len() <= 64,1919            "Collection name can not be longer than 63 char"1920        );1921        assert!(1922            item.name.len() <= 256,1923            "Collection description can not be longer than 255 char"1924        );1925        assert!(1926            item.token_prefix.len() <= 16,1927            "Token prefix can not be longer than 15 char"1928        );19291930        // Generate next collection ID1931        let next_id = CreatedCollectionCount::get()1932            .checked_add(1)1933            .unwrap();19341935        CreatedCollectionCount::put(next_id);1936    }19371938    fn init_nft_token(item: &NftItemType<T::AccountId>) {1939        let current_index = <ItemListIndex>::get(item.collection)1940            .checked_add(1)1941            .unwrap();19421943        let item_owner = item.owner.clone();1944        let collection_id = item.collection.clone();1945        Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();19461947        <ItemListIndex>::insert(collection_id, current_index);19481949        // Update balance1950        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1951            .checked_add(1)1952            .unwrap();1953        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);1954    }19551956    fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {1957        let current_index = <ItemListIndex>::get(item.collection)1958            .checked_add(1)1959            .unwrap();1960        let owner = item.owner.clone();1961        let value = item.value as u64;19621963        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();19641965        <ItemListIndex>::insert(item.collection, current_index);19661967        // Update balance1968        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1969            .checked_add(value)1970            .unwrap();1971        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1972    }19731974    fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {1975        let current_index = <ItemListIndex>::get(item.collection)1976            .checked_add(1)1977            .unwrap();19781979        let value = item.owner.first().unwrap().fraction as u64;1980        let owner = item.owner.first().unwrap().owner.clone();19811982        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();19831984        <ItemListIndex>::insert(item.collection, current_index);19851986        // Update balance1987        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1988            .checked_add(value)1989            .unwrap();1990        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1991    }19921993    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {19941995        // add to account limit1996        if <AccountItemCount<T>>::contains_key(owner.clone()) {19971998            // bound Owned tokens by a single address1999            let count = <AccountItemCount<T>>::get(owner.clone());2000            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);20012002            <AccountItemCount<T>>::insert(owner.clone(), count2003                .checked_add(1)2004                .ok_or(Error::<T>::NumOverflow)?);2005        }2006        else {2007            <AccountItemCount<T>>::insert(owner.clone(), 1);2008        }20092010        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2011        if list_exists {2012            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2013            let item_contains = list.contains(&item_index.clone());20142015            if !item_contains {2016                list.push(item_index.clone());2017            }20182019            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2020        } else {2021            let mut itm = Vec::new();2022            itm.push(item_index.clone());2023            <AddressTokens<T>>::insert(collection_id, owner, itm);2024            2025        }20262027        Ok(())2028    }20292030    fn remove_token_index(2031        collection_id: u64,2032        item_index: u64,2033        owner: T::AccountId,2034    ) -> DispatchResult {20352036        // update counter2037        <AccountItemCount<T>>::insert(owner.clone(), 2038            <AccountItemCount<T>>::get(owner.clone())2039            .checked_sub(1)2040            .ok_or(Error::<T>::NumOverflow)?);204120422043        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2044        if list_exists {2045            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2046            let item_contains = list.contains(&item_index.clone());20472048            if item_contains {2049                list.retain(|&item| item != item_index);2050                <AddressTokens<T>>::insert(collection_id, owner, list);2051            }2052        }20532054        Ok(())2055    }20562057    fn move_token_index(2058        collection_id: u64,2059        item_index: u64,2060        old_owner: T::AccountId,2061        new_owner: T::AccountId,2062    ) -> DispatchResult {2063        Self::remove_token_index(collection_id, item_index, old_owner)?;2064        Self::add_token_index(collection_id, item_index, new_owner)?;20652066        Ok(())2067    }2068}20692070////////////////////////////////////////////////////////////////////////////////////////////////////2071// Economic models2072// #region20732074/// Fee multiplier.2075pub type Multiplier = FixedU128;20762077type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2078    <T as system::Trait>::AccountId,2079>>::Balance;2080type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2081    <T as system::Trait>::AccountId,2082>>::NegativeImbalance;20832084/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2085/// in the queue.2086#[derive(Encode, Decode, Clone, Eq, PartialEq)]2087pub struct ChargeTransactionPayment<T: Trait + Send + Sync>(2088    #[codec(compact)] BalanceOf<T>2089);20902091impl<T: Trait + Send + Sync> sp_std::fmt::Debug2092    for ChargeTransactionPayment<T>2093{2094    #[cfg(feature = "std")]2095    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2096        write!(f, "ChargeTransactionPayment<{:?}>", self.0)2097    }2098    #[cfg(not(feature = "std"))]2099    fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2100        Ok(())2101    }2102}21032104impl<T: Trait + Send + Sync> ChargeTransactionPayment<T>2105where2106    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2107    BalanceOf<T>: Send + Sync + FixedPointOperand,2108{2109    /// utility constructor. Used only in client/factory code.2110    pub fn from(fee: BalanceOf<T>) -> Self {2111        Self(fee)2112    }21132114    pub fn traditional_fee(2115        len: usize,2116        info: &DispatchInfoOf<T::Call>,2117        tip: BalanceOf<T>,2118    ) -> BalanceOf<T>2119    where2120        T::Call: Dispatchable<Info = DispatchInfo>,2121    {2122        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2123    }21242125    fn withdraw_fee(2126        &self,2127        who: &T::AccountId,2128        call: &T::Call,2129        info: &DispatchInfoOf<T::Call>,2130        len: usize,2131    ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {2132        let tip = self.0;21332134        // Set fee based on call type. Creating collection costs 1 Unique.2135        // All other transactions have traditional fees so far2136        // let fee = match call.is_sub_type() {2137        //     Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2138        //     _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2139        //                                                 // _ => <BalanceOf<T>>::from(100)2140        // };2141        let fee = Self::traditional_fee(len, info, tip);21422143        // Determine who is paying transaction fee based on ecnomic model2144        // Parse call to extract collection ID and access collection sponsor2145        let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2146            Some(Call::create_item(collection_id, _properties, _owner)) => {2147                <Collection<T>>::get(collection_id).sponsor2148            }2149            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {2150                let _collection_mode = <Collection<T>>::get(collection_id).mode;21512152                // sponsor timeout2153                let sponsor_transfer = match _collection_mode {2154                    CollectionMode::NFT => {2155                        let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);2156                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2157                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2158                        if block_number >= limit_time {2159                            <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);2160                            true2161                        }2162                        else {2163                            false2164                        }2165                    }2166                    CollectionMode::Fungible(_) => {2167                        let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);2168                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2169                        if basket.iter().any(|i| i.address == _new_owner.clone())2170                        {2171                            let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();2172                            let limit_time = item.start_block + ChainLimit::get().fungible_sponsor_transfer_timeout.into();2173                            if block_number >= limit_time {2174                                basket.retain(|x| x.address == item.address);2175                                basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });2176                                <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);2177                                true2178                            }2179                            else {2180                                false2181                            }2182                        }2183                        else {2184                            basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});2185                            true2186                        }2187                    }2188                    CollectionMode::ReFungible(_) => {2189                        let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);2190                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2191                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2192                        if block_number >= limit_time {2193                            <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);2194                            true2195                        } else {2196                            false2197                        }2198                    }2199                    _ => {2200                        false2201                    },2202                };22032204                if !sponsor_transfer {2205                    T::AccountId::default()2206                } else {2207                    <Collection<T>>::get(collection_id).sponsor2208                }2209            }22102211            _ => T::AccountId::default(),2212        };22132214        // Sponsor smart contracts2215        sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {22162217            // On instantiation: set the contract owner2218            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, data)) => {22192220                let new_contract_address = <T as pallet_contracts::Trait>::DetermineContractAddress::contract_address_for(2221                    code_hash,2222                    &data,2223                    &who,2224                );2225                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());22262227                T::AccountId::default()2228            },22292230            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2231            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {22322233                let mut sp = T::AccountId::default();2234                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());2235                if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2236                    if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2237                        sp = called_contract;2238                    }2239                }22402241                sp2242            },22432244            _ => sponsor,2245        };22462247        let mut who_pays_fee: T::AccountId = sponsor.clone();2248        if sponsor == T::AccountId::default() {2249            who_pays_fee = who.clone();2250        }22512252        // Only mess with balances if fee is not zero.2253        if fee.is_zero() {2254            return Ok((fee, None));2255        }22562257        match <T as transaction_payment::Trait>::Currency::withdraw(2258            &who_pays_fee,2259            fee,2260            if tip.is_zero() {2261                WithdrawReason::TransactionPayment.into()2262            } else {2263                WithdrawReason::TransactionPayment | WithdrawReason::Tip2264            },2265            ExistenceRequirement::KeepAlive,2266        ) {2267            Ok(imbalance) => Ok((fee, Some(imbalance))),2268            Err(_) => Err(InvalidTransaction::Payment.into()),2269        }2270    }2271}227222732274impl<T: Trait + Send + Sync> SignedExtension2275    for ChargeTransactionPayment<T>2276where2277    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2278    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2279{2280    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2281    type AccountId = T::AccountId;2282    type Call = T::Call;2283    type AdditionalSigned = ();2284    type Pre = (2285        BalanceOf<T>,2286        Self::AccountId,2287        Option<NegativeImbalanceOf<T>>,2288        BalanceOf<T>,2289    );2290    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2291        Ok(())2292    }22932294    fn validate(2295        &self,2296        _who: &Self::AccountId,2297        _call: &Self::Call,2298        _info: &DispatchInfoOf<Self::Call>,2299        _len: usize,2300    ) -> TransactionValidity {2301        Ok(ValidTransaction::default())2302    }23032304    fn pre_dispatch(2305        self,2306        who: &Self::AccountId,2307        call: &Self::Call,2308        info: &DispatchInfoOf<Self::Call>,2309        len: usize,2310    ) -> Result<Self::Pre, TransactionValidityError> {2311        let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2312        Ok((self.0, who.clone(), imbalance, fee))2313    }23142315    fn post_dispatch(2316        pre: Self::Pre,2317        info: &DispatchInfoOf<Self::Call>,2318        post_info: &PostDispatchInfoOf<Self::Call>,2319        len: usize,2320        _result: &DispatchResult,2321    ) -> Result<(), TransactionValidityError> {2322        let (tip, who, imbalance, fee) = pre;2323        if let Some(payed) = imbalance {2324            let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(2325                len as u32, info, post_info, tip,2326            );2327            let refund = fee.saturating_sub(actual_fee);2328            let actual_payment =2329                match <T as transaction_payment::Trait>::Currency::deposit_into_existing(2330                    &who, refund,2331                ) {2332                    Ok(refund_imbalance) => {2333                        // The refund cannot be larger than the up front payed max weight.2334                        // `PostDispatchInfo::calc_unspent` guards against such a case.2335                        match payed.offset(refund_imbalance) {2336                            Ok(actual_payment) => actual_payment,2337                            Err(_) => return Err(InvalidTransaction::Payment.into()),2338                        }2339                    }2340                    // We do not recreate the account using the refund. The up front payment2341                    // is gone in that case.2342                    Err(_) => payed,2343                };2344            let imbalances = actual_payment.split(tip);2345            <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(2346                Some(imbalances.0).into_iter().chain(Some(imbalances.1)),2347            );2348        }2349        Ok(())2350    }2351}23522353// #endregion