git.delta.rocks / unique-network / refs/commits / 96b20f2918fb

1#![cfg_attr(not(feature = "std"), no_std)]23/// For more guidance on Substrate FRAME, see the example pallet4/// https://github.com/paritytech/substrate/blob/master/frame/example/src/lib.rs5use codec::{Decode, Encode};6pub use frame_support::{7    construct_runtime, decl_event, decl_module, decl_storage,8    dispatch::DispatchResult,9    ensure, parameter_types,10    traits::{11        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,12        Randomness, WithdrawReason,13    },14    weights::{15        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},16        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,17        WeightToFeePolynomial,18    },19    IsSubType, StorageValue,20};2122use frame_system::{self as system, ensure_signed};23use sp_runtime::sp_std::prelude::Vec;24use sp_runtime::{25    traits::{26        DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SaturatedConversion, Saturating,27        SignedExtension, Zero,28    },29    transaction_validity::{30        InvalidTransaction, TransactionPriority, TransactionValidity, TransactionValidityError,31        ValidTransaction,32    },33    FixedPointOperand, FixedU128,34};35use sp_std::prelude::*;3637#[cfg(test)]38mod mock;3940#[cfg(test)]41mod tests;4243#[derive(Encode, Decode, Debug, Eq, Clone, PartialEq)]44pub enum CollectionMode {45    Invalid,46    // custom data size47    NFT(u32),48    // decimal points49    Fungible(u32),50    // custom data size and decimal points51    ReFungible(u32, u32),52}5354impl Into<u8> for CollectionMode {55    fn into(self) -> u8 {56        match self {57            CollectionMode::Invalid => 0,58            CollectionMode::NFT(_) => 1,59            CollectionMode::Fungible(_) => 2,60            CollectionMode::ReFungible(_, _) => 3,61        }62    }63}6465#[derive(Encode, Decode, Debug, Clone, PartialEq)]66pub enum AccessMode {67    Normal,68    WhiteList,69}70impl Default for AccessMode {71    fn default() -> Self {72        Self::Normal73    }74}7576impl Default for CollectionMode {77    fn default() -> Self {78        Self::Invalid79    }80}8182#[derive(Encode, Decode, Default, Clone, PartialEq)]83#[cfg_attr(feature = "std", derive(Debug))]84pub struct Ownership<AccountId> {85    pub owner: AccountId,86    pub fraction: u128,87}8889#[derive(Encode, Decode, Default, Clone, PartialEq)]90#[cfg_attr(feature = "std", derive(Debug))]91pub struct CollectionType<AccountId> {92    pub owner: AccountId,93    pub mode: CollectionMode,94    pub access: AccessMode,95    pub decimal_points: u32,96    pub name: Vec<u16>,        // 64 include null escape char97    pub description: Vec<u16>, // 256 include null escape char98    pub token_prefix: Vec<u8>, // 16 include null escape char99    pub custom_data_size: u32,100    pub offchain_schema: Vec<u8>,101    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender102    pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship103}104105#[derive(Encode, Decode, Default, Clone, PartialEq)]106#[cfg_attr(feature = "std", derive(Debug))]107pub struct CollectionAdminsType<AccountId> {108    pub admin: AccountId,109    pub collection_id: u64,110}111112#[derive(Encode, Decode, Default, Clone, PartialEq)]113#[cfg_attr(feature = "std", derive(Debug))]114pub struct NftItemType<AccountId> {115    pub collection: u64,116    pub owner: AccountId,117    pub data: Vec<u8>,118}119120#[derive(Encode, Decode, Default, Clone, PartialEq)]121#[cfg_attr(feature = "std", derive(Debug))]122pub struct FungibleItemType<AccountId> {123    pub collection: u64,124    pub owner: AccountId,125    pub value: u128,126}127128#[derive(Encode, Decode, Default, Clone, PartialEq)]129#[cfg_attr(feature = "std", derive(Debug))]130pub struct ReFungibleItemType<AccountId> {131    pub collection: u64,132    pub owner: Vec<Ownership<AccountId>>,133    pub data: Vec<u8>,134}135136#[derive(Encode, Decode, Default, Clone, PartialEq)]137#[cfg_attr(feature = "std", derive(Debug))]138pub struct ApprovePermissions<AccountId> {139    pub approved: AccountId,140    pub amount: u64,141}142143#[derive(Encode, Decode, Default, Clone, PartialEq)]144#[cfg_attr(feature = "std", derive(Debug))]145pub struct VestingItem<AccountId, Moment> {146    pub sender: AccountId,147    pub recipient: AccountId,148    pub collection_id: u64,149    pub item_id: u64,150    pub amount: u64,151    pub vesting_date: Moment,152}153154pub trait Trait: system::Trait {155    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;156}157158decl_storage! {159    trait Store for Module<T: Trait> as Nft {160161        // Private members162        NextCollectionID: u64;163        ItemListIndex: map hasher(blake2_128_concat) u64 => u64;164165        pub Collection get(fn collection): map hasher(identity) u64 => CollectionType<T::AccountId>;166        pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;167        pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;168169        /// Balance owner per collection map170        pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;171172        /// second parameter: item id + owner account id173        pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;174175        /// Item collections176        pub NftItemList get(fn nft_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;177        pub FungibleItemList get(fn fungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;178        pub ReFungibleItemList get(fn refungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;179180        // Active vesting list181        // pub VestingList get(fn vesting): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => VestingItem<T::AccountId, T::Moment>;182183        /// Index list184        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;185186        // Sponsorship187        pub ContractSponsor get(fn contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;188        pub UnconfirmedContractSponsor get(fn unconfirmed_contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;189    }190}191192decl_event!(193    pub enum Event<T>194    where195        AccountId = <T as system::Trait>::AccountId,196    {197        Created(u64, u8, AccountId),198        ItemCreated(u64, u64),199        ItemDestroyed(u64, u64),200    }201);202203decl_module! {204    pub struct Module<T: Trait> for enum Call where origin: T::Origin {205206        fn deposit_event() = default;207208        // Create collection of NFT with given parameters209        //210        // @param customDataSz size of custom data in each collection item211        // returns collection ID212        #[weight = 0]213        pub fn create_collection(   origin,214                                    collection_name: Vec<u16>,215                                    collection_description: Vec<u16>,216                                    token_prefix: Vec<u8>,217                                    mode: CollectionMode) -> DispatchResult {218219            // Anyone can create a collection220            let who = ensure_signed(origin)?;221            let custom_data_size = match mode {222                CollectionMode::NFT(size) => size,223                CollectionMode::ReFungible(size, _) => size,224                _ => 0225            };226227            let decimal_points = match mode {228                CollectionMode::Fungible(points) => points,229                CollectionMode::ReFungible(_, points) => points,230                _ => 0231            };232233            // check params234            ensure!(decimal_points <= 4, "decimal_points parameter must be lower than 4");235236            let mut name = collection_name.to_vec();237            name.push(0);238            ensure!(name.len() <= 64, "Collection name can not be longer than 63 char");239240            let mut description = collection_description.to_vec();241            description.push(0);242            ensure!(name.len() <= 256, "Collection description can not be longer than 255 char");243244            let mut prefix = token_prefix.to_vec();245            prefix.push(0);246            ensure!(prefix.len() <= 16, "Token prefix can not be longer than 15 char");247248            // Generate next collection ID249            let next_id = NextCollectionID::get()250                .checked_add(1)251                .expect("collection id error");252253            NextCollectionID::put(next_id);254255            // Create new collection256            let new_collection = CollectionType {257                owner: who.clone(),258                name: name,259                mode: mode.clone(),260                access: AccessMode::Normal,261                description: description,262                decimal_points: decimal_points,263                token_prefix: prefix,264                offchain_schema: Vec::new(),265                custom_data_size: custom_data_size,266                sponsor: T::AccountId::default(),267                unconfirmed_sponsor: T::AccountId::default(),268            };269270            // Add new collection to map271            <Collection<T>>::insert(next_id, new_collection);272273            // call event274            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));275276            Ok(())277        }278279        #[weight = 0]280        pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {281282            let sender = ensure_signed(origin)?;283            Self::check_owner_permissions(collection_id, sender)?;284285            // TODO Items remove286            <AddressTokens<T>>::remove_prefix(collection_id);287            <ApprovedList<T>>::remove_prefix(collection_id);288            <Balance<T>>::remove_prefix(collection_id);289            <ItemListIndex>::remove(collection_id);290            <AdminList<T>>::remove(collection_id);291            <Collection<T>>::remove(collection_id);292            <WhiteList<T>>::remove(collection_id);293294            Ok(())295        }296297        #[weight = 0]298        pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {299300            let sender = ensure_signed(origin)?;301            Self::check_owner_permissions(collection_id, sender)?;302            let mut target_collection = <Collection<T>>::get(collection_id);303            target_collection.owner = new_owner;304            <Collection<T>>::insert(collection_id, target_collection);305306            Ok(())307        }308309        #[weight = 0]310        pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {311312            let sender = ensure_signed(origin)?;313            Self::check_owner_or_admin_permissions(collection_id, sender)?;314            let mut admin_arr: Vec<T::AccountId> = Vec::new();315316            if <AdminList<T>>::contains_key(collection_id)317            {318                admin_arr = <AdminList<T>>::get(collection_id);319                ensure!(!admin_arr.contains(&new_admin_id), "Account already has admin role");320            }321322            admin_arr.push(new_admin_id);323            <AdminList<T>>::insert(collection_id, admin_arr);324325            Ok(())326        }327328        #[weight = 0]329        pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {330331            let sender = ensure_signed(origin)?;332            Self::check_owner_or_admin_permissions(collection_id, sender)?;333334            if <AdminList<T>>::contains_key(collection_id)335            {336                let mut admin_arr = <AdminList<T>>::get(collection_id);337                admin_arr.retain(|i| *i != account_id);338                <AdminList<T>>::insert(collection_id, admin_arr);339            }340341            Ok(())342        }343344        #[weight = 0]345        pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {346347            let sender = ensure_signed(origin)?;348            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");349350            let mut target_collection = <Collection<T>>::get(collection_id);351            ensure!(sender == target_collection.owner, "You do not own this collection");352353            target_collection.unconfirmed_sponsor = new_sponsor;354            <Collection<T>>::insert(collection_id, target_collection);355356            Ok(())357        }358359        #[weight = 0]360        pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {361362            let sender = ensure_signed(origin)?;363            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");364365            let mut target_collection = <Collection<T>>::get(collection_id);366            ensure!(sender == target_collection.unconfirmed_sponsor, "This address is not set as sponsor, use setCollectionSponsor first");367368            target_collection.sponsor = target_collection.unconfirmed_sponsor;369            target_collection.unconfirmed_sponsor = T::AccountId::default();370            <Collection<T>>::insert(collection_id, target_collection);371372            Ok(())373        }374375        #[weight = 0]376        pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {377378            let sender = ensure_signed(origin)?;379            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");380381            let mut target_collection = <Collection<T>>::get(collection_id);382            ensure!(sender == target_collection.owner, "You do not own this collection");383384            target_collection.sponsor = T::AccountId::default();385            <Collection<T>>::insert(collection_id, target_collection);386387            Ok(())388        }389390        #[weight = 0]391        pub fn create_item(origin, collection_id: u64, properties: Vec<u8>, owner: T::AccountId) -> DispatchResult {392393            let sender = ensure_signed(origin)?;394            let target_collection = <Collection<T>>::get(collection_id);395            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;396397            match target_collection.mode398            {399                CollectionMode::NFT(_) => {400401                    // check size402                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");403404                    // Create nft item405                    let item = NftItemType {406                        collection: collection_id,407                        owner: owner,408                        data: properties,409                    };410411                    Self::add_nft_item(item)?;412413                },414                CollectionMode::Fungible(_) => {415416                    // check size417                    ensure!(properties.len() as u32 == 0, "Size of item must be 0 with fungible type");418419                    let item = FungibleItemType {420                        collection: collection_id,421                        owner: owner,422                        value: (10 as u128).pow(target_collection.decimal_points)423                    };424425                    Self::add_fungible_item(item)?;426                },427                CollectionMode::ReFungible(_, _) => {428429                    // check size430                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");431432                    let mut owner_list = Vec::new();433                    let value = (10 as u128).pow(target_collection.decimal_points);434                    owner_list.push(Ownership {owner: owner, fraction: value});435436                    let item = ReFungibleItemType {437                        collection: collection_id,438                        owner: owner_list,439                        data: properties440                    };441442                    Self::add_refungible_item(item)?;443                },444                _ => ()445            };446447            // call event448            Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));449450            Ok(())451        }452453        #[weight = 0]454        pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {455456            let sender = ensure_signed(origin)?;457            let item_owner = Self::is_item_owner(sender.clone(), collection_id, item_id);458            if !item_owner459            {460                Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;461            }462            let target_collection = <Collection<T>>::get(collection_id);463464            match target_collection.mode465            {466                CollectionMode::NFT(_) => Self::burn_nft_item(collection_id, item_id)?,467                CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,468                CollectionMode::ReFungible(_, _)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,469                _ => ()470            };471472            // call event473            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));474475            Ok(())476        }477478        #[weight = 0]479        pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {480481            let sender = ensure_signed(origin)?;482            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id), "Only item owner can call transfer method");483484            let target_collection = <Collection<T>>::get(collection_id);485486            // TODO: implement other modes487            match target_collection.mode488            {489                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,490                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,491                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,492                _ => ()493            };494495            Ok(())496        }497498        #[weight = 0]499        pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {500501            let sender = ensure_signed(origin)?;502503            // amount param stub504            let amount = 100000000;505506            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id), "Only item owner can call transfer method");507508            let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));509            if list_exists {510511                let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));512                let item_contains = list.iter().any(|i| i.approved == approved);513514                if !item_contains {515                    list.push(ApprovePermissions { approved: approved.clone(), amount: amount });516                    <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);517                }518            } else {519520                let mut list = Vec::new();521                list.push(ApprovePermissions { approved: approved.clone(), amount: amount });522                <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);523            }524525            Ok(())526        }527528        #[weight = 0]529        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {530531            let sender = ensure_signed(origin)?;532            let approved_list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone()));533            if approved_list_exists534            {535                let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));536                let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());537                ensure!(opt_item.is_some(), "No approve found");538                ensure!(opt_item.unwrap().amount >= value, "Requested value more than approved");539540                // remove approve541                let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))542                    .into_iter().filter(|i| i.approved != sender.clone()).collect();543                <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);544            }545            else546            {547                Self::check_owner_or_admin_permissions(collection_id, sender)?;548            }549550            let target_collection = <Collection<T>>::get(collection_id);551552            match target_collection.mode553            {554                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, from, recipient)?,555                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,556                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,557                _ => ()558            };559560            Ok(())561        }562563        #[weight = 0]564        pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {565566            // let no_perm_mes = "You do not have permissions to modify this collection";567            // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);568            // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));569            // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);570571            // // on_nft_received  call572573            // Self::transfer(origin, collection_id, item_id, new_owner)?;574575            Ok(())576        }577578        #[weight = 0]579        pub fn set_offchain_schema(580            origin,581            collection_id: u64,582            schema: Vec<u8>583        ) -> DispatchResult {584            let sender = ensure_signed(origin)?;585            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;586587            let mut target_collection = <Collection<T>>::get(collection_id);588            target_collection.offchain_schema = schema;589            <Collection<T>>::insert(collection_id, target_collection);590591            Ok(())592        }593    }594}595596impl<T: Trait> Module<T> {597    fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {598        let current_index = <ItemListIndex>::get(item.collection)599            .checked_add(1)600            .expect("Item list index id error");601        let itemcopy = item.clone();602        let owner = item.owner.clone();603        let value = item.value as u64;604605        Self::add_token_index(item.collection, current_index, owner.clone())?;606607        <ItemListIndex>::insert(item.collection, current_index);608        <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);609610        // Update balance611        let new_balance = <Balance<T>>::get(item.collection, owner.clone())612            .checked_add(value)613            .unwrap();614        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);615616        Ok(())617    }618619    fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {620        let current_index = <ItemListIndex>::get(item.collection)621            .checked_add(1)622            .expect("Item list index id error");623        let itemcopy = item.clone();624625        let value = item.owner.first().unwrap().fraction as u64;626        let owner = item.owner.first().unwrap().owner.clone();627628        Self::add_token_index(item.collection, current_index, owner.clone())?;629630        <ItemListIndex>::insert(item.collection, current_index);631        <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);632633        // Update balance634        let new_balance = <Balance<T>>::get(item.collection, owner.clone())635            .checked_add(value)636            .unwrap();637        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);638639        Ok(())640    }641642    fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {643        let current_index = <ItemListIndex>::get(item.collection)644            .checked_add(1)645            .expect("Item list index id error");646647        let item_owner = item.owner.clone();648        let collection_id = item.collection.clone();649        Self::add_token_index(collection_id, current_index, item.owner.clone())?;650651        <ItemListIndex>::insert(collection_id, current_index);652        <NftItemList<T>>::insert(collection_id, current_index, item);653654        // Update balance655        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())656            .checked_add(1)657            .unwrap();658        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);659660        Ok(())661    }662663    fn burn_refungible_item(664        collection_id: u64,665        item_id: u64,666        owner: T::AccountId,667    ) -> DispatchResult {668        ensure!(669            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),670            "Item does not exists"671        );672        let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);673        let item = collection674            .owner675            .iter()676            .filter(|&i| i.owner == owner)677            .next()678            .unwrap();679        Self::remove_token_index(collection_id, item_id, owner.clone())?;680681        // remove approve list682        <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));683684        // update balance685        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())686            .checked_sub(item.fraction as u64)687            .unwrap();688        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);689690        <ReFungibleItemList<T>>::remove(collection_id, item_id);691692        Ok(())693    }694695    fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {696        ensure!(697            <NftItemList<T>>::contains_key(collection_id, item_id),698            "Item does not exists"699        );700        let item = <NftItemList<T>>::get(collection_id, item_id);701        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;702703        // remove approve list704        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));705706        // update balance707        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())708            .checked_sub(1)709            .unwrap();710        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);711        <NftItemList<T>>::remove(collection_id, item_id);712713        Ok(())714    }715716    fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {717        ensure!(718            <FungibleItemList<T>>::contains_key(collection_id, item_id),719            "Item does not exists"720        );721        let item = <FungibleItemList<T>>::get(collection_id, item_id);722        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;723724        // remove approve list725        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));726727        // update balance728        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())729            .checked_sub(item.value as u64)730            .unwrap();731        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);732733        <FungibleItemList<T>>::remove(collection_id, item_id);734735        Ok(())736    }737738    fn collection_exists(collection_id: u64) -> DispatchResult {739        ensure!(740            <Collection<T>>::contains_key(collection_id),741            "This collection does not exist"742        );743        Ok(())744    }745746    fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {747        Self::collection_exists(collection_id)?;748749        let target_collection = <Collection<T>>::get(collection_id);750        ensure!(751            subject == target_collection.owner,752            "You do not own this collection"753        );754755        Ok(())756    }757758    fn check_owner_or_admin_permissions(759        collection_id: u64,760        subject: T::AccountId,761    ) -> DispatchResult {762        Self::collection_exists(collection_id)?;763764        let target_collection = <Collection<T>>::get(collection_id);765        let is_owner = subject == target_collection.owner;766767        let no_perm_mes = "You do not have permissions to modify this collection";768        let exists = <AdminList<T>>::contains_key(collection_id);769770        if !is_owner {771            ensure!(exists, no_perm_mes);772            ensure!(773                <AdminList<T>>::get(collection_id).contains(&subject),774                no_perm_mes775            );776        }777        Ok(())778    }779780    fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {781        let target_collection = <Collection<T>>::get(collection_id);782783        match target_collection.mode {784            CollectionMode::NFT(_) => {785                <NftItemList<T>>::get(collection_id, item_id).owner == subject786            }787            CollectionMode::Fungible(_) => {788                <FungibleItemList<T>>::get(collection_id, item_id).owner == subject789            }790            CollectionMode::ReFungible(_, _) => {791                <ReFungibleItemList<T>>::get(collection_id, item_id)792                    .owner793                    .iter()794                    .any(|i| i.owner == subject)795            }796            CollectionMode::Invalid => false,797        }798    }799800    fn transfer_fungible(801        collection_id: u64,802        item_id: u64,803        value: u64,804        owner: T::AccountId,805        new_owner: T::AccountId,806    ) -> DispatchResult {807        let full_item = <FungibleItemList<T>>::get(collection_id, item_id);808        let amount = full_item.value;809810        ensure!(amount >= value.into(), "Item balance not enouth");811812        // update balance813        let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())814            .checked_sub(value)815            .unwrap();816        <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);817818        let mut new_owner_account_id = 0;819        let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());820        if new_owner_items.len() > 0 {821            new_owner_account_id = new_owner_items[0];822        }823824        let val64 = value.into();825826        // transfer827        if amount == val64 && new_owner_account_id == 0 {828            // change owner829            // new owner do not have account830            let mut new_full_item = full_item.clone();831            new_full_item.owner = new_owner.clone();832            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);833834            // update balance835            let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())836                .checked_add(value)837                .unwrap();838            <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);839840            // update index collection841            Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;842        } else {843            let mut new_full_item = full_item.clone();844            new_full_item.value -= val64;845846            // separate amount847            if new_owner_account_id > 0 {848                // new owner has account849                let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);850                item.value += val64;851852                // update balance853                let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())854                    .checked_add(value)855                    .unwrap();856                <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);857858                <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);859            } else {860                // new owner do not have account861                let item = FungibleItemType {862                    collection: collection_id,863                    owner: new_owner.clone(),864                    value: val64,865                };866867                Self::add_fungible_item(item)?;868            }869870            if amount == val64 {871                Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;872873                // remove approve list874                <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));875                <FungibleItemList<T>>::remove(collection_id, item_id);876            }877878            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);879        }880881        Ok(())882    }883884    fn transfer_refungible(885        collection_id: u64,886        item_id: u64,887        value: u64,888        owner: T::AccountId,889        new_owner: T::AccountId,890    ) -> DispatchResult {891        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);892        let item = full_item893            .owner894            .iter()895            .filter(|i| i.owner == owner)896            .next()897            .unwrap();898        let amount = item.fraction;899900        ensure!(amount >= value.into(), "Item balance not enouth");901902        // update balance903        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())904            .checked_sub(value)905            .unwrap();906        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);907908        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())909            .checked_add(value)910            .unwrap();911        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);912913        let old_owner = item.owner.clone();914        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);915        let val64 = value.into();916917        // transfer918        if amount == val64 && !new_owner_has_account {919            // change owner920            // new owner do not have account921            let mut new_full_item = full_item.clone();922            new_full_item923                .owner924                .iter_mut()925                .find(|i| i.owner == owner)926                .unwrap()927                .owner = new_owner.clone();928            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);929930            // update index collection931            Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;932        } else {933            let mut new_full_item = full_item.clone();934            new_full_item935                .owner936                .iter_mut()937                .find(|i| i.owner == owner)938                .unwrap()939                .fraction -= val64;940941            // separate amount942            if new_owner_has_account {943                // new owner has account944                new_full_item945                    .owner946                    .iter_mut()947                    .find(|i| i.owner == new_owner)948                    .unwrap()949                    .fraction += val64;950            } else {951                // new owner do not have account952                new_full_item.owner.push(Ownership {953                    owner: new_owner.clone(),954                    fraction: val64,955                });956                Self::add_token_index(collection_id, item_id, new_owner.clone())?;957            }958959            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);960        }961962        Ok(())963    }964965    fn transfer_nft(966        collection_id: u64,967        item_id: u64,968        sender: T::AccountId,969        new_owner: T::AccountId,970    ) -> DispatchResult {971        let mut item = <NftItemList<T>>::get(collection_id, item_id);972973        ensure!(974            sender == item.owner,975            "sender parameter and item owner must be equal"976        );977978        // update balance979        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())980            .checked_sub(1)981            .unwrap();982        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);983984        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())985            .checked_add(1)986            .unwrap();987        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);988989        // change owner990        let old_owner = item.owner.clone();991        item.owner = new_owner.clone();992        <NftItemList<T>>::insert(collection_id, item_id, item);993994        // update index collection995        Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;996997        // reset approved list998        <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));999        Ok(())1000    }10011002    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {1003        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1004        if list_exists {1005            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1006            let item_contains = list.contains(&item_index.clone());10071008            if !item_contains {1009                list.push(item_index.clone());1010            }10111012            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);1013        } else {1014            let mut itm = Vec::new();1015            itm.push(item_index.clone());1016            <AddressTokens<T>>::insert(collection_id, owner, itm);1017        }10181019        Ok(())1020    }10211022    fn remove_token_index(1023        collection_id: u64,1024        item_index: u64,1025        owner: T::AccountId,1026    ) -> DispatchResult {1027        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1028        if list_exists {1029            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1030            let item_contains = list.contains(&item_index.clone());10311032            if item_contains {1033                list.retain(|&item| item != item_index);1034                <AddressTokens<T>>::insert(collection_id, owner, list);1035            }1036        }10371038        Ok(())1039    }10401041    fn move_token_index(1042        collection_id: u64,1043        item_index: u64,1044        old_owner: T::AccountId,1045        new_owner: T::AccountId,1046    ) -> DispatchResult {1047        Self::remove_token_index(collection_id, item_index, old_owner)?;1048        Self::add_token_index(collection_id, item_index, new_owner)?;10491050        Ok(())1051    }1052}10531054////////////////////////////////////////////////////////////////////////////////////////////////////1055// Economic models10561057/// Fee multiplier.1058pub type Multiplier = FixedU128;10591060type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1061    <T as system::Trait>::AccountId,1062>>::Balance;1063type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1064    <T as system::Trait>::AccountId,1065>>::NegativeImbalance;10661067/// Require the transactor pay for themselves and maybe include a tip to gain additional priority1068/// in the queue.1069#[derive(Encode, Decode, Clone, Eq, PartialEq)]1070pub struct ChargeTransactionPayment<T: transaction_payment::Trait + Send + Sync>(1071    #[codec(compact)] BalanceOf<T>,1072);10731074impl<T: Trait + transaction_payment::Trait + Send + Sync> sp_std::fmt::Debug1075    for ChargeTransactionPayment<T>1076{1077    #[cfg(feature = "std")]1078    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1079        write!(f, "ChargeTransactionPayment<{:?}>", self.0)1080    }1081    #[cfg(not(feature = "std"))]1082    fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1083        Ok(())1084    }1085}10861087impl<T: Trait + transaction_payment::Trait + Send + Sync> ChargeTransactionPayment<T>1088where1089    T::Call:1090        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Module<T>, T>,1091    BalanceOf<T>: Send + Sync + FixedPointOperand,1092{1093    /// utility constructor. Used only in client/factory code.1094    pub fn from(fee: BalanceOf<T>) -> Self {1095        Self(fee)1096    }10971098    pub fn traditional_fee(1099        len: usize,1100        info: &DispatchInfoOf<T::Call>,1101        tip: BalanceOf<T>,1102    ) -> BalanceOf<T>1103    where1104        T::Call: Dispatchable<Info = DispatchInfo>,1105    {1106        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)1107    }11081109    fn withdraw_fee(1110        &self,1111        who: &T::AccountId,1112        call: &T::Call,1113        info: &DispatchInfoOf<T::Call>,1114        len: usize,1115    ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {1116        let tip = self.0;11171118        // Set fee based on call type. Creating collection costs 1 Unique.1119        // All other transactions have traditional fees so far1120        let fee = match call.is_sub_type() {1121            Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),1122            _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes1123                                                        // _ => <BalanceOf<T>>::from(100)1124        };11251126        // Determine who is paying transaction fee based on ecnomic model1127        // Parse call to extract collection ID and access collection sponsor1128        let sponsor: T::AccountId = match call.is_sub_type() {1129            Some(Call::create_item(collection_id, _properties, _owner)) => {1130                <Collection<T>>::get(collection_id).sponsor1131            }1132            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {1133                <Collection<T>>::get(collection_id).sponsor1134            }11351136            _ => T::AccountId::default(),1137        };11381139        let mut who_pays_fee: T::AccountId = sponsor.clone();1140        if sponsor == T::AccountId::default() {1141            who_pays_fee = who.clone();1142        }11431144        // Only mess with balances if fee is not zero.1145        if fee.is_zero() {1146            return Ok((fee, None));1147        }11481149        match <T as transaction_payment::Trait>::Currency::withdraw(1150            &who_pays_fee,1151            fee,1152            if tip.is_zero() {1153                WithdrawReason::TransactionPayment.into()1154            } else {1155                WithdrawReason::TransactionPayment | WithdrawReason::Tip1156            },1157            ExistenceRequirement::KeepAlive,1158        ) {1159            Ok(imbalance) => Ok((fee, Some(imbalance))),1160            Err(_) => Err(InvalidTransaction::Payment.into()),1161        }1162    }1163}11641165impl<T: Trait + transaction_payment::Trait + Send + Sync> SignedExtension1166    for ChargeTransactionPayment<T>1167where1168    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,1169    T::Call:1170        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Module<T>, T>,1171{1172    const IDENTIFIER: &'static str = "ChargeTransactionPayment";1173    type AccountId = T::AccountId;1174    type Call = T::Call;1175    type AdditionalSigned = ();1176    type Pre = (1177        BalanceOf<T>,1178        Self::AccountId,1179        Option<NegativeImbalanceOf<T>>,1180        BalanceOf<T>,1181    );1182    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {1183        Ok(())1184    }11851186    fn validate(1187        &self,1188        who: &Self::AccountId,1189        call: &Self::Call,1190        info: &DispatchInfoOf<Self::Call>,1191        len: usize,1192    ) -> TransactionValidity {1193        let (fee, _) = self.withdraw_fee(who, call, info, len)?;11941195        let mut r = ValidTransaction::default();1196        // NOTE: we probably want to maximize the _fee (of any type) per weight unit_ here, which1197        // will be a bit more than setting the priority to tip. For now, this is enough.1198        r.priority = fee.saturated_into::<TransactionPriority>();1199        Ok(r)1200    }12011202    fn pre_dispatch(1203        self,1204        who: &Self::AccountId,1205        call: &Self::Call,1206        info: &DispatchInfoOf<Self::Call>,1207        len: usize,1208    ) -> Result<Self::Pre, TransactionValidityError> {1209        let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;1210        Ok((self.0, who.clone(), imbalance, fee))1211    }12121213    fn post_dispatch(1214        pre: Self::Pre,1215        info: &DispatchInfoOf<Self::Call>,1216        post_info: &PostDispatchInfoOf<Self::Call>,1217        len: usize,1218        _result: &DispatchResult,1219    ) -> Result<(), TransactionValidityError> {1220        let (tip, who, imbalance, fee) = pre;1221        if let Some(payed) = imbalance {1222            let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(1223                len as u32, info, post_info, tip,1224            );1225            let refund = fee.saturating_sub(actual_fee);1226            let actual_payment =1227                match <T as transaction_payment::Trait>::Currency::deposit_into_existing(1228                    &who, refund,1229                ) {1230                    Ok(refund_imbalance) => {1231                        // The refund cannot be larger than the up front payed max weight.1232                        // `PostDispatchInfo::calc_unspent` guards against such a case.1233                        match payed.offset(refund_imbalance) {1234                            Ok(actual_payment) => actual_payment,1235                            Err(_) => return Err(InvalidTransaction::Payment.into()),1236                        }1237                    }1238                    // We do not recreate the account using the refund. The up front payment1239                    // is gone in that case.1240                    Err(_) => payed,1241                };1242            let imbalances = actual_payment.split(tip);1243            <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(1244                Some(imbalances.0).into_iter().chain(Some(imbalances.1)),1245            );1246        }1247        Ok(())1248    }1249}