git.delta.rocks / unique-network / refs/commits / 2b0cd0f6b4f0

1#![cfg_attr(not(feature = "std"), no_std)]23#[cfg(feature = "std")]4pub use std::*;56#[cfg(feature = "std")]7pub use serde::*;89use codec::{Decode, Encode};10pub use frame_support::{11    construct_runtime, decl_event, decl_module, decl_storage, decl_error,12    dispatch::DispatchResult,13    ensure, fail, parameter_types,14    traits::{15        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,16        Randomness, WithdrawReason,17    },18    weights::{19        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},20        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,21        WeightToFeePolynomial,22    },23    IsSubType, StorageValue,24};2526use frame_system::{self as system, ensure_signed, ensure_root};27use sp_runtime::sp_std::prelude::Vec;28use sp_runtime::{29    traits::{30        DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SignedExtension, Zero,31    },32    transaction_validity::{33        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,34    },35    FixedPointOperand, FixedU128,36};37use pallet_contracts::ContractAddressFor;38use sp_runtime::traits::StaticLookup;3940#[cfg(test)]41mod mock;4243#[cfg(test)]44mod tests;4546mod default_weights;4748pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;49pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;50pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;5152// Structs53// #region5455pub type CollectionId = u32;56pub type TokenId = u32;5758pub type DecimalPoints = u8;5960#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]61#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]62pub enum CollectionMode {63    Invalid,64    NFT,65    // decimal points66    Fungible(DecimalPoints),67    // decimal points68    ReFungible(DecimalPoints),69}7071impl Into<u8> for CollectionMode {72    fn into(self) -> u8 {73        match self {74            CollectionMode::Invalid => 0,75            CollectionMode::NFT => 1,76            CollectionMode::Fungible(_) => 2,77            CollectionMode::ReFungible(_) => 3,78        }79    }80}8182#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]83#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]84pub enum AccessMode {85    Normal,86    WhiteList,87}88impl Default for AccessMode {89    fn default() -> Self {90        Self::Normal91    }92}9394impl Default for CollectionMode {95    fn default() -> Self {96        Self::Invalid97    }98}99100#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]101#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]102pub struct Ownership<AccountId> {103    pub owner: AccountId,104    pub fraction: u128,105}106107#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]108#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]109pub struct CollectionType<AccountId> {110    pub owner: AccountId,111    pub mode: CollectionMode,112    pub access: AccessMode,113    pub decimal_points: DecimalPoints,114    pub name: Vec<u16>,        // 64 include null escape char115    pub description: Vec<u16>, // 256 include null escape char116    pub token_prefix: Vec<u8>, // 16 include null escape char117    pub mint_mode: bool,118    pub offchain_schema: Vec<u8>,119    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender120    pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship121    pub limits: CollectionLimits, // Collection private restrictions 122    pub variable_on_chain_schema: Vec<u8>, //123    pub const_on_chain_schema: Vec<u8>, //124}125126#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]127#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]128pub struct NftItemType<AccountId> {129    pub collection: CollectionId,130    pub owner: AccountId,131    pub const_data: Vec<u8>,132    pub variable_data: Vec<u8>,133}134135#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]136#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]137pub struct FungibleItemType<AccountId> {138    pub collection: CollectionId,139    pub owner: AccountId,140    pub value: u128,141}142143#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]144#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]145pub struct ReFungibleItemType<AccountId> {146    pub collection: CollectionId,147    pub owner: Vec<Ownership<AccountId>>,148    pub const_data: Vec<u8>,149    pub variable_data: Vec<u8>,150}151152#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]153#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]154pub struct ApprovePermissions<AccountId> {155    pub approved: AccountId,156    pub amount: u128,157}158159#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]160#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]161pub struct VestingItem<AccountId, Moment> {162    pub sender: AccountId,163    pub recipient: AccountId,164    pub collection_id: CollectionId,165    pub item_id: TokenId,166    pub amount: u64,167    pub vesting_date: Moment,168}169170#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]171#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]172pub struct BasketItem<AccountId, BlockNumber> {173    pub address: AccountId,174    pub start_block: BlockNumber,175}176177#[derive(Encode, Decode, Debug, Clone, PartialEq)]178#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]179pub struct CollectionLimits {180    pub account_token_ownership_limit: u32,181    pub sponsored_data_size: u32,182    pub token_limit: u32,183184    // Timeouts for item types in passed blocks185    pub sponsor_transfer_timeout: u32,186}187188impl Default for CollectionLimits {189    fn default() -> CollectionLimits {190        CollectionLimits { 191            account_token_ownership_limit: 10_000_000, 192            token_limit: u32::max_value(),193            sponsored_data_size: u32::max_value(), 194            sponsor_transfer_timeout: 14400 }195    }196}197198#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]199#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]200pub struct ChainLimits {201    pub collection_numbers_limit: u32,202    pub account_token_ownership_limit: u32,203    pub collections_admins_limit: u64,204    pub custom_data_limit: u32,205206    // Timeouts for item types in passed blocks207    pub nft_sponsor_transfer_timeout: u32,208    pub fungible_sponsor_transfer_timeout: u32,209    pub refungible_sponsor_transfer_timeout: u32,210}211212pub trait WeightInfo {213	fn create_collection() -> Weight;214	fn destroy_collection() -> Weight;215	fn add_to_white_list() -> Weight;216	fn remove_from_white_list() -> Weight;217    fn set_public_access_mode() -> Weight;218    fn set_mint_permission() -> Weight;219    fn change_collection_owner() -> Weight;220    fn add_collection_admin() -> Weight;221    fn remove_collection_admin() -> Weight;222    fn set_collection_sponsor() -> Weight;223    fn confirm_sponsorship() -> Weight;224    fn remove_collection_sponsor() -> Weight;225    fn create_item(s: usize) -> Weight;226    fn burn_item() -> Weight;227    fn transfer() -> Weight;228    fn approve() -> Weight;229    fn transfer_from() -> Weight;230    fn set_offchain_schema() -> Weight;231    fn set_const_on_chain_schema() -> Weight;232    fn set_variable_on_chain_schema() -> Weight;233    fn set_variable_meta_data() -> Weight;234    fn enable_contract_sponsoring() -> Weight;235}236237#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]238#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]239pub struct CreateNftData {240    pub const_data: Vec<u8>,241    pub variable_data: Vec<u8>,242}243244#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]245#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]246pub struct CreateFungibleData {247}248249#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]250#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]251pub struct CreateReFungibleData {252    pub const_data: Vec<u8>,253    pub variable_data: Vec<u8>,254}255256#[derive(Encode, Decode, Debug, Clone, PartialEq)]257#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]258pub enum CreateItemData {259    NFT(CreateNftData),260    Fungible(CreateFungibleData),261    ReFungible(CreateReFungibleData)262}263264impl CreateItemData {265    pub fn len(&self) -> usize {266        let len = match self {267            CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),268            CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),269            _ => 0270        };271        272        return len;273    }274}275276impl From<CreateNftData> for CreateItemData {277    fn from(item: CreateNftData) -> Self {278        CreateItemData::NFT(item)279    }280}281282impl From<CreateReFungibleData> for CreateItemData {283    fn from(item: CreateReFungibleData) -> Self {284        CreateItemData::ReFungible(item)285    }286}287288impl From<CreateFungibleData> for CreateItemData {289    fn from(item: CreateFungibleData) -> Self {290        CreateItemData::Fungible(item)291    }292}293294295decl_error! {296	/// Error for non-fungible-token module.297	pub enum Error for Module<T: Trait> {298        /// Total collections bound exceeded.299        TotalCollectionsLimitExceeded,300		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.301        CollectionDecimalPointLimitExceeded, 302        /// Collection name can not be longer than 63 char.303        CollectionNameLimitExceeded, 304        /// Collection description can not be longer than 255 char.305        CollectionDescriptionLimitExceeded, 306        /// Token prefix can not be longer than 15 char.307        CollectionTokenPrefixLimitExceeded,308        /// This collection does not exist.309        CollectionNotFound,310        /// Item not exists.311        TokenNotFound,312        /// Arithmetic calculation overflow.313        NumOverflow,       314        /// Account already has admin role.315        AlreadyAdmin,  316        /// You do not own this collection.317        NoPermission,318        /// This address is not set as sponsor, use setCollectionSponsor first.319        ConfirmUnsetSponsorFail,320        /// Collection is not in mint mode.321        PublicMintingNotAllowed,322        /// Sender parameter and item owner must be equal.323        MustBeTokenOwner,324        /// Item balance not enough.325        TokenValueTooLow,326        /// Size of item is too large.327        NftSizeLimitExceeded,328        /// No approve found329        ApproveNotFound,330        /// Requested value more than approved.331        TokenValueNotEnough,332        /// Only approved addresses can call this method.333        ApproveRequired,334        /// Address is not in white list.335        AddresNotInWhiteList,336        /// Number of collection admins bound exceeded.337        CollectionAdminsLimitExceeded,338        /// Owned tokens by a single address bound exceeded.339        AddressOwnershipLimitExceeded,340        /// Length of items properties must be greater than 0.341        EmptyArgument,342        /// const_data exceeded data limit.343        TokenConstDataLimitExceeded,344        /// variable_data exceeded data limit.345        TokenVariableDataLimitExceeded,346        /// Not NFT item data used to mint in NFT collection.347        NotNftDataUsedToMintNftCollectionToken,348        /// Not Fungible item data used to mint in Fungible collection.349        NotFungibleDataUsedToMintFungibleCollectionToken,350        /// Not Re Fungible item data used to mint in Re Fungible collection.351        NotReFungibleDataUsedToMintReFungibleCollectionToken,352        /// Unexpected collection type.353        UnexpectedCollectionType,354        /// Can't store metadata in fungible tokens.355        CantStoreMetadataInFungibleTokens,356        /// Collection token limit exceeded357        CollectionTokenLimitExceeded,358        /// Account token limit exceeded per collection359        AccountTokenLimitExceeded,360        /// Collection limit bounds per collection exceeded361        CollectionLimitBoundsExceeded362	}363}364365pub trait Trait: system::Trait + Sized + transaction_payment::Trait + pallet_contracts::Trait {366    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;367368    /// Weight information for extrinsics in this pallet.369	type WeightInfo: WeightInfo;370}371372#[cfg(feature = "runtime-benchmarks")]373mod benchmarking;374375// #endregion376377decl_storage! {378    trait Store for Module<T: Trait> as Nft {379380        // Private members381        NextCollectionID: CollectionId;382        CreatedCollectionCount: u32;383        ChainVersion: u64;384        ItemListIndex: map hasher(identity) CollectionId => TokenId;385386        // Chain limits struct387        pub ChainLimit get(fn chain_limit) config(): ChainLimits;388389        // Bound counters390        CollectionCount: u32;391        pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;392393        // Basic collections394        pub Collection get(fn collection) config(): map hasher(identity) CollectionId => CollectionType<T::AccountId>;395        pub AdminList get(fn admin_list_collection): map hasher(identity) CollectionId => Vec<T::AccountId>;396        pub WhiteList get(fn white_list): map hasher(identity) CollectionId => Vec<T::AccountId>;397398        /// Balance owner per collection map399        pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;400401        /// second parameter: item id + owner account id402        pub ApprovedList get(fn approved): double_map hasher(identity) CollectionId, hasher(twox_64_concat) (TokenId, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;403404        /// Item collections405        pub NftItemList get(fn nft_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => NftItemType<T::AccountId>;406        pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => FungibleItemType<T::AccountId>;407        pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => ReFungibleItemType<T::AccountId>;408409        /// Index list410        pub AddressTokens get(fn address_tokens): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => Vec<TokenId>;411412        /// Tokens transfer baskets413        pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;414        pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => Vec<BasketItem<T::AccountId, T::BlockNumber>>;415        pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;416417        // Contract Sponsorship and Ownership418        pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;419        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;420        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;421        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;422    }423    add_extra_genesis {424        build(|config: &GenesisConfig<T>| {425            // Modification of storage426            for (_num, _c) in &config.collection {427                <Module<T>>::init_collection(_c);428            }429430            for (_num, _q, _i) in &config.nft_item_id {431                <Module<T>>::init_nft_token(_i);432            }433434            for (_num, _q, _i) in &config.fungible_item_id {435                <Module<T>>::init_fungible_token(_i);436            }437438            for (_num, _q, _i) in &config.refungible_item_id {439                <Module<T>>::init_refungible_token(_i);440            }441        })442    }443}444445decl_event!(446    pub enum Event<T>447    where448        AccountId = <T as system::Trait>::AccountId,449    {450        /// New collection was created451        /// 452        /// # Arguments453        /// 454        /// * collection_id: Globally unique identifier of newly created collection.455        /// 456        /// * mode: [CollectionMode] converted into u8.457        /// 458        /// * account_id: Collection owner.459        Created(CollectionId, u8, AccountId),460461        /// New item was created.462        /// 463        /// # Arguments464        /// 465        /// * collection_id: Id of the collection where item was created.466        /// 467        /// * item_id: Id of an item. Unique within the collection.468        ItemCreated(CollectionId, TokenId),469470        /// Collection item was burned.471        /// 472        /// # Arguments473        /// 474        /// collection_id.475        /// 476        /// item_id: Identifier of burned NFT.477        ItemDestroyed(CollectionId, TokenId),478    }479);480481decl_module! {482    pub struct Module<T: Trait> for enum Call where origin: T::Origin {483484        fn deposit_event() = default;485        type Error = Error<T>;486487        fn on_initialize(now: T::BlockNumber) -> Weight {488489            if ChainVersion::get() < 2490            {491                let value = NextCollectionID::get();492                CreatedCollectionCount::put(value);493                ChainVersion::put(2);494            }495496            0497        }498499        /// 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.500        /// 501        /// # Permissions502        /// 503        /// * Anyone.504        /// 505        /// # Arguments506        /// 507        /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.508        /// 509        /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.510        /// 511        /// * token_prefix: UTF-8 string with token prefix.512        /// 513        /// * mode: [CollectionMode] collection type and type dependent data.514        // returns collection ID515        #[weight = T::WeightInfo::create_collection()]516        pub fn create_collection(origin,517                                 collection_name: Vec<u16>,518                                 collection_description: Vec<u16>,519                                 token_prefix: Vec<u8>,520                                 mode: CollectionMode) -> DispatchResult {521522            // Anyone can create a collection523            let who = ensure_signed(origin)?;524525            let decimal_points = match mode {526                CollectionMode::Fungible(points) => points,527                CollectionMode::ReFungible(points) => points,528                _ => 0529            };530531            // bound Total number of collections532            ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);533534            // check params535            ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);536537            let mut name = collection_name.to_vec();538            name.push(0);539            ensure!(name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);540541            let mut description = collection_description.to_vec();542            description.push(0);543            ensure!(name.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);544545            let mut prefix = token_prefix.to_vec();546            prefix.push(0);547            ensure!(prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);548549            // Generate next collection ID550            let next_id = CreatedCollectionCount::get()551                .checked_add(1)552                .ok_or(Error::<T>::NumOverflow)?;553554            // bound counter555            let total = CollectionCount::get()556                .checked_add(1)557                .ok_or(Error::<T>::NumOverflow)?;558559            CreatedCollectionCount::put(next_id);560            CollectionCount::put(total);561562            // Create new collection563            let new_collection = CollectionType {564                owner: who.clone(),565                name: name,566                mode: mode.clone(),567                mint_mode: false,568                access: AccessMode::Normal,569                description: description,570                decimal_points: decimal_points,571                token_prefix: prefix,572                offchain_schema: Vec::new(),573                sponsor: T::AccountId::default(),574                unconfirmed_sponsor: T::AccountId::default(),575                variable_on_chain_schema: Vec::new(),576                const_on_chain_schema: Vec::new(),577                limits: CollectionLimits::default(),578            };579580            // Add new collection to map581            <Collection<T>>::insert(next_id, new_collection);582583            // call event584            Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));585586            Ok(())587        }588589        /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.590        /// 591        /// # Permissions592        /// 593        /// * Collection Owner.594        /// 595        /// # Arguments596        /// 597        /// * collection_id: collection to destroy.598        #[weight = T::WeightInfo::destroy_collection()]599        pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {600601            let sender = ensure_signed(origin)?;602            Self::check_owner_permissions(collection_id, sender)?;603604            <AddressTokens<T>>::remove_prefix(collection_id);605            <ApprovedList<T>>::remove_prefix(collection_id);606            <Balance<T>>::remove_prefix(collection_id);607            <ItemListIndex>::remove(collection_id);608            <AdminList<T>>::remove(collection_id);609            <Collection<T>>::remove(collection_id);610            <WhiteList<T>>::remove(collection_id);611612            <NftItemList<T>>::remove_prefix(collection_id);613            <FungibleItemList<T>>::remove_prefix(collection_id);614            <ReFungibleItemList<T>>::remove_prefix(collection_id);615616            <NftTransferBasket<T>>::remove_prefix(collection_id);617            <FungibleTransferBasket<T>>::remove_prefix(collection_id);618            <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);619620            if CollectionCount::get() > 0621            {622                // bound couter623                let total = CollectionCount::get()624                    .checked_sub(1)625                    .ok_or(Error::<T>::NumOverflow)?;626627                CollectionCount::put(total);628            }629630            Ok(())631        }632633        /// Add an address to white list.634        /// 635        /// # Permissions636        /// 637        /// * Collection Owner638        /// * Collection Admin639        /// 640        /// # Arguments641        /// 642        /// * collection_id.643        /// 644        /// * address.645        #[weight = T::WeightInfo::add_to_white_list()]646        pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{647648            let sender = ensure_signed(origin)?;649            Self::check_owner_or_admin_permissions(collection_id, sender)?;650651            let mut white_list_collection: Vec<T::AccountId>;652            if <WhiteList<T>>::contains_key(collection_id) {653                white_list_collection = <WhiteList<T>>::get(collection_id);654                if !white_list_collection.contains(&address.clone())655                {656                    white_list_collection.push(address.clone());657                }658            }659            else {660                white_list_collection = Vec::new();661                white_list_collection.push(address.clone());662            }663664            <WhiteList<T>>::insert(collection_id, white_list_collection);665            Ok(())666        }667668        /// Remove an address from white list.669        /// 670        /// # Permissions671        /// 672        /// * Collection Owner673        /// * Collection Admin674        /// 675        /// # Arguments676        /// 677        /// * collection_id.678        /// 679        /// * address.680        #[weight = T::WeightInfo::remove_from_white_list()]681        pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{682683            let sender = ensure_signed(origin)?;684            Self::check_owner_or_admin_permissions(collection_id, sender)?;685686            if <WhiteList<T>>::contains_key(collection_id) {687                let mut white_list_collection = <WhiteList<T>>::get(collection_id);688                if white_list_collection.contains(&address.clone())689                {690                    white_list_collection.retain(|i| *i != address.clone());691                    <WhiteList<T>>::insert(collection_id, white_list_collection);692                }693            }694695            Ok(())696        }697698        /// Toggle between normal and white list access for the methods with access for `Anyone`.699        /// 700        /// # Permissions701        /// 702        /// * Collection Owner.703        /// 704        /// # Arguments705        /// 706        /// * collection_id.707        /// 708        /// * mode: [AccessMode]709        #[weight = T::WeightInfo::set_public_access_mode()]710        pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult711        {712            let sender = ensure_signed(origin)?;713714            Self::check_owner_permissions(collection_id, sender)?;715            let mut target_collection = <Collection<T>>::get(collection_id);716            target_collection.access = mode;717            <Collection<T>>::insert(collection_id, target_collection);718719            Ok(())720        }721722        /// Allows Anyone to create tokens if:723        /// * White List is enabled, and724        /// * Address is added to white list, and725        /// * This method was called with True parameter726        /// 727        /// # Permissions728        /// * Collection Owner729        ///730        /// # Arguments731        /// 732        /// * collection_id.733        /// 734        /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.735        #[weight = T::WeightInfo::set_mint_permission()]736        pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult737        {738            let sender = ensure_signed(origin)?;739740            Self::check_owner_permissions(collection_id, sender)?;741            let mut target_collection = <Collection<T>>::get(collection_id);742            target_collection.mint_mode = mint_permission;743            <Collection<T>>::insert(collection_id, target_collection);744745            Ok(())746        }747748        /// Change the owner of the collection.749        /// 750        /// # Permissions751        /// 752        /// * Collection Owner.753        /// 754        /// # Arguments755        /// 756        /// * collection_id.757        /// 758        /// * new_owner.759        #[weight = T::WeightInfo::change_collection_owner()]760        pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {761762            let sender = ensure_signed(origin)?;763            Self::check_owner_permissions(collection_id, sender)?;764            let mut target_collection = <Collection<T>>::get(collection_id);765            target_collection.owner = new_owner;766            <Collection<T>>::insert(collection_id, target_collection);767768            Ok(())769        }770771        /// Adds an admin of the Collection.772        /// 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. 773        /// 774        /// # Permissions775        /// 776        /// * Collection Owner.777        /// * Collection Admin.778        /// 779        /// # Arguments780        /// 781        /// * collection_id: ID of the Collection to add admin for.782        /// 783        /// * new_admin_id: Address of new admin to add.784        #[weight = T::WeightInfo::add_collection_admin()]785        pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {786787            let sender = ensure_signed(origin)?;788            Self::check_owner_or_admin_permissions(collection_id, sender)?;789            let mut admin_arr: Vec<T::AccountId> = Vec::new();790791            if <AdminList<T>>::contains_key(collection_id)792            {793                admin_arr = <AdminList<T>>::get(collection_id);794                ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);795            }796797            // Number of collection admins798            ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);799800            admin_arr.push(new_admin_id);801            <AdminList<T>>::insert(collection_id, admin_arr);802803            Ok(())804        }805806        /// 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.807        ///808        /// # Permissions809        /// 810        /// * Collection Owner.811        /// * Collection Admin.812        /// 813        /// # Arguments814        /// 815        /// * collection_id: ID of the Collection to remove admin for.816        /// 817        /// * account_id: Address of admin to remove.818        #[weight = T::WeightInfo::remove_collection_admin()]819        pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {820821            let sender = ensure_signed(origin)?;822            Self::check_owner_or_admin_permissions(collection_id, sender)?;823824            if <AdminList<T>>::contains_key(collection_id)825            {826                let mut admin_arr = <AdminList<T>>::get(collection_id);827                admin_arr.retain(|i| *i != account_id);828                <AdminList<T>>::insert(collection_id, admin_arr);829            }830831            Ok(())832        }833834        /// # Permissions835        /// 836        /// * Collection Owner837        /// 838        /// # Arguments839        /// 840        /// * collection_id.841        /// 842        /// * new_sponsor.843        #[weight = T::WeightInfo::set_collection_sponsor()]844        pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {845846            let sender = ensure_signed(origin)?;847            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);848849            let mut target_collection = <Collection<T>>::get(collection_id);850            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);851852            target_collection.unconfirmed_sponsor = new_sponsor;853            <Collection<T>>::insert(collection_id, target_collection);854855            Ok(())856        }857858        /// # Permissions859        /// 860        /// * Sponsor.861        /// 862        /// # Arguments863        /// 864        /// * collection_id.865        #[weight = T::WeightInfo::confirm_sponsorship()]866        pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {867868            let sender = ensure_signed(origin)?;869            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);870871            let mut target_collection = <Collection<T>>::get(collection_id);872            ensure!(sender == target_collection.unconfirmed_sponsor, Error::<T>::ConfirmUnsetSponsorFail);873874            target_collection.sponsor = target_collection.unconfirmed_sponsor;875            target_collection.unconfirmed_sponsor = T::AccountId::default();876            <Collection<T>>::insert(collection_id, target_collection);877878            Ok(())879        }880881        /// Switch back to pay-per-own-transaction model.882        ///883        /// # Permissions884        ///885        /// * Collection owner.886        /// 887        /// # Arguments888        /// 889        /// * collection_id.890        #[weight = T::WeightInfo::remove_collection_sponsor()]891        pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {892893            let sender = ensure_signed(origin)?;894            ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);895896            let mut target_collection = <Collection<T>>::get(collection_id);897            ensure!(sender == target_collection.owner, Error::<T>::NoPermission);898899            target_collection.sponsor = T::AccountId::default();900            <Collection<T>>::insert(collection_id, target_collection);901902            Ok(())903        }904905        /// This method creates a concrete instance of NFT Collection created with CreateCollection method.906        /// 907        /// # Permissions908        /// 909        /// * Collection Owner.910        /// * Collection Admin.911        /// * Anyone if912        ///     * White List is enabled, and913        ///     * Address is added to white list, and914        ///     * MintPermission is enabled (see SetMintPermission method)915        /// 916        /// # Arguments917        /// 918        /// * collection_id: ID of the collection.919        /// 920        /// * owner: Address, initial owner of the NFT.921        ///922        /// * data: Token data to store on chain.923        // #[weight =924        // (130_000_000 as Weight)925        // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))926        // .saturating_add(RocksDbWeight::get().reads(10 as Weight))927        // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]928929        #[weight = T::WeightInfo::create_item(data.len())]930        pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {931932            let sender = ensure_signed(origin)?;933934            Self::collection_exists(collection_id)?;935936            let target_collection = <Collection<T>>::get(collection_id);937938            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;939            Self::validate_create_item_args(&target_collection, &data)?;940            Self::create_item_no_validation(collection_id, &target_collection, owner, data)?;941942            Ok(())943        }944945        /// This method creates multiple instances of NFT Collection created with CreateCollection method.946        /// 947        /// # Permissions948        /// 949        /// * Collection Owner.950        /// * Collection Admin.951        /// * Anyone if952        ///     * White List is enabled, and953        ///     * Address is added to white list, and954        ///     * MintPermission is enabled (see SetMintPermission method)955        /// 956        /// # Arguments957        /// 958        /// * collection_id: ID of the collection.959        /// 960        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].961        /// 962        /// * owner: Address, initial owner of the NFT.963        #[weight = T::WeightInfo::create_item(items_data.into_iter()964                               .map(|data| { data.len() })965                               .sum())]966        pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {967968            ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);969            let sender = ensure_signed(origin)?;970971            Self::collection_exists(collection_id)?;972            let target_collection = <Collection<T>>::get(collection_id);973974            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;975976            for data in &items_data {977                Self::validate_create_item_args(&target_collection, data)?;978            }979            for data in &items_data {980                Self::create_item_no_validation(collection_id, &target_collection, owner.clone(), data.clone())?;981            }982983            Ok(())984        }985986        /// Destroys a concrete instance of NFT.987        /// 988        /// # Permissions989        /// 990        /// * Collection Owner.991        /// * Collection Admin.992        /// * Current NFT Owner.993        /// 994        /// # Arguments995        /// 996        /// * collection_id: ID of the collection.997        /// 998        /// * item_id: ID of NFT to burn.999        #[weight = T::WeightInfo::burn_item()]1000        pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId) -> DispatchResult {10011002            let sender = ensure_signed(origin)?;1003            Self::collection_exists(collection_id)?;10041005            // Transfer permissions check1006            let target_collection = <Collection<T>>::get(collection_id);1007            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1008                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1009                Error::<T>::NoPermission);10101011            if target_collection.access == AccessMode::WhiteList {1012                Self::check_white_list(collection_id, &sender)?;1013            }10141015            match target_collection.mode1016            {1017                CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1018                CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,1019                CollectionMode::ReFungible(_)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,1020                _ => ()1021            };10221023            // call event1024            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));10251026            Ok(())1027        }10281029        /// Change ownership of the token.1030        /// 1031        /// # Permissions1032        /// 1033        /// * Collection Owner1034        /// * Collection Admin1035        /// * Current NFT owner1036        ///1037        /// # Arguments1038        /// 1039        /// * recipient: Address of token recipient.1040        /// 1041        /// * collection_id.1042        /// 1043        /// * item_id: ID of the item1044        ///     * Non-Fungible Mode: Required.1045        ///     * Fungible Mode: Ignored.1046        ///     * Re-Fungible Mode: Required.1047        /// 1048        /// * value: Amount to transfer.1049        ///     * Non-Fungible Mode: Ignored1050        ///     * Fungible Mode: Must specify transferred amount1051        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1052        #[weight = T::WeightInfo::transfer()]1053        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {10541055            let sender = ensure_signed(origin)?;1056            let target_collection = <Collection<T>>::get(collection_id);10571058            // Limits check1059            Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;10601061            // Transfer permissions check1062            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1063                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1064                Error::<T>::NoPermission);10651066            if target_collection.access == AccessMode::WhiteList {1067                Self::check_white_list(collection_id, &sender)?;1068                Self::check_white_list(collection_id, &recipient)?;1069            }10701071            match target_collection.mode1072            {1073                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,1074                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,1075                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,1076                _ => ()1077            };10781079            Ok(())1080        }10811082        /// Set, change, or remove approved address to transfer the ownership of the NFT.1083        /// 1084        /// # Permissions1085        /// 1086        /// * Collection Owner1087        /// * Collection Admin1088        /// * Current NFT owner1089        /// 1090        /// # Arguments1091        /// 1092        /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1093        /// 1094        /// * collection_id.1095        /// 1096        /// * item_id: ID of the item.1097        #[weight = T::WeightInfo::approve()]1098        pub fn approve(origin, approved: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> DispatchResult {10991100            let sender = ensure_signed(origin)?;11011102            // Transfer permissions check1103            let target_collection = <Collection<T>>::get(collection_id);1104            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1105                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1106                Error::<T>::NoPermission);11071108            if target_collection.access == AccessMode::WhiteList {1109                Self::check_white_list(collection_id, &sender)?;1110                Self::check_white_list(collection_id, &approved)?;1111            }11121113            // amount param stub1114            let amount = 100000000;11151116            let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));1117            if list_exists {11181119                let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));1120                let item_contains = list.iter().any(|i| i.approved == approved);11211122                if !item_contains {1123                    list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1124                    <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1125                }1126            } else {11271128                let mut list = Vec::new();1129                list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1130                <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1131            }11321133            Ok(())1134        }1135        1136        /// 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.1137        /// 1138        /// # Permissions1139        /// * Collection Owner1140        /// * Collection Admin1141        /// * Current NFT owner1142        /// * Address approved by current NFT owner1143        /// 1144        /// # Arguments1145        /// 1146        /// * from: Address that owns token.1147        /// 1148        /// * recipient: Address of token recipient.1149        /// 1150        /// * collection_id.1151        /// 1152        /// * item_id: ID of the item.1153        /// 1154        /// * value: Amount to transfer.1155        #[weight = T::WeightInfo::transfer_from()]1156        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {11571158            let sender = ensure_signed(origin)?;1159            let mut appoved_transfer = false;11601161            // Check approve1162            if <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone())) {1163                let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));1164                let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());1165                if opt_item.is_some()1166                {1167                    appoved_transfer = true;1168                    ensure!(opt_item.unwrap().amount >= value, Error::<T>::TokenValueNotEnough);1169                }1170            }11711172            let target_collection = <Collection<T>>::get(collection_id);11731174            // Limits check1175            Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;11761177            // Transfer permissions check         1178            ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1179            Error::<T>::NoPermission);11801181            if target_collection.access == AccessMode::WhiteList {1182                Self::check_white_list(collection_id, &sender)?;1183                Self::check_white_list(collection_id, &recipient)?;1184            }11851186            // remove approve1187            let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))1188                .into_iter().filter(|i| i.approved != sender.clone()).collect();1189            <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);119011911192            match target_collection.mode1193            {1194                CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1195                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,1196                CollectionMode::ReFungible(_)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1197                _ => ()1198            };11991200            Ok(())1201        }12021203        ///1204        #[weight = 0]1205        pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {12061207            // let no_perm_mes = "You do not have permissions to modify this collection";1208            // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1209            // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1210            // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);12111212            // // on_nft_received  call12131214            // Self::transfer(origin, collection_id, item_id, new_owner)?;12151216            Ok(())1217        }12181219        /// Set off-chain data schema.1220        /// 1221        /// # Permissions1222        /// 1223        /// * Collection Owner1224        /// * Collection Admin1225        /// 1226        /// # Arguments1227        /// 1228        /// * collection_id.1229        /// 1230        /// * schema: String representing the offchain data schema.1231        #[weight = T::WeightInfo::set_variable_meta_data()]1232        pub fn set_variable_meta_data (1233            origin,1234            collection_id: CollectionId,1235            item_id: TokenId,1236            data: Vec<u8>1237        ) -> DispatchResult {1238            let sender = ensure_signed(origin)?;1239            1240            Self::collection_exists(collection_id)?;1241            1242            ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);12431244            // Modify permissions check1245            let target_collection = <Collection<T>>::get(collection_id);1246            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1247                Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1248                Error::<T>::NoPermission);12491250            Self::item_exists(collection_id, item_id, &target_collection.mode)?;12511252            match target_collection.mode1253            {1254                CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1255                CollectionMode::ReFungible(_)  => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1256                CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1257                _ => fail!(Error::<T>::UnexpectedCollectionType)1258            };12591260            Ok(())1261        }1262        12631264        /// Set off-chain data schema.1265        /// 1266        /// # Permissions1267        /// 1268        /// * Collection Owner1269        /// * Collection Admin1270        /// 1271        /// # Arguments1272        /// 1273        /// * collection_id.1274        /// 1275        /// * schema: String representing the offchain data schema.1276        #[weight = T::WeightInfo::set_offchain_schema()]1277        pub fn set_offchain_schema(1278            origin,1279            collection_id: CollectionId,1280            schema: Vec<u8>1281        ) -> DispatchResult {1282            let sender = ensure_signed(origin)?;1283            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12841285            let mut target_collection = <Collection<T>>::get(collection_id);1286            target_collection.offchain_schema = schema;1287            <Collection<T>>::insert(collection_id, target_collection);12881289            Ok(())1290        }12911292        /// Set const on-chain data schema.1293        /// 1294        /// # Permissions1295        /// 1296        /// * Collection Owner1297        /// * Collection Admin1298        /// 1299        /// # Arguments1300        /// 1301        /// * collection_id.1302        /// 1303        /// * schema: String representing the const on-chain data schema.1304        #[weight = T::WeightInfo::set_const_on_chain_schema()]1305        pub fn set_const_on_chain_schema (1306            origin,1307            collection_id: CollectionId,1308            schema: Vec<u8>1309        ) -> DispatchResult {1310            let sender = ensure_signed(origin)?;1311            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13121313            let mut target_collection = <Collection<T>>::get(collection_id);1314            target_collection.const_on_chain_schema = schema;1315            <Collection<T>>::insert(collection_id, target_collection);13161317            Ok(())1318        }13191320        /// Set variable on-chain data schema.1321        /// 1322        /// # Permissions1323        /// 1324        /// * Collection Owner1325        /// * Collection Admin1326        /// 1327        /// # Arguments1328        /// 1329        /// * collection_id.1330        /// 1331        /// * schema: String representing the variable on-chain data schema.1332        #[weight = T::WeightInfo::set_const_on_chain_schema()]1333        pub fn set_variable_on_chain_schema (1334            origin,1335            collection_id: CollectionId,1336            schema: Vec<u8>1337        ) -> DispatchResult {1338            let sender = ensure_signed(origin)?;1339            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13401341            let mut target_collection = <Collection<T>>::get(collection_id);1342            target_collection.variable_on_chain_schema = schema;1343            <Collection<T>>::insert(collection_id, target_collection);13441345            Ok(())1346        }13471348        // Sudo permissions function1349        #[weight = 0]1350        pub fn set_chain_limits(1351            origin,1352            limits: ChainLimits1353        ) -> DispatchResult {1354            ensure_root(origin)?;1355            <ChainLimit>::put(limits);1356            Ok(())1357        }13581359        /// Enable smart contract self-sponsoring.1360        /// 1361        /// # Permissions1362        /// 1363        /// * Contract Owner1364        /// 1365        /// # Arguments1366        /// 1367        /// * contract address1368        /// * enable flag1369        /// 1370        #[weight = T::WeightInfo::enable_contract_sponsoring()]1371        pub fn enable_contract_sponsoring(1372            origin,1373            contract_address: T::AccountId,1374            enable: bool1375        ) -> DispatchResult {13761377            let sender = ensure_signed(origin)?;13781379            #[cfg(feature = "runtime-benchmarks")]1380            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());13811382            let mut is_owner = false;1383            if <ContractOwner<T>>::contains_key(contract_address.clone()) {1384                let owner = <ContractOwner<T>>::get(&contract_address);1385                is_owner = sender == owner;1386            }1387            ensure!(is_owner, Error::<T>::NoPermission);13881389            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1390            Ok(())1391        }13921393        /// Set the rate limit for contract sponsoring to specified number of blocks.1394        /// 1395        /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1396        /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1397        /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1398        /// from contract endowment if there are at least B blocks between such transactions. 1399        /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1400        /// 1401        /// # Permissions1402        /// 1403        /// * Contract Owner1404        /// 1405        /// # Arguments1406        /// 1407        /// -`contract_address`: Address of the contract to sponsor1408        /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1409        /// 1410        #[weight = 0]1411        pub fn set_contract_sponsoring_rate_limit(1412            origin,1413            contract_address: T::AccountId,1414            rate_limit: T::BlockNumber1415        ) -> DispatchResult {1416            let sender = ensure_signed(origin)?;1417            let mut is_owner = false;1418            if <ContractOwner<T>>::contains_key(contract_address.clone()) {1419                let owner = <ContractOwner<T>>::get(&contract_address);1420                is_owner = sender == owner;1421            }1422            ensure!(is_owner, Error::<T>::NoPermission);14231424            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1425            Ok(())1426        }14271428        #[weight = 0]1429        pub fn set_collection_limits(1430            origin,1431            collection_id: u32,1432            limits: CollectionLimits,1433        ) -> DispatchResult {1434            let sender = ensure_signed(origin)?;1435            Self::check_owner_permissions(collection_id, sender.clone())?;1436            let mut target_collection = <Collection<T>>::get(collection_id);1437            let chain_limits = ChainLimit::get();1438            let climits = target_collection.limits;14391440            // collection bounds1441            ensure!(limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1442                limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP,  1443                Error::<T>::CollectionLimitBoundsExceeded);14441445            // token_limit   check  prev1446            ensure!(climits.token_limit > limits.token_limit && 1447                limits.token_limit <= chain_limits.account_token_ownership_limit, 1448                Error::<T>::AccountTokenLimitExceeded);14491450            target_collection.limits = limits;1451            <Collection<T>>::insert(collection_id, target_collection);14521453            Ok(())1454        } 1455    }1456}14571458impl<T: Trait> Module<T> {14591460    fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {1461        1462        // check token limit and account token limit1463        let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1464        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);1465        1466        Ok(())1467    }14681469    fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {14701471        // check token limit and account token limit1472        let total_items: u32 = ItemListIndex::get(collection_id);1473        let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1474        ensure!(collection.limits.token_limit > total_items,  Error::<T>::CollectionTokenLimitExceeded);1475        ensure!(collection.limits.account_token_ownership_limit > account_items,  Error::<T>::AccountTokenLimitExceeded);14761477        if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1478            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1479            Self::check_white_list(collection_id, owner)?;1480            Self::check_white_list(collection_id, sender)?;1481        }14821483        Ok(())1484    }14851486    fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1487        match target_collection.mode1488        {1489            CollectionMode::NFT => {1490                if let CreateItemData::NFT(data) = data {1491                    // check sizes1492                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1493                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1494                } else {1495                    fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1496                }1497            },1498            CollectionMode::Fungible(_) => {1499                if let CreateItemData::Fungible(_) = data {1500                } else {1501                    fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1502                }1503            },1504            CollectionMode::ReFungible(_) => {1505                if let CreateItemData::ReFungible(data) = data {15061507                    // check sizes1508                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1509                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1510                } else {1511                    fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1512                }1513            },1514            _ => { fail!(Error::<T>::UnexpectedCollectionType); }1515        };15161517        Ok(())1518    }15191520    fn create_item_no_validation(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1521        match data1522        {1523            CreateItemData::NFT(data) => {1524                let item = NftItemType {1525                    collection: collection_id,1526                    owner,1527                    const_data: data.const_data,1528                    variable_data: data.variable_data1529                };15301531                Self::add_nft_item(item)?;1532            },1533            CreateItemData::Fungible(_) => {1534                let item = FungibleItemType {1535                    collection: collection_id,1536                    owner,1537                    value: (10 as u128).pow(collection.decimal_points as u32)1538                };15391540                Self::add_fungible_item(item)?;1541            },1542            CreateItemData::ReFungible(data) => {1543                let mut owner_list = Vec::new();1544                let value = (10 as u128).pow(collection.decimal_points as u32);1545                owner_list.push(Ownership {owner: owner.clone(), fraction: value});15461547                let item = ReFungibleItemType {1548                    collection: collection_id,1549                    owner: owner_list,1550                    const_data: data.const_data,1551                    variable_data: data.variable_data1552                };15531554                Self::add_refungible_item(item)?;1555            }1556        };15571558        // call event1559        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));15601561        Ok(())1562    }15631564    fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {1565        let current_index = <ItemListIndex>::get(item.collection)1566            .checked_add(1)1567            .ok_or(Error::<T>::NumOverflow)?;1568        let itemcopy = item.clone();1569        let owner = item.owner.clone();15701571        Self::add_token_index(item.collection, current_index, owner.clone())?;15721573        <ItemListIndex>::insert(item.collection, current_index);1574        <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);15751576        // Add current block1577        let v: Vec<BasketItem<T::AccountId, T::BlockNumber>> = Vec::new();1578        <FungibleTransferBasket<T>>::insert(item.collection, current_index, v);1579        1580        // Update balance1581        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1582            .checked_add(item.value)1583            .ok_or(Error::<T>::NumOverflow)?;1584        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);15851586        Ok(())1587    }15881589    fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1590        let current_index = <ItemListIndex>::get(item.collection)1591            .checked_add(1)1592            .ok_or(Error::<T>::NumOverflow)?;1593        let itemcopy = item.clone();15941595        let value = item.owner.first().unwrap().fraction;1596        let owner = item.owner.first().unwrap().owner.clone();15971598        Self::add_token_index(item.collection, current_index, owner.clone())?;15991600        <ItemListIndex>::insert(item.collection, current_index);1601        <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);16021603        // Add current block1604        let block_number: T::BlockNumber = 0.into();1605        <ReFungibleTransferBasket<T>>::insert(item.collection, current_index, block_number);16061607        // Update balance1608        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1609            .checked_add(value)1610            .ok_or(Error::<T>::NumOverflow)?;1611        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);16121613        Ok(())1614    }16151616    fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {1617        let current_index = <ItemListIndex>::get(item.collection)1618            .checked_add(1)1619            .ok_or(Error::<T>::NumOverflow)?;16201621        let item_owner = item.owner.clone();1622        let collection_id = item.collection.clone();1623        Self::add_token_index(collection_id, current_index, item.owner.clone())?;16241625        <ItemListIndex>::insert(collection_id, current_index);1626        <NftItemList<T>>::insert(collection_id, current_index, item);16271628        // Add current block1629        let block_number: T::BlockNumber = 0.into();1630        <NftTransferBasket<T>>::insert(collection_id, current_index, block_number);16311632        // Update balance1633        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1634            .checked_add(1)1635            .ok_or(Error::<T>::NumOverflow)?;1636        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);16371638        Ok(())1639    }16401641    fn burn_refungible_item(1642        collection_id: CollectionId,1643        item_id: TokenId,1644        owner: T::AccountId,1645    ) -> DispatchResult {1646        ensure!(1647            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1648            Error::<T>::TokenNotFound1649        );1650        let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);1651        let item = collection1652            .owner1653            .iter()1654            .filter(|&i| i.owner == owner)1655            .next()1656            .unwrap();1657        Self::remove_token_index(collection_id, item_id, owner.clone())?;16581659        // remove approve list1660        <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));16611662        // update balance1663        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1664            .checked_sub(item.fraction)1665            .ok_or(Error::<T>::NumOverflow)?;1666        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);16671668        <ReFungibleItemList<T>>::remove(collection_id, item_id);16691670        Ok(())1671    }16721673    fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1674        ensure!(1675            <NftItemList<T>>::contains_key(collection_id, item_id),1676            Error::<T>::TokenNotFound1677        );1678        let item = <NftItemList<T>>::get(collection_id, item_id);1679        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;16801681        // remove approve list1682        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));16831684        // update balance1685        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1686            .checked_sub(1)1687            .ok_or(Error::<T>::NumOverflow)?;1688        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1689        <NftItemList<T>>::remove(collection_id, item_id);16901691        Ok(())1692    }16931694    fn burn_fungible_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1695        ensure!(1696            <FungibleItemList<T>>::contains_key(collection_id, item_id),1697            Error::<T>::TokenNotFound1698        );1699        let item = <FungibleItemList<T>>::get(collection_id, item_id);1700        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;17011702        // remove approve list1703        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));17041705        // update balance1706        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1707            .checked_sub(item.value)1708            .ok_or(Error::<T>::NumOverflow)?;1709        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);17101711        <FungibleItemList<T>>::remove(collection_id, item_id);17121713        Ok(())1714    }17151716    fn collection_exists(collection_id: CollectionId) -> DispatchResult {1717        ensure!(1718            <Collection<T>>::contains_key(collection_id),1719            Error::<T>::CollectionNotFound1720        );1721        Ok(())1722    }17231724    fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {1725        Self::collection_exists(collection_id)?;17261727        let target_collection = <Collection<T>>::get(collection_id);1728        ensure!(1729            subject == target_collection.owner,1730            Error::<T>::NoPermission1731        );17321733        Ok(())1734    }17351736    fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {1737        let target_collection = <Collection<T>>::get(collection_id);1738        let mut result: bool = subject == target_collection.owner;1739        let exists = <AdminList<T>>::contains_key(collection_id);17401741        if !result & exists {1742            if <AdminList<T>>::get(collection_id).contains(&subject) {1743                result = true1744            }1745        }17461747        result1748    }17491750    fn check_owner_or_admin_permissions(1751        collection_id: CollectionId,1752        subject: T::AccountId,1753    ) -> DispatchResult {1754        Self::collection_exists(collection_id)?;1755        let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());17561757        ensure!(1758            result,1759            Error::<T>::NoPermission1760        );1761        Ok(())1762    }17631764    fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {1765        let target_collection = <Collection<T>>::get(collection_id);17661767        match target_collection.mode {1768            CollectionMode::NFT => {1769                <NftItemList<T>>::get(collection_id, item_id).owner == subject1770            }1771            CollectionMode::Fungible(_) => {1772                <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1773            }1774            CollectionMode::ReFungible(_) => {1775                <ReFungibleItemList<T>>::get(collection_id, item_id)1776                    .owner1777                    .iter()1778                    .any(|i| i.owner == subject)1779            }1780            CollectionMode::Invalid => false,1781        }1782    }17831784    fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {1785        let mes = Error::<T>::AddresNotInWhiteList;1786        ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1787        let wl = <WhiteList<T>>::get(collection_id);1788        ensure!(wl.contains(address), mes);17891790        Ok(())1791    }17921793    fn transfer_fungible(1794        collection_id: CollectionId,1795        item_id: TokenId,1796        value: u128,1797        owner: T::AccountId,1798        new_owner: T::AccountId,1799    ) -> DispatchResult {1800        ensure!(1801            <FungibleItemList<T>>::contains_key(collection_id, item_id),1802            Error::<T>::TokenNotFound1803        );18041805        let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1806        let amount = full_item.value;18071808        ensure!(amount >= value, Error::<T>::TokenValueTooLow);18091810        // update balance1811        let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1812            .checked_sub(value)1813            .ok_or(Error::<T>::NumOverflow)?;1814        <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);18151816        let mut new_owner_account_id = 0;1817        let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());1818        if new_owner_items.len() > 0 {1819            new_owner_account_id = new_owner_items[0];1820        }18211822        // transfer1823        if amount == value && new_owner_account_id == 0 {1824            // change owner1825            // new owner do not have account1826            let mut new_full_item = full_item.clone();1827            new_full_item.owner = new_owner.clone();1828            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);18291830            // update balance1831            let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1832                .checked_add(value)1833                .ok_or(Error::<T>::NumOverflow)?;1834            <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18351836            // update index collection1837            Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1838        } else {1839            let mut new_full_item = full_item.clone();1840            new_full_item.value -= value;18411842            // separate amount1843            if new_owner_account_id > 0 {1844                // new owner has account1845                let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1846                item.value += value;18471848                // update balance1849                let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1850                    .checked_add(value)1851                    .ok_or(Error::<T>::NumOverflow)?;1852                <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18531854                <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);1855            } else {1856                // new owner do not have account1857                let item = FungibleItemType {1858                    collection: collection_id,1859                    owner: new_owner.clone(),1860                    value1861                };18621863                Self::add_fungible_item(item)?;1864            }18651866            if amount == value {1867                Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;18681869                // remove approve list1870                <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));1871                <FungibleItemList<T>>::remove(collection_id, item_id);1872            }18731874            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1875        }18761877        Ok(())1878    }18791880    fn transfer_refungible(1881        collection_id: CollectionId,1882        item_id: TokenId,1883        value: u128,1884        owner: T::AccountId,1885        new_owner: T::AccountId,1886    ) -> DispatchResult {1887        ensure!(1888            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1889            Error::<T>::TokenNotFound1890        );18911892        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1893        let item = full_item1894            .owner1895            .iter()1896            .filter(|i| i.owner == owner)1897            .next()1898            .ok_or(Error::<T>::NumOverflow)?;1899        let amount = item.fraction;19001901        ensure!(amount >= value, Error::<T>::TokenValueTooLow);19021903        // update balance1904        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1905            .checked_sub(value)1906            .ok_or(Error::<T>::NumOverflow)?;1907        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);19081909        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1910            .checked_add(value)1911            .ok_or(Error::<T>::NumOverflow)?;1912        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);19131914        let old_owner = item.owner.clone();1915        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);19161917        // transfer1918        if amount == value && !new_owner_has_account {1919            // change owner1920            // new owner do not have account1921            let mut new_full_item = full_item.clone();1922            new_full_item1923                .owner1924                .iter_mut()1925                .find(|i| i.owner == owner)1926                .unwrap()1927                .owner = new_owner.clone();1928            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);19291930            // update index collection1931            Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1932        } else {1933            let mut new_full_item = full_item.clone();1934            new_full_item1935                .owner1936                .iter_mut()1937                .find(|i| i.owner == owner)1938                .unwrap()1939                .fraction -= value;19401941            // separate amount1942            if new_owner_has_account {1943                // new owner has account1944                new_full_item1945                    .owner1946                    .iter_mut()1947                    .find(|i| i.owner == new_owner)1948                    .unwrap()1949                    .fraction += value;1950            } else {1951                // new owner do not have account1952                new_full_item.owner.push(Ownership {1953                    owner: new_owner.clone(),1954                    fraction: value,1955                });1956                Self::add_token_index(collection_id, item_id, new_owner.clone())?;1957            }19581959            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1960        }19611962        Ok(())1963    }19641965    fn transfer_nft(1966        collection_id: CollectionId,1967        item_id: TokenId,1968        sender: T::AccountId,1969        new_owner: T::AccountId,1970    ) -> DispatchResult {1971        ensure!(1972            <NftItemList<T>>::contains_key(collection_id, item_id),1973            Error::<T>::TokenNotFound1974        );19751976        let mut item = <NftItemList<T>>::get(collection_id, item_id);19771978        ensure!(1979            sender == item.owner,1980            Error::<T>::MustBeTokenOwner1981        );19821983        // update balance1984        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1985            .checked_sub(1)1986            .ok_or(Error::<T>::NumOverflow)?;1987        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);19881989        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1990            .checked_add(1)1991            .ok_or(Error::<T>::NumOverflow)?;1992        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);19931994        // change owner1995        let old_owner = item.owner.clone();1996        item.owner = new_owner.clone();1997        <NftItemList<T>>::insert(collection_id, item_id, item);19981999        // update index collection2000        Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;20012002        // reset approved list2003        <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));2004        Ok(())2005    }2006    2007    fn item_exists(2008        collection_id: CollectionId,2009        item_id: TokenId,2010        mode: &CollectionMode2011    ) -> DispatchResult {2012        match mode {2013            CollectionMode::NFT => ensure!(<NftItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),2014            CollectionMode::ReFungible(_) => ensure!(<ReFungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),2015            CollectionMode::Fungible(_) => ensure!(<FungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),2016            _ => ()2017        };2018        2019        Ok(())2020    }20212022    fn set_re_fungible_variable_data(2023        collection_id: CollectionId,2024        item_id: TokenId,2025        data: Vec<u8>2026    ) -> DispatchResult {2027        let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);20282029        item.variable_data = data;20302031        <ReFungibleItemList<T>>::insert(collection_id, item_id, item);20322033        Ok(())2034    }20352036    fn set_nft_variable_data(2037        collection_id: CollectionId,2038        item_id: TokenId,2039        data: Vec<u8>2040    ) -> DispatchResult {2041        let mut item = <NftItemList<T>>::get(collection_id, item_id);2042        2043        item.variable_data = data;20442045        <NftItemList<T>>::insert(collection_id, item_id, item);2046        2047        Ok(())2048    }20492050    fn init_collection(item: &CollectionType<T::AccountId>) {2051        // check params2052        assert!(2053            item.decimal_points <= MAX_DECIMAL_POINTS,2054            "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2055        );2056        assert!(2057            item.name.len() <= 64,2058            "Collection name can not be longer than 63 char"2059        );2060        assert!(2061            item.name.len() <= 256,2062            "Collection description can not be longer than 255 char"2063        );2064        assert!(2065            item.token_prefix.len() <= 16,2066            "Token prefix can not be longer than 15 char"2067        );20682069        // Generate next collection ID2070        let next_id = CreatedCollectionCount::get()2071            .checked_add(1)2072            .unwrap();20732074        CreatedCollectionCount::put(next_id);2075    }20762077    fn init_nft_token(item: &NftItemType<T::AccountId>) {2078        let current_index = <ItemListIndex>::get(item.collection)2079            .checked_add(1)2080            .unwrap();20812082        let item_owner = item.owner.clone();2083        let collection_id = item.collection.clone();2084        Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();20852086        <ItemListIndex>::insert(collection_id, current_index);20872088        // Update balance2089        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())2090            .checked_add(1)2091            .unwrap();2092        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2093    }20942095    fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {2096        let current_index = <ItemListIndex>::get(item.collection)2097            .checked_add(1)2098            .unwrap();2099        let owner = item.owner.clone();21002101        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();21022103        <ItemListIndex>::insert(item.collection, current_index);21042105        // Update balance2106        let new_balance = <Balance<T>>::get(item.collection, owner.clone())2107            .checked_add(item.value)2108            .unwrap();2109        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2110    }21112112    fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {2113        let current_index = <ItemListIndex>::get(item.collection)2114            .checked_add(1)2115            .unwrap();21162117        let value = item.owner.first().unwrap().fraction;2118        let owner = item.owner.first().unwrap().owner.clone();21192120        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();21212122        <ItemListIndex>::insert(item.collection, current_index);21232124        // Update balance2125        let new_balance = <Balance<T>>::get(item.collection, owner.clone())2126            .checked_add(value)2127            .unwrap();2128        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2129    }21302131    fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: T::AccountId) -> DispatchResult {21322133        // add to account limit2134        if <AccountItemCount<T>>::contains_key(owner.clone()) {21352136            // bound Owned tokens by a single address2137            let count = <AccountItemCount<T>>::get(owner.clone());2138            ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);21392140            <AccountItemCount<T>>::insert(owner.clone(), count2141                .checked_add(1)2142                .ok_or(Error::<T>::NumOverflow)?);2143        }2144        else {2145            <AccountItemCount<T>>::insert(owner.clone(), 1);2146        }21472148        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2149        if list_exists {2150            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2151            let item_contains = list.contains(&item_index.clone());21522153            if !item_contains {2154                list.push(item_index.clone());2155            }21562157            <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2158        } else {2159            let mut itm = Vec::new();2160            itm.push(item_index.clone());2161            <AddressTokens<T>>::insert(collection_id, owner, itm);2162            2163        }21642165        Ok(())2166    }21672168    fn remove_token_index(2169        collection_id: CollectionId,2170        item_index: TokenId,2171        owner: T::AccountId,2172    ) -> DispatchResult {21732174        // update counter2175        <AccountItemCount<T>>::insert(owner.clone(), 2176            <AccountItemCount<T>>::get(owner.clone())2177            .checked_sub(1)2178            .ok_or(Error::<T>::NumOverflow)?);217921802181        let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2182        if list_exists {2183            let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2184            let item_contains = list.contains(&item_index.clone());21852186            if item_contains {2187                list.retain(|&item| item != item_index);2188                <AddressTokens<T>>::insert(collection_id, owner, list);2189            }2190        }21912192        Ok(())2193    }21942195    fn move_token_index(2196        collection_id: CollectionId,2197        item_index: TokenId,2198        old_owner: T::AccountId,2199        new_owner: T::AccountId,2200    ) -> DispatchResult {2201        Self::remove_token_index(collection_id, item_index, old_owner)?;2202        Self::add_token_index(collection_id, item_index, new_owner)?;22032204        Ok(())2205    }2206}22072208////////////////////////////////////////////////////////////////////////////////////////////////////2209// Economic models2210// #region22112212/// Fee multiplier.2213pub type Multiplier = FixedU128;22142215type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2216    <T as system::Trait>::AccountId,2217>>::Balance;2218type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2219    <T as system::Trait>::AccountId,2220>>::NegativeImbalance;22212222/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2223/// in the queue.2224#[derive(Encode, Decode, Clone, Eq, PartialEq)]2225pub struct ChargeTransactionPayment<T: Trait + Send + Sync>(2226    #[codec(compact)] BalanceOf<T>2227);22282229impl<T: Trait + Send + Sync> sp_std::fmt::Debug2230    for ChargeTransactionPayment<T>2231{2232    #[cfg(feature = "std")]2233    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2234        write!(f, "ChargeTransactionPayment<{:?}>", self.0)2235    }2236    #[cfg(not(feature = "std"))]2237    fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2238        Ok(())2239    }2240}22412242impl<T: Trait + Send + Sync> ChargeTransactionPayment<T>2243where2244    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2245    BalanceOf<T>: Send + Sync + FixedPointOperand,2246{2247    /// utility constructor. Used only in client/factory code.2248    pub fn from(fee: BalanceOf<T>) -> Self {2249        Self(fee)2250    }22512252    pub fn traditional_fee(2253        len: usize,2254        info: &DispatchInfoOf<T::Call>,2255        tip: BalanceOf<T>,2256    ) -> BalanceOf<T>2257    where2258        T::Call: Dispatchable<Info = DispatchInfo>,2259    {2260        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2261    }22622263    fn withdraw_fee(2264        &self,2265        who: &T::AccountId,2266        call: &T::Call,2267        info: &DispatchInfoOf<T::Call>,2268        len: usize,2269    ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {2270        let tip = self.0;22712272        // Set fee based on call type. Creating collection costs 1 Unique.2273        // All other transactions have traditional fees so far2274        // let fee = match call.is_sub_type() {2275        //     Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2276        //     _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2277        //                                                 // _ => <BalanceOf<T>>::from(100)2278        // };2279        let fee = Self::traditional_fee(len, info, tip);22802281        // Determine who is paying transaction fee based on ecnomic model2282        // Parse call to extract collection ID and access collection sponsor2283        let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2284            Some(Call::create_item(collection_id, _owner, _properties)) => {22852286                // check free create limit2287                if <Collection<T>>::get(collection_id).limits.sponsored_data_size >= (_properties.len() as u32)2288                {2289                    <Collection<T>>::get(collection_id).sponsor2290                } else {2291                    T::AccountId::default()2292                }2293            }2294            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {2295                2296                let _collection_limits = <Collection<T>>::get(collection_id).limits;2297                let _collection_mode = <Collection<T>>::get(collection_id).mode;22982299                // sponsor timeout2300                let sponsor_transfer = match _collection_mode {2301                    CollectionMode::NFT => {23022303                        // get correct limit2304                        let limit: u32 = if _collection_limits.sponsor_transfer_timeout > 0 {2305                            _collection_limits.sponsor_transfer_timeout2306                        } else {2307                            ChainLimit::get().nft_sponsor_transfer_timeout2308                        };23092310                        let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);2311                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2312                        let limit_time = basket + limit.into();2313                        if block_number >= limit_time {2314                            <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);2315                            true2316                        }2317                        else {2318                            false2319                        }2320                    }2321                    CollectionMode::Fungible(_) => {23222323                        // get correct limit2324                        let limit: u32 = if _collection_limits.sponsor_transfer_timeout > 0 {2325                            _collection_limits.sponsor_transfer_timeout2326                        } else {2327                            ChainLimit::get().fungible_sponsor_transfer_timeout2328                        };23292330                        let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);2331                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2332                        if basket.iter().any(|i| i.address == _new_owner.clone())2333                        {2334                            let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();2335                            let limit_time = item.start_block + limit.into();2336                            if block_number >= limit_time {2337                                basket.retain(|x| x.address == item.address);2338                                basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });2339                                <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);2340                                true2341                            }2342                            else {2343                                false2344                            }2345                        }2346                        else {2347                            basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});2348                            true2349                        }2350                    }2351                    CollectionMode::ReFungible(_) => {23522353                        // get correct limit2354                        let limit: u32 = if _collection_limits.sponsor_transfer_timeout > 0 {2355                            _collection_limits.sponsor_transfer_timeout2356                        } else {2357                            ChainLimit::get().refungible_sponsor_transfer_timeout2358                        };23592360                        let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);2361                        let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2362                        let limit_time = basket + limit.into();2363                        if block_number >= limit_time {2364                            <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);2365                            true2366                        } else {2367                            false2368                        }2369                    }2370                    _ => {2371                        false2372                    },2373                };23742375                if !sponsor_transfer {2376                    T::AccountId::default()2377                } else {2378                    <Collection<T>>::get(collection_id).sponsor2379                }2380            }23812382            _ => T::AccountId::default(),2383        };23842385        // Sponsor smart contracts2386        sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {23872388            // On instantiation: set the contract owner2389            Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, data)) => {23902391                let new_contract_address = <T as pallet_contracts::Trait>::DetermineContractAddress::contract_address_for(2392                    code_hash,2393                    &data,2394                    &who,2395                );2396                <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());23972398                T::AccountId::default()2399            },24002401            // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2402            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {24032404                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());24052406                let mut sponsor_transfer = false;2407                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2408                    let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2409                    let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2410                    let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2411                    let limit_time = last_tx_block + rate_limit;24122413                    if block_number >= limit_time {2414                        <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2415                        sponsor_transfer = true;2416                    }2417                } else {2418                    sponsor_transfer = false;2419                }2420               2421                2422                let mut sp = T::AccountId::default();2423                if sponsor_transfer {2424                    if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2425                        if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2426                            sp = called_contract;2427                        }2428                    }2429                }24302431                sp2432            },24332434            _ => sponsor,2435        };24362437        let mut who_pays_fee: T::AccountId = sponsor.clone();2438        if sponsor == T::AccountId::default() {2439            who_pays_fee = who.clone();2440        }24412442        // Only mess with balances if fee is not zero.2443        if fee.is_zero() {2444            return Ok((fee, None));2445        }24462447        match <T as transaction_payment::Trait>::Currency::withdraw(2448            &who_pays_fee,2449            fee,2450            if tip.is_zero() {2451                WithdrawReason::TransactionPayment.into()2452            } else {2453                WithdrawReason::TransactionPayment | WithdrawReason::Tip2454            },2455            ExistenceRequirement::KeepAlive,2456        ) {2457            Ok(imbalance) => Ok((fee, Some(imbalance))),2458            Err(_) => Err(InvalidTransaction::Payment.into()),2459        }2460    }2461}246224632464impl<T: Trait + Send + Sync> SignedExtension2465    for ChargeTransactionPayment<T>2466where2467    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2468    T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2469{2470    const IDENTIFIER: &'static str = "ChargeTransactionPayment";2471    type AccountId = T::AccountId;2472    type Call = T::Call;2473    type AdditionalSigned = ();2474    type Pre = (2475        BalanceOf<T>,2476        Self::AccountId,2477        Option<NegativeImbalanceOf<T>>,2478        BalanceOf<T>,2479    );2480    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2481        Ok(())2482    }24832484    fn validate(2485        &self,2486        _who: &Self::AccountId,2487        _call: &Self::Call,2488        _info: &DispatchInfoOf<Self::Call>,2489        _len: usize,2490    ) -> TransactionValidity {2491        Ok(ValidTransaction::default())2492    }24932494    fn pre_dispatch(2495        self,2496        who: &Self::AccountId,2497        call: &Self::Call,2498        info: &DispatchInfoOf<Self::Call>,2499        len: usize,2500    ) -> Result<Self::Pre, TransactionValidityError> {2501        let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2502        Ok((self.0, who.clone(), imbalance, fee))2503    }25042505    fn post_dispatch(2506        pre: Self::Pre,2507        info: &DispatchInfoOf<Self::Call>,2508        post_info: &PostDispatchInfoOf<Self::Call>,2509        len: usize,2510        _result: &DispatchResult,2511    ) -> Result<(), TransactionValidityError> {2512        let (tip, who, imbalance, fee) = pre;2513        if let Some(payed) = imbalance {2514            let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(2515                len as u32, info, post_info, tip,2516            );2517            let refund = fee.saturating_sub(actual_fee);2518            let actual_payment =2519                match <T as transaction_payment::Trait>::Currency::deposit_into_existing(2520                    &who, refund,2521                ) {2522                    Ok(refund_imbalance) => {2523                        // The refund cannot be larger than the up front payed max weight.2524                        // `PostDispatchInfo::calc_unspent` guards against such a case.2525                        match payed.offset(refund_imbalance) {2526                            Ok(actual_payment) => actual_payment,2527                            Err(_) => return Err(InvalidTransaction::Payment.into()),2528                        }2529                    }2530                    // We do not recreate the account using the refund. The up front payment2531                    // is gone in that case.2532                    Err(_) => payed,2533                };2534            let imbalances = actual_payment.split(tip);2535            <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(2536                Some(imbalances.0).into_iter().chain(Some(imbalances.1)),2537            );2538        }2539        Ok(())2540    }2541}25422543// #endregion