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

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};25// use frame_support::weights::{Weight, constants::RocksDbWeight as DbWeight};2627use frame_system::{self as system, ensure_signed, ensure_root};28use sp_runtime::sp_std::prelude::Vec;29use sp_runtime::{30    traits::{31        DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SignedExtension, Zero,32    },33    transaction_validity::{34        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,35    },36    FixedPointOperand, FixedU128,37};38use pallet_contracts::ContractAddressFor;39use sp_runtime::traits::StaticLookup;4041#[cfg(test)]42mod mock;4344#[cfg(test)]45mod tests;4647mod default_weights;4849// Structs50// #region5152#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]53#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]54pub enum CollectionMode {55    Invalid,56    // custom data size57    NFT(u32),58    // decimal points59    Fungible(u32),60    // custom data size and decimal points61    ReFungible(u32, u32),62}6364impl Into<u8> for CollectionMode {65    fn into(self) -> u8 {66        match self {67            CollectionMode::Invalid => 0,68            CollectionMode::NFT(_) => 1,69            CollectionMode::Fungible(_) => 2,70            CollectionMode::ReFungible(_, _) => 3,71        }72    }73}7475#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]76#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]77pub enum AccessMode {78    Normal,79    WhiteList,80}81impl Default for AccessMode {82    fn default() -> Self {83        Self::Normal84    }85}8687impl Default for CollectionMode {88    fn default() -> Self {89        Self::Invalid90    }91}9293#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]94#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]95pub struct Ownership<AccountId> {96    pub owner: AccountId,97    pub fraction: u128,98}99100#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]101#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]102pub struct CollectionType<AccountId> {103    pub owner: AccountId,104    pub mode: CollectionMode,105    pub access: AccessMode,106    pub decimal_points: u32,107    pub name: Vec<u16>,        // 64 include null escape char108    pub description: Vec<u16>, // 256 include null escape char109    pub token_prefix: Vec<u8>, // 16 include null escape char110    pub custom_data_size: u32,111    pub mint_mode: bool,112    pub offchain_schema: Vec<u8>,113    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender114    pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship115}116117#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]118#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]119pub struct CollectionAdminsType<AccountId> {120    pub admin: AccountId,121    pub collection_id: u64,122}123124#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]125#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]126pub struct NftItemType<AccountId> {127    pub collection: u64,128    pub owner: AccountId,129    pub data: Vec<u8>,130}131132#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]133#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]134pub struct FungibleItemType<AccountId> {135    pub collection: u64,136    pub owner: AccountId,137    pub value: u128,138}139140#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]141#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]142pub struct ReFungibleItemType<AccountId> {143    pub collection: u64,144    pub owner: Vec<Ownership<AccountId>>,145    pub data: Vec<u8>,146}147148#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]149#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]150pub struct ApprovePermissions<AccountId> {151    pub approved: AccountId,152    pub amount: u64,153}154155#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]156#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]157pub struct VestingItem<AccountId, Moment> {158    pub sender: AccountId,159    pub recipient: AccountId,160    pub collection_id: u64,161    pub item_id: u64,162    pub amount: u64,163    pub vesting_date: Moment,164}165166#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]167#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]168pub struct BasketItem<AccountId, BlockNumber> {169    pub address: AccountId,170    pub start_block: BlockNumber,171}172173#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]174#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]175pub struct ChainLimits {176    pub collection_numbers_limit: u64,177    pub account_token_ownership_limit: u64,178    pub collections_admins_limit: u64,179    pub custom_data_limit: u32,180181    // Timeouts for item types in passed blocks182    pub nft_sponsor_transfer_timeout: u32,183    pub fungible_sponsor_transfer_timeout: u32,184    pub refungible_sponsor_transfer_timeout: u32,185}186187pub trait WeightInfo {188	fn create_collection() -> Weight;189	fn destroy_collection() -> Weight;190	fn add_to_white_list() -> Weight;191	fn remove_from_white_list() -> Weight;192    fn set_public_access_mode() -> Weight;193    fn set_mint_permission() -> Weight;194    fn change_collection_owner() -> Weight;195    fn add_collection_admin() -> Weight;196    fn remove_collection_admin() -> Weight;197    fn set_collection_sponsor() -> Weight;198    fn confirm_sponsorship() -> Weight;199    fn remove_collection_sponsor() -> Weight;200    fn create_item(s: usize, ) -> Weight;201    fn burn_item() -> Weight;202    fn transfer() -> Weight;203    fn approve() -> Weight;204    fn transfer_from() -> Weight;205    fn set_offchain_schema() -> Weight;206    // fn enable_contract_sponsoring() -> Weight;207}208209pub trait Trait: system::Trait + Sized + transaction_payment::Trait + pallet_contracts::Trait {210    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;211212    /// Weight information for extrinsics in this pallet.213	type WeightInfo: WeightInfo;214}215216#[cfg(feature = "runtime-benchmarks")]217mod benchmarking;218219// #endregion220221decl_storage! {222    trait Store for Module<T: Trait> as Nft {223224        // Private members225        NextCollectionID: u64;226        CreatedCollectionCount: u64;227        ChainVersion: u64;228        ItemListIndex: map hasher(blake2_128_concat) u64 => u64;229230        // Chain limits struct231        pub ChainLimit get(fn chain_limit) config(): ChainLimits;232233        // Bound counters234        CollectionCount: u64;235        pub AccountItemCount get(fn account_item_count): map hasher(identity) T::AccountId => u64;236237        // Basic collections238        pub Collection get(fn collection) config(): map hasher(identity) u64 => CollectionType<T::AccountId>;239        pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;240        pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;241242        /// Balance owner per collection map243        pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;244245        /// second parameter: item id + owner account id246        pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;247248        /// Item collections249        pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;250        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;251        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;252253        /// Index list254        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;255256        /// Tokens transfer baskets257        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;258        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>>;259        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;260261        // Contract Sponsorship and Ownership262        pub ContractOwner get(fn contract_owner): map hasher(identity) T::AccountId => T::AccountId;263        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(identity) T::AccountId => bool;264    }265    add_extra_genesis {266        build(|config: &GenesisConfig<T>| {267            // Modification of storage268            for (_num, _c) in &config.collection {269                <Module<T>>::init_collection(_c);270            }271272            for (_num, _q, _i) in &config.nft_item_id {273                <Module<T>>::init_nft_token(_i);274            }275276            for (_num, _q, _i) in &config.fungible_item_id {277                <Module<T>>::init_fungible_token(_i);278            }279280            for (_num, _q, _i) in &config.refungible_item_id {281                <Module<T>>::init_refungible_token(_i);282            }283        })284    }285}286287decl_event!(288    pub enum Event<T>289    where290        AccountId = <T as system::Trait>::AccountId,291    {292        /// New collection was created293        /// 294        /// # Arguments295        /// 296        /// * collection_id: Globally unique identifier of newly created collection.297        /// 298        /// * mode: [CollectionMode] converted into u8.299        /// 300        /// * account_id: Collection owner.301        Created(u64, u8, AccountId),302303        /// New item was created.304        /// 305        /// # Arguments306        /// 307        /// * collection_id: Id of the collection where item was created.308        /// 309        /// * item_id: Id of an item. Unique within the collection.310        ItemCreated(u64, u64),311312        /// Collection item was burned.313        /// 314        /// # Arguments315        /// 316        /// collection_id.317        /// 318        /// item_id: Identifier of burned NFT.319        ItemDestroyed(u64, u64),320    }321);322323decl_module! {324    pub struct Module<T: Trait> for enum Call where origin: T::Origin {325326        fn deposit_event() = default;327328        fn on_initialize(now: T::BlockNumber) -> Weight {329330            if ChainVersion::get() < 2331            {332                let value = NextCollectionID::get();333                CreatedCollectionCount::put(value);334                ChainVersion::put(2);335            }336337            0338        }339340        /// 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.341        /// 342        /// # Permissions343        /// 344        /// * Anyone.345        /// 346        /// # Arguments347        /// 348        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.349        /// 350        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.351        /// 352        /// * token_prefix: UTF-8 string with token prefix.353        /// 354        /// * mode: [CollectionMode] collection type and type dependent data.355        // returns collection ID356        #[weight = T::WeightInfo::create_collection()]357        pub fn create_collection(origin,358                                 collection_name: Vec<u16>,359                                 collection_description: Vec<u16>,360                                 token_prefix: Vec<u8>,361                                 mode: CollectionMode) -> DispatchResult {362363            // Anyone can create a collection364            let who = ensure_signed(origin)?;365            let custom_data_size = match mode {366                CollectionMode::NFT(size) => {367368                    // bound Custom data size369                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");370                    size371                },372                CollectionMode::ReFungible(size, _) => {373374                    // bound Custom data size375                    ensure!(size < ChainLimit::get().custom_data_limit, "Custom data size bound exceeded");376                    size377                },378                _ => 0379            };380381            let decimal_points = match mode {382                CollectionMode::Fungible(points) => points,383                CollectionMode::ReFungible(_, points) => points,384                _ => 0385            };386387            // bound Total number of collections388            ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, "Total collections bound exceeded");389390            // check params391            ensure!(decimal_points <= 4, "decimal_points parameter must be lower than 4");392393            let mut name = collection_name.to_vec();394            name.push(0);395            ensure!(name.len() <= 64, "Collection name can not be longer than 63 char");396397            let mut description = collection_description.to_vec();398            description.push(0);399            ensure!(name.len() <= 256, "Collection description can not be longer than 255 char");400401            let mut prefix = token_prefix.to_vec();402            prefix.push(0);403            ensure!(prefix.len() <= 16, "Token prefix can not be longer than 15 char");404405            // Generate next collection ID406            let next_id = CreatedCollectionCount::get()407                .checked_add(1)408                .expect("collection id error");409410            // bound counter411            let total = CollectionCount::get()412                .checked_add(1)413                .expect("collection counter error");414415            CreatedCollectionCount::put(next_id);416            CollectionCount::put(total);417418            // Create new collection419            let new_collection = CollectionType {420                owner: who.clone(),421                name: name,422                mode: mode.clone(),423                mint_mode: false,424                access: AccessMode::Normal,425                description: description,426                decimal_points: decimal_points,427                token_prefix: prefix,428                offchain_schema: Vec::new(),429                custom_data_size: custom_data_size,430                sponsor: T::AccountId::default(),431                unconfirmed_sponsor: T::AccountId::default(),432            };433434            // Add new collection to map435            <Collection<T>>::insert(next_id, new_collection);436437            // call event438            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));439440            Ok(())441        }442443        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.444        /// 445        /// # Permissions446        /// 447        /// * Collection Owner.448        /// 449        /// # Arguments450        /// 451        /// * collection_id: collection to destroy.452        #[weight = T::WeightInfo::destroy_collection()]453        pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {454455            let sender = ensure_signed(origin)?;456            Self::check_owner_permissions(collection_id, sender)?;457458            <AddressTokens<T>>::remove_prefix(collection_id);459            <ApprovedList<T>>::remove_prefix(collection_id);460            <Balance<T>>::remove_prefix(collection_id);461            <ItemListIndex>::remove(collection_id);462            <AdminList<T>>::remove(collection_id);463            <Collection<T>>::remove(collection_id);464            <WhiteList<T>>::remove(collection_id);465466            <NftItemList<T>>::remove_prefix(collection_id);467            <FungibleItemList<T>>::remove_prefix(collection_id);468            <ReFungibleItemList<T>>::remove_prefix(collection_id);469470            <NftTransferBasket<T>>::remove_prefix(collection_id);471            <FungibleTransferBasket<T>>::remove_prefix(collection_id);472            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);473474            if CollectionCount::get() > 0475            {476                // bound couter477                let total = CollectionCount::get()478                    .checked_sub(1)479                    .expect("collection counter error");480481                CollectionCount::put(total);482            }483484            Ok(())485        }486487        /// Add an address to white list.488        /// 489        /// # Permissions490        /// 491        /// * Collection Owner492        /// * Collection Admin493        /// 494        /// # Arguments495        /// 496        /// * collection_id.497        /// 498        /// * address.499        #[weight = T::WeightInfo::add_to_white_list()]500        pub fn add_to_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{501502            let sender = ensure_signed(origin)?;503            Self::check_owner_or_admin_permissions(collection_id, sender)?;504505            let mut white_list_collection: Vec<T::AccountId>;506            if <WhiteList<T>>::contains_key(collection_id) {507                white_list_collection = <WhiteList<T>>::get(collection_id);508                if !white_list_collection.contains(&address.clone())509                {510                    white_list_collection.push(address.clone());511                }512            }513            else {514                white_list_collection = Vec::new();515                white_list_collection.push(address.clone());516            }517518            <WhiteList<T>>::insert(collection_id, white_list_collection);519            Ok(())520        }521522        /// Remove an address from white list.523        /// 524        /// # Permissions525        /// 526        /// * Collection Owner527        /// * Collection Admin528        /// 529        /// # Arguments530        /// 531        /// * collection_id.532        /// 533        /// * address.534        #[weight = T::WeightInfo::remove_from_white_list()]535        pub fn remove_from_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{536537            let sender = ensure_signed(origin)?;538            Self::check_owner_or_admin_permissions(collection_id, sender)?;539540            if <WhiteList<T>>::contains_key(collection_id) {541                let mut white_list_collection = <WhiteList<T>>::get(collection_id);542                if white_list_collection.contains(&address.clone())543                {544                    white_list_collection.retain(|i| *i != address.clone());545                    <WhiteList<T>>::insert(collection_id, white_list_collection);546                }547            }548549            Ok(())550        }551552        /// Toggle between normal and white list access for the methods with access for `Anyone`.553        /// 554        /// # Permissions555        /// 556        /// * Collection Owner.557        /// 558        /// # Arguments559        /// 560        /// * collection_id.561        /// 562        /// * mode: [AccessMode]563        #[weight = T::WeightInfo::set_public_access_mode()]564        pub fn set_public_access_mode(origin, collection_id: u64, mode: AccessMode) -> DispatchResult565        {566            let sender = ensure_signed(origin)?;567568            Self::check_owner_permissions(collection_id, sender)?;569            let mut target_collection = <Collection<T>>::get(collection_id);570            target_collection.access = mode;571            <Collection<T>>::insert(collection_id, target_collection);572573            Ok(())574        }575576        /// Allows Anyone to create tokens if:577        /// * White List is enabled, and578        /// * Address is added to white list, and579        /// * This method was called with True parameter580        /// 581        /// # Permissions582        /// * Collection Owner583        ///584        /// # Arguments585        /// 586        /// * collection_id.587        /// 588        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.589        #[weight = T::WeightInfo::set_mint_permission()]590        pub fn set_mint_permission(origin, collection_id: u64, mint_permission: bool) -> DispatchResult591        {592            let sender = ensure_signed(origin)?;593594            Self::check_owner_permissions(collection_id, sender)?;595            let mut target_collection = <Collection<T>>::get(collection_id);596            target_collection.mint_mode = mint_permission;597            <Collection<T>>::insert(collection_id, target_collection);598599            Ok(())600        }601602        /// Change the owner of the collection.603        /// 604        /// # Permissions605        /// 606        /// * Collection Owner.607        /// 608        /// # Arguments609        /// 610        /// * collection_id.611        /// 612        /// * new_owner.613        #[weight = T::WeightInfo::change_collection_owner()]614        pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {615616            let sender = ensure_signed(origin)?;617            Self::check_owner_permissions(collection_id, sender)?;618            let mut target_collection = <Collection<T>>::get(collection_id);619            target_collection.owner = new_owner;620            <Collection<T>>::insert(collection_id, target_collection);621622            Ok(())623        }624625        /// Adds an admin of the Collection.626        /// 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. 627        /// 628        /// # Permissions629        /// 630        /// * Collection Owner.631        /// * Collection Admin.632        /// 633        /// # Arguments634        /// 635        /// * collection_id: ID of the Collection to add admin for.636        /// 637        /// * new_admin_id: Address of new admin to add.638        #[weight = T::WeightInfo::add_collection_admin()]639        pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {640641            let sender = ensure_signed(origin)?;642            Self::check_owner_or_admin_permissions(collection_id, sender)?;643            let mut admin_arr: Vec<T::AccountId> = Vec::new();644645            if <AdminList<T>>::contains_key(collection_id)646            {647                admin_arr = <AdminList<T>>::get(collection_id);648                ensure!(!admin_arr.contains(&new_admin_id), "Account already has admin role");649            }650651            // Number of collection admins652            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, "Number of collection admins bound exceeded");653654            admin_arr.push(new_admin_id);655            <AdminList<T>>::insert(collection_id, admin_arr);656657            Ok(())658        }659660        /// 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.661        ///662        /// # Permissions663        /// 664        /// * Collection Owner.665        /// * Collection Admin.666        /// 667        /// # Arguments668        /// 669        /// * collection_id: ID of the Collection to remove admin for.670        /// 671        /// * account_id: Address of admin to remove.672        #[weight = T::WeightInfo::remove_collection_admin()]673        pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {674675            let sender = ensure_signed(origin)?;676            Self::check_owner_or_admin_permissions(collection_id, sender)?;677678            if <AdminList<T>>::contains_key(collection_id)679            {680                let mut admin_arr = <AdminList<T>>::get(collection_id);681                admin_arr.retain(|i| *i != account_id);682                <AdminList<T>>::insert(collection_id, admin_arr);683            }684685            Ok(())686        }687688        /// # Permissions689        /// 690        /// * Collection Owner691        /// 692        /// # Arguments693        /// 694        /// * collection_id.695        /// 696        /// * new_sponsor.697        #[weight = T::WeightInfo::set_collection_sponsor()]698        pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {699700            let sender = ensure_signed(origin)?;701            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");702703            let mut target_collection = <Collection<T>>::get(collection_id);704            ensure!(sender == target_collection.owner, "You do not own this collection");705706            target_collection.unconfirmed_sponsor = new_sponsor;707            <Collection<T>>::insert(collection_id, target_collection);708709            Ok(())710        }711712        /// # Permissions713        /// 714        /// * Sponsor.715        /// 716        /// # Arguments717        /// 718        /// * collection_id.719        #[weight = T::WeightInfo::confirm_sponsorship()]720        pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {721722            let sender = ensure_signed(origin)?;723            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");724725            let mut target_collection = <Collection<T>>::get(collection_id);726            ensure!(sender == target_collection.unconfirmed_sponsor, "This address is not set as sponsor, use setCollectionSponsor first");727728            target_collection.sponsor = target_collection.unconfirmed_sponsor;729            target_collection.unconfirmed_sponsor = T::AccountId::default();730            <Collection<T>>::insert(collection_id, target_collection);731732            Ok(())733        }734735        /// Switch back to pay-per-own-transaction model.736        ///737        /// # Permissions738        ///739        /// * Collection owner.740        /// 741        /// # Arguments742        /// 743        /// * collection_id.744        #[weight = T::WeightInfo::remove_collection_sponsor()]745        pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {746747            let sender = ensure_signed(origin)?;748            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");749750            let mut target_collection = <Collection<T>>::get(collection_id);751            ensure!(sender == target_collection.owner, "You do not own this collection");752753            target_collection.sponsor = T::AccountId::default();754            <Collection<T>>::insert(collection_id, target_collection);755756            Ok(())757        }758759        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.760        /// 761        /// # Permissions762        /// 763        /// * Collection Owner.764        /// * Collection Admin.765        /// * Anyone if766        ///     * White List is enabled, and767        ///     * Address is added to white list, and768        ///     * MintPermission is enabled (see SetMintPermission method)769        /// 770        /// # Arguments771        /// 772        /// * collection_id: ID of the collection.773        /// 774        /// * 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.775        /// 776        /// * owner: Address, initial owner of the NFT.777        // #[weight =778        // (130_000_000 as Weight)779        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))780        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))781        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]782783        #[weight = T::WeightInfo::create_item(properties.len())]784        pub fn create_item(origin, collection_id: u64, properties: Vec<u8>, owner: T::AccountId) -> DispatchResult {785786            let sender = ensure_signed(origin)?;787            Self::collection_exists(collection_id)?;788            let target_collection = <Collection<T>>::get(collection_id);789790            if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {791                ensure!(target_collection.mint_mode == true, "Public minting is not allowed for this collection");792                Self::check_white_list(collection_id, &owner)?;793                Self::check_white_list(collection_id, &sender)?;794            }795796            match target_collection.mode797            {798                CollectionMode::NFT(_) => {799800                    // check size801                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");802803                    // Create nft item804                    let item = NftItemType {805                        collection: collection_id,806                        owner: owner,807                        data: properties.clone(),808                    };809810                    Self::add_nft_item(item)?;811812                },813                CollectionMode::Fungible(_) => {814815                    // check size816                    ensure!(properties.len() as u32 == 0, "Size of item must be 0 with fungible type");817818                    let item = FungibleItemType {819                        collection: collection_id,820                        owner: owner,821                        value: (10 as u128).pow(target_collection.decimal_points)822                    };823824                    Self::add_fungible_item(item)?;825                },826                CollectionMode::ReFungible(_, _) => {827828                    // check size829                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");830831                    let mut owner_list = Vec::new();832                    let value = (10 as u128).pow(target_collection.decimal_points);833                    owner_list.push(Ownership {owner: owner.clone(), fraction: value});834835                    let item = ReFungibleItemType {836                        collection: collection_id,837                        owner: owner_list,838                        data: properties.clone()839                    };840841                    Self::add_refungible_item(item)?;842                },843                _ => { ensure!(1 == 0,"just error"); }844845            };846847            // call event848            Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));849850            Ok(())851        }852853        /// Destroys a concrete instance of NFT.854        /// 855        /// # Permissions856        /// 857        /// * Collection Owner.858        /// * Collection Admin.859        /// * Current NFT Owner.860        /// 861        /// # Arguments862        /// 863        /// * collection_id: ID of the collection.864        /// 865        /// * item_id: ID of NFT to burn.866        #[weight = T::WeightInfo::burn_item()]867        pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {868869            let sender = ensure_signed(origin)?;870            Self::collection_exists(collection_id)?;871872            // Transfer permissions check873            let target_collection = <Collection<T>>::get(collection_id);874            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||875                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),876                "Only item owner, collection owner and admins can modify item");877878            if target_collection.access == AccessMode::WhiteList {879                Self::check_white_list(collection_id, &sender)?;880            }881882            match target_collection.mode883            {884                CollectionMode::NFT(_) => Self::burn_nft_item(collection_id, item_id)?,885                CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,886                CollectionMode::ReFungible(_, _)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,887                _ => ()888            };889890            // call event891            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));892893            Ok(())894        }895896        /// Change ownership of the token.897        /// 898        /// # Permissions899        /// 900        /// * Collection Owner901        /// * Collection Admin902        /// * Current NFT owner903        ///904        /// # Arguments905        /// 906        /// * recipient: Address of token recipient.907        /// 908        /// * collection_id.909        /// 910        /// * item_id: ID of the item911        ///     * Non-Fungible Mode: Required.912        ///     * Fungible Mode: Ignored.913        ///     * Re-Fungible Mode: Required.914        /// 915        /// * value: Amount to transfer.916        ///     * Non-Fungible Mode: Ignored917        ///     * Fungible Mode: Must specify transferred amount918        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)919        #[weight = T::WeightInfo::transfer()]920        pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {921922            let sender = ensure_signed(origin)?;923924            // Transfer permissions check925            let target_collection = <Collection<T>>::get(collection_id);926            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||927                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),928                "Only item owner, collection owner and admins can modify item");929930            if target_collection.access == AccessMode::WhiteList {931                Self::check_white_list(collection_id, &sender)?;932                Self::check_white_list(collection_id, &recipient)?;933            }934935            match target_collection.mode936            {937                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,938                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,939                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,940                _ => ()941            };942943            Ok(())944        }945946        /// Set, change, or remove approved address to transfer the ownership of the NFT.947        /// 948        /// # Permissions949        /// 950        /// * Collection Owner951        /// * Collection Admin952        /// * Current NFT owner953        /// 954        /// # Arguments955        /// 956        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).957        /// 958        /// * collection_id.959        /// 960        /// * item_id: ID of the item.961        #[weight = T::WeightInfo::approve()]962        pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {963964            let sender = ensure_signed(origin)?;965966            // Transfer permissions check967            let target_collection = <Collection<T>>::get(collection_id);968            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||969                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),970                "Only item owner, collection owner and admins can approve");971972            if target_collection.access == AccessMode::WhiteList {973                Self::check_white_list(collection_id, &sender)?;974                Self::check_white_list(collection_id, &approved)?;975            }976977            // amount param stub978            let amount = 100000000;979980            let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));981            if list_exists {982983                let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));984                let item_contains = list.iter().any(|i| i.approved == approved);985986                if !item_contains {987                    list.push(ApprovePermissions { approved: approved.clone(), amount: amount });988                    <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);989                }990            } else {991992                let mut list = Vec::new();993                list.push(ApprovePermissions { approved: approved.clone(), amount: amount });994                <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);995            }996997            Ok(())998        }999        1000        /// 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.1001        /// 1002        /// # Permissions1003        /// * Collection Owner1004        /// * Collection Admin1005        /// * Current NFT owner1006        /// * Address approved by current NFT owner1007        /// 1008        /// # Arguments1009        /// 1010        /// * from: Address that owns token.1011        /// 1012        /// * recipient: Address of token recipient.1013        /// 1014        /// * collection_id.1015        /// 1016        /// * item_id: ID of the item.1017        /// 1018        /// * value: Amount to transfer.1019        #[weight = T::WeightInfo::transfer_from()]1020        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {10211022            let sender = ensure_signed(origin)?;1023            let mut appoved_transfer = false;10241025            // Check approve1026            if <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone())) {1027                let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));1028                let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());1029                if opt_item.is_some()1030                {1031                    appoved_transfer = true;1032                    ensure!(opt_item.unwrap().amount >= value, "Requested value more than approved");1033                }1034            }10351036            // Transfer permissions check1037            let target_collection = <Collection<T>>::get(collection_id);1038            ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1039                "Only item owner, collection owner and admins can modify items");10401041            if target_collection.access == AccessMode::WhiteList {1042                Self::check_white_list(collection_id, &sender)?;1043                Self::check_white_list(collection_id, &recipient)?;1044            }10451046            // remove approve1047            let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))1048                .into_iter().filter(|i| i.approved != sender.clone()).collect();1049            <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);105010511052            match target_collection.mode1053            {1054                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, from, recipient)?,1055                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,1056                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1057                _ => ()1058            };10591060            Ok(())1061        }10621063        ///1064        #[weight = 0]1065        pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {10661067            // let no_perm_mes = "You do not have permissions to modify this collection";1068            // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1069            // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1070            // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10711072            // // on_nft_received  call10731074            // Self::transfer(origin, collection_id, item_id, new_owner)?;10751076            Ok(())1077        }10781079        /// Set off-chain data schema.1080        /// 1081        /// # Permissions1082        /// 1083        /// * Collection Owner1084        /// * Collection Admin1085        /// 1086        /// # Arguments1087        /// 1088        /// * collection_id.1089        /// 1090        /// * schema: String representing the offchain data schema.1091        #[weight = T::WeightInfo::set_offchain_schema()]1092        pub fn set_offchain_schema(1093            origin,1094            collection_id: u64,1095            schema: Vec<u8>1096        ) -> DispatchResult {1097            let sender = ensure_signed(origin)?;1098            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;10991100            let mut target_collection = <Collection<T>>::get(collection_id);1101            target_collection.offchain_schema = schema;1102            <Collection<T>>::insert(collection_id, target_collection);11031104            Ok(())1105        }11061107        // Sudo permissions function1108        #[weight = 0]1109        pub fn set_chain_limits(1110            origin,1111            limits: ChainLimits1112        ) -> DispatchResult {1113            ensure_root(origin)?;1114            <ChainLimit>::put(limits);1115            Ok(())1116        }11171118        /// Enable smart contract self-sponsoring.1119        /// 1120        /// # Permissions1121        /// 1122        /// * Contract Owner1123        /// 1124        /// # Arguments1125        /// 1126        /// * contract address1127        /// * enable flag1128        /// 1129        #[weight = 0]1130        pub fn enable_contract_sponsoring(1131            origin,1132            contract_address: T::AccountId,1133            enable: bool1134        ) -> DispatchResult {1135            let sender = ensure_signed(origin)?;1136            let mut is_owner = false;1137            if <ContractOwner<T>>::contains_key(contract_address.clone()) {1138                let owner = <ContractOwner<T>>::get(&contract_address);1139                is_owner = sender == owner;1140            }1141            ensure!(is_owner, "Only contract owner may call this method");11421143            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1144            Ok(())1145        }11461147    }1148}11491150impl<T: Trait> Module<T> {1151    fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {1152        let current_index = <ItemListIndex>::get(item.collection)1153            .checked_add(1)1154            .expect("Item list index id error");1155        let itemcopy = item.clone();1156        let owner = item.owner.clone();1157        let value = item.value as u64;11581159        Self::add_token_index(item.collection, current_index, owner.clone())?;11601161        <ItemListIndex>::insert(item.collection, current_index);1162        <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);11631164        // Add current block1165        let v: Vec<BasketItem<T::AccountId, T::BlockNumber>> = Vec::new();1166        <FungibleTransferBasket<T>>::insert(item.collection, current_index, v);1167        1168        // Update balance1169        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1170            .checked_add(value)1171            .unwrap();1172        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);11731174        Ok(())1175    }11761177    fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1178        let current_index = <ItemListIndex>::get(item.collection)1179            .checked_add(1)1180            .expect("Item list index id error");1181        let itemcopy = item.clone();11821183        let value = item.owner.first().unwrap().fraction as u64;1184        let owner = item.owner.first().unwrap().owner.clone();11851186        Self::add_token_index(item.collection, current_index, owner.clone())?;11871188        <ItemListIndex>::insert(item.collection, current_index);1189        <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);11901191        // Add current block1192        let block_number: T::BlockNumber = 0.into();1193        <ReFungibleTransferBasket<T>>::insert(item.collection, current_index, block_number);11941195        // Update balance1196        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1197            .checked_add(value)1198            .unwrap();1199        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);12001201        Ok(())1202    }12031204    fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {1205        let current_index = <ItemListIndex>::get(item.collection)1206            .checked_add(1)1207            .expect("Item list index id error");12081209        let item_owner = item.owner.clone();1210        let collection_id = item.collection.clone();1211        Self::add_token_index(collection_id, current_index, item.owner.clone())?;12121213        <ItemListIndex>::insert(collection_id, current_index);1214        <NftItemList<T>>::insert(collection_id, current_index, item);12151216        // Add current block1217        let block_number: T::BlockNumber = 0.into();1218        <NftTransferBasket<T>>::insert(collection_id, current_index, block_number);12191220        // Update balance1221        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1222            .checked_add(1)1223            .unwrap();1224        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);12251226        Ok(())1227    }12281229    fn burn_refungible_item(1230        collection_id: u64,1231        item_id: u64,1232        owner: T::AccountId,1233    ) -> DispatchResult {1234        ensure!(1235            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1236            "Item does not exists"1237        );1238        let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);1239        let item = collection1240            .owner1241            .iter()1242            .filter(|&i| i.owner == owner)1243            .next()1244            .unwrap();1245        Self::remove_token_index(collection_id, item_id, owner.clone())?;12461247        // remove approve list1248        <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));12491250        // update balance1251        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1252            .checked_sub(item.fraction as u64)1253            .unwrap();1254        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);12551256        <ReFungibleItemList<T>>::remove(collection_id, item_id);12571258        Ok(())1259    }12601261    fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {1262        ensure!(1263            <NftItemList<T>>::contains_key(collection_id, item_id),1264            "Item does not exists"1265        );1266        let item = <NftItemList<T>>::get(collection_id, item_id);1267        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;12681269        // remove approve list1270        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));12711272        // update balance1273        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1274            .checked_sub(1)1275            .unwrap();1276        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1277        <NftItemList<T>>::remove(collection_id, item_id);12781279        Ok(())1280    }12811282    fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {1283        ensure!(1284            <FungibleItemList<T>>::contains_key(collection_id, item_id),1285            "Item does not exists"1286        );1287        let item = <FungibleItemList<T>>::get(collection_id, item_id);1288        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;12891290        // remove approve list1291        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));12921293        // update balance1294        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1295            .checked_sub(item.value as u64)1296            .unwrap();1297        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);12981299        <FungibleItemList<T>>::remove(collection_id, item_id);13001301        Ok(())1302    }13031304    fn collection_exists(collection_id: u64) -> DispatchResult {1305        ensure!(1306            <Collection<T>>::contains_key(collection_id),1307            "This collection does not exist"1308        );1309        Ok(())1310    }13111312    fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {1313        Self::collection_exists(collection_id)?;13141315        let target_collection = <Collection<T>>::get(collection_id);1316        ensure!(1317            subject == target_collection.owner,1318            "You do not own this collection"1319        );13201321        Ok(())1322    }13231324    fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {1325        let target_collection = <Collection<T>>::get(collection_id);1326        let mut result: bool = subject == target_collection.owner;1327        let exists = <AdminList<T>>::contains_key(collection_id);13281329        if !result & exists {1330            if <AdminList<T>>::get(collection_id).contains(&subject) {1331                result = true1332            }1333        }13341335        result1336    }13371338    fn check_owner_or_admin_permissions(1339        collection_id: u64,1340        subject: T::AccountId,1341    ) -> DispatchResult {1342        Self::collection_exists(collection_id)?;1343        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());13441345        ensure!(1346            result,1347            "You do not have permissions to modify this collection"1348        );1349        Ok(())1350    }13511352    fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {1353        let target_collection = <Collection<T>>::get(collection_id);13541355        match target_collection.mode {1356            CollectionMode::NFT(_) => {1357                <NftItemList<T>>::get(collection_id, item_id).owner == subject1358            }1359            CollectionMode::Fungible(_) => {1360                <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1361            }1362            CollectionMode::ReFungible(_, _) => {1363                <ReFungibleItemList<T>>::get(collection_id, item_id)1364                    .owner1365                    .iter()1366                    .any(|i| i.owner == subject)1367            }1368            CollectionMode::Invalid => false,1369        }1370    }13711372    fn check_white_list(collection_id: u64, address: &T::AccountId) -> DispatchResult {1373        let mes = "Address is not in white list";1374        ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1375        let wl = <WhiteList<T>>::get(collection_id);1376        ensure!(wl.contains(address), mes);13771378        Ok(())1379    }13801381    fn transfer_fungible(1382        collection_id: u64,1383        item_id: u64,1384        value: u64,1385        owner: T::AccountId,1386        new_owner: T::AccountId,1387    ) -> DispatchResult {1388        ensure!(1389            <FungibleItemList<T>>::contains_key(collection_id, item_id),1390            "Item not exists"1391        );13921393        let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1394        let amount = full_item.value;13951396        ensure!(amount >= value.into(), "Item balance not enouth");13971398        // update balance1399        let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1400            .checked_sub(value)1401            .unwrap();1402        <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);14031404        let mut new_owner_account_id = 0;1405        let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());1406        if new_owner_items.len() > 0 {1407            new_owner_account_id = new_owner_items[0];1408        }14091410        let val64 = value.into();14111412        // transfer1413        if amount == val64 && new_owner_account_id == 0 {1414            // change owner1415            // new owner do not have account1416            let mut new_full_item = full_item.clone();1417            new_full_item.owner = new_owner.clone();1418            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);14191420            // update balance1421            let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1422                .checked_add(value)1423                .unwrap();1424            <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);14251426            // update index collection1427            Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1428        } else {1429            let mut new_full_item = full_item.clone();1430            new_full_item.value -= val64;14311432            // separate amount1433            if new_owner_account_id > 0 {1434                // new owner has account1435                let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1436                item.value += val64;14371438                // update balance1439                let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1440                    .checked_add(value)1441                    .unwrap();1442                <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);14431444                <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);1445            } else {1446                // new owner do not have account1447                let item = FungibleItemType {1448                    collection: collection_id,1449                    owner: new_owner.clone(),1450                    value: val64,1451                };14521453                Self::add_fungible_item(item)?;1454            }14551456            if amount == val64 {1457                Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;14581459                // remove approve list1460                <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));1461                <FungibleItemList<T>>::remove(collection_id, item_id);1462            }14631464            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1465        }14661467        Ok(())1468    }14691470    fn transfer_refungible(1471        collection_id: u64,1472        item_id: u64,1473        value: u64,1474        owner: T::AccountId,1475        new_owner: T::AccountId,1476    ) -> DispatchResult {1477        ensure!(1478            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1479            "Item not exists"1480        );14811482        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1483        let item = full_item1484            .owner1485            .iter()1486            .filter(|i| i.owner == owner)1487            .next()1488            .unwrap();1489        let amount = item.fraction;14901491        ensure!(amount >= value.into(), "Item balance not enouth");14921493        // update balance1494        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1495            .checked_sub(value)1496            .unwrap();1497        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);14981499        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1500            .checked_add(value)1501            .unwrap();1502        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);15031504        let old_owner = item.owner.clone();1505        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);1506        let val64 = value.into();15071508        // transfer1509        if amount == val64 && !new_owner_has_account {1510            // change owner1511            // new owner do not have account1512            let mut new_full_item = full_item.clone();1513            new_full_item1514                .owner1515                .iter_mut()1516                .find(|i| i.owner == owner)1517                .unwrap()1518                .owner = new_owner.clone();1519            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);15201521            // update index collection1522            Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1523        } else {1524            let mut new_full_item = full_item.clone();1525            new_full_item1526                .owner1527                .iter_mut()1528                .find(|i| i.owner == owner)1529                .unwrap()1530                .fraction -= val64;15311532            // separate amount1533            if new_owner_has_account {1534                // new owner has account1535                new_full_item1536                    .owner1537                    .iter_mut()1538                    .find(|i| i.owner == new_owner)1539                    .unwrap()1540                    .fraction += val64;1541            } else {1542                // new owner do not have account1543                new_full_item.owner.push(Ownership {1544                    owner: new_owner.clone(),1545                    fraction: val64,1546                });1547                Self::add_token_index(collection_id, item_id, new_owner.clone())?;1548            }15491550            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1551        }15521553        Ok(())1554    }15551556    fn transfer_nft(1557        collection_id: u64,1558        item_id: u64,1559        sender: T::AccountId,1560        new_owner: T::AccountId,1561    ) -> DispatchResult {1562        ensure!(1563            <NftItemList<T>>::contains_key(collection_id, item_id),1564            "Item not exists"1565        );15661567        let mut item = <NftItemList<T>>::get(collection_id, item_id);15681569        ensure!(1570            sender == item.owner,1571            "sender parameter and item owner must be equal"1572        );15731574        // update balance1575        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1576            .checked_sub(1)1577            .unwrap();1578        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);15791580        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1581            .checked_add(1)1582            .unwrap();1583        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);15841585        // change owner1586        let old_owner = item.owner.clone();1587        item.owner = new_owner.clone();1588        <NftItemList<T>>::insert(collection_id, item_id, item);15891590        // update index collection1591        Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;15921593        // reset approved list1594        <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1595        Ok(())1596    }15971598    fn init_collection(item: &CollectionType<T::AccountId>) {1599        // check params1600        assert!(1601            item.decimal_points <= 4,1602            "decimal_points parameter must be lower than 4"1603        );1604        assert!(1605            item.name.len() <= 64,1606            "Collection name can not be longer than 63 char"1607        );1608        assert!(1609            item.name.len() <= 256,1610            "Collection description can not be longer than 255 char"1611        );1612        assert!(1613            item.token_prefix.len() <= 16,1614            "Token prefix can not be longer than 15 char"1615        );16161617        // Generate next collection ID1618        let next_id = CreatedCollectionCount::get()1619            .checked_add(1)1620            .expect("collection id error");16211622        CreatedCollectionCount::put(next_id);1623    }16241625    fn init_nft_token(item: &NftItemType<T::AccountId>) {1626        let current_index = <ItemListIndex>::get(item.collection)1627            .checked_add(1)1628            .expect("Item list index id error");16291630        let item_owner = item.owner.clone();1631        let collection_id = item.collection.clone();1632        Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();16331634        <ItemListIndex>::insert(collection_id, current_index);16351636        // Update balance1637        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1638            .checked_add(1)1639            .unwrap();1640        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);1641    }16421643    fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {1644        let current_index = <ItemListIndex>::get(item.collection)1645            .checked_add(1)1646            .expect("Item list index id error");1647        let owner = item.owner.clone();1648        let value = item.value as u64;16491650        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();16511652        <ItemListIndex>::insert(item.collection, current_index);16531654        // Update balance1655        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1656            .checked_add(value)1657            .unwrap();1658        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1659    }16601661    fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {1662        let current_index = <ItemListIndex>::get(item.collection)1663            .checked_add(1)1664            .expect("Item list index id error");16651666        let value = item.owner.first().unwrap().fraction as u64;1667        let owner = item.owner.first().unwrap().owner.clone();16681669        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();16701671        <ItemListIndex>::insert(item.collection, current_index);16721673        // Update balance1674        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1675            .checked_add(value)1676            .unwrap();1677        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1678    }16791680    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {16811682        // add to account limit1683        if <AccountItemCount<T>>::contains_key(owner.clone()) {16841685            // bound Owned tokens by a single address1686            let count = <AccountItemCount<T>>::get(owner.clone());1687            ensure!(count < ChainLimit::get().account_token_ownership_limit, "Owned tokens by a single address bound exceeded");16881689            <AccountItemCount<T>>::insert(owner.clone(), 1690                count.checked_add(1).unwrap());1691        }1692        else {1693            <AccountItemCount<T>>::insert(owner.clone(), 1);1694        }16951696        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1697        if list_exists {1698            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1699            let item_contains = list.contains(&item_index.clone());17001701            if !item_contains {1702                list.push(item_index.clone());1703            }17041705            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);1706        } else {1707            let mut itm = Vec::new();1708            itm.push(item_index.clone());1709            <AddressTokens<T>>::insert(collection_id, owner, itm);1710            1711        }17121713        Ok(())1714    }17151716    fn remove_token_index(1717        collection_id: u64,1718        item_index: u64,1719        owner: T::AccountId,1720    ) -> DispatchResult {17211722        // update counter1723        <AccountItemCount<T>>::insert(owner.clone(), 1724            <AccountItemCount<T>>::get(owner.clone()).checked_sub(1).unwrap());172517261727        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1728        if list_exists {1729            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1730            let item_contains = list.contains(&item_index.clone());17311732            if item_contains {1733                list.retain(|&item| item != item_index);1734                <AddressTokens<T>>::insert(collection_id, owner, list);1735            }1736        }17371738        Ok(())1739    }17401741    fn move_token_index(1742        collection_id: u64,1743        item_index: u64,1744        old_owner: T::AccountId,1745        new_owner: T::AccountId,1746    ) -> DispatchResult {1747        Self::remove_token_index(collection_id, item_index, old_owner)?;1748        Self::add_token_index(collection_id, item_index, new_owner)?;17491750        Ok(())1751    }1752}17531754////////////////////////////////////////////////////////////////////////////////////////////////////1755// Economic models1756// #region17571758/// Fee multiplier.1759pub type Multiplier = FixedU128;17601761type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1762    <T as system::Trait>::AccountId,1763>>::Balance;1764type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1765    <T as system::Trait>::AccountId,1766>>::NegativeImbalance;17671768/// Require the transactor pay for themselves and maybe include a tip to gain additional priority1769/// in the queue.1770#[derive(Encode, Decode, Clone, Eq, PartialEq)]1771pub struct ChargeTransactionPayment<T: Trait + Send + Sync>(1772    #[codec(compact)] BalanceOf<T>1773);17741775impl<T: Trait + Send + Sync> sp_std::fmt::Debug1776    for ChargeTransactionPayment<T>1777{1778    #[cfg(feature = "std")]1779    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1780        write!(f, "ChargeTransactionPayment<{:?}>", self.0)1781    }1782    #[cfg(not(feature = "std"))]1783    fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1784        Ok(())1785    }1786}17871788impl<T: Trait + Send + Sync> ChargeTransactionPayment<T>1789where1790    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,1791    BalanceOf<T>: Send + Sync + FixedPointOperand,1792{1793    /// utility constructor. Used only in client/factory code.1794    pub fn from(fee: BalanceOf<T>) -> Self {1795        Self(fee)1796    }17971798    pub fn traditional_fee(1799        len: usize,1800        info: &DispatchInfoOf<T::Call>,1801        tip: BalanceOf<T>,1802    ) -> BalanceOf<T>1803    where1804        T::Call: Dispatchable<Info = DispatchInfo>,1805    {1806        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)1807    }18081809    fn withdraw_fee(1810        &self,1811        who: &T::AccountId,1812        call: &T::Call,1813        info: &DispatchInfoOf<T::Call>,1814        len: usize,1815    ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {1816        let tip = self.0;18171818        // Set fee based on call type. Creating collection costs 1 Unique.1819        // All other transactions have traditional fees so far1820        // let fee = match call.is_sub_type() {1821        //     Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),1822        //     _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes1823        //                                                 // _ => <BalanceOf<T>>::from(100)1824        // };1825        let fee = Self::traditional_fee(len, info, tip);18261827        // Determine who is paying transaction fee based on ecnomic model1828        // Parse call to extract collection ID and access collection sponsor1829        let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {1830            Some(Call::create_item(collection_id, _properties, _owner)) => {1831                <Collection<T>>::get(collection_id).sponsor1832            }1833            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {1834                let _collection_mode = <Collection<T>>::get(collection_id).mode;18351836                // sponsor timeout1837                let sponsor_transfer = match _collection_mode {1838                    CollectionMode::NFT(_) => {1839                        let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);1840                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;1841                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();1842                        if block_number >= limit_time {1843                            <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);1844                            true1845                        }1846                        else {1847                            false1848                        }1849                    }1850                    CollectionMode::Fungible(_) => {1851                        let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);1852                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;1853                        if basket.iter().any(|i| i.address == _new_owner.clone())1854                        {1855                            let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();1856                            let limit_time = item.start_block + ChainLimit::get().fungible_sponsor_transfer_timeout.into();1857                            if block_number >= limit_time {1858                                basket.retain(|x| x.address == item.address);1859                                basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });1860                                <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);1861                                true1862                            }1863                            else {1864                                false1865                            }1866                        }1867                        else {1868                            basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});1869                            true1870                        }1871                    }1872                    CollectionMode::ReFungible(_, _) => {1873                        let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);1874                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;1875                        let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();1876                        if block_number >= limit_time {1877                            <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);1878                            true1879                        } else {1880                            false1881                        }1882                    }1883                    _ => {1884                        false1885                    },1886                };18871888                if !sponsor_transfer {1889                    T::AccountId::default()1890                } else {1891                    <Collection<T>>::get(collection_id).sponsor1892                }1893            }18941895            _ => T::AccountId::default(),1896        };18971898        // Sponsor smart contracts1899        sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {19001901            // On instantiation: set the contract owner1902            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, data)) => {19031904                let new_contract_address = <T as pallet_contracts::Trait>::DetermineContractAddress::contract_address_for(1905                    code_hash,1906                    &data,1907                    &who,1908                );1909                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());19101911                T::AccountId::default()1912            },19131914            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is1915            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {19161917                let mut sp = T::AccountId::default();1918                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());1919                if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {1920                    if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {1921                        sp = called_contract;1922                    }1923                }19241925                sp1926            },19271928            _ => sponsor,1929        };19301931        let mut who_pays_fee: T::AccountId = sponsor.clone();1932        if sponsor == T::AccountId::default() {1933            who_pays_fee = who.clone();1934        }19351936        // Only mess with balances if fee is not zero.1937        if fee.is_zero() {1938            return Ok((fee, None));1939        }19401941        match <T as transaction_payment::Trait>::Currency::withdraw(1942            &who_pays_fee,1943            fee,1944            if tip.is_zero() {1945                WithdrawReason::TransactionPayment.into()1946            } else {1947                WithdrawReason::TransactionPayment | WithdrawReason::Tip1948            },1949            ExistenceRequirement::KeepAlive,1950        ) {1951            Ok(imbalance) => Ok((fee, Some(imbalance))),1952            Err(_) => Err(InvalidTransaction::Payment.into()),1953        }1954    }1955}195619571958impl<T: Trait + Send + Sync> SignedExtension1959    for ChargeTransactionPayment<T>1960where1961    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,1962    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,1963{1964    const IDENTIFIER: &'static str = "ChargeTransactionPayment";1965    type AccountId = T::AccountId;1966    type Call = T::Call;1967    type AdditionalSigned = ();1968    type Pre = (1969        BalanceOf<T>,1970        Self::AccountId,1971        Option<NegativeImbalanceOf<T>>,1972        BalanceOf<T>,1973    );1974    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {1975        Ok(())1976    }19771978    fn validate(1979        &self,1980        _who: &Self::AccountId,1981        _call: &Self::Call,1982        _info: &DispatchInfoOf<Self::Call>,1983        _len: usize,1984    ) -> TransactionValidity {1985        Ok(ValidTransaction::default())1986    }19871988    fn pre_dispatch(1989        self,1990        who: &Self::AccountId,1991        call: &Self::Call,1992        info: &DispatchInfoOf<Self::Call>,1993        len: usize,1994    ) -> Result<Self::Pre, TransactionValidityError> {1995        let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;1996        Ok((self.0, who.clone(), imbalance, fee))1997    }19981999    fn post_dispatch(2000        pre: Self::Pre,2001        info: &DispatchInfoOf<Self::Call>,2002        post_info: &PostDispatchInfoOf<Self::Call>,2003        len: usize,2004        _result: &DispatchResult,2005    ) -> Result<(), TransactionValidityError> {2006        let (tip, who, imbalance, fee) = pre;2007        if let Some(payed) = imbalance {2008            let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(2009                len as u32, info, post_info, tip,2010            );2011            let refund = fee.saturating_sub(actual_fee);2012            let actual_payment =2013                match <T as transaction_payment::Trait>::Currency::deposit_into_existing(2014                    &who, refund,2015                ) {2016                    Ok(refund_imbalance) => {2017                        // The refund cannot be larger than the up front payed max weight.2018                        // `PostDispatchInfo::calc_unspent` guards against such a case.2019                        match payed.offset(refund_imbalance) {2020                            Ok(actual_payment) => actual_payment,2021                            Err(_) => return Err(InvalidTransaction::Payment.into()),2022                        }2023                    }2024                    // We do not recreate the account using the refund. The up front payment2025                    // is gone in that case.2026                    Err(_) => payed,2027                };2028            let imbalances = actual_payment.split(tip);2029            <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(2030                Some(imbalances.0).into_iter().chain(Some(imbalances.1)),2031            );2032        }2033        Ok(())2034    }2035}20362037// #endregion20382039