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

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        /// New collection was created262        /// 263        /// # Arguments264        /// 265        /// * collection_id: Globally unique identifier of newly created collection.266        /// 267        /// * mode: [CollectionMode] converted into u8.268        /// 269        /// * account_id: Collection owner.270        Created(u64, u8, AccountId),271272        /// New item was created.273        /// 274        /// # Arguments275        /// 276        /// * collection_id: Id of the collection where item was created.277        /// 278        /// * item_id: Id of an item. Unique within the collection.279        ItemCreated(u64, u64),280281        /// Collection item was burned.282        /// 283        /// # Arguments284        /// 285        /// collection_id.286        /// 287        /// item_id: Identifier of burned NFT.288        ItemDestroyed(u64, u64),289    }290);291292decl_module! {293    pub struct Module<T: Trait> for enum Call where origin: T::Origin {294295        fn deposit_event() = default;296297        fn on_initialize(now: T::BlockNumber) -> Weight {298299            if ChainVersion::get() < 2300            {301                let value = NextCollectionID::get();302                CreatedCollectionCount::put(value);303                ChainVersion::put(2);304            }305306            0307        }308309        /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.310        /// 311        /// # Permissions312        /// 313        /// * Anyone.314        /// 315        /// # Arguments316        /// 317        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.318        /// 319        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.320        /// 321        /// * token_prefix: UTF-8 string with token prefix.322        /// 323        /// * mode: [CollectionMode] collection type and type dependent data.324        // returns collection ID325        #[weight = 0]326        pub fn create_collection(origin,327                                 collection_name: Vec<u16>,328                                 collection_description: Vec<u16>,329                                 token_prefix: Vec<u8>,330                                 mode: CollectionMode) -> DispatchResult {331332            // Anyone can create a collection333            let who = ensure_signed(origin)?;334            let custom_data_size = match mode {335                CollectionMode::NFT(size) => {336337                    // bound Custom data size338                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");339                    size340                },341                CollectionMode::ReFungible(size, _) => {342343                    // bound Custom data size344                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");345                    size346                },347                _ => 0348            };349350            let decimal_points = match mode {351                CollectionMode::Fungible(points) => points,352                CollectionMode::ReFungible(_, points) => points,353                _ => 0354            };355356            // bound Total number of collections357            ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, "Total collections bound exceeded");358359            // check params360            ensure!(decimal_points <= 4, "decimal_points parameter must be lower than 4");361362            let mut name = collection_name.to_vec();363            name.push(0);364            ensure!(name.len() <= 64, "Collection name can not be longer than 63 char");365366            let mut description = collection_description.to_vec();367            description.push(0);368            ensure!(name.len() <= 256, "Collection description can not be longer than 255 char");369370            let mut prefix = token_prefix.to_vec();371            prefix.push(0);372            ensure!(prefix.len() <= 16, "Token prefix can not be longer than 15 char");373374            // Generate next collection ID375            let next_id = CreatedCollectionCount::get()376                .checked_add(1)377                .expect("collection id error");378379            // bound counter380            let total = CollectionCount::get()381                .checked_add(1)382                .expect("collection counter error");383384            CreatedCollectionCount::put(next_id);385            CollectionCount::put(total);386387            // Create new collection388            let new_collection = CollectionType {389                owner: who.clone(),390                name: name,391                mode: mode.clone(),392                mint_mode: false,393                access: AccessMode::Normal,394                description: description,395                decimal_points: decimal_points,396                token_prefix: prefix,397                offchain_schema: Vec::new(),398                custom_data_size: custom_data_size,399                sponsor: T::AccountId::default(),400                unconfirmed_sponsor: T::AccountId::default(),401            };402403            // Add new collection to map404            <Collection<T>>::insert(next_id, new_collection);405406            // call event407            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));408409            Ok(())410        }411412        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.413        /// 414        /// # Permissions415        /// 416        /// * Collection Owner.417        /// 418        /// # Arguments419        /// 420        /// * collection_id: collection to destroy.421        #[weight = 0]422        pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {423424            let sender = ensure_signed(origin)?;425            Self::check_owner_permissions(collection_id, sender)?;426427            <AddressTokens<T>>::remove_prefix(collection_id);428            <ApprovedList<T>>::remove_prefix(collection_id);429            <Balance<T>>::remove_prefix(collection_id);430            <ItemListIndex>::remove(collection_id);431            <AdminList<T>>::remove(collection_id);432            <Collection<T>>::remove(collection_id);433            <WhiteList<T>>::remove(collection_id);434435            <NftItemList<T>>::remove_prefix(collection_id);436            <FungibleItemList<T>>::remove_prefix(collection_id);437            <ReFungibleItemList<T>>::remove_prefix(collection_id);438439            <NftTransferBasket<T>>::remove_prefix(collection_id);440            <FungibleTransferBasket<T>>::remove_prefix(collection_id);441            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);442443            if CollectionCount::get() > 0444            {445                // bound couter446                let total = CollectionCount::get()447                    .checked_sub(1)448                    .expect("collection counter error");449450                CollectionCount::put(total);451            }452453            Ok(())454        }455456        /// Add an address to white list.457        /// 458        /// # Permissions459        /// 460        /// * Collection Owner461        /// * Collection Admin462        /// 463        /// # Arguments464        /// 465        /// * collection_id.466        /// 467        /// * address.468        #[weight = 0]469        pub fn add_to_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{470471            let sender = ensure_signed(origin)?;472            Self::check_owner_or_admin_permissions(collection_id, sender)?;473474            let mut white_list_collection: Vec<T::AccountId>;475            if <WhiteList<T>>::contains_key(collection_id) {476                white_list_collection = <WhiteList<T>>::get(collection_id);477                if !white_list_collection.contains(&address.clone())478                {479                    white_list_collection.push(address.clone());480                }481            }482            else {483                white_list_collection = Vec::new();484                white_list_collection.push(address.clone());485            }486487            <WhiteList<T>>::insert(collection_id, white_list_collection);488            Ok(())489        }490491        /// Remove an address from white list.492        /// 493        /// # Permissions494        /// 495        /// * Collection Owner496        /// * Collection Admin497        /// 498        /// # Arguments499        /// 500        /// * collection_id.501        /// 502        /// * address.503        #[weight = 0]504        pub fn remove_from_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{505506            let sender = ensure_signed(origin)?;507            Self::check_owner_or_admin_permissions(collection_id, sender)?;508509            if <WhiteList<T>>::contains_key(collection_id) {510                let mut white_list_collection = <WhiteList<T>>::get(collection_id);511                if white_list_collection.contains(&address.clone())512                {513                    white_list_collection.retain(|i| *i != address.clone());514                    <WhiteList<T>>::insert(collection_id, white_list_collection);515                }516            }517518            Ok(())519        }520521        /// Toggle between normal and white list access for the methods with access for `Anyone`.522        /// 523        /// # Permissions524        /// 525        /// * Collection Owner.526        /// 527        /// # Arguments528        /// 529        /// * collection_id.530        /// 531        /// * mode: [AccessMode]532        #[weight = 0]533        pub fn set_public_access_mode(origin, collection_id: u64, mode: AccessMode) -> DispatchResult534        {535            let sender = ensure_signed(origin)?;536537            Self::check_owner_permissions(collection_id, sender)?;538            let mut target_collection = <Collection<T>>::get(collection_id);539            target_collection.access = mode;540            <Collection<T>>::insert(collection_id, target_collection);541542            Ok(())543        }544545        /// Allows Anyone to create tokens if:546        /// * White List is enabled, and547        /// * Address is added to white list, and548        /// * This method was called with True parameter549        /// 550        /// # Permissions551        /// * Collection Owner552        ///553        /// # Arguments554        /// 555        /// * collection_id.556        /// 557        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.558        #[weight = 0]559        pub fn set_mint_permission(origin, collection_id: u64, mint_permission: bool) -> DispatchResult560        {561            let sender = ensure_signed(origin)?;562563            Self::check_owner_permissions(collection_id, sender)?;564            let mut target_collection = <Collection<T>>::get(collection_id);565            target_collection.mint_mode = mint_permission;566            <Collection<T>>::insert(collection_id, target_collection);567568            Ok(())569        }570571        /// Change the owner of the collection.572        /// 573        /// # Permissions574        /// 575        /// * Collection Owner.576        /// 577        /// # Arguments578        /// 579        /// * collection_id.580        /// 581        /// * new_owner.582        #[weight = 0]583        pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {584585            let sender = ensure_signed(origin)?;586            Self::check_owner_permissions(collection_id, sender)?;587            let mut target_collection = <Collection<T>>::get(collection_id);588            target_collection.owner = new_owner;589            <Collection<T>>::insert(collection_id, target_collection);590591            Ok(())592        }593594        /// Adds an admin of the Collection.595        /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership. 596        /// 597        /// # Permissions598        /// 599        /// * Collection Owner.600        /// * Collection Admin.601        /// 602        /// # Arguments603        /// 604        /// * collection_id: ID of the Collection to add admin for.605        /// 606        /// * new_admin_id: Address of new admin to add.607        #[weight = 0]608        pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {609610            let sender = ensure_signed(origin)?;611            Self::check_owner_or_admin_permissions(collection_id, sender)?;612            let mut admin_arr: Vec<T::AccountId> = Vec::new();613614            if <AdminList<T>>::contains_key(collection_id)615            {616                admin_arr = <AdminList<T>>::get(collection_id);617                ensure!(!admin_arr.contains(&new_admin_id), "Account already has admin role");618            }619620            // Number of collection admins621            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, "Number of collection admins bound exceeded");622623            admin_arr.push(new_admin_id);624            <AdminList<T>>::insert(collection_id, admin_arr);625626            Ok(())627        }628629        /// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.630        ///631        /// # Permissions632        /// 633        /// * Collection Owner.634        /// * Collection Admin.635        /// 636        /// # Arguments637        /// 638        /// * collection_id: ID of the Collection to remove admin for.639        /// 640        /// * account_id: Address of admin to remove.641        #[weight = 0]642        pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {643644            let sender = ensure_signed(origin)?;645            Self::check_owner_or_admin_permissions(collection_id, sender)?;646647            if <AdminList<T>>::contains_key(collection_id)648            {649                let mut admin_arr = <AdminList<T>>::get(collection_id);650                admin_arr.retain(|i| *i != account_id);651                <AdminList<T>>::insert(collection_id, admin_arr);652            }653654            Ok(())655        }656657        /// # Permissions658        /// 659        /// * Collection Owner660        /// 661        /// # Arguments662        /// 663        /// * collection_id.664        /// 665        /// * new_sponsor.666        #[weight = 0]667        pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {668669            let sender = ensure_signed(origin)?;670            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");671672            let mut target_collection = <Collection<T>>::get(collection_id);673            ensure!(sender == target_collection.owner, "You do not own this collection");674675            target_collection.unconfirmed_sponsor = new_sponsor;676            <Collection<T>>::insert(collection_id, target_collection);677678            Ok(())679        }680681        /// # Permissions682        /// 683        /// * Sponsor.684        /// 685        /// # Arguments686        /// 687        /// * collection_id.688        #[weight = 0]689        pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {690691            let sender = ensure_signed(origin)?;692            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");693694            let mut target_collection = <Collection<T>>::get(collection_id);695            ensure!(sender == target_collection.unconfirmed_sponsor, "This address is not set as sponsor, use setCollectionSponsor first");696697            target_collection.sponsor = target_collection.unconfirmed_sponsor;698            target_collection.unconfirmed_sponsor = T::AccountId::default();699            <Collection<T>>::insert(collection_id, target_collection);700701            Ok(())702        }703704        /// Switch back to pay-per-own-transaction model.705        ///706        /// # Permissions707        ///708        /// * Collection owner.709        /// 710        /// # Arguments711        /// 712        /// * collection_id.713        #[weight = 0]714        pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {715716            let sender = ensure_signed(origin)?;717            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");718719            let mut target_collection = <Collection<T>>::get(collection_id);720            ensure!(sender == target_collection.owner, "You do not own this collection");721722            target_collection.sponsor = T::AccountId::default();723            <Collection<T>>::insert(collection_id, target_collection);724725            Ok(())726        }727728        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.729        /// 730        /// # Permissions731        /// 732        /// * Collection Owner.733        /// * Collection Admin.734        /// * Anyone if735        ///     * White List is enabled, and736        ///     * Address is added to white list, and737        ///     * MintPermission is enabled (see SetMintPermission method)738        /// 739        /// # Arguments740        /// 741        /// * collection_id: ID of the collection.742        /// 743        /// * properties: Array of bytes that contains NFT properties. Since NFT Module is agnostic of properties meaning, it is treated purely as an array of bytes.744        /// 745        /// * owner: Address, initial owner of the NFT.746        #[weight = 0]747        pub fn create_item(origin, collection_id: u64, properties: Vec<u8>, owner: T::AccountId) -> DispatchResult {748749            let sender = ensure_signed(origin)?;750            Self::collection_exists(collection_id)?;751            let target_collection = <Collection<T>>::get(collection_id);752753            if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {754                ensure!(target_collection.mint_mode == true, "Public minting is not allowed for this collection");755                Self::check_white_list(collection_id, &owner)?;756                Self::check_white_list(collection_id, &sender)?;757            }758759            match target_collection.mode760            {761                CollectionMode::NFT(_) => {762763                    // check size764                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");765766                    // Create nft item767                    let item = NftItemType {768                        collection: collection_id,769                        owner: owner,770                        data: properties.clone(),771                    };772773                    Self::add_nft_item(item)?;774775                },776                CollectionMode::Fungible(_) => {777778                    // check size779                    ensure!(properties.len() as u32 == 0, "Size of item must be 0 with fungible type");780781                    let item = FungibleItemType {782                        collection: collection_id,783                        owner: owner,784                        value: (10 as u128).pow(target_collection.decimal_points)785                    };786787                    Self::add_fungible_item(item)?;788                },789                CollectionMode::ReFungible(_, _) => {790791                    // check size792                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");793794                    let mut owner_list = Vec::new();795                    let value = (10 as u128).pow(target_collection.decimal_points);796                    owner_list.push(Ownership {owner: owner.clone(), fraction: value});797798                    let item = ReFungibleItemType {799                        collection: collection_id,800                        owner: owner_list,801                        data: properties.clone()802                    };803804                    Self::add_refungible_item(item)?;805                },806                _ => { ensure!(1 == 0,"just error"); }807808            };809810            // call event811            Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));812813            Ok(())814        }815816        /// Destroys a concrete instance of NFT.817        /// 818        /// # Permissions819        /// 820        /// * Collection Owner.821        /// * Collection Admin.822        /// * Current NFT Owner.823        /// 824        /// # Arguments825        /// 826        /// * collection_id: ID of the collection.827        /// 828        /// * item_id: ID of NFT to burn.829        #[weight = 0]830        pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {831832            let sender = ensure_signed(origin)?;833            Self::collection_exists(collection_id)?;834835            // Transfer permissions check836            let target_collection = <Collection<T>>::get(collection_id);837            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||838                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),839                "Only item owner, collection owner and admins can modify item");840841            if target_collection.access == AccessMode::WhiteList {842                Self::check_white_list(collection_id, &sender)?;843            }844845            match target_collection.mode846            {847                CollectionMode::NFT(_) => Self::burn_nft_item(collection_id, item_id)?,848                CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,849                CollectionMode::ReFungible(_, _)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,850                _ => ()851            };852853            // call event854            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));855856            Ok(())857        }858859        /// Change ownership of the token.860        /// 861        /// # Permissions862        /// 863        /// * Collection Owner864        /// * Collection Admin865        /// * Current NFT owner866        ///867        /// # Arguments868        /// 869        /// * recipient: Address of token recipient.870        /// 871        /// * collection_id.872        /// 873        /// * item_id: ID of the item874        ///     * Non-Fungible Mode: Required.875        ///     * Fungible Mode: Ignored.876        ///     * Re-Fungible Mode: Required.877        /// 878        /// * value: Amount to transfer.879        ///     * Non-Fungible Mode: Ignored880        ///     * Fungible Mode: Must specify transferred amount881        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)882        #[weight = 0]883        pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {884885            let sender = ensure_signed(origin)?;886887            // Transfer permissions check888            let target_collection = <Collection<T>>::get(collection_id);889            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||890                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),891                "Only item owner, collection owner and admins can modify item");892893            if target_collection.access == AccessMode::WhiteList {894                Self::check_white_list(collection_id, &sender)?;895                Self::check_white_list(collection_id, &recipient)?;896            }897898            match target_collection.mode899            {900                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,901                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,902                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,903                _ => ()904            };905906            Ok(())907        }908909        /// Set, change, or remove approved address to transfer the ownership of the NFT.910        /// 911        /// # Permissions912        /// 913        /// * Collection Owner914        /// * Collection Admin915        /// * Current NFT owner916        /// 917        /// # Arguments918        /// 919        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).920        /// 921        /// * collection_id.922        /// 923        /// * item_id: ID of the item.924        #[weight = 0]925        pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {926927            let sender = ensure_signed(origin)?;928929            // Transfer permissions check930            let target_collection = <Collection<T>>::get(collection_id);931            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||932                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),933                "Only item owner, collection owner and admins can approve");934935            if target_collection.access == AccessMode::WhiteList {936                Self::check_white_list(collection_id, &sender)?;937                Self::check_white_list(collection_id, &approved)?;938            }939940            // amount param stub941            let amount = 100000000;942943            let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));944            if list_exists {945946                let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));947                let item_contains = list.iter().any(|i| i.approved == approved);948949                if !item_contains {950                    list.push(ApprovePermissions { approved: approved.clone(), amount: amount });951                    <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);952                }953            } else {954955                let mut list = Vec::new();956                list.push(ApprovePermissions { approved: approved.clone(), amount: amount });957                <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);958            }959960            Ok(())961        }962        963        /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.964        /// 965        /// # Permissions966        /// * Collection Owner967        /// * Collection Admin968        /// * Current NFT owner969        /// * Address approved by current NFT owner970        /// 971        /// # Arguments972        /// 973        /// * from: Address that owns token.974        /// 975        /// * recipient: Address of token recipient.976        /// 977        /// * collection_id.978        /// 979        /// * item_id: ID of the item.980        /// 981        /// * value: Amount to transfer.982        #[weight = 0]983        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {984985            let sender = ensure_signed(origin)?;986            let mut appoved_transfer = false;987988            // Check approve989            if <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone())) {990                let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));991                let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());992                appoved_transfer = opt_item.is_some();993                ensure!(opt_item.unwrap().amount >= value, "Requested value more than approved");994            }995996            // Transfer permissions check997            let target_collection = <Collection<T>>::get(collection_id);998            ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),999                "Only item owner, collection owner and admins can modify items");10001001            if target_collection.access == AccessMode::WhiteList {1002                Self::check_white_list(collection_id, &sender)?;1003                Self::check_white_list(collection_id, &recipient)?;1004            }10051006            // remove approve1007            let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))1008                .into_iter().filter(|i| i.approved != sender.clone()).collect();1009            <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);101010111012            match target_collection.mode1013            {1014                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, from, recipient)?,1015                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,1016                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1017                _ => ()1018            };10191020            Ok(())1021        }10221023        ///1024        #[weight = 0]1025        pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {10261027            // let no_perm_mes = "You do not have permissions to modify this collection";1028            // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1029            // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1030            // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10311032            // // on_nft_received  call10331034            // Self::transfer(origin, collection_id, item_id, new_owner)?;10351036            Ok(())1037        }10381039        /// Set off-chain data schema.1040        /// 1041        /// # Permissions1042        /// 1043        /// * Collection Owner1044        /// * Collection Admin1045        /// 1046        /// # Arguments1047        /// 1048        /// * collection_id.1049        /// 1050        /// * schema: String representing the offchain data schema.1051        #[weight = 0]1052        pub fn set_offchain_schema(1053            origin,1054            collection_id: u64,1055            schema: Vec<u8>1056        ) -> DispatchResult {1057            let sender = ensure_signed(origin)?;1058            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;10591060            let mut target_collection = <Collection<T>>::get(collection_id);1061            target_collection.offchain_schema = schema;1062            <Collection<T>>::insert(collection_id, target_collection);10631064            Ok(())1065        }10661067        // Sudo permissions function1068        #[weight = 0]1069        pub fn set_chain_limits(1070            origin,1071            limits: ChainLimits1072        ) -> DispatchResult {1073            ensure_root(origin)?;1074            <ChainLimit>::put(limits);1075            Ok(())1076        }        1077    }1078}10791080impl<T: Trait> Module<T> {1081    fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {1082        let current_index = <ItemListIndex>::get(item.collection)1083            .checked_add(1)1084            .expect("Item list index id error");1085        let itemcopy = item.clone();1086        let owner = item.owner.clone();1087        let value = item.value as u64;10881089        Self::add_token_index(item.collection, current_index, owner.clone())?;10901091        <ItemListIndex>::insert(item.collection, current_index);1092        <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);10931094        // Add current block1095        let v: Vec<BasketItem<T::AccountId, T::BlockNumber>> = Vec::new();1096        <FungibleTransferBasket<T>>::insert(item.collection, current_index, v);1097        1098        // Update balance1099        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1100            .checked_add(value)1101            .unwrap();1102        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);11031104        Ok(())1105    }11061107    fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1108        let current_index = <ItemListIndex>::get(item.collection)1109            .checked_add(1)1110            .expect("Item list index id error");1111        let itemcopy = item.clone();11121113        let value = item.owner.first().unwrap().fraction as u64;1114        let owner = item.owner.first().unwrap().owner.clone();11151116        Self::add_token_index(item.collection, current_index, owner.clone())?;11171118        <ItemListIndex>::insert(item.collection, current_index);1119        <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);11201121        // Add current block1122        let block_number: T::BlockNumber = 0.into();1123        <ReFungibleTransferBasket<T>>::insert(item.collection, current_index, block_number);11241125        // Update balance1126        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1127            .checked_add(value)1128            .unwrap();1129        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);11301131        Ok(())1132    }11331134    fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {1135        let current_index = <ItemListIndex>::get(item.collection)1136            .checked_add(1)1137            .expect("Item list index id error");11381139        let item_owner = item.owner.clone();1140        let collection_id = item.collection.clone();1141        Self::add_token_index(collection_id, current_index, item.owner.clone())?;11421143        <ItemListIndex>::insert(collection_id, current_index);1144        <NftItemList<T>>::insert(collection_id, current_index, item);11451146        // Add current block1147        let block_number: T::BlockNumber = 0.into();1148        <NftTransferBasket<T>>::insert(collection_id, current_index, block_number);11491150        // Update balance1151        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1152            .checked_add(1)1153            .unwrap();1154        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);11551156        Ok(())1157    }11581159    fn burn_refungible_item(1160        collection_id: u64,1161        item_id: u64,1162        owner: T::AccountId,1163    ) -> DispatchResult {1164        ensure!(1165            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1166            "Item does not exists"1167        );1168        let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);1169        let item = collection1170            .owner1171            .iter()1172            .filter(|&i| i.owner == owner)1173            .next()1174            .unwrap();1175        Self::remove_token_index(collection_id, item_id, owner.clone())?;11761177        // remove approve list1178        <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));11791180        // update balance1181        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1182            .checked_sub(item.fraction as u64)1183            .unwrap();1184        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);11851186        <ReFungibleItemList<T>>::remove(collection_id, item_id);11871188        Ok(())1189    }11901191    fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {1192        ensure!(1193            <NftItemList<T>>::contains_key(collection_id, item_id),1194            "Item does not exists"1195        );1196        let item = <NftItemList<T>>::get(collection_id, item_id);1197        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;11981199        // remove approve list1200        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));12011202        // update balance1203        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1204            .checked_sub(1)1205            .unwrap();1206        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1207        <NftItemList<T>>::remove(collection_id, item_id);12081209        Ok(())1210    }12111212    fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {1213        ensure!(1214            <FungibleItemList<T>>::contains_key(collection_id, item_id),1215            "Item does not exists"1216        );1217        let item = <FungibleItemList<T>>::get(collection_id, item_id);1218        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;12191220        // remove approve list1221        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));12221223        // update balance1224        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1225            .checked_sub(item.value as u64)1226            .unwrap();1227        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);12281229        <FungibleItemList<T>>::remove(collection_id, item_id);12301231        Ok(())1232    }12331234    fn collection_exists(collection_id: u64) -> DispatchResult {1235        ensure!(1236            <Collection<T>>::contains_key(collection_id),1237            "This collection does not exist"1238        );1239        Ok(())1240    }12411242    fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {1243        Self::collection_exists(collection_id)?;12441245        let target_collection = <Collection<T>>::get(collection_id);1246        ensure!(1247            subject == target_collection.owner,1248            "You do not own this collection"1249        );12501251        Ok(())1252    }12531254    fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {1255        let target_collection = <Collection<T>>::get(collection_id);1256        let mut result: bool = subject == target_collection.owner;1257        let exists = <AdminList<T>>::contains_key(collection_id);12581259        if !result & exists {1260            if <AdminList<T>>::get(collection_id).contains(&subject) {1261                result = true1262            }1263        }12641265        result1266    }12671268    fn check_owner_or_admin_permissions(1269        collection_id: u64,1270        subject: T::AccountId,1271    ) -> DispatchResult {1272        Self::collection_exists(collection_id)?;1273        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());12741275        ensure!(1276            result,1277            "You do not have permissions to modify this collection"1278        );1279        Ok(())1280    }12811282    fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {1283        let target_collection = <Collection<T>>::get(collection_id);12841285        match target_collection.mode {1286            CollectionMode::NFT(_) => {1287                <NftItemList<T>>::get(collection_id, item_id).owner == subject1288            }1289            CollectionMode::Fungible(_) => {1290                <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1291            }1292            CollectionMode::ReFungible(_, _) => {1293                <ReFungibleItemList<T>>::get(collection_id, item_id)1294                    .owner1295                    .iter()1296                    .any(|i| i.owner == subject)1297            }1298            CollectionMode::Invalid => false,1299        }1300    }13011302    fn check_white_list(collection_id: u64, address: &T::AccountId) -> DispatchResult {1303        let mes = "Address is not in white list";1304        ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1305        let wl = <WhiteList<T>>::get(collection_id);1306        ensure!(wl.contains(address), mes);13071308        Ok(())1309    }13101311    fn transfer_fungible(1312        collection_id: u64,1313        item_id: u64,1314        value: u64,1315        owner: T::AccountId,1316        new_owner: T::AccountId,1317    ) -> DispatchResult {1318        ensure!(1319            <FungibleItemList<T>>::contains_key(collection_id, item_id),1320            "Item not exists"1321        );13221323        let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1324        let amount = full_item.value;13251326        ensure!(amount >= value.into(), "Item balance not enouth");13271328        // update balance1329        let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1330            .checked_sub(value)1331            .unwrap();1332        <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);13331334        let mut new_owner_account_id = 0;1335        let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());1336        if new_owner_items.len() > 0 {1337            new_owner_account_id = new_owner_items[0];1338        }13391340        let val64 = value.into();13411342        // transfer1343        if amount == val64 && new_owner_account_id == 0 {1344            // change owner1345            // new owner do not have account1346            let mut new_full_item = full_item.clone();1347            new_full_item.owner = new_owner.clone();1348            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);13491350            // update balance1351            let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1352                .checked_add(value)1353                .unwrap();1354            <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);13551356            // update index collection1357            Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1358        } else {1359            let mut new_full_item = full_item.clone();1360            new_full_item.value -= val64;13611362            // separate amount1363            if new_owner_account_id > 0 {1364                // new owner has account1365                let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1366                item.value += val64;13671368                // update balance1369                let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1370                    .checked_add(value)1371                    .unwrap();1372                <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);13731374                <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);1375            } else {1376                // new owner do not have account1377                let item = FungibleItemType {1378                    collection: collection_id,1379                    owner: new_owner.clone(),1380                    value: val64,1381                };13821383                Self::add_fungible_item(item)?;1384            }13851386            if amount == val64 {1387                Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;13881389                // remove approve list1390                <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));1391                <FungibleItemList<T>>::remove(collection_id, item_id);1392            }13931394            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1395        }13961397        Ok(())1398    }13991400    fn transfer_refungible(1401        collection_id: u64,1402        item_id: u64,1403        value: u64,1404        owner: T::AccountId,1405        new_owner: T::AccountId,1406    ) -> DispatchResult {1407        ensure!(1408            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1409            "Item not exists"1410        );14111412        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1413        let item = full_item1414            .owner1415            .iter()1416            .filter(|i| i.owner == owner)1417            .next()1418            .unwrap();1419        let amount = item.fraction;14201421        ensure!(amount >= value.into(), "Item balance not enouth");14221423        // update balance1424        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1425            .checked_sub(value)1426            .unwrap();1427        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);14281429        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1430            .checked_add(value)1431            .unwrap();1432        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);14331434        let old_owner = item.owner.clone();1435        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);1436        let val64 = value.into();14371438        // transfer1439        if amount == val64 && !new_owner_has_account {1440            // change owner1441            // new owner do not have account1442            let mut new_full_item = full_item.clone();1443            new_full_item1444                .owner1445                .iter_mut()1446                .find(|i| i.owner == owner)1447                .unwrap()1448                .owner = new_owner.clone();1449            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);14501451            // update index collection1452            Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1453        } else {1454            let mut new_full_item = full_item.clone();1455            new_full_item1456                .owner1457                .iter_mut()1458                .find(|i| i.owner == owner)1459                .unwrap()1460                .fraction -= val64;14611462            // separate amount1463            if new_owner_has_account {1464                // new owner has account1465                new_full_item1466                    .owner1467                    .iter_mut()1468                    .find(|i| i.owner == new_owner)1469                    .unwrap()1470                    .fraction += val64;1471            } else {1472                // new owner do not have account1473                new_full_item.owner.push(Ownership {1474                    owner: new_owner.clone(),1475                    fraction: val64,1476                });1477                Self::add_token_index(collection_id, item_id, new_owner.clone())?;1478            }14791480            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1481        }14821483        Ok(())1484    }14851486    fn transfer_nft(1487        collection_id: u64,1488        item_id: u64,1489        sender: T::AccountId,1490        new_owner: T::AccountId,1491    ) -> DispatchResult {1492        ensure!(1493            <NftItemList<T>>::contains_key(collection_id, item_id),1494            "Item not exists"1495        );14961497        let mut item = <NftItemList<T>>::get(collection_id, item_id);14981499        ensure!(1500            sender == item.owner,1501            "sender parameter and item owner must be equal"1502        );15031504        // update balance1505        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1506            .checked_sub(1)1507            .unwrap();1508        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);15091510        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1511            .checked_add(1)1512            .unwrap();1513        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);15141515        // change owner1516        let old_owner = item.owner.clone();1517        item.owner = new_owner.clone();1518        <NftItemList<T>>::insert(collection_id, item_id, item);15191520        // update index collection1521        Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;15221523        // reset approved list1524        <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1525        Ok(())1526    }15271528    fn init_collection(item: &CollectionType<T::AccountId>) {1529        // check params1530        assert!(1531            item.decimal_points <= 4,1532            "decimal_points parameter must be lower than 4"1533        );1534        assert!(1535            item.name.len() <= 64,1536            "Collection name can not be longer than 63 char"1537        );1538        assert!(1539            item.name.len() <= 256,1540            "Collection description can not be longer than 255 char"1541        );1542        assert!(1543            item.token_prefix.len() <= 16,1544            "Token prefix can not be longer than 15 char"1545        );15461547        // Generate next collection ID1548        let next_id = CreatedCollectionCount::get()1549            .checked_add(1)1550            .expect("collection id error");15511552        CreatedCollectionCount::put(next_id);1553    }15541555    fn init_nft_token(item: &NftItemType<T::AccountId>) {1556        let current_index = <ItemListIndex>::get(item.collection)1557            .checked_add(1)1558            .expect("Item list index id error");15591560        let item_owner = item.owner.clone();1561        let collection_id = item.collection.clone();1562        Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();15631564        <ItemListIndex>::insert(collection_id, current_index);15651566        // Update balance1567        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1568            .checked_add(1)1569            .unwrap();1570        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);1571    }15721573    fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {1574        let current_index = <ItemListIndex>::get(item.collection)1575            .checked_add(1)1576            .expect("Item list index id error");1577        let owner = item.owner.clone();1578        let value = item.value as u64;15791580        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();15811582        <ItemListIndex>::insert(item.collection, current_index);15831584        // Update balance1585        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1586            .checked_add(value)1587            .unwrap();1588        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1589    }15901591    fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {1592        let current_index = <ItemListIndex>::get(item.collection)1593            .checked_add(1)1594            .expect("Item list index id error");15951596        let value = item.owner.first().unwrap().fraction as u64;1597        let owner = item.owner.first().unwrap().owner.clone();15981599        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();16001601        <ItemListIndex>::insert(item.collection, current_index);16021603        // Update balance1604        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1605            .checked_add(value)1606            .unwrap();1607        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1608    }16091610    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {16111612        // add to account limit1613        if <AccountItemCount<T>>::contains_key(owner.clone()) {16141615            // bound Owned tokens by a single address1616            let count = <AccountItemCount<T>>::get(owner.clone());1617            ensure!(count < ChainLimit::get().account_token_ownership_limit, "Owned tokens by a single address bound exceeded");16181619            <AccountItemCount<T>>::insert(owner.clone(), 1620                count.checked_add(1).unwrap());1621        }1622        else {1623            <AccountItemCount<T>>::insert(owner.clone(), 1);1624        }16251626        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1627        if list_exists {1628            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1629            let item_contains = list.contains(&item_index.clone());16301631            if !item_contains {1632                list.push(item_index.clone());1633            }16341635            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);1636        } else {1637            let mut itm = Vec::new();1638            itm.push(item_index.clone());1639            <AddressTokens<T>>::insert(collection_id, owner, itm);1640            1641        }16421643        Ok(())1644    }16451646    fn remove_token_index(1647        collection_id: u64,1648        item_index: u64,1649        owner: T::AccountId,1650    ) -> DispatchResult {16511652        // update counter1653        <AccountItemCount<T>>::insert(owner.clone(), 1654            <AccountItemCount<T>>::get(owner.clone()).checked_sub(1).unwrap());165516561657        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1658        if list_exists {1659            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1660            let item_contains = list.contains(&item_index.clone());16611662            if item_contains {1663                list.retain(|&item| item != item_index);1664                <AddressTokens<T>>::insert(collection_id, owner, list);1665            }1666        }16671668        Ok(())1669    }16701671    fn move_token_index(1672        collection_id: u64,1673        item_index: u64,1674        old_owner: T::AccountId,1675        new_owner: T::AccountId,1676    ) -> DispatchResult {1677        Self::remove_token_index(collection_id, item_index, old_owner)?;1678        Self::add_token_index(collection_id, item_index, new_owner)?;16791680        Ok(())1681    }1682}16831684////////////////////////////////////////////////////////////////////////////////////////////////////1685// Economic models1686// #region16871688/// Fee multiplier.1689pub type Multiplier = FixedU128;16901691type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1692    <T as system::Trait>::AccountId,1693>>::Balance;1694type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1695    <T as system::Trait>::AccountId,1696>>::NegativeImbalance;16971698/// Require the transactor pay for themselves and maybe include a tip to gain additional priority1699/// in the queue.1700#[derive(Encode, Decode, Clone, Eq, PartialEq)]1701pub struct ChargeTransactionPayment<T: transaction_payment::Trait + Send + Sync>(1702    #[codec(compact)] BalanceOf<T>,1703);17041705impl<T: Trait + transaction_payment::Trait + Send + Sync> sp_std::fmt::Debug1706    for ChargeTransactionPayment<T>1707{1708    #[cfg(feature = "std")]1709    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1710        write!(f, "ChargeTransactionPayment<{:?}>", self.0)1711    }1712    #[cfg(not(feature = "std"))]1713    fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1714        Ok(())1715    }1716}17171718impl<T: Trait + transaction_payment::Trait + Send + Sync> ChargeTransactionPayment<T>1719where1720    T::Call:1721        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>>,1722    BalanceOf<T>: Send + Sync + FixedPointOperand,1723{1724    /// utility constructor. Used only in client/factory code.1725    pub fn from(fee: BalanceOf<T>) -> Self {1726        Self(fee)1727    }17281729    pub fn traditional_fee(1730        len: usize,1731        info: &DispatchInfoOf<T::Call>,1732        tip: BalanceOf<T>,1733    ) -> BalanceOf<T>1734    where1735        T::Call: Dispatchable<Info = DispatchInfo>,1736    {1737        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)1738    }17391740    fn withdraw_fee(1741        &self,1742        who: &T::AccountId,1743        call: &T::Call,1744        info: &DispatchInfoOf<T::Call>,1745        len: usize,1746    ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {1747        let tip = self.0;17481749        // Set fee based on call type. Creating collection costs 1 Unique.1750        // All other transactions have traditional fees so far1751        let fee = match call.is_sub_type() {1752            Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),1753            _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes1754                                                        // _ => <BalanceOf<T>>::from(100)1755        };17561757        // Determine who is paying transaction fee based on ecnomic model1758        // Parse call to extract collection ID and access collection sponsor1759        let sponsor: T::AccountId = match call.is_sub_type() {1760            Some(Call::create_item(collection_id, _properties, _owner)) => {1761                <Collection<T>>::get(collection_id).sponsor1762            }1763            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {1764                let _collection_mode = <Collection<T>>::get(collection_id).mode;17651766                // sponsor timeout1767                let sponsor_transfer = match _collection_mode {1768                    CollectionMode::NFT(_) => {1769                        let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);1770                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;1771                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();1772                        if block_number >= limit_time {1773                            <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);1774                            true1775                        }1776                        else {1777                            false1778                        }1779                    }1780                    CollectionMode::Fungible(_) => {1781                        let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);1782                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;1783                        if basket.iter().any(|i| i.address == _new_owner.clone())1784                        {1785                            let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();1786                            let limit_time = item.start_block + ChainLimit::get().fungible_sponsor_transfer_timeout.into();1787                            if block_number >= limit_time {1788                                basket.retain(|x| x.address == item.address);1789                                basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });1790                                <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);1791                                true1792                            }1793                            else {1794                                false1795                            }1796                        }1797                        else {1798                            basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});1799                            true1800                        }1801                    }1802                    CollectionMode::ReFungible(_, _) => {1803                        let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);1804                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;1805                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();1806                        if block_number >= limit_time {1807                            <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);1808                            true1809                        } else {1810                            false1811                        }1812                    }1813                    _ => {1814                        false1815                    },1816                };18171818                if !sponsor_transfer {1819                    T::AccountId::default()1820                } else {1821                    <Collection<T>>::get(collection_id).sponsor1822                }1823            }18241825            _ => T::AccountId::default(),1826        };18271828        let mut who_pays_fee: T::AccountId = sponsor.clone();1829        if sponsor == T::AccountId::default() {1830            who_pays_fee = who.clone();1831        }18321833        // Only mess with balances if fee is not zero.1834        if fee.is_zero() {1835            return Ok((fee, None));1836        }18371838        match <T as transaction_payment::Trait>::Currency::withdraw(1839            &who_pays_fee,1840            fee,1841            if tip.is_zero() {1842                WithdrawReason::TransactionPayment.into()1843            } else {1844                WithdrawReason::TransactionPayment | WithdrawReason::Tip1845            },1846            ExistenceRequirement::KeepAlive,1847        ) {1848            Ok(imbalance) => Ok((fee, Some(imbalance))),1849            Err(_) => Err(InvalidTransaction::Payment.into()),1850        }1851    }1852}18531854impl<T: Trait + transaction_payment::Trait + Send + Sync> SignedExtension1855    for ChargeTransactionPayment<T>1856where1857    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,1858    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>>,1859{1860    const IDENTIFIER: &'static str = "ChargeTransactionPayment";1861    type AccountId = T::AccountId;1862    type Call = T::Call;1863    type AdditionalSigned = ();1864    type Pre = (1865        BalanceOf<T>,1866        Self::AccountId,1867        Option<NegativeImbalanceOf<T>>,1868        BalanceOf<T>,1869    );1870    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {1871        Ok(())1872    }18731874    fn validate(1875        &self,1876        who: &Self::AccountId,1877        call: &Self::Call,1878        info: &DispatchInfoOf<Self::Call>,1879        len: usize,1880    ) -> TransactionValidity {1881        let (fee, _) = self.withdraw_fee(who, call, info, len)?;18821883        let mut r = ValidTransaction::default();1884        // NOTE: we probably want to maximize the _fee (of any type) per weight unit_ here, which1885        // will be a bit more than setting the priority to tip. For now, this is enough.1886        r.priority = fee.saturated_into::<TransactionPriority>();1887        Ok(r)1888    }18891890    fn pre_dispatch(1891        self,1892        who: &Self::AccountId,1893        call: &Self::Call,1894        info: &DispatchInfoOf<Self::Call>,1895        len: usize,1896    ) -> Result<Self::Pre, TransactionValidityError> {1897        let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;1898        Ok((self.0, who.clone(), imbalance, fee))1899    }19001901    fn post_dispatch(1902        pre: Self::Pre,1903        info: &DispatchInfoOf<Self::Call>,1904        post_info: &PostDispatchInfoOf<Self::Call>,1905        len: usize,1906        _result: &DispatchResult,1907    ) -> Result<(), TransactionValidityError> {1908        let (tip, who, imbalance, fee) = pre;1909        if let Some(payed) = imbalance {1910            let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(1911                len as u32, info, post_info, tip,1912            );1913            let refund = fee.saturating_sub(actual_fee);1914            let actual_payment =1915                match <T as transaction_payment::Trait>::Currency::deposit_into_existing(1916                    &who, refund,1917                ) {1918                    Ok(refund_imbalance) => {1919                        // The refund cannot be larger than the up front payed max weight.1920                        // `PostDispatchInfo::calc_unspent` guards against such a case.1921                        match payed.offset(refund_imbalance) {1922                            Ok(actual_payment) => actual_payment,1923                            Err(_) => return Err(InvalidTransaction::Payment.into()),1924                        }1925                    }1926                    // We do not recreate the account using the refund. The up front payment1927                    // is gone in that case.1928                    Err(_) => payed,1929                };1930            let imbalances = actual_payment.split(tip);1931            <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(1932                Some(imbalances.0).into_iter().chain(Some(imbalances.1)),1933            );1934        }1935        Ok(())1936    }1937}1938// #endregion