git.delta.rocks / unique-network / refs/commits / 5a0b0e30f20b

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,12    dispatch::DispatchResult,13    ensure, 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, SaturatedConversion, Saturating,31        SignedExtension, Zero,32    },33    transaction_validity::{34        InvalidTransaction, TransactionPriority, TransactionValidity, TransactionValidityError,35        ValidTransaction,36    },37    FixedPointOperand, FixedU128,38};3940#[cfg(test)]41mod mock;4243#[cfg(test)]44mod tests;4546// Structs47// #region4849#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]50#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]51pub enum CollectionMode {52    Invalid,53    // custom data size54    NFT(u32),55    // decimal points56    Fungible(u32),57    // custom data size and decimal points58    ReFungible(u32, u32),59}6061impl Into<u8> for CollectionMode {62    fn into(self) -> u8 {63        match self {64            CollectionMode::Invalid => 0,65            CollectionMode::NFT(_) => 1,66            CollectionMode::Fungible(_) => 2,67            CollectionMode::ReFungible(_, _) => 3,68        }69    }70}7172#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]73#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]74pub enum AccessMode {75    Normal,76    WhiteList,77}78impl Default for AccessMode {79    fn default() -> Self {80        Self::Normal81    }82}8384impl Default for CollectionMode {85    fn default() -> Self {86        Self::Invalid87    }88}8990#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]91#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]92pub struct Ownership<AccountId> {93    pub owner: AccountId,94    pub fraction: u128,95}9697#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]98#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]99pub struct CollectionType<AccountId> {100    pub owner: AccountId,101    pub mode: CollectionMode,102    pub access: AccessMode,103    pub decimal_points: u32,104    pub name: Vec<u16>,        // 64 include null escape char105    pub description: Vec<u16>, // 256 include null escape char106    pub token_prefix: Vec<u8>, // 16 include null escape char107    pub custom_data_size: u32,108    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}113114#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]115#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]116pub struct CollectionAdminsType<AccountId> {117    pub admin: AccountId,118    pub collection_id: u64,119}120121#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]122#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]123pub struct NftItemType<AccountId> {124    pub collection: u64,125    pub owner: AccountId,126    pub data: Vec<u8>,127}128129#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]130#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]131pub struct FungibleItemType<AccountId> {132    pub collection: u64,133    pub owner: AccountId,134    pub value: u128,135}136137#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]138#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]139pub struct ReFungibleItemType<AccountId> {140    pub collection: u64,141    pub owner: Vec<Ownership<AccountId>>,142    pub data: Vec<u8>,143}144145#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]146#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]147pub struct ApprovePermissions<AccountId> {148    pub approved: AccountId,149    pub amount: u64,150}151152#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]153#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]154pub struct VestingItem<AccountId, Moment> {155    pub sender: AccountId,156    pub recipient: AccountId,157    pub collection_id: u64,158    pub item_id: u64,159    pub amount: u64,160    pub vesting_date: Moment,161}162163#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]164#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]165pub struct BasketItem<AccountId, BlockNumber> {166    pub address: AccountId,167    pub start_block: BlockNumber,168}169170#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]171#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]172pub struct ChainLimits {173    pub collection_numbers_limit: u64,174    pub account_token_ownership_limit: u64,175    pub collections_admins_limit: u64,176    pub custom_data_limit: u32,177178    // Timeouts for item types in passed blocks179    pub nft_sponsor_transfer_timeout: u32,180    pub fungible_sponsor_transfer_timeout: u32,181    pub refungible_sponsor_transfer_timeout: u32,182}183184pub trait Trait: system::Trait {185    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;186}187188// #endregion189190decl_storage! {191    trait Store for Module<T: Trait> as Nft {192193        // Private members194        NextCollectionID: u64;195        CreatedCollectionCount: u64;196        ChainVersion: u64;197        ItemListIndex: map hasher(blake2_128_concat) u64 => u64;198199        // Chain limits struct200        pub ChainLimit get(fn chain_limit) config(): ChainLimits;201202        // Bound counters203        CollectionCount: u64;204        pub AccountItemCount get(fn account_item_count): map hasher(identity) T::AccountId => u64;205206        // Basic collections207        pub Collection get(fn collection) config(): map hasher(identity) u64 => CollectionType<T::AccountId>;208        pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;209        pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;210211        /// Balance owner per collection map212        pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;213214        /// second parameter: item id + owner account id215        pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;216217        /// Item collections218        pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;219        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;220        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;221222        /// Index list223        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;224225        /// Tokens transfer baskets226        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;227        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>>;228        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;229230        // Sponsorship231        pub ContractSponsor get(fn contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;232        pub UnconfirmedContractSponsor get(fn unconfirmed_contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;233    }234    add_extra_genesis {235        build(|config: &GenesisConfig<T>| {236            // Modification of storage237            for (_num, _c) in &config.collection {238                <Module<T>>::init_collection(_c);239            }240241            for (_num, _q, _i) in &config.nft_item_id {242                <Module<T>>::init_nft_token(_i);243            }244245            for (_num, _q, _i) in &config.fungible_item_id {246                <Module<T>>::init_fungible_token(_i);247            }248249            for (_num, _q, _i) in &config.refungible_item_id {250                <Module<T>>::init_refungible_token(_i);251            }252        })253    }254}255256decl_event!(257    pub enum Event<T>258    where259        AccountId = <T as system::Trait>::AccountId,260    {261        Created(u64, u8, AccountId),262        ItemCreated(u64, u64),263        ItemDestroyed(u64, u64),264    }265);266267decl_module! {268    pub struct Module<T: Trait> for enum Call where origin: T::Origin {269270        fn deposit_event() = default;271272        fn on_initialize(now: T::BlockNumber) -> Weight {273274            if ChainVersion::get() < 2275            {276                let value = NextCollectionID::get();277                CreatedCollectionCount::put(value);278                ChainVersion::put(2);279            }280281            0282        }283284        // Create collection of NFT with given parameters285        //286        // @param customDataSz size of custom data in each collection item287        // returns collection ID288        #[weight = 0]289        pub fn create_collection(origin,290                                 collection_name: Vec<u16>,291                                 collection_description: Vec<u16>,292                                 token_prefix: Vec<u8>,293                                 mode: CollectionMode) -> DispatchResult {294295            // Anyone can create a collection296            let who = ensure_signed(origin)?;297            let custom_data_size = match mode {298                CollectionMode::NFT(size) => {299300                    // bound Custom data size301                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");302                    size303                },304                CollectionMode::ReFungible(size, _) => {305306                    // bound Custom data size307                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");308                    size309                },310                _ => 0311            };312313            let decimal_points = match mode {314                CollectionMode::Fungible(points) => points,315                CollectionMode::ReFungible(_, points) => points,316                _ => 0317            };318319            // bound Total number of collections320            ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, "Total collections bound exceeded");321322            // check params323            ensure!(decimal_points <= 4, "decimal_points parameter must be lower than 4");324325            let mut name = collection_name.to_vec();326            name.push(0);327            ensure!(name.len() <= 64, "Collection name can not be longer than 63 char");328329            let mut description = collection_description.to_vec();330            description.push(0);331            ensure!(name.len() <= 256, "Collection description can not be longer than 255 char");332333            let mut prefix = token_prefix.to_vec();334            prefix.push(0);335            ensure!(prefix.len() <= 16, "Token prefix can not be longer than 15 char");336337            // Generate next collection ID338            let next_id = CreatedCollectionCount::get()339                .checked_add(1)340                .expect("collection id error");341342            // bound counter343            let total = CollectionCount::get()344                .checked_add(1)345                .expect("collection counter error");346347            CreatedCollectionCount::put(next_id);348            CollectionCount::put(total);349350            // Create new collection351            let new_collection = CollectionType {352                owner: who.clone(),353                name: name,354                mode: mode.clone(),355                mint_mode: false,356                access: AccessMode::Normal,357                description: description,358                decimal_points: decimal_points,359                token_prefix: prefix,360                offchain_schema: Vec::new(),361                custom_data_size: custom_data_size,362                sponsor: T::AccountId::default(),363                unconfirmed_sponsor: T::AccountId::default(),364            };365366            // Add new collection to map367            <Collection<T>>::insert(next_id, new_collection);368369            // call event370            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));371372            Ok(())373        }374375        #[weight = 0]376        pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {377378            let sender = ensure_signed(origin)?;379            Self::check_owner_permissions(collection_id, sender)?;380381            <AddressTokens<T>>::remove_prefix(collection_id);382            <ApprovedList<T>>::remove_prefix(collection_id);383            <Balance<T>>::remove_prefix(collection_id);384            <ItemListIndex>::remove(collection_id);385            <AdminList<T>>::remove(collection_id);386            <Collection<T>>::remove(collection_id);387            <WhiteList<T>>::remove(collection_id);388389            <NftItemList<T>>::remove_prefix(collection_id);390            <FungibleItemList<T>>::remove_prefix(collection_id);391            <ReFungibleItemList<T>>::remove_prefix(collection_id);392393            <NftTransferBasket<T>>::remove_prefix(collection_id);394            <FungibleTransferBasket<T>>::remove_prefix(collection_id);395            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);396397            if CollectionCount::get() > 0398            {399                // bound couter400                let total = CollectionCount::get()401                    .checked_sub(1)402                    .expect("collection counter error");403404                CollectionCount::put(total);405            }406407            Ok(())408        }409410        #[weight = 0]411        pub fn add_to_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{412413            let sender = ensure_signed(origin)?;414            Self::check_owner_or_admin_permissions(collection_id, sender)?;415416            let mut white_list_collection: Vec<T::AccountId>;417            if <WhiteList<T>>::contains_key(collection_id) {418                white_list_collection = <WhiteList<T>>::get(collection_id);419                if !white_list_collection.contains(&address.clone())420                {421                    white_list_collection.push(address.clone());422                }423            }424            else {425                white_list_collection = Vec::new();426                white_list_collection.push(address.clone());427            }428429            <WhiteList<T>>::insert(collection_id, white_list_collection);430            Ok(())431        }432433        #[weight = 0]434        pub fn remove_from_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{435436            let sender = ensure_signed(origin)?;437            Self::check_owner_or_admin_permissions(collection_id, sender)?;438439            if <WhiteList<T>>::contains_key(collection_id) {440                let mut white_list_collection = <WhiteList<T>>::get(collection_id);441                if white_list_collection.contains(&address.clone())442                {443                    white_list_collection.retain(|i| *i != address.clone());444                    <WhiteList<T>>::insert(collection_id, white_list_collection);445                }446            }447448            Ok(())449        }450451        #[weight = 0]452        pub fn set_public_access_mode(origin, collection_id: u64, mode: AccessMode) -> DispatchResult453        {454            let sender = ensure_signed(origin)?;455456            Self::check_owner_permissions(collection_id, sender)?;457            let mut target_collection = <Collection<T>>::get(collection_id);458            target_collection.access = mode;459            <Collection<T>>::insert(collection_id, target_collection);460461            Ok(())462        }463464        #[weight = 0]465        pub fn set_mint_permission(origin, collection_id: u64, mint_permission: bool) -> DispatchResult466        {467            let sender = ensure_signed(origin)?;468469            Self::check_owner_permissions(collection_id, sender)?;470            let mut target_collection = <Collection<T>>::get(collection_id);471            target_collection.mint_mode = mint_permission;472            <Collection<T>>::insert(collection_id, target_collection);473474            Ok(())475        }476477        #[weight = 0]478        pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {479480            let sender = ensure_signed(origin)?;481            Self::check_owner_permissions(collection_id, sender)?;482            let mut target_collection = <Collection<T>>::get(collection_id);483            target_collection.owner = new_owner;484            <Collection<T>>::insert(collection_id, target_collection);485486            Ok(())487        }488489        #[weight = 0]490        pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {491492            let sender = ensure_signed(origin)?;493            Self::check_owner_or_admin_permissions(collection_id, sender)?;494            let mut admin_arr: Vec<T::AccountId> = Vec::new();495496            if <AdminList<T>>::contains_key(collection_id)497            {498                admin_arr = <AdminList<T>>::get(collection_id);499                ensure!(!admin_arr.contains(&new_admin_id), "Account already has admin role");500            }501502            // Number of collection admins503            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, "Number of collection admins bound exceeded");504505            admin_arr.push(new_admin_id);506            <AdminList<T>>::insert(collection_id, admin_arr);507508            Ok(())509        }510511        #[weight = 0]512        pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {513514            let sender = ensure_signed(origin)?;515            Self::check_owner_or_admin_permissions(collection_id, sender)?;516517            if <AdminList<T>>::contains_key(collection_id)518            {519                let mut admin_arr = <AdminList<T>>::get(collection_id);520                admin_arr.retain(|i| *i != account_id);521                <AdminList<T>>::insert(collection_id, admin_arr);522            }523524            Ok(())525        }526527        #[weight = 0]528        pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {529530            let sender = ensure_signed(origin)?;531            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");532533            let mut target_collection = <Collection<T>>::get(collection_id);534            ensure!(sender == target_collection.owner, "You do not own this collection");535536            target_collection.unconfirmed_sponsor = new_sponsor;537            <Collection<T>>::insert(collection_id, target_collection);538539            Ok(())540        }541542        #[weight = 0]543        pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {544545            let sender = ensure_signed(origin)?;546            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");547548            let mut target_collection = <Collection<T>>::get(collection_id);549            ensure!(sender == target_collection.unconfirmed_sponsor, "This address is not set as sponsor, use setCollectionSponsor first");550551            target_collection.sponsor = target_collection.unconfirmed_sponsor;552            target_collection.unconfirmed_sponsor = T::AccountId::default();553            <Collection<T>>::insert(collection_id, target_collection);554555            Ok(())556        }557558        #[weight = 0]559        pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {560561            let sender = ensure_signed(origin)?;562            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");563564            let mut target_collection = <Collection<T>>::get(collection_id);565            ensure!(sender == target_collection.owner, "You do not own this collection");566567            target_collection.sponsor = T::AccountId::default();568            <Collection<T>>::insert(collection_id, target_collection);569570            Ok(())571        }572573        #[weight = 0]574        pub fn create_item(origin, collection_id: u64, properties: Vec<u8>, owner: T::AccountId) -> DispatchResult {575576            let sender = ensure_signed(origin)?;577            Self::collection_exists(collection_id)?;578            let target_collection = <Collection<T>>::get(collection_id);579580            if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {581                ensure!(target_collection.mint_mode == true, "Collection is not in mint mode");582                Self::check_white_list(collection_id, owner.clone())?;583            }584585            match target_collection.mode586            {587                CollectionMode::NFT(_) => {588589                    // check size590                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");591592                    // Create nft item593                    let item = NftItemType {594                        collection: collection_id,595                        owner: owner,596                        data: properties,597                    };598599                    Self::add_nft_item(item)?;600601                },602                CollectionMode::Fungible(_) => {603604                    // check size605                    ensure!(properties.len() as u32 == 0, "Size of item must be 0 with fungible type");606607                    let item = FungibleItemType {608                        collection: collection_id,609                        owner: owner,610                        value: (10 as u128).pow(target_collection.decimal_points)611                    };612613                    Self::add_fungible_item(item)?;614                },615                CollectionMode::ReFungible(_, _) => {616617                    // check size618                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");619620                    let mut owner_list = Vec::new();621                    let value = (10 as u128).pow(target_collection.decimal_points);622                    owner_list.push(Ownership {owner: owner, fraction: value});623624                    let item = ReFungibleItemType {625                        collection: collection_id,626                        owner: owner_list,627                        data: properties628                    };629630                    Self::add_refungible_item(item)?;631                },632                _ => ()633            };634635            // call event636            Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));637638            Ok(())639        }640641        #[weight = 0]642        pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {643644            let sender = ensure_signed(origin)?;645            Self::collection_exists(collection_id)?;646647            // Transfer permissions check648            let target_collection = <Collection<T>>::get(collection_id);649            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||650                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),651                "Only item owner, collection owner and admins can modify item");652653            if target_collection.access == AccessMode::WhiteList {654                Self::check_white_list(collection_id, sender.clone())?;655            }656657            match target_collection.mode658            {659                CollectionMode::NFT(_) => Self::burn_nft_item(collection_id, item_id)?,660                CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,661                CollectionMode::ReFungible(_, _)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,662                _ => ()663            };664665            // call event666            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));667668            Ok(())669        }670671        #[weight = 0]672        pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {673674            let sender = ensure_signed(origin)?;675676            // Transfer permissions check677            let target_collection = <Collection<T>>::get(collection_id);678            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||679                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),680                "Only item owner, collection owner and admins can modify item");681682            if target_collection.access == AccessMode::WhiteList {683                Self::check_white_list(collection_id, sender.clone())?;684                Self::check_white_list(collection_id, recipient.clone())?;685            }686687            match target_collection.mode688            {689                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,690                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,691                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,692                _ => ()693            };694695            Ok(())696        }697698        #[weight = 0]699        pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {700701            let sender = ensure_signed(origin)?;702703            // Transfer permissions check704            let target_collection = <Collection<T>>::get(collection_id);705            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||706                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),707                "Only item owner, collection owner and admins can approve");708709            if target_collection.access == AccessMode::WhiteList {710                Self::check_white_list(collection_id, sender.clone())?;711                Self::check_white_list(collection_id, approved.clone())?;712            }713714            // amount param stub715            let amount = 100000000;716717            let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));718            if list_exists {719720                let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));721                let item_contains = list.iter().any(|i| i.approved == approved);722723                if !item_contains {724                    list.push(ApprovePermissions { approved: approved.clone(), amount: amount });725                    <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);726                }727            } else {728729                let mut list = Vec::new();730                list.push(ApprovePermissions { approved: approved.clone(), amount: amount });731                <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);732            }733734            Ok(())735        }736737        #[weight = 0]738        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {739740            let sender = ensure_signed(origin)?;741            let mut appoved_transfer = false;742743            // Check approve744            if <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone())) {745                let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));746                let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());747                appoved_transfer = opt_item.is_some();748                ensure!(opt_item.unwrap().amount >= value, "Requested value more than approved");749            }750751            // Transfer permissions check752            let target_collection = <Collection<T>>::get(collection_id);753            ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),754                "Only item owner, collection owner and admins can modify items");755756            if target_collection.access == AccessMode::WhiteList {757                Self::check_white_list(collection_id, sender.clone())?;758                Self::check_white_list(collection_id, recipient.clone())?;759            }760761            // remove approve762            let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))763                .into_iter().filter(|i| i.approved != sender.clone()).collect();764            <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);765766767            match target_collection.mode768            {769                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, from, recipient)?,770                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,771                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,772                _ => ()773            };774775            Ok(())776        }777778        #[weight = 0]779        pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {780781            // let no_perm_mes = "You do not have permissions to modify this collection";782            // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);783            // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));784            // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);785786            // // on_nft_received  call787788            // Self::transfer(origin, collection_id, item_id, new_owner)?;789790            Ok(())791        }792793        #[weight = 0]794        pub fn set_offchain_schema(795            origin,796            collection_id: u64,797            schema: Vec<u8>798        ) -> DispatchResult {799            let sender = ensure_signed(origin)?;800            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;801802            let mut target_collection = <Collection<T>>::get(collection_id);803            target_collection.offchain_schema = schema;804            <Collection<T>>::insert(collection_id, target_collection);805806            Ok(())807        }808809        // Sudo permissions function810        #[weight = 0]811        pub fn set_chain_limits(812            origin,813            limits: ChainLimits814        ) -> DispatchResult {815            ensure_root(origin)?;816            <ChainLimit>::put(limits);817            Ok(())818        }        819    }820}821822impl<T: Trait> Module<T> {823    fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {824        let current_index = <ItemListIndex>::get(item.collection)825            .checked_add(1)826            .expect("Item list index id error");827        let itemcopy = item.clone();828        let owner = item.owner.clone();829        let value = item.value as u64;830831        Self::add_token_index(item.collection, current_index, owner.clone())?;832833        <ItemListIndex>::insert(item.collection, current_index);834        <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);835836        // Update balance837        let new_balance = <Balance<T>>::get(item.collection, owner.clone())838            .checked_add(value)839            .unwrap();840        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);841842        Ok(())843    }844845    fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {846        let current_index = <ItemListIndex>::get(item.collection)847            .checked_add(1)848            .expect("Item list index id error");849        let itemcopy = item.clone();850851        let value = item.owner.first().unwrap().fraction as u64;852        let owner = item.owner.first().unwrap().owner.clone();853854        Self::add_token_index(item.collection, current_index, owner.clone())?;855856        <ItemListIndex>::insert(item.collection, current_index);857        <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);858859        // Update balance860        let new_balance = <Balance<T>>::get(item.collection, owner.clone())861            .checked_add(value)862            .unwrap();863        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);864865        Ok(())866    }867868    fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {869        let current_index = <ItemListIndex>::get(item.collection)870            .checked_add(1)871            .expect("Item list index id error");872873        let item_owner = item.owner.clone();874        let collection_id = item.collection.clone();875        Self::add_token_index(collection_id, current_index, item.owner.clone())?;876877        <ItemListIndex>::insert(collection_id, current_index);878        <NftItemList<T>>::insert(collection_id, current_index, item);879880        // Update balance881        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())882            .checked_add(1)883            .unwrap();884        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);885886        Ok(())887    }888889    fn burn_refungible_item(890        collection_id: u64,891        item_id: u64,892        owner: T::AccountId,893    ) -> DispatchResult {894        ensure!(895            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),896            "Item does not exists"897        );898        let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);899        let item = collection900            .owner901            .iter()902            .filter(|&i| i.owner == owner)903            .next()904            .unwrap();905        Self::remove_token_index(collection_id, item_id, owner.clone())?;906907        // remove approve list908        <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));909910        // update balance911        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())912            .checked_sub(item.fraction as u64)913            .unwrap();914        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);915916        <ReFungibleItemList<T>>::remove(collection_id, item_id);917918        Ok(())919    }920921    fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {922        ensure!(923            <NftItemList<T>>::contains_key(collection_id, item_id),924            "Item does not exists"925        );926        let item = <NftItemList<T>>::get(collection_id, item_id);927        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;928929        // remove approve list930        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));931932        // update balance933        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())934            .checked_sub(1)935            .unwrap();936        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);937        <NftItemList<T>>::remove(collection_id, item_id);938939        Ok(())940    }941942    fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {943        ensure!(944            <FungibleItemList<T>>::contains_key(collection_id, item_id),945            "Item does not exists"946        );947        let item = <FungibleItemList<T>>::get(collection_id, item_id);948        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;949950        // remove approve list951        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));952953        // update balance954        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())955            .checked_sub(item.value as u64)956            .unwrap();957        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);958959        <FungibleItemList<T>>::remove(collection_id, item_id);960961        Ok(())962    }963964    fn collection_exists(collection_id: u64) -> DispatchResult {965        ensure!(966            <Collection<T>>::contains_key(collection_id),967            "This collection does not exist"968        );969        Ok(())970    }971972    fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {973        Self::collection_exists(collection_id)?;974975        let target_collection = <Collection<T>>::get(collection_id);976        ensure!(977            subject == target_collection.owner,978            "You do not own this collection"979        );980981        Ok(())982    }983984    fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {985        let target_collection = <Collection<T>>::get(collection_id);986        let mut result: bool = subject == target_collection.owner;987        let exists = <AdminList<T>>::contains_key(collection_id);988989        if !result & exists {990            if <AdminList<T>>::get(collection_id).contains(&subject) {991                result = true992            }993        }994995        result996    }997998    fn check_owner_or_admin_permissions(999        collection_id: u64,1000        subject: T::AccountId,1001    ) -> DispatchResult {1002        Self::collection_exists(collection_id)?;1003        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());10041005        ensure!(1006            result,1007            "You do not have permissions to modify this collection"1008        );1009        Ok(())1010    }10111012    fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {1013        let target_collection = <Collection<T>>::get(collection_id);10141015        match target_collection.mode {1016            CollectionMode::NFT(_) => {1017                <NftItemList<T>>::get(collection_id, item_id).owner == subject1018            }1019            CollectionMode::Fungible(_) => {1020                <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1021            }1022            CollectionMode::ReFungible(_, _) => {1023                <ReFungibleItemList<T>>::get(collection_id, item_id)1024                    .owner1025                    .iter()1026                    .any(|i| i.owner == subject)1027            }1028            CollectionMode::Invalid => false,1029        }1030    }10311032    fn check_white_list(collection_id: u64, address: T::AccountId) -> DispatchResult {1033        let mes = "Address is not in white list";1034        ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1035        let wl = <WhiteList<T>>::get(collection_id);1036        ensure!(wl.contains(&address.clone()), mes);10371038        Ok(())1039    }10401041    fn transfer_fungible(1042        collection_id: u64,1043        item_id: u64,1044        value: u64,1045        owner: T::AccountId,1046        new_owner: T::AccountId,1047    ) -> DispatchResult {1048        ensure!(1049            <FungibleItemList<T>>::contains_key(collection_id, item_id),1050            "Item not exists"1051        );10521053        let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1054        let amount = full_item.value;10551056        ensure!(amount >= value.into(), "Item balance not enouth");10571058        // update balance1059        let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1060            .checked_sub(value)1061            .unwrap();1062        <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);10631064        let mut new_owner_account_id = 0;1065        let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());1066        if new_owner_items.len() > 0 {1067            new_owner_account_id = new_owner_items[0];1068        }10691070        let val64 = value.into();10711072        // transfer1073        if amount == val64 && new_owner_account_id == 0 {1074            // change owner1075            // new owner do not have account1076            let mut new_full_item = full_item.clone();1077            new_full_item.owner = new_owner.clone();1078            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);10791080            // update balance1081            let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1082                .checked_add(value)1083                .unwrap();1084            <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);10851086            // update index collection1087            Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1088        } else {1089            let mut new_full_item = full_item.clone();1090            new_full_item.value -= val64;10911092            // separate amount1093            if new_owner_account_id > 0 {1094                // new owner has account1095                let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1096                item.value += val64;10971098                // update balance1099                let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1100                    .checked_add(value)1101                    .unwrap();1102                <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);11031104                <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);1105            } else {1106                // new owner do not have account1107                let item = FungibleItemType {1108                    collection: collection_id,1109                    owner: new_owner.clone(),1110                    value: val64,1111                };11121113                Self::add_fungible_item(item)?;1114            }11151116            if amount == val64 {1117                Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;11181119                // remove approve list1120                <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));1121                <FungibleItemList<T>>::remove(collection_id, item_id);1122            }11231124            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1125        }11261127        Ok(())1128    }11291130    fn transfer_refungible(1131        collection_id: u64,1132        item_id: u64,1133        value: u64,1134        owner: T::AccountId,1135        new_owner: T::AccountId,1136    ) -> DispatchResult {1137        ensure!(1138            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1139            "Item not exists"1140        );11411142        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1143        let item = full_item1144            .owner1145            .iter()1146            .filter(|i| i.owner == owner)1147            .next()1148            .unwrap();1149        let amount = item.fraction;11501151        ensure!(amount >= value.into(), "Item balance not enouth");11521153        // update balance1154        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1155            .checked_sub(value)1156            .unwrap();1157        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);11581159        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1160            .checked_add(value)1161            .unwrap();1162        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);11631164        let old_owner = item.owner.clone();1165        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);1166        let val64 = value.into();11671168        // transfer1169        if amount == val64 && !new_owner_has_account {1170            // change owner1171            // new owner do not have account1172            let mut new_full_item = full_item.clone();1173            new_full_item1174                .owner1175                .iter_mut()1176                .find(|i| i.owner == owner)1177                .unwrap()1178                .owner = new_owner.clone();1179            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);11801181            // update index collection1182            Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1183        } else {1184            let mut new_full_item = full_item.clone();1185            new_full_item1186                .owner1187                .iter_mut()1188                .find(|i| i.owner == owner)1189                .unwrap()1190                .fraction -= val64;11911192            // separate amount1193            if new_owner_has_account {1194                // new owner has account1195                new_full_item1196                    .owner1197                    .iter_mut()1198                    .find(|i| i.owner == new_owner)1199                    .unwrap()1200                    .fraction += val64;1201            } else {1202                // new owner do not have account1203                new_full_item.owner.push(Ownership {1204                    owner: new_owner.clone(),1205                    fraction: val64,1206                });1207                Self::add_token_index(collection_id, item_id, new_owner.clone())?;1208            }12091210            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1211        }12121213        Ok(())1214    }12151216    fn transfer_nft(1217        collection_id: u64,1218        item_id: u64,1219        sender: T::AccountId,1220        new_owner: T::AccountId,1221    ) -> DispatchResult {1222        ensure!(1223            <NftItemList<T>>::contains_key(collection_id, item_id),1224            "Item not exists"1225        );12261227        let mut item = <NftItemList<T>>::get(collection_id, item_id);12281229        ensure!(1230            sender == item.owner,1231            "sender parameter and item owner must be equal"1232        );12331234        // update balance1235        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1236            .checked_sub(1)1237            .unwrap();1238        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);12391240        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1241            .checked_add(1)1242            .unwrap();1243        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);12441245        // change owner1246        let old_owner = item.owner.clone();1247        item.owner = new_owner.clone();1248        <NftItemList<T>>::insert(collection_id, item_id, item);12491250        // update index collection1251        Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;12521253        // reset approved list1254        <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1255        Ok(())1256    }12571258    fn init_collection(item: &CollectionType<T::AccountId>) {1259        // check params1260        assert!(1261            item.decimal_points <= 4,1262            "decimal_points parameter must be lower than 4"1263        );1264        assert!(1265            item.name.len() <= 64,1266            "Collection name can not be longer than 63 char"1267        );1268        assert!(1269            item.name.len() <= 256,1270            "Collection description can not be longer than 255 char"1271        );1272        assert!(1273            item.token_prefix.len() <= 16,1274            "Token prefix can not be longer than 15 char"1275        );12761277        // Generate next collection ID1278        let next_id = CreatedCollectionCount::get()1279            .checked_add(1)1280            .expect("collection id error");12811282        CreatedCollectionCount::put(next_id);1283    }12841285    fn init_nft_token(item: &NftItemType<T::AccountId>) {1286        let current_index = <ItemListIndex>::get(item.collection)1287            .checked_add(1)1288            .expect("Item list index id error");12891290        let item_owner = item.owner.clone();1291        let collection_id = item.collection.clone();1292        Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();12931294        <ItemListIndex>::insert(collection_id, current_index);12951296        // Update balance1297        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1298            .checked_add(1)1299            .unwrap();1300        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);1301    }13021303    fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {1304        let current_index = <ItemListIndex>::get(item.collection)1305            .checked_add(1)1306            .expect("Item list index id error");1307        let owner = item.owner.clone();1308        let value = item.value as u64;13091310        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();13111312        <ItemListIndex>::insert(item.collection, current_index);13131314        // Update balance1315        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1316            .checked_add(value)1317            .unwrap();1318        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1319    }13201321    fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {1322        let current_index = <ItemListIndex>::get(item.collection)1323            .checked_add(1)1324            .expect("Item list index id error");13251326        let value = item.owner.first().unwrap().fraction as u64;1327        let owner = item.owner.first().unwrap().owner.clone();13281329        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();13301331        <ItemListIndex>::insert(item.collection, current_index);13321333        // Update balance1334        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1335            .checked_add(value)1336            .unwrap();1337        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1338    }13391340    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {13411342        // add to account limit1343        if <AccountItemCount<T>>::contains_key(owner.clone()) {13441345            // bound Owned tokens by a single address1346            let count = <AccountItemCount<T>>::get(owner.clone());1347            ensure!(count < ChainLimit::get().account_token_ownership_limit, "Owned tokens by a single address bound exceeded");13481349            <AccountItemCount<T>>::insert(owner.clone(), 1350                count.checked_add(1).unwrap());1351        }1352        else {1353            <AccountItemCount<T>>::insert(owner.clone(), 1);1354        }13551356        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1357        if list_exists {1358            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1359            let item_contains = list.contains(&item_index.clone());13601361            if !item_contains {1362                list.push(item_index.clone());1363            }13641365            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);1366        } else {1367            let mut itm = Vec::new();1368            itm.push(item_index.clone());1369            <AddressTokens<T>>::insert(collection_id, owner, itm);1370            1371        }13721373        Ok(())1374    }13751376    fn remove_token_index(1377        collection_id: u64,1378        item_index: u64,1379        owner: T::AccountId,1380    ) -> DispatchResult {13811382        // update counter1383        <AccountItemCount<T>>::insert(owner.clone(), 1384            <AccountItemCount<T>>::get(owner.clone()).checked_sub(1).unwrap());138513861387        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1388        if list_exists {1389            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1390            let item_contains = list.contains(&item_index.clone());13911392            if item_contains {1393                list.retain(|&item| item != item_index);1394                <AddressTokens<T>>::insert(collection_id, owner, list);1395            }1396        }13971398        Ok(())1399    }14001401    fn move_token_index(1402        collection_id: u64,1403        item_index: u64,1404        old_owner: T::AccountId,1405        new_owner: T::AccountId,1406    ) -> DispatchResult {1407        Self::remove_token_index(collection_id, item_index, old_owner)?;1408        Self::add_token_index(collection_id, item_index, new_owner)?;14091410        Ok(())1411    }1412}14131414////////////////////////////////////////////////////////////////////////////////////////////////////1415// Economic models1416// #region14171418/// Fee multiplier.1419pub type Multiplier = FixedU128;14201421type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1422    <T as system::Trait>::AccountId,1423>>::Balance;1424type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1425    <T as system::Trait>::AccountId,1426>>::NegativeImbalance;14271428/// Require the transactor pay for themselves and maybe include a tip to gain additional priority1429/// in the queue.1430#[derive(Encode, Decode, Clone, Eq, PartialEq)]1431pub struct ChargeTransactionPayment<T: transaction_payment::Trait + Send + Sync>(1432    #[codec(compact)] BalanceOf<T>,1433);14341435impl<T: Trait + transaction_payment::Trait + Send + Sync> sp_std::fmt::Debug1436    for ChargeTransactionPayment<T>1437{1438    #[cfg(feature = "std")]1439    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1440        write!(f, "ChargeTransactionPayment<{:?}>", self.0)1441    }1442    #[cfg(not(feature = "std"))]1443    fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1444        Ok(())1445    }1446}14471448impl<T: Trait + transaction_payment::Trait + Send + Sync> ChargeTransactionPayment<T>1449where1450    T::Call:1451        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Module<T>, T>,1452    BalanceOf<T>: Send + Sync + FixedPointOperand,1453{1454    /// utility constructor. Used only in client/factory code.1455    pub fn from(fee: BalanceOf<T>) -> Self {1456        Self(fee)1457    }14581459    pub fn traditional_fee(1460        len: usize,1461        info: &DispatchInfoOf<T::Call>,1462        tip: BalanceOf<T>,1463    ) -> BalanceOf<T>1464    where1465        T::Call: Dispatchable<Info = DispatchInfo>,1466    {1467        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)1468    }14691470    fn withdraw_fee(1471        &self,1472        who: &T::AccountId,1473        call: &T::Call,1474        info: &DispatchInfoOf<T::Call>,1475        len: usize,1476    ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {1477        let tip = self.0;14781479        // Set fee based on call type. Creating collection costs 1 Unique.1480        // All other transactions have traditional fees so far1481        let fee = match call.is_sub_type() {1482            Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),1483            _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes1484                                                        // _ => <BalanceOf<T>>::from(100)1485        };14861487        // Determine who is paying transaction fee based on ecnomic model1488        // Parse call to extract collection ID and access collection sponsor1489        let sponsor: T::AccountId = match call.is_sub_type() {1490            Some(Call::create_item(collection_id, _properties, _owner)) => {1491                <Collection<T>>::get(collection_id).sponsor1492            }1493            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {1494                let _collection_mode = <Collection<T>>::get(collection_id).mode;14951496                // sponsor timeout1497                let sponsor_timeout = match _collection_mode {1498                    CollectionMode::NFT(_) => {1499                        let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);1500                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;1501                        let time = basket - ChainLimit::get().nft_sponsor_transfer_timeout.into() - block_number;1502                        if time <= 0.into() {1503                            <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);1504                        }1505                        time1506                    }1507                    CollectionMode::Fungible(_) => {1508                        let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);1509                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;1510                        let time: T::BlockNumber;1511                        if basket.iter().any(|i| i.address == _new_owner.clone())1512                        {1513                            let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();1514                            time = block_number - ChainLimit::get().fungible_sponsor_transfer_timeout.into() - item.start_block;1515                            if time <= 0.into() {1516                                basket.retain(|x| x.address == item.address);1517                                basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });1518                                <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);1519                            }1520                        }1521                        else {1522                            time = block_number;1523                            basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});1524                        }15251526                        time1527                    }1528                    CollectionMode::ReFungible(_, _) => {1529                        let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);1530                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;1531                        let time = basket - ChainLimit::get().refungible_sponsor_transfer_timeout.into() - block_number;1532                        if time <= 0.into() {1533                            <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);1534                        }1535                        time1536                    }1537                    _ => {1538                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;1539                        block_number1540                    },1541                };15421543                if sponsor_timeout > 0.into() {1544                    T::AccountId::default()1545                } else {1546                    <Collection<T>>::get(collection_id).sponsor1547                }1548            }15491550            _ => T::AccountId::default(),1551        };15521553        let mut who_pays_fee: T::AccountId = sponsor.clone();1554        if sponsor == T::AccountId::default() {1555            who_pays_fee = who.clone();1556        }15571558        // Only mess with balances if fee is not zero.1559        if fee.is_zero() {1560            return Ok((fee, None));1561        }15621563        match <T as transaction_payment::Trait>::Currency::withdraw(1564            &who_pays_fee,1565            fee,1566            if tip.is_zero() {1567                WithdrawReason::TransactionPayment.into()1568            } else {1569                WithdrawReason::TransactionPayment | WithdrawReason::Tip1570            },1571            ExistenceRequirement::KeepAlive,1572        ) {1573            Ok(imbalance) => Ok((fee, Some(imbalance))),1574            Err(_) => Err(InvalidTransaction::Payment.into()),1575        }1576    }1577}15781579impl<T: Trait + transaction_payment::Trait + Send + Sync> SignedExtension1580    for ChargeTransactionPayment<T>1581where1582    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,1583    T::Call:1584        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Module<T>, T>,1585{1586    const IDENTIFIER: &'static str = "ChargeTransactionPayment";1587    type AccountId = T::AccountId;1588    type Call = T::Call;1589    type AdditionalSigned = ();1590    type Pre = (1591        BalanceOf<T>,1592        Self::AccountId,1593        Option<NegativeImbalanceOf<T>>,1594        BalanceOf<T>,1595    );1596    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {1597        Ok(())1598    }15991600    fn validate(1601        &self,1602        who: &Self::AccountId,1603        call: &Self::Call,1604        info: &DispatchInfoOf<Self::Call>,1605        len: usize,1606    ) -> TransactionValidity {1607        let (fee, _) = self.withdraw_fee(who, call, info, len)?;16081609        let mut r = ValidTransaction::default();1610        // NOTE: we probably want to maximize the _fee (of any type) per weight unit_ here, which1611        // will be a bit more than setting the priority to tip. For now, this is enough.1612        r.priority = fee.saturated_into::<TransactionPriority>();1613        Ok(r)1614    }16151616    fn pre_dispatch(1617        self,1618        who: &Self::AccountId,1619        call: &Self::Call,1620        info: &DispatchInfoOf<Self::Call>,1621        len: usize,1622    ) -> Result<Self::Pre, TransactionValidityError> {1623        let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;1624        Ok((self.0, who.clone(), imbalance, fee))1625    }16261627    fn post_dispatch(1628        pre: Self::Pre,1629        info: &DispatchInfoOf<Self::Call>,1630        post_info: &PostDispatchInfoOf<Self::Call>,1631        len: usize,1632        _result: &DispatchResult,1633    ) -> Result<(), TransactionValidityError> {1634        let (tip, who, imbalance, fee) = pre;1635        if let Some(payed) = imbalance {1636            let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(1637                len as u32, info, post_info, tip,1638            );1639            let refund = fee.saturating_sub(actual_fee);1640            let actual_payment =1641                match <T as transaction_payment::Trait>::Currency::deposit_into_existing(1642                    &who, refund,1643                ) {1644                    Ok(refund_imbalance) => {1645                        // The refund cannot be larger than the up front payed max weight.1646                        // `PostDispatchInfo::calc_unspent` guards against such a case.1647                        match payed.offset(refund_imbalance) {1648                            Ok(actual_payment) => actual_payment,1649                            Err(_) => return Err(InvalidTransaction::Payment.into()),1650                        }1651                    }1652                    // We do not recreate the account using the refund. The up front payment1653                    // is gone in that case.1654                    Err(_) => payed,1655                };1656            let imbalances = actual_payment.split(tip);1657            <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(1658                Some(imbalances.0).into_iter().chain(Some(imbalances.1)),1659            );1660        }1661        Ok(())1662    }1663}1664// #endregion