difftreelog
NFTPAR-149. Benchmark EnableContractSponsoring
in: master
5 files changed
pallets/nft/src/benchmarking.rsdiffbeforeafterboth--- a/pallets/nft/src/benchmarking.rs
+++ b/pallets/nft/src/benchmarking.rs
@@ -311,6 +311,11 @@
}: transfer_from(RawOrigin::Signed(caller.clone()), caller.clone(), recipient.clone(), 2, 1, 1)
+ enable_contract_sponsoring {
+ let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
+
+ }: enable_contract_sponsoring(RawOrigin::Signed(caller.clone()), caller.clone(), true)
+
set_offchain_schema {
let col_name1: Vec<u16> = "Test1".encode_utf16().collect::<Vec<u16>>();
let col_desc1: Vec<u16> = "TestDescription1".encode_utf16().collect::<Vec<u16>>();
pallets/nft/src/default_weights.rsdiffbeforeafterboth--- a/pallets/nft/src/default_weights.rs
+++ b/pallets/nft/src/default_weights.rs
@@ -112,11 +112,11 @@
// .saturating_add(DbWeight::get().reads(1 as Weight))
// .saturating_add(DbWeight::get().writes(1 as Weight))
// }
- // fn enable_contract_sponsoring() -> Weight {
- // (0 as Weight)
- // .saturating_add(DbWeight::get().reads(1 as Weight))
- // .saturating_add(DbWeight::get().writes(1 as Weight))
- // }
+ fn enable_contract_sponsoring() -> Weight {
+ (13_000_000 as Weight)
+ .saturating_add(DbWeight::get().reads(1 as Weight))
+ .saturating_add(DbWeight::get().writes(1 as Weight))
+ }
// fn set_contract_sponsoring_rate_limit() -> Weight {
// (0 as Weight)
// .saturating_add(DbWeight::get().reads(1 as Weight))
pallets/nft/src/lib.rsdiffbeforeafterboth1#![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;4748// Structs49// #region5051#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]52#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]53pub enum CollectionMode {54 Invalid,55 NFT,56 // decimal points57 Fungible(u32),58 // decimal points59 ReFungible(u32),60}6162impl Into<u8> for CollectionMode {63 fn into(self) -> u8 {64 match self {65 CollectionMode::Invalid => 0,66 CollectionMode::NFT => 1,67 CollectionMode::Fungible(_) => 2,68 CollectionMode::ReFungible(_) => 3,69 }70 }71}7273#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]74#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]75pub enum AccessMode {76 Normal,77 WhiteList,78}79impl Default for AccessMode {80 fn default() -> Self {81 Self::Normal82 }83}8485impl Default for CollectionMode {86 fn default() -> Self {87 Self::Invalid88 }89}9091#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]92#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]93pub struct Ownership<AccountId> {94 pub owner: AccountId,95 pub fraction: u128,96}9798#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]99#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]100pub struct CollectionType<AccountId> {101 pub owner: AccountId,102 pub mode: CollectionMode,103 pub access: AccessMode,104 pub decimal_points: u32,105 pub name: Vec<u16>, // 64 include null escape char106 pub description: Vec<u16>, // 256 include null escape char107 pub token_prefix: Vec<u8>, // 16 include null escape char108 pub mint_mode: bool,109 pub offchain_schema: Vec<u8>,110 pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender111 pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship112 pub variable_on_chain_schema: Vec<u8>, //113 pub const_on_chain_schema: Vec<u8>, //114}115116#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]117#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]118pub struct NftItemType<AccountId> {119 pub collection: u64,120 pub owner: AccountId,121 pub const_data: Vec<u8>,122 pub variable_data: Vec<u8>,123}124125#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]126#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]127pub struct FungibleItemType<AccountId> {128 pub collection: u64,129 pub owner: AccountId,130 pub value: u128,131}132133#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]134#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]135pub struct ReFungibleItemType<AccountId> {136 pub collection: u64,137 pub owner: Vec<Ownership<AccountId>>,138 pub const_data: Vec<u8>,139 pub variable_data: Vec<u8>,140}141142#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]143#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]144pub struct ApprovePermissions<AccountId> {145 pub approved: AccountId,146 pub amount: u64,147}148149#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]150#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]151pub struct VestingItem<AccountId, Moment> {152 pub sender: AccountId,153 pub recipient: AccountId,154 pub collection_id: u64,155 pub item_id: u64,156 pub amount: u64,157 pub vesting_date: Moment,158}159160#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]161#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]162pub struct BasketItem<AccountId, BlockNumber> {163 pub address: AccountId,164 pub start_block: BlockNumber,165}166167#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]168#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]169pub struct ChainLimits {170 pub collection_numbers_limit: u64,171 pub account_token_ownership_limit: u64,172 pub collections_admins_limit: u64,173 pub custom_data_limit: u32,174175 // Timeouts for item types in passed blocks176 pub nft_sponsor_transfer_timeout: u32,177 pub fungible_sponsor_transfer_timeout: u32,178 pub refungible_sponsor_transfer_timeout: u32,179}180181pub trait WeightInfo {182 fn create_collection() -> Weight;183 fn destroy_collection() -> Weight;184 fn add_to_white_list() -> Weight;185 fn remove_from_white_list() -> Weight;186 fn set_public_access_mode() -> Weight;187 fn set_mint_permission() -> Weight;188 fn change_collection_owner() -> Weight;189 fn add_collection_admin() -> Weight;190 fn remove_collection_admin() -> Weight;191 fn set_collection_sponsor() -> Weight;192 fn confirm_sponsorship() -> Weight;193 fn remove_collection_sponsor() -> Weight;194 fn create_item(s: usize) -> Weight;195 fn burn_item() -> Weight;196 fn transfer() -> Weight;197 fn approve() -> Weight;198 fn transfer_from() -> Weight;199 fn set_offchain_schema() -> Weight;200 fn set_const_on_chain_schema() -> Weight;201 fn set_variable_on_chain_schema() -> Weight;202 fn set_variable_meta_data() -> Weight;203 // fn enable_contract_sponsoring() -> Weight;204}205206#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]207#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]208pub struct CreateNftData {209 pub const_data: Vec<u8>,210 pub variable_data: Vec<u8>,211}212213#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]214#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]215pub struct CreateFungibleData {216}217218#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct CreateReFungibleData {221 pub const_data: Vec<u8>,222 pub variable_data: Vec<u8>,223}224225#[derive(Encode, Decode, Debug, Clone, PartialEq)]226#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]227pub enum CreateItemData {228 NFT(CreateNftData),229 Fungible(CreateFungibleData),230 ReFungible(CreateReFungibleData)231}232233impl CreateItemData {234 pub fn len(&self) -> usize {235 let len = match self {236 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),237 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),238 _ => 0239 };240 241 return len;242 }243}244245impl From<CreateNftData> for CreateItemData {246 fn from(item: CreateNftData) -> Self {247 CreateItemData::NFT(item)248 }249}250251impl From<CreateReFungibleData> for CreateItemData {252 fn from(item: CreateReFungibleData) -> Self {253 CreateItemData::ReFungible(item)254 }255}256257impl From<CreateFungibleData> for CreateItemData {258 fn from(item: CreateFungibleData) -> Self {259 CreateItemData::Fungible(item)260 }261}262263264decl_error! {265 /// Error for non-fungible-token module.266 pub enum Error for Module<T: Trait> {267 /// Total collections bound exceeded268 TotalCollectionsLimitExceeded,269 /// Decimal_points parameter must be lower than 4270 CollectionDecimalPointLimitExceeded, 271 /// Collection name can not be longer than 63 char272 CollectionNameLimitExceeded, 273 /// Collection description can not be longer than 255 char274 CollectionDescriptionLimitExceeded, 275 /// Token prefix can not be longer than 15 char276 CollectionTokenPrefixLimitExceeded,277 /// This collection does not exist278 CollectionNotFound,279 /// Item not exists280 TokenNotFound,281 /// Arithmetic calculation overflow282 NumOverflow, 283 /// Account already has admin role284 AlreadyAdmin, 285 /// You do not own this collection286 NoPermission,287 /// This address is not set as sponsor, use setCollectionSponsor first288 ConfirmUnsetSponsorFail,289 /// Collection is not in mint mode290 PublicMintingNotAllowed,291 /// Sender parameter and item owner must be equal292 MustBeTokenOwner,293 /// Item balance not enouth294 TokenValueTooLow,295 /// Size of item is too large296 NftSizeLimitExceeded,297 /// Size of item must be 0 with fungible type298 FungibleUnexpectedParam,299 /// No approve found300 ApproveNotFound,301 /// Requested value more than approved302 TokenValueNotEnough,303 /// Only approved addresses can call this method304 ApproveRequired,305 /// Address is not in white list306 AddresNotInWhiteList,307 /// Number of collection admins bound exceeded308 CollectionAdminsLimitExceeded,309 /// Owned tokens by a single address bound exceeded310 AddressOwnershipLimitExceeded,311 /// Length of items properties must be greater than 0312 EmptyArgument,313 }314}315316pub trait Trait: system::Trait + Sized + transaction_payment::Trait + pallet_contracts::Trait {317 type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;318319 /// Weight information for extrinsics in this pallet.320 type WeightInfo: WeightInfo;321}322323#[cfg(feature = "runtime-benchmarks")]324mod benchmarking;325326// #endregion327328decl_storage! {329 trait Store for Module<T: Trait> as Nft {330331 // Private members332 NextCollectionID: u64;333 CreatedCollectionCount: u64;334 ChainVersion: u64;335 ItemListIndex: map hasher(blake2_128_concat) u64 => u64;336337 // Chain limits struct338 pub ChainLimit get(fn chain_limit) config(): ChainLimits;339340 // Bound counters341 CollectionCount: u64;342 pub AccountItemCount get(fn account_item_count): map hasher(identity) T::AccountId => u64;343344 // Basic collections345 pub Collection get(fn collection) config(): map hasher(identity) u64 => CollectionType<T::AccountId>;346 pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;347 pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;348349 /// Balance owner per collection map350 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;351352 /// second parameter: item id + owner account id353 pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;354355 /// Item collections356 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;357 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;358 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;359360 /// Index list361 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;362363 /// Tokens transfer baskets364 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;365 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => Vec<BasketItem<T::AccountId, T::BlockNumber>>;366 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;367368 // Contract Sponsorship and Ownership369 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;370 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;371 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;372 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;373 }374 add_extra_genesis {375 build(|config: &GenesisConfig<T>| {376 // Modification of storage377 for (_num, _c) in &config.collection {378 <Module<T>>::init_collection(_c);379 }380381 for (_num, _q, _i) in &config.nft_item_id {382 <Module<T>>::init_nft_token(_i);383 }384385 for (_num, _q, _i) in &config.fungible_item_id {386 <Module<T>>::init_fungible_token(_i);387 }388389 for (_num, _q, _i) in &config.refungible_item_id {390 <Module<T>>::init_refungible_token(_i);391 }392 })393 }394}395396decl_event!(397 pub enum Event<T>398 where399 AccountId = <T as system::Trait>::AccountId,400 {401 /// New collection was created402 /// 403 /// # Arguments404 /// 405 /// * collection_id: Globally unique identifier of newly created collection.406 /// 407 /// * mode: [CollectionMode] converted into u8.408 /// 409 /// * account_id: Collection owner.410 Created(u64, u8, AccountId),411412 /// New item was created.413 /// 414 /// # Arguments415 /// 416 /// * collection_id: Id of the collection where item was created.417 /// 418 /// * item_id: Id of an item. Unique within the collection.419 ItemCreated(u64, u64),420421 /// Collection item was burned.422 /// 423 /// # Arguments424 /// 425 /// collection_id.426 /// 427 /// item_id: Identifier of burned NFT.428 ItemDestroyed(u64, u64),429 }430);431432decl_module! {433 pub struct Module<T: Trait> for enum Call where origin: T::Origin {434435 fn deposit_event() = default;436 type Error = Error<T>;437438 fn on_initialize(now: T::BlockNumber) -> Weight {439440 if ChainVersion::get() < 2441 {442 let value = NextCollectionID::get();443 CreatedCollectionCount::put(value);444 ChainVersion::put(2);445 }446447 0448 }449450 /// 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.451 /// 452 /// # Permissions453 /// 454 /// * Anyone.455 /// 456 /// # Arguments457 /// 458 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.459 /// 460 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.461 /// 462 /// * token_prefix: UTF-8 string with token prefix.463 /// 464 /// * mode: [CollectionMode] collection type and type dependent data.465 // returns collection ID466 #[weight = T::WeightInfo::create_collection()]467 pub fn create_collection(origin,468 collection_name: Vec<u16>,469 collection_description: Vec<u16>,470 token_prefix: Vec<u8>,471 mode: CollectionMode) -> DispatchResult {472473 // Anyone can create a collection474 let who = ensure_signed(origin)?;475476 let decimal_points = match mode {477 CollectionMode::Fungible(points) => points,478 CollectionMode::ReFungible(points) => points,479 _ => 0480 };481482 // bound Total number of collections483 ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);484485 // check params486 ensure!(decimal_points <= 4, Error::<T>::CollectionDecimalPointLimitExceeded);487488 let mut name = collection_name.to_vec();489 name.push(0);490 ensure!(name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);491492 let mut description = collection_description.to_vec();493 description.push(0);494 ensure!(name.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);495496 let mut prefix = token_prefix.to_vec();497 prefix.push(0);498 ensure!(prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);499500 // Generate next collection ID501 let next_id = CreatedCollectionCount::get()502 .checked_add(1)503 .ok_or(Error::<T>::NumOverflow)?;504505 // bound counter506 let total = CollectionCount::get()507 .checked_add(1)508 .ok_or(Error::<T>::NumOverflow)?;509510 CreatedCollectionCount::put(next_id);511 CollectionCount::put(total);512513 // Create new collection514 let new_collection = CollectionType {515 owner: who.clone(),516 name: name,517 mode: mode.clone(),518 mint_mode: false,519 access: AccessMode::Normal,520 description: description,521 decimal_points: decimal_points,522 token_prefix: prefix,523 offchain_schema: Vec::new(),524 sponsor: T::AccountId::default(),525 unconfirmed_sponsor: T::AccountId::default(),526 variable_on_chain_schema: Vec::new(),527 const_on_chain_schema: Vec::new(),528 };529530 // Add new collection to map531 <Collection<T>>::insert(next_id, new_collection);532533 // call event534 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));535536 Ok(())537 }538539 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.540 /// 541 /// # Permissions542 /// 543 /// * Collection Owner.544 /// 545 /// # Arguments546 /// 547 /// * collection_id: collection to destroy.548 #[weight = T::WeightInfo::destroy_collection()]549 pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {550551 let sender = ensure_signed(origin)?;552 Self::check_owner_permissions(collection_id, sender)?;553554 <AddressTokens<T>>::remove_prefix(collection_id);555 <ApprovedList<T>>::remove_prefix(collection_id);556 <Balance<T>>::remove_prefix(collection_id);557 <ItemListIndex>::remove(collection_id);558 <AdminList<T>>::remove(collection_id);559 <Collection<T>>::remove(collection_id);560 <WhiteList<T>>::remove(collection_id);561562 <NftItemList<T>>::remove_prefix(collection_id);563 <FungibleItemList<T>>::remove_prefix(collection_id);564 <ReFungibleItemList<T>>::remove_prefix(collection_id);565566 <NftTransferBasket<T>>::remove_prefix(collection_id);567 <FungibleTransferBasket<T>>::remove_prefix(collection_id);568 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);569570 if CollectionCount::get() > 0571 {572 // bound couter573 let total = CollectionCount::get()574 .checked_sub(1)575 .ok_or(Error::<T>::NumOverflow)?;576577 CollectionCount::put(total);578 }579580 Ok(())581 }582583 /// Add an address to white list.584 /// 585 /// # Permissions586 /// 587 /// * Collection Owner588 /// * Collection Admin589 /// 590 /// # Arguments591 /// 592 /// * collection_id.593 /// 594 /// * address.595 #[weight = T::WeightInfo::add_to_white_list()]596 pub fn add_to_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{597598 let sender = ensure_signed(origin)?;599 Self::check_owner_or_admin_permissions(collection_id, sender)?;600601 let mut white_list_collection: Vec<T::AccountId>;602 if <WhiteList<T>>::contains_key(collection_id) {603 white_list_collection = <WhiteList<T>>::get(collection_id);604 if !white_list_collection.contains(&address.clone())605 {606 white_list_collection.push(address.clone());607 }608 }609 else {610 white_list_collection = Vec::new();611 white_list_collection.push(address.clone());612 }613614 <WhiteList<T>>::insert(collection_id, white_list_collection);615 Ok(())616 }617618 /// Remove an address from white list.619 /// 620 /// # Permissions621 /// 622 /// * Collection Owner623 /// * Collection Admin624 /// 625 /// # Arguments626 /// 627 /// * collection_id.628 /// 629 /// * address.630 #[weight = T::WeightInfo::remove_from_white_list()]631 pub fn remove_from_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{632633 let sender = ensure_signed(origin)?;634 Self::check_owner_or_admin_permissions(collection_id, sender)?;635636 if <WhiteList<T>>::contains_key(collection_id) {637 let mut white_list_collection = <WhiteList<T>>::get(collection_id);638 if white_list_collection.contains(&address.clone())639 {640 white_list_collection.retain(|i| *i != address.clone());641 <WhiteList<T>>::insert(collection_id, white_list_collection);642 }643 }644645 Ok(())646 }647648 /// Toggle between normal and white list access for the methods with access for `Anyone`.649 /// 650 /// # Permissions651 /// 652 /// * Collection Owner.653 /// 654 /// # Arguments655 /// 656 /// * collection_id.657 /// 658 /// * mode: [AccessMode]659 #[weight = T::WeightInfo::set_public_access_mode()]660 pub fn set_public_access_mode(origin, collection_id: u64, mode: AccessMode) -> DispatchResult661 {662 let sender = ensure_signed(origin)?;663664 Self::check_owner_permissions(collection_id, sender)?;665 let mut target_collection = <Collection<T>>::get(collection_id);666 target_collection.access = mode;667 <Collection<T>>::insert(collection_id, target_collection);668669 Ok(())670 }671672 /// Allows Anyone to create tokens if:673 /// * White List is enabled, and674 /// * Address is added to white list, and675 /// * This method was called with True parameter676 /// 677 /// # Permissions678 /// * Collection Owner679 ///680 /// # Arguments681 /// 682 /// * collection_id.683 /// 684 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.685 #[weight = T::WeightInfo::set_mint_permission()]686 pub fn set_mint_permission(origin, collection_id: u64, mint_permission: bool) -> DispatchResult687 {688 let sender = ensure_signed(origin)?;689690 Self::check_owner_permissions(collection_id, sender)?;691 let mut target_collection = <Collection<T>>::get(collection_id);692 target_collection.mint_mode = mint_permission;693 <Collection<T>>::insert(collection_id, target_collection);694695 Ok(())696 }697698 /// Change the owner of the collection.699 /// 700 /// # Permissions701 /// 702 /// * Collection Owner.703 /// 704 /// # Arguments705 /// 706 /// * collection_id.707 /// 708 /// * new_owner.709 #[weight = T::WeightInfo::change_collection_owner()]710 pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {711712 let sender = ensure_signed(origin)?;713 Self::check_owner_permissions(collection_id, sender)?;714 let mut target_collection = <Collection<T>>::get(collection_id);715 target_collection.owner = new_owner;716 <Collection<T>>::insert(collection_id, target_collection);717718 Ok(())719 }720721 /// Adds an admin of the Collection.722 /// 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. 723 /// 724 /// # Permissions725 /// 726 /// * Collection Owner.727 /// * Collection Admin.728 /// 729 /// # Arguments730 /// 731 /// * collection_id: ID of the Collection to add admin for.732 /// 733 /// * new_admin_id: Address of new admin to add.734 #[weight = T::WeightInfo::add_collection_admin()]735 pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {736737 let sender = ensure_signed(origin)?;738 Self::check_owner_or_admin_permissions(collection_id, sender)?;739 let mut admin_arr: Vec<T::AccountId> = Vec::new();740741 if <AdminList<T>>::contains_key(collection_id)742 {743 admin_arr = <AdminList<T>>::get(collection_id);744 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);745 }746747 // Number of collection admins748 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);749750 admin_arr.push(new_admin_id);751 <AdminList<T>>::insert(collection_id, admin_arr);752753 Ok(())754 }755756 /// 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.757 ///758 /// # Permissions759 /// 760 /// * Collection Owner.761 /// * Collection Admin.762 /// 763 /// # Arguments764 /// 765 /// * collection_id: ID of the Collection to remove admin for.766 /// 767 /// * account_id: Address of admin to remove.768 #[weight = T::WeightInfo::remove_collection_admin()]769 pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {770771 let sender = ensure_signed(origin)?;772 Self::check_owner_or_admin_permissions(collection_id, sender)?;773774 if <AdminList<T>>::contains_key(collection_id)775 {776 let mut admin_arr = <AdminList<T>>::get(collection_id);777 admin_arr.retain(|i| *i != account_id);778 <AdminList<T>>::insert(collection_id, admin_arr);779 }780781 Ok(())782 }783784 /// # Permissions785 /// 786 /// * Collection Owner787 /// 788 /// # Arguments789 /// 790 /// * collection_id.791 /// 792 /// * new_sponsor.793 #[weight = T::WeightInfo::set_collection_sponsor()]794 pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {795796 let sender = ensure_signed(origin)?;797 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);798799 let mut target_collection = <Collection<T>>::get(collection_id);800 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);801802 target_collection.unconfirmed_sponsor = new_sponsor;803 <Collection<T>>::insert(collection_id, target_collection);804805 Ok(())806 }807808 /// # Permissions809 /// 810 /// * Sponsor.811 /// 812 /// # Arguments813 /// 814 /// * collection_id.815 #[weight = T::WeightInfo::confirm_sponsorship()]816 pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {817818 let sender = ensure_signed(origin)?;819 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);820821 let mut target_collection = <Collection<T>>::get(collection_id);822 ensure!(sender == target_collection.unconfirmed_sponsor, Error::<T>::ConfirmUnsetSponsorFail);823824 target_collection.sponsor = target_collection.unconfirmed_sponsor;825 target_collection.unconfirmed_sponsor = T::AccountId::default();826 <Collection<T>>::insert(collection_id, target_collection);827828 Ok(())829 }830831 /// Switch back to pay-per-own-transaction model.832 ///833 /// # Permissions834 ///835 /// * Collection owner.836 /// 837 /// # Arguments838 /// 839 /// * collection_id.840 #[weight = T::WeightInfo::remove_collection_sponsor()]841 pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {842843 let sender = ensure_signed(origin)?;844 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);845846 let mut target_collection = <Collection<T>>::get(collection_id);847 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);848849 target_collection.sponsor = T::AccountId::default();850 <Collection<T>>::insert(collection_id, target_collection);851852 Ok(())853 }854855 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.856 /// 857 /// # Permissions858 /// 859 /// * Collection Owner.860 /// * Collection Admin.861 /// * Anyone if862 /// * White List is enabled, and863 /// * Address is added to white list, and864 /// * MintPermission is enabled (see SetMintPermission method)865 /// 866 /// # Arguments867 /// 868 /// * collection_id: ID of the collection.869 /// 870 /// * owner: Address, initial owner of the NFT.871 ///872 /// * data: Token data to store on chain.873 // #[weight =874 // (130_000_000 as Weight)875 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))876 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))877 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]878879 #[weight = T::WeightInfo::create_item(data.len())]880 pub fn create_item(origin, collection_id: u64, owner: T::AccountId, data: CreateItemData) -> DispatchResult {881882 let sender = ensure_signed(origin)?;883884 Self::collection_exists(collection_id)?;885886 let target_collection = <Collection<T>>::get(collection_id);887888 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;889 Self::validate_create_item_args(&target_collection, &data)?;890 Self::create_item_no_validation(collection_id, &target_collection, owner, data)?;891892 Ok(())893 }894895 /// This method creates multiple instances of NFT Collection created with CreateCollection method.896 /// 897 /// # Permissions898 /// 899 /// * Collection Owner.900 /// * Collection Admin.901 /// * Anyone if902 /// * White List is enabled, and903 /// * Address is added to white list, and904 /// * MintPermission is enabled (see SetMintPermission method)905 /// 906 /// # Arguments907 /// 908 /// * collection_id: ID of the collection.909 /// 910 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].911 /// 912 /// * owner: Address, initial owner of the NFT.913 #[weight = T::WeightInfo::create_item(items_data.into_iter()914 .map(|data| { data.len() })915 .sum())]916 pub fn create_multiple_items(origin, collection_id: u64, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {917918 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);919 let sender = ensure_signed(origin)?;920921 Self::collection_exists(collection_id)?;922 let target_collection = <Collection<T>>::get(collection_id);923924 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;925926 for data in &items_data {927 Self::validate_create_item_args(&target_collection, data)?;928 }929 for data in &items_data {930 Self::create_item_no_validation(collection_id, &target_collection, owner.clone(), data.clone())?;931 }932933 Ok(())934 }935936 /// Destroys a concrete instance of NFT.937 /// 938 /// # Permissions939 /// 940 /// * Collection Owner.941 /// * Collection Admin.942 /// * Current NFT Owner.943 /// 944 /// # Arguments945 /// 946 /// * collection_id: ID of the collection.947 /// 948 /// * item_id: ID of NFT to burn.949 #[weight = T::WeightInfo::burn_item()]950 pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {951952 let sender = ensure_signed(origin)?;953 Self::collection_exists(collection_id)?;954955 // Transfer permissions check956 let target_collection = <Collection<T>>::get(collection_id);957 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||958 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),959 Error::<T>::NoPermission);960961 if target_collection.access == AccessMode::WhiteList {962 Self::check_white_list(collection_id, &sender)?;963 }964965 match target_collection.mode966 {967 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,968 CollectionMode::Fungible(_) => Self::burn_fungible_item(collection_id, item_id)?,969 CollectionMode::ReFungible(_) => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,970 _ => ()971 };972973 // call event974 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));975976 Ok(())977 }978979 /// Change ownership of the token.980 /// 981 /// # Permissions982 /// 983 /// * Collection Owner984 /// * Collection Admin985 /// * Current NFT owner986 ///987 /// # Arguments988 /// 989 /// * recipient: Address of token recipient.990 /// 991 /// * collection_id.992 /// 993 /// * item_id: ID of the item994 /// * Non-Fungible Mode: Required.995 /// * Fungible Mode: Ignored.996 /// * Re-Fungible Mode: Required.997 /// 998 /// * value: Amount to transfer.999 /// * Non-Fungible Mode: Ignored1000 /// * Fungible Mode: Must specify transferred amount1001 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1002 #[weight = T::WeightInfo::transfer()]1003 pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {10041005 let sender = ensure_signed(origin)?;10061007 // Transfer permissions check1008 let target_collection = <Collection<T>>::get(collection_id);1009 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1010 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1011 Error::<T>::NoPermission);10121013 if target_collection.access == AccessMode::WhiteList {1014 Self::check_white_list(collection_id, &sender)?;1015 Self::check_white_list(collection_id, &recipient)?;1016 }10171018 match target_collection.mode1019 {1020 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,1021 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,1022 CollectionMode::ReFungible(_) => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,1023 _ => ()1024 };10251026 Ok(())1027 }10281029 /// Set, change, or remove approved address to transfer the ownership of the NFT.1030 /// 1031 /// # Permissions1032 /// 1033 /// * Collection Owner1034 /// * Collection Admin1035 /// * Current NFT owner1036 /// 1037 /// # Arguments1038 /// 1039 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1040 /// 1041 /// * collection_id.1042 /// 1043 /// * item_id: ID of the item.1044 #[weight = T::WeightInfo::approve()]1045 pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {10461047 let sender = ensure_signed(origin)?;10481049 // Transfer permissions check1050 let target_collection = <Collection<T>>::get(collection_id);1051 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1052 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1053 Error::<T>::NoPermission);10541055 if target_collection.access == AccessMode::WhiteList {1056 Self::check_white_list(collection_id, &sender)?;1057 Self::check_white_list(collection_id, &approved)?;1058 }10591060 // amount param stub1061 let amount = 100000000;10621063 let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));1064 if list_exists {10651066 let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));1067 let item_contains = list.iter().any(|i| i.approved == approved);10681069 if !item_contains {1070 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1071 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1072 }1073 } else {10741075 let mut list = Vec::new();1076 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1077 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1078 }10791080 Ok(())1081 }1082 1083 /// 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.1084 /// 1085 /// # Permissions1086 /// * Collection Owner1087 /// * Collection Admin1088 /// * Current NFT owner1089 /// * Address approved by current NFT owner1090 /// 1091 /// # Arguments1092 /// 1093 /// * from: Address that owns token.1094 /// 1095 /// * recipient: Address of token recipient.1096 /// 1097 /// * collection_id.1098 /// 1099 /// * item_id: ID of the item.1100 /// 1101 /// * value: Amount to transfer.1102 #[weight = T::WeightInfo::transfer_from()]1103 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {11041105 let sender = ensure_signed(origin)?;1106 let mut appoved_transfer = false;11071108 // Check approve1109 if <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone())) {1110 let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));1111 let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());1112 if opt_item.is_some()1113 {1114 appoved_transfer = true;1115 ensure!(opt_item.unwrap().amount >= value, Error::<T>::TokenValueNotEnough);1116 }1117 }11181119 // Transfer permissions check1120 let target_collection = <Collection<T>>::get(collection_id);1121 ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1122 Error::<T>::NoPermission);11231124 if target_collection.access == AccessMode::WhiteList {1125 Self::check_white_list(collection_id, &sender)?;1126 Self::check_white_list(collection_id, &recipient)?;1127 }11281129 // remove approve1130 let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))1131 .into_iter().filter(|i| i.approved != sender.clone()).collect();1132 <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);113311341135 match target_collection.mode1136 {1137 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1138 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,1139 CollectionMode::ReFungible(_) => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1140 _ => ()1141 };11421143 Ok(())1144 }11451146 ///1147 #[weight = 0]1148 pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {11491150 // let no_perm_mes = "You do not have permissions to modify this collection";1151 // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1152 // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1153 // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);11541155 // // on_nft_received call11561157 // Self::transfer(origin, collection_id, item_id, new_owner)?;11581159 Ok(())1160 }11611162 /// Set off-chain data schema.1163 /// 1164 /// # Permissions1165 /// 1166 /// * Collection Owner1167 /// * Collection Admin1168 /// 1169 /// # Arguments1170 /// 1171 /// * collection_id.1172 /// 1173 /// * schema: String representing the offchain data schema.1174 #[weight = T::WeightInfo::set_variable_meta_data()]1175 pub fn set_variable_meta_data (1176 origin,1177 collection_id: u64,1178 item_id: u64,1179 data: Vec<u8>1180 ) -> DispatchResult {1181 let sender = ensure_signed(origin)?;1182 1183 Self::collection_exists(collection_id)?;11841185 // Modify permissions check1186 let target_collection = <Collection<T>>::get(collection_id);1187 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1188 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1189 Error::<T>::NoPermission);11901191 Self::item_exists(collection_id, item_id, &target_collection.mode)?;11921193 match target_collection.mode1194 {1195 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1196 CollectionMode::ReFungible(_) => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1197 _ => ()1198 };11991200 Ok(())1201 }1202 12031204 /// Set off-chain data schema.1205 /// 1206 /// # Permissions1207 /// 1208 /// * Collection Owner1209 /// * Collection Admin1210 /// 1211 /// # Arguments1212 /// 1213 /// * collection_id.1214 /// 1215 /// * schema: String representing the offchain data schema.1216 #[weight = T::WeightInfo::set_offchain_schema()]1217 pub fn set_offchain_schema(1218 origin,1219 collection_id: u64,1220 schema: Vec<u8>1221 ) -> DispatchResult {1222 let sender = ensure_signed(origin)?;1223 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12241225 let mut target_collection = <Collection<T>>::get(collection_id);1226 target_collection.offchain_schema = schema;1227 <Collection<T>>::insert(collection_id, target_collection);12281229 Ok(())1230 }12311232 /// Set const on-chain data schema.1233 /// 1234 /// # Permissions1235 /// 1236 /// * Collection Owner1237 /// * Collection Admin1238 /// 1239 /// # Arguments1240 /// 1241 /// * collection_id.1242 /// 1243 /// * schema: String representing the const on-chain data schema.1244 #[weight = T::WeightInfo::set_const_on_chain_schema()]1245 pub fn set_const_on_chain_schema (1246 origin,1247 collection_id: u64,1248 schema: Vec<u8>1249 ) -> DispatchResult {1250 let sender = ensure_signed(origin)?;1251 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12521253 let mut target_collection = <Collection<T>>::get(collection_id);1254 target_collection.const_on_chain_schema = schema;1255 <Collection<T>>::insert(collection_id, target_collection);12561257 Ok(())1258 }12591260 /// Set variable on-chain data schema.1261 /// 1262 /// # Permissions1263 /// 1264 /// * Collection Owner1265 /// * Collection Admin1266 /// 1267 /// # Arguments1268 /// 1269 /// * collection_id.1270 /// 1271 /// * schema: String representing the variable on-chain data schema.1272 #[weight = T::WeightInfo::set_const_on_chain_schema()]1273 pub fn set_variable_on_chain_schema (1274 origin,1275 collection_id: u64,1276 schema: Vec<u8>1277 ) -> DispatchResult {1278 let sender = ensure_signed(origin)?;1279 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12801281 let mut target_collection = <Collection<T>>::get(collection_id);1282 target_collection.variable_on_chain_schema = schema;1283 <Collection<T>>::insert(collection_id, target_collection);12841285 Ok(())1286 }12871288 // Sudo permissions function1289 #[weight = 0]1290 pub fn set_chain_limits(1291 origin,1292 limits: ChainLimits1293 ) -> DispatchResult {1294 ensure_root(origin)?;1295 <ChainLimit>::put(limits);1296 Ok(())1297 }12981299 /// Enable smart contract self-sponsoring.1300 /// 1301 /// # Permissions1302 /// 1303 /// * Contract Owner1304 /// 1305 /// # Arguments1306 /// 1307 /// * contract address1308 /// * enable flag1309 /// 1310 #[weight = 0]1311 pub fn enable_contract_sponsoring(1312 origin,1313 contract_address: T::AccountId,1314 enable: bool1315 ) -> DispatchResult {1316 let sender = ensure_signed(origin)?;1317 let mut is_owner = false;1318 if <ContractOwner<T>>::contains_key(contract_address.clone()) {1319 let owner = <ContractOwner<T>>::get(&contract_address);1320 is_owner = sender == owner;1321 }1322 ensure!(is_owner, Error::<T>::NoPermission);13231324 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1325 Ok(())1326 }13271328 /// Set the rate limit for contract sponsoring to specified number of blocks.1329 /// 1330 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1331 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1332 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1333 /// from contract endowment if there are at least B blocks between such transactions. 1334 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1335 /// 1336 /// # Permissions1337 /// 1338 /// * Contract Owner1339 /// 1340 /// # Arguments1341 /// 1342 /// -`contract_address`: Address of the contract to sponsor1343 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1344 /// 1345 #[weight = 0]1346 pub fn set_contract_sponsoring_rate_limit(1347 origin,1348 contract_address: T::AccountId,1349 rate_limit: T::BlockNumber1350 ) -> DispatchResult {1351 let sender = ensure_signed(origin)?;1352 let mut is_owner = false;1353 if <ContractOwner<T>>::contains_key(contract_address.clone()) {1354 let owner = <ContractOwner<T>>::get(&contract_address);1355 is_owner = sender == owner;1356 }1357 ensure!(is_owner, Error::<T>::NoPermission);13581359 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1360 Ok(())1361 }13621363 }1364}13651366impl<T: Trait> Module<T> {13671368 fn can_create_items_in_collection(collection_id: u64, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {13691370 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1371 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1372 Self::check_white_list(collection_id, owner)?;1373 Self::check_white_list(collection_id, sender)?;1374 }13751376 Ok(())1377 }13781379 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1380 match target_collection.mode1381 {1382 CollectionMode::NFT => {1383 if let CreateItemData::NFT(data) = data {1384 // check sizes1385 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");1386 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");1387 } else {1388 fail!("Not NFT item data used to mint in NFT collection.");1389 }1390 },1391 CollectionMode::Fungible(_) => {1392 if let CreateItemData::Fungible(_) = data {1393 } else {1394 fail!("Not Fungible item data used to mint in Fungible collection.");1395 }1396 },1397 CollectionMode::ReFungible(_) => {1398 if let CreateItemData::ReFungible(data) = data {13991400 // check sizes1401 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");1402 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");1403 } else {1404 fail!("Not Re Fungible item data used to mint in Re Fungible collection.");1405 }1406 },1407 _ => { fail!("Unexpected collection type."); }1408 };14091410 Ok(())1411 }14121413 fn create_item_no_validation(collection_id: u64, collection: &CollectionType<T::AccountId>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1414 match data1415 {1416 CreateItemData::NFT(data) => {1417 let item = NftItemType {1418 collection: collection_id,1419 owner,1420 const_data: data.const_data,1421 variable_data: data.variable_data1422 };14231424 Self::add_nft_item(item)?;1425 },1426 CreateItemData::Fungible(_) => {1427 let item = FungibleItemType {1428 collection: collection_id,1429 owner,1430 value: (10 as u128).pow(collection.decimal_points)1431 };14321433 Self::add_fungible_item(item)?;1434 },1435 CreateItemData::ReFungible(data) => {1436 let mut owner_list = Vec::new();1437 let value = (10 as u128).pow(collection.decimal_points);1438 owner_list.push(Ownership {owner: owner.clone(), fraction: value});14391440 let item = ReFungibleItemType {1441 collection: collection_id,1442 owner: owner_list,1443 const_data: data.const_data,1444 variable_data: data.variable_data1445 };14461447 Self::add_refungible_item(item)?;1448 }1449 };145014511452 // call event1453 Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));14541455 Ok(())1456 }14571458 fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {1459 let current_index = <ItemListIndex>::get(item.collection)1460 .checked_add(1)1461 .ok_or(Error::<T>::NumOverflow)?;1462 let itemcopy = item.clone();1463 let owner = item.owner.clone();1464 let value = item.value as u64;14651466 Self::add_token_index(item.collection, current_index, owner.clone())?;14671468 <ItemListIndex>::insert(item.collection, current_index);1469 <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);14701471 // Add current block1472 let v: Vec<BasketItem<T::AccountId, T::BlockNumber>> = Vec::new();1473 <FungibleTransferBasket<T>>::insert(item.collection, current_index, v);1474 1475 // Update balance1476 let new_balance = <Balance<T>>::get(item.collection, owner.clone())1477 .checked_add(value)1478 .ok_or(Error::<T>::NumOverflow)?;1479 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);14801481 Ok(())1482 }14831484 fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1485 let current_index = <ItemListIndex>::get(item.collection)1486 .checked_add(1)1487 .ok_or(Error::<T>::NumOverflow)?;1488 let itemcopy = item.clone();14891490 let value = item.owner.first().unwrap().fraction as u64;1491 let owner = item.owner.first().unwrap().owner.clone();14921493 Self::add_token_index(item.collection, current_index, owner.clone())?;14941495 <ItemListIndex>::insert(item.collection, current_index);1496 <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);14971498 // Add current block1499 let block_number: T::BlockNumber = 0.into();1500 <ReFungibleTransferBasket<T>>::insert(item.collection, current_index, block_number);15011502 // Update balance1503 let new_balance = <Balance<T>>::get(item.collection, owner.clone())1504 .checked_add(value)1505 .ok_or(Error::<T>::NumOverflow)?;1506 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);15071508 Ok(())1509 }15101511 fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {1512 let current_index = <ItemListIndex>::get(item.collection)1513 .checked_add(1)1514 .ok_or(Error::<T>::NumOverflow)?;15151516 let item_owner = item.owner.clone();1517 let collection_id = item.collection.clone();1518 Self::add_token_index(collection_id, current_index, item.owner.clone())?;15191520 <ItemListIndex>::insert(collection_id, current_index);1521 <NftItemList<T>>::insert(collection_id, current_index, item);15221523 // Add current block1524 let block_number: T::BlockNumber = 0.into();1525 <NftTransferBasket<T>>::insert(collection_id, current_index, block_number);15261527 // Update balance1528 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1529 .checked_add(1)1530 .ok_or(Error::<T>::NumOverflow)?;1531 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);15321533 Ok(())1534 }15351536 fn burn_refungible_item(1537 collection_id: u64,1538 item_id: u64,1539 owner: T::AccountId,1540 ) -> DispatchResult {1541 ensure!(1542 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1543 Error::<T>::TokenNotFound1544 );1545 let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);1546 let item = collection1547 .owner1548 .iter()1549 .filter(|&i| i.owner == owner)1550 .next()1551 .unwrap();1552 Self::remove_token_index(collection_id, item_id, owner.clone())?;15531554 // remove approve list1555 <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));15561557 // update balance1558 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1559 .checked_sub(item.fraction as u64)1560 .ok_or(Error::<T>::NumOverflow)?;1561 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);15621563 <ReFungibleItemList<T>>::remove(collection_id, item_id);15641565 Ok(())1566 }15671568 fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {1569 ensure!(1570 <NftItemList<T>>::contains_key(collection_id, item_id),1571 Error::<T>::TokenNotFound1572 );1573 let item = <NftItemList<T>>::get(collection_id, item_id);1574 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;15751576 // remove approve list1577 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));15781579 // update balance1580 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1581 .checked_sub(1)1582 .ok_or(Error::<T>::NumOverflow)?;1583 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1584 <NftItemList<T>>::remove(collection_id, item_id);15851586 Ok(())1587 }15881589 fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {1590 ensure!(1591 <FungibleItemList<T>>::contains_key(collection_id, item_id),1592 Error::<T>::TokenNotFound1593 );1594 let item = <FungibleItemList<T>>::get(collection_id, item_id);1595 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;15961597 // remove approve list1598 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));15991600 // update balance1601 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1602 .checked_sub(item.value as u64)1603 .ok_or(Error::<T>::NumOverflow)?;1604 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);16051606 <FungibleItemList<T>>::remove(collection_id, item_id);16071608 Ok(())1609 }16101611 fn collection_exists(collection_id: u64) -> DispatchResult {1612 ensure!(1613 <Collection<T>>::contains_key(collection_id),1614 Error::<T>::CollectionNotFound1615 );1616 Ok(())1617 }16181619 fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {1620 Self::collection_exists(collection_id)?;16211622 let target_collection = <Collection<T>>::get(collection_id);1623 ensure!(1624 subject == target_collection.owner,1625 Error::<T>::NoPermission1626 );16271628 Ok(())1629 }16301631 fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {1632 let target_collection = <Collection<T>>::get(collection_id);1633 let mut result: bool = subject == target_collection.owner;1634 let exists = <AdminList<T>>::contains_key(collection_id);16351636 if !result & exists {1637 if <AdminList<T>>::get(collection_id).contains(&subject) {1638 result = true1639 }1640 }16411642 result1643 }16441645 fn check_owner_or_admin_permissions(1646 collection_id: u64,1647 subject: T::AccountId,1648 ) -> DispatchResult {1649 Self::collection_exists(collection_id)?;1650 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());16511652 ensure!(1653 result,1654 Error::<T>::NoPermission1655 );1656 Ok(())1657 }16581659 fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {1660 let target_collection = <Collection<T>>::get(collection_id);16611662 match target_collection.mode {1663 CollectionMode::NFT => {1664 <NftItemList<T>>::get(collection_id, item_id).owner == subject1665 }1666 CollectionMode::Fungible(_) => {1667 <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1668 }1669 CollectionMode::ReFungible(_) => {1670 <ReFungibleItemList<T>>::get(collection_id, item_id)1671 .owner1672 .iter()1673 .any(|i| i.owner == subject)1674 }1675 CollectionMode::Invalid => false,1676 }1677 }16781679 fn check_white_list(collection_id: u64, address: &T::AccountId) -> DispatchResult {1680 let mes = Error::<T>::AddresNotInWhiteList;1681 ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1682 let wl = <WhiteList<T>>::get(collection_id);1683 ensure!(wl.contains(address), mes);16841685 Ok(())1686 }16871688 fn transfer_fungible(1689 collection_id: u64,1690 item_id: u64,1691 value: u64,1692 owner: T::AccountId,1693 new_owner: T::AccountId,1694 ) -> DispatchResult {1695 ensure!(1696 <FungibleItemList<T>>::contains_key(collection_id, item_id),1697 Error::<T>::TokenNotFound1698 );16991700 let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1701 let amount = full_item.value;17021703 ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);17041705 // update balance1706 let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1707 .checked_sub(value)1708 .ok_or(Error::<T>::NumOverflow)?;1709 <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);17101711 let mut new_owner_account_id = 0;1712 let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());1713 if new_owner_items.len() > 0 {1714 new_owner_account_id = new_owner_items[0];1715 }17161717 let val64 = value.into();17181719 // transfer1720 if amount == val64 && new_owner_account_id == 0 {1721 // change owner1722 // new owner do not have account1723 let mut new_full_item = full_item.clone();1724 new_full_item.owner = new_owner.clone();1725 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);17261727 // update balance1728 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1729 .checked_add(value)1730 .ok_or(Error::<T>::NumOverflow)?;1731 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17321733 // update index collection1734 Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1735 } else {1736 let mut new_full_item = full_item.clone();1737 new_full_item.value -= val64;17381739 // separate amount1740 if new_owner_account_id > 0 {1741 // new owner has account1742 let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1743 item.value += val64;17441745 // update balance1746 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1747 .checked_add(value)1748 .ok_or(Error::<T>::NumOverflow)?;1749 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17501751 <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);1752 } else {1753 // new owner do not have account1754 let item = FungibleItemType {1755 collection: collection_id,1756 owner: new_owner.clone(),1757 value: val64,1758 };17591760 Self::add_fungible_item(item)?;1761 }17621763 if amount == val64 {1764 Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;17651766 // remove approve list1767 <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));1768 <FungibleItemList<T>>::remove(collection_id, item_id);1769 }17701771 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1772 }17731774 Ok(())1775 }17761777 fn transfer_refungible(1778 collection_id: u64,1779 item_id: u64,1780 value: u64,1781 owner: T::AccountId,1782 new_owner: T::AccountId,1783 ) -> DispatchResult {1784 ensure!(1785 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1786 Error::<T>::TokenNotFound1787 );17881789 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1790 let item = full_item1791 .owner1792 .iter()1793 .filter(|i| i.owner == owner)1794 .next()1795 .ok_or(Error::<T>::NumOverflow)?;1796 let amount = item.fraction;17971798 ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);17991800 // update balance1801 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1802 .checked_sub(value)1803 .ok_or(Error::<T>::NumOverflow)?;1804 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);18051806 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1807 .checked_add(value)1808 .ok_or(Error::<T>::NumOverflow)?;1809 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18101811 let old_owner = item.owner.clone();1812 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);1813 let val64 = value.into();18141815 // transfer1816 if amount == val64 && !new_owner_has_account {1817 // change owner1818 // new owner do not have account1819 let mut new_full_item = full_item.clone();1820 new_full_item1821 .owner1822 .iter_mut()1823 .find(|i| i.owner == owner)1824 .unwrap()1825 .owner = new_owner.clone();1826 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);18271828 // update index collection1829 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1830 } else {1831 let mut new_full_item = full_item.clone();1832 new_full_item1833 .owner1834 .iter_mut()1835 .find(|i| i.owner == owner)1836 .unwrap()1837 .fraction -= val64;18381839 // separate amount1840 if new_owner_has_account {1841 // new owner has account1842 new_full_item1843 .owner1844 .iter_mut()1845 .find(|i| i.owner == new_owner)1846 .unwrap()1847 .fraction += val64;1848 } else {1849 // new owner do not have account1850 new_full_item.owner.push(Ownership {1851 owner: new_owner.clone(),1852 fraction: val64,1853 });1854 Self::add_token_index(collection_id, item_id, new_owner.clone())?;1855 }18561857 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1858 }18591860 Ok(())1861 }18621863 fn transfer_nft(1864 collection_id: u64,1865 item_id: u64,1866 sender: T::AccountId,1867 new_owner: T::AccountId,1868 ) -> DispatchResult {1869 ensure!(1870 <NftItemList<T>>::contains_key(collection_id, item_id),1871 Error::<T>::TokenNotFound1872 );18731874 let mut item = <NftItemList<T>>::get(collection_id, item_id);18751876 ensure!(1877 sender == item.owner,1878 Error::<T>::MustBeTokenOwner1879 );18801881 // update balance1882 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1883 .checked_sub(1)1884 .ok_or(Error::<T>::NumOverflow)?;1885 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);18861887 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1888 .checked_add(1)1889 .ok_or(Error::<T>::NumOverflow)?;1890 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18911892 // change owner1893 let old_owner = item.owner.clone();1894 item.owner = new_owner.clone();1895 <NftItemList<T>>::insert(collection_id, item_id, item);18961897 // update index collection1898 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;18991900 // reset approved list1901 <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1902 Ok(())1903 }1904 1905 fn item_exists(1906 collection_id: u64,1907 item_id: u64,1908 mode: &CollectionMode1909 ) -> DispatchResult {1910 match mode {1911 CollectionMode::NFT => ensure!(<NftItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1912 CollectionMode::ReFungible(_) => ensure!(<ReFungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1913 CollectionMode::Fungible(_) => ensure!(<FungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1914 _ => ()1915 };1916 1917 Ok(())1918 }19191920 fn set_re_fungible_variable_data(1921 collection_id: u64,1922 item_id: u64,1923 data: Vec<u8>1924 ) -> DispatchResult {1925 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);19261927 item.variable_data = data;19281929 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);19301931 Ok(())1932 }19331934 fn set_nft_variable_data(1935 collection_id: u64,1936 item_id: u64,1937 data: Vec<u8>1938 ) -> DispatchResult {1939 let mut item = <NftItemList<T>>::get(collection_id, item_id);1940 1941 item.variable_data = data;19421943 <NftItemList<T>>::insert(collection_id, item_id, item);1944 1945 Ok(())1946 }19471948 fn init_collection(item: &CollectionType<T::AccountId>) {1949 // check params1950 assert!(1951 item.decimal_points <= 4,1952 "decimal_points parameter must be lower than 4"1953 );1954 assert!(1955 item.name.len() <= 64,1956 "Collection name can not be longer than 63 char"1957 );1958 assert!(1959 item.name.len() <= 256,1960 "Collection description can not be longer than 255 char"1961 );1962 assert!(1963 item.token_prefix.len() <= 16,1964 "Token prefix can not be longer than 15 char"1965 );19661967 // Generate next collection ID1968 let next_id = CreatedCollectionCount::get()1969 .checked_add(1)1970 .unwrap();19711972 CreatedCollectionCount::put(next_id);1973 }19741975 fn init_nft_token(item: &NftItemType<T::AccountId>) {1976 let current_index = <ItemListIndex>::get(item.collection)1977 .checked_add(1)1978 .unwrap();19791980 let item_owner = item.owner.clone();1981 let collection_id = item.collection.clone();1982 Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();19831984 <ItemListIndex>::insert(collection_id, current_index);19851986 // Update balance1987 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1988 .checked_add(1)1989 .unwrap();1990 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);1991 }19921993 fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {1994 let current_index = <ItemListIndex>::get(item.collection)1995 .checked_add(1)1996 .unwrap();1997 let owner = item.owner.clone();1998 let value = item.value as u64;19992000 Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();20012002 <ItemListIndex>::insert(item.collection, current_index);20032004 // Update balance2005 let new_balance = <Balance<T>>::get(item.collection, owner.clone())2006 .checked_add(value)2007 .unwrap();2008 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2009 }20102011 fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {2012 let current_index = <ItemListIndex>::get(item.collection)2013 .checked_add(1)2014 .unwrap();20152016 let value = item.owner.first().unwrap().fraction as u64;2017 let owner = item.owner.first().unwrap().owner.clone();20182019 Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();20202021 <ItemListIndex>::insert(item.collection, current_index);20222023 // Update balance2024 let new_balance = <Balance<T>>::get(item.collection, owner.clone())2025 .checked_add(value)2026 .unwrap();2027 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2028 }20292030 fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {20312032 // add to account limit2033 if <AccountItemCount<T>>::contains_key(owner.clone()) {20342035 // bound Owned tokens by a single address2036 let count = <AccountItemCount<T>>::get(owner.clone());2037 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);20382039 <AccountItemCount<T>>::insert(owner.clone(), count2040 .checked_add(1)2041 .ok_or(Error::<T>::NumOverflow)?);2042 }2043 else {2044 <AccountItemCount<T>>::insert(owner.clone(), 1);2045 }20462047 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2048 if list_exists {2049 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2050 let item_contains = list.contains(&item_index.clone());20512052 if !item_contains {2053 list.push(item_index.clone());2054 }20552056 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2057 } else {2058 let mut itm = Vec::new();2059 itm.push(item_index.clone());2060 <AddressTokens<T>>::insert(collection_id, owner, itm);2061 2062 }20632064 Ok(())2065 }20662067 fn remove_token_index(2068 collection_id: u64,2069 item_index: u64,2070 owner: T::AccountId,2071 ) -> DispatchResult {20722073 // update counter2074 <AccountItemCount<T>>::insert(owner.clone(), 2075 <AccountItemCount<T>>::get(owner.clone())2076 .checked_sub(1)2077 .ok_or(Error::<T>::NumOverflow)?);207820792080 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2081 if list_exists {2082 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2083 let item_contains = list.contains(&item_index.clone());20842085 if item_contains {2086 list.retain(|&item| item != item_index);2087 <AddressTokens<T>>::insert(collection_id, owner, list);2088 }2089 }20902091 Ok(())2092 }20932094 fn move_token_index(2095 collection_id: u64,2096 item_index: u64,2097 old_owner: T::AccountId,2098 new_owner: T::AccountId,2099 ) -> DispatchResult {2100 Self::remove_token_index(collection_id, item_index, old_owner)?;2101 Self::add_token_index(collection_id, item_index, new_owner)?;21022103 Ok(())2104 }2105}21062107////////////////////////////////////////////////////////////////////////////////////////////////////2108// Economic models2109// #region21102111/// Fee multiplier.2112pub type Multiplier = FixedU128;21132114type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2115 <T as system::Trait>::AccountId,2116>>::Balance;2117type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2118 <T as system::Trait>::AccountId,2119>>::NegativeImbalance;21202121/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2122/// in the queue.2123#[derive(Encode, Decode, Clone, Eq, PartialEq)]2124pub struct ChargeTransactionPayment<T: Trait + Send + Sync>(2125 #[codec(compact)] BalanceOf<T>2126);21272128impl<T: Trait + Send + Sync> sp_std::fmt::Debug2129 for ChargeTransactionPayment<T>2130{2131 #[cfg(feature = "std")]2132 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2133 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2134 }2135 #[cfg(not(feature = "std"))]2136 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2137 Ok(())2138 }2139}21402141impl<T: Trait + Send + Sync> ChargeTransactionPayment<T>2142where2143 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2144 BalanceOf<T>: Send + Sync + FixedPointOperand,2145{2146 /// utility constructor. Used only in client/factory code.2147 pub fn from(fee: BalanceOf<T>) -> Self {2148 Self(fee)2149 }21502151 pub fn traditional_fee(2152 len: usize,2153 info: &DispatchInfoOf<T::Call>,2154 tip: BalanceOf<T>,2155 ) -> BalanceOf<T>2156 where2157 T::Call: Dispatchable<Info = DispatchInfo>,2158 {2159 <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2160 }21612162 fn withdraw_fee(2163 &self,2164 who: &T::AccountId,2165 call: &T::Call,2166 info: &DispatchInfoOf<T::Call>,2167 len: usize,2168 ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {2169 let tip = self.0;21702171 // Set fee based on call type. Creating collection costs 1 Unique.2172 // All other transactions have traditional fees so far2173 // let fee = match call.is_sub_type() {2174 // Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2175 // _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2176 // // _ => <BalanceOf<T>>::from(100)2177 // };2178 let fee = Self::traditional_fee(len, info, tip);21792180 // Determine who is paying transaction fee based on ecnomic model2181 // Parse call to extract collection ID and access collection sponsor2182 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2183 Some(Call::create_item(collection_id, _properties, _owner)) => {2184 <Collection<T>>::get(collection_id).sponsor2185 }2186 Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {2187 let _collection_mode = <Collection<T>>::get(collection_id).mode;21882189 // sponsor timeout2190 let sponsor_transfer = match _collection_mode {2191 CollectionMode::NFT => {2192 let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);2193 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2194 let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2195 if block_number >= limit_time {2196 <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);2197 true2198 }2199 else {2200 false2201 }2202 }2203 CollectionMode::Fungible(_) => {2204 let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);2205 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2206 if basket.iter().any(|i| i.address == _new_owner.clone())2207 {2208 let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();2209 let limit_time = item.start_block + ChainLimit::get().fungible_sponsor_transfer_timeout.into();2210 if block_number >= limit_time {2211 basket.retain(|x| x.address == item.address);2212 basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });2213 <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);2214 true2215 }2216 else {2217 false2218 }2219 }2220 else {2221 basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});2222 true2223 }2224 }2225 CollectionMode::ReFungible(_) => {2226 let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);2227 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2228 let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2229 if block_number >= limit_time {2230 <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);2231 true2232 } else {2233 false2234 }2235 }2236 _ => {2237 false2238 },2239 };22402241 if !sponsor_transfer {2242 T::AccountId::default()2243 } else {2244 <Collection<T>>::get(collection_id).sponsor2245 }2246 }22472248 _ => T::AccountId::default(),2249 };22502251 // Sponsor smart contracts2252 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {22532254 // On instantiation: set the contract owner2255 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, data)) => {22562257 let new_contract_address = <T as pallet_contracts::Trait>::DetermineContractAddress::contract_address_for(2258 code_hash,2259 &data,2260 &who,2261 );2262 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());22632264 T::AccountId::default()2265 },22662267 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2268 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {22692270 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());22712272 let mut sponsor_transfer = false;2273 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2274 let last_tx_block = <ContractSponsorBasket<T>>::get(&called_contract);2275 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2276 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2277 let limit_time = last_tx_block + rate_limit;22782279 if block_number >= limit_time {2280 <ContractSponsorBasket<T>>::insert(called_contract.clone(), block_number);2281 sponsor_transfer = true;2282 }2283 } else {2284 sponsor_transfer = false;2285 }2286 2287 2288 let mut sp = T::AccountId::default();2289 if sponsor_transfer {2290 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2291 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2292 sp = called_contract;2293 }2294 }2295 }22962297 sp2298 },22992300 _ => sponsor,2301 };23022303 let mut who_pays_fee: T::AccountId = sponsor.clone();2304 if sponsor == T::AccountId::default() {2305 who_pays_fee = who.clone();2306 }23072308 // Only mess with balances if fee is not zero.2309 if fee.is_zero() {2310 return Ok((fee, None));2311 }23122313 match <T as transaction_payment::Trait>::Currency::withdraw(2314 &who_pays_fee,2315 fee,2316 if tip.is_zero() {2317 WithdrawReason::TransactionPayment.into()2318 } else {2319 WithdrawReason::TransactionPayment | WithdrawReason::Tip2320 },2321 ExistenceRequirement::KeepAlive,2322 ) {2323 Ok(imbalance) => Ok((fee, Some(imbalance))),2324 Err(_) => Err(InvalidTransaction::Payment.into()),2325 }2326 }2327}232823292330impl<T: Trait + Send + Sync> SignedExtension2331 for ChargeTransactionPayment<T>2332where2333 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2334 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2335{2336 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2337 type AccountId = T::AccountId;2338 type Call = T::Call;2339 type AdditionalSigned = ();2340 type Pre = (2341 BalanceOf<T>,2342 Self::AccountId,2343 Option<NegativeImbalanceOf<T>>,2344 BalanceOf<T>,2345 );2346 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2347 Ok(())2348 }23492350 fn validate(2351 &self,2352 _who: &Self::AccountId,2353 _call: &Self::Call,2354 _info: &DispatchInfoOf<Self::Call>,2355 _len: usize,2356 ) -> TransactionValidity {2357 Ok(ValidTransaction::default())2358 }23592360 fn pre_dispatch(2361 self,2362 who: &Self::AccountId,2363 call: &Self::Call,2364 info: &DispatchInfoOf<Self::Call>,2365 len: usize,2366 ) -> Result<Self::Pre, TransactionValidityError> {2367 let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2368 Ok((self.0, who.clone(), imbalance, fee))2369 }23702371 fn post_dispatch(2372 pre: Self::Pre,2373 info: &DispatchInfoOf<Self::Call>,2374 post_info: &PostDispatchInfoOf<Self::Call>,2375 len: usize,2376 _result: &DispatchResult,2377 ) -> Result<(), TransactionValidityError> {2378 let (tip, who, imbalance, fee) = pre;2379 if let Some(payed) = imbalance {2380 let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(2381 len as u32, info, post_info, tip,2382 );2383 let refund = fee.saturating_sub(actual_fee);2384 let actual_payment =2385 match <T as transaction_payment::Trait>::Currency::deposit_into_existing(2386 &who, refund,2387 ) {2388 Ok(refund_imbalance) => {2389 // The refund cannot be larger than the up front payed max weight.2390 // `PostDispatchInfo::calc_unspent` guards against such a case.2391 match payed.offset(refund_imbalance) {2392 Ok(actual_payment) => actual_payment,2393 Err(_) => return Err(InvalidTransaction::Payment.into()),2394 }2395 }2396 // We do not recreate the account using the refund. The up front payment2397 // is gone in that case.2398 Err(_) => payed,2399 };2400 let imbalances = actual_payment.split(tip);2401 <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(2402 Some(imbalances.0).into_iter().chain(Some(imbalances.1)),2403 );2404 }2405 Ok(())2406 }2407}24082409// #endregion1#![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;4748// Structs49// #region5051#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]52#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]53pub enum CollectionMode {54 Invalid,55 NFT,56 // decimal points57 Fungible(u32),58 // decimal points59 ReFungible(u32),60}6162impl Into<u8> for CollectionMode {63 fn into(self) -> u8 {64 match self {65 CollectionMode::Invalid => 0,66 CollectionMode::NFT => 1,67 CollectionMode::Fungible(_) => 2,68 CollectionMode::ReFungible(_) => 3,69 }70 }71}7273#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]74#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]75pub enum AccessMode {76 Normal,77 WhiteList,78}79impl Default for AccessMode {80 fn default() -> Self {81 Self::Normal82 }83}8485impl Default for CollectionMode {86 fn default() -> Self {87 Self::Invalid88 }89}9091#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]92#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]93pub struct Ownership<AccountId> {94 pub owner: AccountId,95 pub fraction: u128,96}9798#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]99#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]100pub struct CollectionType<AccountId> {101 pub owner: AccountId,102 pub mode: CollectionMode,103 pub access: AccessMode,104 pub decimal_points: u32,105 pub name: Vec<u16>, // 64 include null escape char106 pub description: Vec<u16>, // 256 include null escape char107 pub token_prefix: Vec<u8>, // 16 include null escape char108 pub mint_mode: bool,109 pub offchain_schema: Vec<u8>,110 pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender111 pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship112 pub variable_on_chain_schema: Vec<u8>, //113 pub const_on_chain_schema: Vec<u8>, //114}115116#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]117#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]118pub struct NftItemType<AccountId> {119 pub collection: u64,120 pub owner: AccountId,121 pub const_data: Vec<u8>,122 pub variable_data: Vec<u8>,123}124125#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]126#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]127pub struct FungibleItemType<AccountId> {128 pub collection: u64,129 pub owner: AccountId,130 pub value: u128,131}132133#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]134#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]135pub struct ReFungibleItemType<AccountId> {136 pub collection: u64,137 pub owner: Vec<Ownership<AccountId>>,138 pub const_data: Vec<u8>,139 pub variable_data: Vec<u8>,140}141142#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]143#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]144pub struct ApprovePermissions<AccountId> {145 pub approved: AccountId,146 pub amount: u64,147}148149#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]150#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]151pub struct VestingItem<AccountId, Moment> {152 pub sender: AccountId,153 pub recipient: AccountId,154 pub collection_id: u64,155 pub item_id: u64,156 pub amount: u64,157 pub vesting_date: Moment,158}159160#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]161#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]162pub struct BasketItem<AccountId, BlockNumber> {163 pub address: AccountId,164 pub start_block: BlockNumber,165}166167#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]168#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]169pub struct ChainLimits {170 pub collection_numbers_limit: u64,171 pub account_token_ownership_limit: u64,172 pub collections_admins_limit: u64,173 pub custom_data_limit: u32,174175 // Timeouts for item types in passed blocks176 pub nft_sponsor_transfer_timeout: u32,177 pub fungible_sponsor_transfer_timeout: u32,178 pub refungible_sponsor_transfer_timeout: u32,179}180181pub trait WeightInfo {182 fn create_collection() -> Weight;183 fn destroy_collection() -> Weight;184 fn add_to_white_list() -> Weight;185 fn remove_from_white_list() -> Weight;186 fn set_public_access_mode() -> Weight;187 fn set_mint_permission() -> Weight;188 fn change_collection_owner() -> Weight;189 fn add_collection_admin() -> Weight;190 fn remove_collection_admin() -> Weight;191 fn set_collection_sponsor() -> Weight;192 fn confirm_sponsorship() -> Weight;193 fn remove_collection_sponsor() -> Weight;194 fn create_item(s: usize) -> Weight;195 fn burn_item() -> Weight;196 fn transfer() -> Weight;197 fn approve() -> Weight;198 fn transfer_from() -> Weight;199 fn set_offchain_schema() -> Weight;200 fn set_const_on_chain_schema() -> Weight;201 fn set_variable_on_chain_schema() -> Weight;202 fn set_variable_meta_data() -> Weight;203 fn enable_contract_sponsoring() -> Weight;204}205206#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]207#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]208pub struct CreateNftData {209 pub const_data: Vec<u8>,210 pub variable_data: Vec<u8>,211}212213#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]214#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]215pub struct CreateFungibleData {216}217218#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct CreateReFungibleData {221 pub const_data: Vec<u8>,222 pub variable_data: Vec<u8>,223}224225#[derive(Encode, Decode, Debug, Clone, PartialEq)]226#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]227pub enum CreateItemData {228 NFT(CreateNftData),229 Fungible(CreateFungibleData),230 ReFungible(CreateReFungibleData)231}232233impl CreateItemData {234 pub fn len(&self) -> usize {235 let len = match self {236 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),237 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),238 _ => 0239 };240 241 return len;242 }243}244245impl From<CreateNftData> for CreateItemData {246 fn from(item: CreateNftData) -> Self {247 CreateItemData::NFT(item)248 }249}250251impl From<CreateReFungibleData> for CreateItemData {252 fn from(item: CreateReFungibleData) -> Self {253 CreateItemData::ReFungible(item)254 }255}256257impl From<CreateFungibleData> for CreateItemData {258 fn from(item: CreateFungibleData) -> Self {259 CreateItemData::Fungible(item)260 }261}262263264decl_error! {265 /// Error for non-fungible-token module.266 pub enum Error for Module<T: Trait> {267 /// Total collections bound exceeded268 TotalCollectionsLimitExceeded,269 /// Decimal_points parameter must be lower than 4270 CollectionDecimalPointLimitExceeded, 271 /// Collection name can not be longer than 63 char272 CollectionNameLimitExceeded, 273 /// Collection description can not be longer than 255 char274 CollectionDescriptionLimitExceeded, 275 /// Token prefix can not be longer than 15 char276 CollectionTokenPrefixLimitExceeded,277 /// This collection does not exist278 CollectionNotFound,279 /// Item not exists280 TokenNotFound,281 /// Arithmetic calculation overflow282 NumOverflow, 283 /// Account already has admin role284 AlreadyAdmin, 285 /// You do not own this collection286 NoPermission,287 /// This address is not set as sponsor, use setCollectionSponsor first288 ConfirmUnsetSponsorFail,289 /// Collection is not in mint mode290 PublicMintingNotAllowed,291 /// Sender parameter and item owner must be equal292 MustBeTokenOwner,293 /// Item balance not enouth294 TokenValueTooLow,295 /// Size of item is too large296 NftSizeLimitExceeded,297 /// Size of item must be 0 with fungible type298 FungibleUnexpectedParam,299 /// No approve found300 ApproveNotFound,301 /// Requested value more than approved302 TokenValueNotEnough,303 /// Only approved addresses can call this method304 ApproveRequired,305 /// Address is not in white list306 AddresNotInWhiteList,307 /// Number of collection admins bound exceeded308 CollectionAdminsLimitExceeded,309 /// Owned tokens by a single address bound exceeded310 AddressOwnershipLimitExceeded,311 /// Length of items properties must be greater than 0312 EmptyArgument,313 }314}315316pub trait Trait: system::Trait + Sized + transaction_payment::Trait + pallet_contracts::Trait {317 type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;318319 /// Weight information for extrinsics in this pallet.320 type WeightInfo: WeightInfo;321}322323#[cfg(feature = "runtime-benchmarks")]324mod benchmarking;325326// #endregion327328decl_storage! {329 trait Store for Module<T: Trait> as Nft {330331 // Private members332 NextCollectionID: u64;333 CreatedCollectionCount: u64;334 ChainVersion: u64;335 ItemListIndex: map hasher(blake2_128_concat) u64 => u64;336337 // Chain limits struct338 pub ChainLimit get(fn chain_limit) config(): ChainLimits;339340 // Bound counters341 CollectionCount: u64;342 pub AccountItemCount get(fn account_item_count): map hasher(identity) T::AccountId => u64;343344 // Basic collections345 pub Collection get(fn collection) config(): map hasher(identity) u64 => CollectionType<T::AccountId>;346 pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;347 pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;348349 /// Balance owner per collection map350 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;351352 /// second parameter: item id + owner account id353 pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;354355 /// Item collections356 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;357 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;358 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;359360 /// Index list361 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;362363 /// Tokens transfer baskets364 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;365 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => Vec<BasketItem<T::AccountId, T::BlockNumber>>;366 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;367368 // Contract Sponsorship and Ownership369 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;370 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;371 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;372 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;373 }374 add_extra_genesis {375 build(|config: &GenesisConfig<T>| {376 // Modification of storage377 for (_num, _c) in &config.collection {378 <Module<T>>::init_collection(_c);379 }380381 for (_num, _q, _i) in &config.nft_item_id {382 <Module<T>>::init_nft_token(_i);383 }384385 for (_num, _q, _i) in &config.fungible_item_id {386 <Module<T>>::init_fungible_token(_i);387 }388389 for (_num, _q, _i) in &config.refungible_item_id {390 <Module<T>>::init_refungible_token(_i);391 }392 })393 }394}395396decl_event!(397 pub enum Event<T>398 where399 AccountId = <T as system::Trait>::AccountId,400 {401 /// New collection was created402 /// 403 /// # Arguments404 /// 405 /// * collection_id: Globally unique identifier of newly created collection.406 /// 407 /// * mode: [CollectionMode] converted into u8.408 /// 409 /// * account_id: Collection owner.410 Created(u64, u8, AccountId),411412 /// New item was created.413 /// 414 /// # Arguments415 /// 416 /// * collection_id: Id of the collection where item was created.417 /// 418 /// * item_id: Id of an item. Unique within the collection.419 ItemCreated(u64, u64),420421 /// Collection item was burned.422 /// 423 /// # Arguments424 /// 425 /// collection_id.426 /// 427 /// item_id: Identifier of burned NFT.428 ItemDestroyed(u64, u64),429 }430);431432decl_module! {433 pub struct Module<T: Trait> for enum Call where origin: T::Origin {434435 fn deposit_event() = default;436 type Error = Error<T>;437438 fn on_initialize(now: T::BlockNumber) -> Weight {439440 if ChainVersion::get() < 2441 {442 let value = NextCollectionID::get();443 CreatedCollectionCount::put(value);444 ChainVersion::put(2);445 }446447 0448 }449450 /// 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.451 /// 452 /// # Permissions453 /// 454 /// * Anyone.455 /// 456 /// # Arguments457 /// 458 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.459 /// 460 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.461 /// 462 /// * token_prefix: UTF-8 string with token prefix.463 /// 464 /// * mode: [CollectionMode] collection type and type dependent data.465 // returns collection ID466 #[weight = T::WeightInfo::create_collection()]467 pub fn create_collection(origin,468 collection_name: Vec<u16>,469 collection_description: Vec<u16>,470 token_prefix: Vec<u8>,471 mode: CollectionMode) -> DispatchResult {472473 // Anyone can create a collection474 let who = ensure_signed(origin)?;475476 let decimal_points = match mode {477 CollectionMode::Fungible(points) => points,478 CollectionMode::ReFungible(points) => points,479 _ => 0480 };481482 // bound Total number of collections483 ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);484485 // check params486 ensure!(decimal_points <= 4, Error::<T>::CollectionDecimalPointLimitExceeded);487488 let mut name = collection_name.to_vec();489 name.push(0);490 ensure!(name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);491492 let mut description = collection_description.to_vec();493 description.push(0);494 ensure!(name.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);495496 let mut prefix = token_prefix.to_vec();497 prefix.push(0);498 ensure!(prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);499500 // Generate next collection ID501 let next_id = CreatedCollectionCount::get()502 .checked_add(1)503 .ok_or(Error::<T>::NumOverflow)?;504505 // bound counter506 let total = CollectionCount::get()507 .checked_add(1)508 .ok_or(Error::<T>::NumOverflow)?;509510 CreatedCollectionCount::put(next_id);511 CollectionCount::put(total);512513 // Create new collection514 let new_collection = CollectionType {515 owner: who.clone(),516 name: name,517 mode: mode.clone(),518 mint_mode: false,519 access: AccessMode::Normal,520 description: description,521 decimal_points: decimal_points,522 token_prefix: prefix,523 offchain_schema: Vec::new(),524 sponsor: T::AccountId::default(),525 unconfirmed_sponsor: T::AccountId::default(),526 variable_on_chain_schema: Vec::new(),527 const_on_chain_schema: Vec::new(),528 };529530 // Add new collection to map531 <Collection<T>>::insert(next_id, new_collection);532533 // call event534 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));535536 Ok(())537 }538539 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.540 /// 541 /// # Permissions542 /// 543 /// * Collection Owner.544 /// 545 /// # Arguments546 /// 547 /// * collection_id: collection to destroy.548 #[weight = T::WeightInfo::destroy_collection()]549 pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {550551 let sender = ensure_signed(origin)?;552 Self::check_owner_permissions(collection_id, sender)?;553554 <AddressTokens<T>>::remove_prefix(collection_id);555 <ApprovedList<T>>::remove_prefix(collection_id);556 <Balance<T>>::remove_prefix(collection_id);557 <ItemListIndex>::remove(collection_id);558 <AdminList<T>>::remove(collection_id);559 <Collection<T>>::remove(collection_id);560 <WhiteList<T>>::remove(collection_id);561562 <NftItemList<T>>::remove_prefix(collection_id);563 <FungibleItemList<T>>::remove_prefix(collection_id);564 <ReFungibleItemList<T>>::remove_prefix(collection_id);565566 <NftTransferBasket<T>>::remove_prefix(collection_id);567 <FungibleTransferBasket<T>>::remove_prefix(collection_id);568 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);569570 if CollectionCount::get() > 0571 {572 // bound couter573 let total = CollectionCount::get()574 .checked_sub(1)575 .ok_or(Error::<T>::NumOverflow)?;576577 CollectionCount::put(total);578 }579580 Ok(())581 }582583 /// Add an address to white list.584 /// 585 /// # Permissions586 /// 587 /// * Collection Owner588 /// * Collection Admin589 /// 590 /// # Arguments591 /// 592 /// * collection_id.593 /// 594 /// * address.595 #[weight = T::WeightInfo::add_to_white_list()]596 pub fn add_to_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{597598 let sender = ensure_signed(origin)?;599 Self::check_owner_or_admin_permissions(collection_id, sender)?;600601 let mut white_list_collection: Vec<T::AccountId>;602 if <WhiteList<T>>::contains_key(collection_id) {603 white_list_collection = <WhiteList<T>>::get(collection_id);604 if !white_list_collection.contains(&address.clone())605 {606 white_list_collection.push(address.clone());607 }608 }609 else {610 white_list_collection = Vec::new();611 white_list_collection.push(address.clone());612 }613614 <WhiteList<T>>::insert(collection_id, white_list_collection);615 Ok(())616 }617618 /// Remove an address from white list.619 /// 620 /// # Permissions621 /// 622 /// * Collection Owner623 /// * Collection Admin624 /// 625 /// # Arguments626 /// 627 /// * collection_id.628 /// 629 /// * address.630 #[weight = T::WeightInfo::remove_from_white_list()]631 pub fn remove_from_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{632633 let sender = ensure_signed(origin)?;634 Self::check_owner_or_admin_permissions(collection_id, sender)?;635636 if <WhiteList<T>>::contains_key(collection_id) {637 let mut white_list_collection = <WhiteList<T>>::get(collection_id);638 if white_list_collection.contains(&address.clone())639 {640 white_list_collection.retain(|i| *i != address.clone());641 <WhiteList<T>>::insert(collection_id, white_list_collection);642 }643 }644645 Ok(())646 }647648 /// Toggle between normal and white list access for the methods with access for `Anyone`.649 /// 650 /// # Permissions651 /// 652 /// * Collection Owner.653 /// 654 /// # Arguments655 /// 656 /// * collection_id.657 /// 658 /// * mode: [AccessMode]659 #[weight = T::WeightInfo::set_public_access_mode()]660 pub fn set_public_access_mode(origin, collection_id: u64, mode: AccessMode) -> DispatchResult661 {662 let sender = ensure_signed(origin)?;663664 Self::check_owner_permissions(collection_id, sender)?;665 let mut target_collection = <Collection<T>>::get(collection_id);666 target_collection.access = mode;667 <Collection<T>>::insert(collection_id, target_collection);668669 Ok(())670 }671672 /// Allows Anyone to create tokens if:673 /// * White List is enabled, and674 /// * Address is added to white list, and675 /// * This method was called with True parameter676 /// 677 /// # Permissions678 /// * Collection Owner679 ///680 /// # Arguments681 /// 682 /// * collection_id.683 /// 684 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.685 #[weight = T::WeightInfo::set_mint_permission()]686 pub fn set_mint_permission(origin, collection_id: u64, mint_permission: bool) -> DispatchResult687 {688 let sender = ensure_signed(origin)?;689690 Self::check_owner_permissions(collection_id, sender)?;691 let mut target_collection = <Collection<T>>::get(collection_id);692 target_collection.mint_mode = mint_permission;693 <Collection<T>>::insert(collection_id, target_collection);694695 Ok(())696 }697698 /// Change the owner of the collection.699 /// 700 /// # Permissions701 /// 702 /// * Collection Owner.703 /// 704 /// # Arguments705 /// 706 /// * collection_id.707 /// 708 /// * new_owner.709 #[weight = T::WeightInfo::change_collection_owner()]710 pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {711712 let sender = ensure_signed(origin)?;713 Self::check_owner_permissions(collection_id, sender)?;714 let mut target_collection = <Collection<T>>::get(collection_id);715 target_collection.owner = new_owner;716 <Collection<T>>::insert(collection_id, target_collection);717718 Ok(())719 }720721 /// Adds an admin of the Collection.722 /// 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. 723 /// 724 /// # Permissions725 /// 726 /// * Collection Owner.727 /// * Collection Admin.728 /// 729 /// # Arguments730 /// 731 /// * collection_id: ID of the Collection to add admin for.732 /// 733 /// * new_admin_id: Address of new admin to add.734 #[weight = T::WeightInfo::add_collection_admin()]735 pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {736737 let sender = ensure_signed(origin)?;738 Self::check_owner_or_admin_permissions(collection_id, sender)?;739 let mut admin_arr: Vec<T::AccountId> = Vec::new();740741 if <AdminList<T>>::contains_key(collection_id)742 {743 admin_arr = <AdminList<T>>::get(collection_id);744 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);745 }746747 // Number of collection admins748 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);749750 admin_arr.push(new_admin_id);751 <AdminList<T>>::insert(collection_id, admin_arr);752753 Ok(())754 }755756 /// 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.757 ///758 /// # Permissions759 /// 760 /// * Collection Owner.761 /// * Collection Admin.762 /// 763 /// # Arguments764 /// 765 /// * collection_id: ID of the Collection to remove admin for.766 /// 767 /// * account_id: Address of admin to remove.768 #[weight = T::WeightInfo::remove_collection_admin()]769 pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {770771 let sender = ensure_signed(origin)?;772 Self::check_owner_or_admin_permissions(collection_id, sender)?;773774 if <AdminList<T>>::contains_key(collection_id)775 {776 let mut admin_arr = <AdminList<T>>::get(collection_id);777 admin_arr.retain(|i| *i != account_id);778 <AdminList<T>>::insert(collection_id, admin_arr);779 }780781 Ok(())782 }783784 /// # Permissions785 /// 786 /// * Collection Owner787 /// 788 /// # Arguments789 /// 790 /// * collection_id.791 /// 792 /// * new_sponsor.793 #[weight = T::WeightInfo::set_collection_sponsor()]794 pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {795796 let sender = ensure_signed(origin)?;797 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);798799 let mut target_collection = <Collection<T>>::get(collection_id);800 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);801802 target_collection.unconfirmed_sponsor = new_sponsor;803 <Collection<T>>::insert(collection_id, target_collection);804805 Ok(())806 }807808 /// # Permissions809 /// 810 /// * Sponsor.811 /// 812 /// # Arguments813 /// 814 /// * collection_id.815 #[weight = T::WeightInfo::confirm_sponsorship()]816 pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {817818 let sender = ensure_signed(origin)?;819 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);820821 let mut target_collection = <Collection<T>>::get(collection_id);822 ensure!(sender == target_collection.unconfirmed_sponsor, Error::<T>::ConfirmUnsetSponsorFail);823824 target_collection.sponsor = target_collection.unconfirmed_sponsor;825 target_collection.unconfirmed_sponsor = T::AccountId::default();826 <Collection<T>>::insert(collection_id, target_collection);827828 Ok(())829 }830831 /// Switch back to pay-per-own-transaction model.832 ///833 /// # Permissions834 ///835 /// * Collection owner.836 /// 837 /// # Arguments838 /// 839 /// * collection_id.840 #[weight = T::WeightInfo::remove_collection_sponsor()]841 pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {842843 let sender = ensure_signed(origin)?;844 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);845846 let mut target_collection = <Collection<T>>::get(collection_id);847 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);848849 target_collection.sponsor = T::AccountId::default();850 <Collection<T>>::insert(collection_id, target_collection);851852 Ok(())853 }854855 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.856 /// 857 /// # Permissions858 /// 859 /// * Collection Owner.860 /// * Collection Admin.861 /// * Anyone if862 /// * White List is enabled, and863 /// * Address is added to white list, and864 /// * MintPermission is enabled (see SetMintPermission method)865 /// 866 /// # Arguments867 /// 868 /// * collection_id: ID of the collection.869 /// 870 /// * owner: Address, initial owner of the NFT.871 ///872 /// * data: Token data to store on chain.873 // #[weight =874 // (130_000_000 as Weight)875 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))876 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))877 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]878879 #[weight = T::WeightInfo::create_item(data.len())]880 pub fn create_item(origin, collection_id: u64, owner: T::AccountId, data: CreateItemData) -> DispatchResult {881882 let sender = ensure_signed(origin)?;883884 Self::collection_exists(collection_id)?;885886 let target_collection = <Collection<T>>::get(collection_id);887888 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;889 Self::validate_create_item_args(&target_collection, &data)?;890 Self::create_item_no_validation(collection_id, &target_collection, owner, data)?;891892 Ok(())893 }894895 /// This method creates multiple instances of NFT Collection created with CreateCollection method.896 /// 897 /// # Permissions898 /// 899 /// * Collection Owner.900 /// * Collection Admin.901 /// * Anyone if902 /// * White List is enabled, and903 /// * Address is added to white list, and904 /// * MintPermission is enabled (see SetMintPermission method)905 /// 906 /// # Arguments907 /// 908 /// * collection_id: ID of the collection.909 /// 910 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].911 /// 912 /// * owner: Address, initial owner of the NFT.913 #[weight = T::WeightInfo::create_item(items_data.into_iter()914 .map(|data| { data.len() })915 .sum())]916 pub fn create_multiple_items(origin, collection_id: u64, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {917918 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);919 let sender = ensure_signed(origin)?;920921 Self::collection_exists(collection_id)?;922 let target_collection = <Collection<T>>::get(collection_id);923924 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;925926 for data in &items_data {927 Self::validate_create_item_args(&target_collection, data)?;928 }929 for data in &items_data {930 Self::create_item_no_validation(collection_id, &target_collection, owner.clone(), data.clone())?;931 }932933 Ok(())934 }935936 /// Destroys a concrete instance of NFT.937 /// 938 /// # Permissions939 /// 940 /// * Collection Owner.941 /// * Collection Admin.942 /// * Current NFT Owner.943 /// 944 /// # Arguments945 /// 946 /// * collection_id: ID of the collection.947 /// 948 /// * item_id: ID of NFT to burn.949 #[weight = T::WeightInfo::burn_item()]950 pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {951952 let sender = ensure_signed(origin)?;953 Self::collection_exists(collection_id)?;954955 // Transfer permissions check956 let target_collection = <Collection<T>>::get(collection_id);957 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||958 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),959 Error::<T>::NoPermission);960961 if target_collection.access == AccessMode::WhiteList {962 Self::check_white_list(collection_id, &sender)?;963 }964965 match target_collection.mode966 {967 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,968 CollectionMode::Fungible(_) => Self::burn_fungible_item(collection_id, item_id)?,969 CollectionMode::ReFungible(_) => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,970 _ => ()971 };972973 // call event974 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));975976 Ok(())977 }978979 /// Change ownership of the token.980 /// 981 /// # Permissions982 /// 983 /// * Collection Owner984 /// * Collection Admin985 /// * Current NFT owner986 ///987 /// # Arguments988 /// 989 /// * recipient: Address of token recipient.990 /// 991 /// * collection_id.992 /// 993 /// * item_id: ID of the item994 /// * Non-Fungible Mode: Required.995 /// * Fungible Mode: Ignored.996 /// * Re-Fungible Mode: Required.997 /// 998 /// * value: Amount to transfer.999 /// * Non-Fungible Mode: Ignored1000 /// * Fungible Mode: Must specify transferred amount1001 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1002 #[weight = T::WeightInfo::transfer()]1003 pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {10041005 let sender = ensure_signed(origin)?;10061007 // Transfer permissions check1008 let target_collection = <Collection<T>>::get(collection_id);1009 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1010 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1011 Error::<T>::NoPermission);10121013 if target_collection.access == AccessMode::WhiteList {1014 Self::check_white_list(collection_id, &sender)?;1015 Self::check_white_list(collection_id, &recipient)?;1016 }10171018 match target_collection.mode1019 {1020 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,1021 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,1022 CollectionMode::ReFungible(_) => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,1023 _ => ()1024 };10251026 Ok(())1027 }10281029 /// Set, change, or remove approved address to transfer the ownership of the NFT.1030 /// 1031 /// # Permissions1032 /// 1033 /// * Collection Owner1034 /// * Collection Admin1035 /// * Current NFT owner1036 /// 1037 /// # Arguments1038 /// 1039 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1040 /// 1041 /// * collection_id.1042 /// 1043 /// * item_id: ID of the item.1044 #[weight = T::WeightInfo::approve()]1045 pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {10461047 let sender = ensure_signed(origin)?;10481049 // Transfer permissions check1050 let target_collection = <Collection<T>>::get(collection_id);1051 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1052 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1053 Error::<T>::NoPermission);10541055 if target_collection.access == AccessMode::WhiteList {1056 Self::check_white_list(collection_id, &sender)?;1057 Self::check_white_list(collection_id, &approved)?;1058 }10591060 // amount param stub1061 let amount = 100000000;10621063 let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));1064 if list_exists {10651066 let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));1067 let item_contains = list.iter().any(|i| i.approved == approved);10681069 if !item_contains {1070 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1071 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1072 }1073 } else {10741075 let mut list = Vec::new();1076 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1077 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1078 }10791080 Ok(())1081 }1082 1083 /// 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.1084 /// 1085 /// # Permissions1086 /// * Collection Owner1087 /// * Collection Admin1088 /// * Current NFT owner1089 /// * Address approved by current NFT owner1090 /// 1091 /// # Arguments1092 /// 1093 /// * from: Address that owns token.1094 /// 1095 /// * recipient: Address of token recipient.1096 /// 1097 /// * collection_id.1098 /// 1099 /// * item_id: ID of the item.1100 /// 1101 /// * value: Amount to transfer.1102 #[weight = T::WeightInfo::transfer_from()]1103 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {11041105 let sender = ensure_signed(origin)?;1106 let mut appoved_transfer = false;11071108 // Check approve1109 if <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone())) {1110 let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));1111 let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());1112 if opt_item.is_some()1113 {1114 appoved_transfer = true;1115 ensure!(opt_item.unwrap().amount >= value, Error::<T>::TokenValueNotEnough);1116 }1117 }11181119 // Transfer permissions check1120 let target_collection = <Collection<T>>::get(collection_id);1121 ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1122 Error::<T>::NoPermission);11231124 if target_collection.access == AccessMode::WhiteList {1125 Self::check_white_list(collection_id, &sender)?;1126 Self::check_white_list(collection_id, &recipient)?;1127 }11281129 // remove approve1130 let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))1131 .into_iter().filter(|i| i.approved != sender.clone()).collect();1132 <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);113311341135 match target_collection.mode1136 {1137 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1138 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,1139 CollectionMode::ReFungible(_) => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1140 _ => ()1141 };11421143 Ok(())1144 }11451146 ///1147 #[weight = 0]1148 pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {11491150 // let no_perm_mes = "You do not have permissions to modify this collection";1151 // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1152 // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1153 // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);11541155 // // on_nft_received call11561157 // Self::transfer(origin, collection_id, item_id, new_owner)?;11581159 Ok(())1160 }11611162 /// Set off-chain data schema.1163 /// 1164 /// # Permissions1165 /// 1166 /// * Collection Owner1167 /// * Collection Admin1168 /// 1169 /// # Arguments1170 /// 1171 /// * collection_id.1172 /// 1173 /// * schema: String representing the offchain data schema.1174 #[weight = T::WeightInfo::set_variable_meta_data()]1175 pub fn set_variable_meta_data (1176 origin,1177 collection_id: u64,1178 item_id: u64,1179 data: Vec<u8>1180 ) -> DispatchResult {1181 let sender = ensure_signed(origin)?;1182 1183 Self::collection_exists(collection_id)?;11841185 // Modify permissions check1186 let target_collection = <Collection<T>>::get(collection_id);1187 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1188 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1189 Error::<T>::NoPermission);11901191 Self::item_exists(collection_id, item_id, &target_collection.mode)?;11921193 match target_collection.mode1194 {1195 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1196 CollectionMode::ReFungible(_) => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1197 _ => ()1198 };11991200 Ok(())1201 }1202 12031204 /// Set off-chain data schema.1205 /// 1206 /// # Permissions1207 /// 1208 /// * Collection Owner1209 /// * Collection Admin1210 /// 1211 /// # Arguments1212 /// 1213 /// * collection_id.1214 /// 1215 /// * schema: String representing the offchain data schema.1216 #[weight = T::WeightInfo::set_offchain_schema()]1217 pub fn set_offchain_schema(1218 origin,1219 collection_id: u64,1220 schema: Vec<u8>1221 ) -> DispatchResult {1222 let sender = ensure_signed(origin)?;1223 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12241225 let mut target_collection = <Collection<T>>::get(collection_id);1226 target_collection.offchain_schema = schema;1227 <Collection<T>>::insert(collection_id, target_collection);12281229 Ok(())1230 }12311232 /// Set const on-chain data schema.1233 /// 1234 /// # Permissions1235 /// 1236 /// * Collection Owner1237 /// * Collection Admin1238 /// 1239 /// # Arguments1240 /// 1241 /// * collection_id.1242 /// 1243 /// * schema: String representing the const on-chain data schema.1244 #[weight = T::WeightInfo::set_const_on_chain_schema()]1245 pub fn set_const_on_chain_schema (1246 origin,1247 collection_id: u64,1248 schema: Vec<u8>1249 ) -> DispatchResult {1250 let sender = ensure_signed(origin)?;1251 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12521253 let mut target_collection = <Collection<T>>::get(collection_id);1254 target_collection.const_on_chain_schema = schema;1255 <Collection<T>>::insert(collection_id, target_collection);12561257 Ok(())1258 }12591260 /// Set variable on-chain data schema.1261 /// 1262 /// # Permissions1263 /// 1264 /// * Collection Owner1265 /// * Collection Admin1266 /// 1267 /// # Arguments1268 /// 1269 /// * collection_id.1270 /// 1271 /// * schema: String representing the variable on-chain data schema.1272 #[weight = T::WeightInfo::set_const_on_chain_schema()]1273 pub fn set_variable_on_chain_schema (1274 origin,1275 collection_id: u64,1276 schema: Vec<u8>1277 ) -> DispatchResult {1278 let sender = ensure_signed(origin)?;1279 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12801281 let mut target_collection = <Collection<T>>::get(collection_id);1282 target_collection.variable_on_chain_schema = schema;1283 <Collection<T>>::insert(collection_id, target_collection);12841285 Ok(())1286 }12871288 // Sudo permissions function1289 #[weight = 0]1290 pub fn set_chain_limits(1291 origin,1292 limits: ChainLimits1293 ) -> DispatchResult {1294 ensure_root(origin)?;1295 <ChainLimit>::put(limits);1296 Ok(())1297 }12981299 /// Enable smart contract self-sponsoring.1300 /// 1301 /// # Permissions1302 /// 1303 /// * Contract Owner1304 /// 1305 /// # Arguments1306 /// 1307 /// * contract address1308 /// * enable flag1309 /// 1310 #[weight = T::WeightInfo::enable_contract_sponsoring()]1311 pub fn enable_contract_sponsoring(1312 origin,1313 contract_address: T::AccountId,1314 enable: bool1315 ) -> DispatchResult {1316 let sender = ensure_signed(origin)?;1317 let mut is_owner = false;1318 if <ContractOwner<T>>::contains_key(contract_address.clone()) {1319 let owner = <ContractOwner<T>>::get(&contract_address);1320 is_owner = sender == owner;1321 }1322 ensure!(is_owner, Error::<T>::NoPermission);13231324 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1325 Ok(())1326 }13271328 /// Set the rate limit for contract sponsoring to specified number of blocks.1329 /// 1330 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1331 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1332 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1333 /// from contract endowment if there are at least B blocks between such transactions. 1334 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1335 /// 1336 /// # Permissions1337 /// 1338 /// * Contract Owner1339 /// 1340 /// # Arguments1341 /// 1342 /// -`contract_address`: Address of the contract to sponsor1343 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1344 /// 1345 #[weight = 0]1346 pub fn set_contract_sponsoring_rate_limit(1347 origin,1348 contract_address: T::AccountId,1349 rate_limit: T::BlockNumber1350 ) -> DispatchResult {1351 let sender = ensure_signed(origin)?;1352 let mut is_owner = false;1353 if <ContractOwner<T>>::contains_key(contract_address.clone()) {1354 let owner = <ContractOwner<T>>::get(&contract_address);1355 is_owner = sender == owner;1356 }1357 ensure!(is_owner, Error::<T>::NoPermission);13581359 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1360 Ok(())1361 }13621363 }1364}13651366impl<T: Trait> Module<T> {13671368 fn can_create_items_in_collection(collection_id: u64, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {13691370 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1371 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1372 Self::check_white_list(collection_id, owner)?;1373 Self::check_white_list(collection_id, sender)?;1374 }13751376 Ok(())1377 }13781379 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1380 match target_collection.mode1381 {1382 CollectionMode::NFT => {1383 if let CreateItemData::NFT(data) = data {1384 // check sizes1385 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");1386 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");1387 } else {1388 fail!("Not NFT item data used to mint in NFT collection.");1389 }1390 },1391 CollectionMode::Fungible(_) => {1392 if let CreateItemData::Fungible(_) = data {1393 } else {1394 fail!("Not Fungible item data used to mint in Fungible collection.");1395 }1396 },1397 CollectionMode::ReFungible(_) => {1398 if let CreateItemData::ReFungible(data) = data {13991400 // check sizes1401 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");1402 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");1403 } else {1404 fail!("Not Re Fungible item data used to mint in Re Fungible collection.");1405 }1406 },1407 _ => { fail!("Unexpected collection type."); }1408 };14091410 Ok(())1411 }14121413 fn create_item_no_validation(collection_id: u64, collection: &CollectionType<T::AccountId>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1414 match data1415 {1416 CreateItemData::NFT(data) => {1417 let item = NftItemType {1418 collection: collection_id,1419 owner,1420 const_data: data.const_data,1421 variable_data: data.variable_data1422 };14231424 Self::add_nft_item(item)?;1425 },1426 CreateItemData::Fungible(_) => {1427 let item = FungibleItemType {1428 collection: collection_id,1429 owner,1430 value: (10 as u128).pow(collection.decimal_points)1431 };14321433 Self::add_fungible_item(item)?;1434 },1435 CreateItemData::ReFungible(data) => {1436 let mut owner_list = Vec::new();1437 let value = (10 as u128).pow(collection.decimal_points);1438 owner_list.push(Ownership {owner: owner.clone(), fraction: value});14391440 let item = ReFungibleItemType {1441 collection: collection_id,1442 owner: owner_list,1443 const_data: data.const_data,1444 variable_data: data.variable_data1445 };14461447 Self::add_refungible_item(item)?;1448 }1449 };145014511452 // call event1453 Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));14541455 Ok(())1456 }14571458 fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {1459 let current_index = <ItemListIndex>::get(item.collection)1460 .checked_add(1)1461 .ok_or(Error::<T>::NumOverflow)?;1462 let itemcopy = item.clone();1463 let owner = item.owner.clone();1464 let value = item.value as u64;14651466 Self::add_token_index(item.collection, current_index, owner.clone())?;14671468 <ItemListIndex>::insert(item.collection, current_index);1469 <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);14701471 // Add current block1472 let v: Vec<BasketItem<T::AccountId, T::BlockNumber>> = Vec::new();1473 <FungibleTransferBasket<T>>::insert(item.collection, current_index, v);1474 1475 // Update balance1476 let new_balance = <Balance<T>>::get(item.collection, owner.clone())1477 .checked_add(value)1478 .ok_or(Error::<T>::NumOverflow)?;1479 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);14801481 Ok(())1482 }14831484 fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1485 let current_index = <ItemListIndex>::get(item.collection)1486 .checked_add(1)1487 .ok_or(Error::<T>::NumOverflow)?;1488 let itemcopy = item.clone();14891490 let value = item.owner.first().unwrap().fraction as u64;1491 let owner = item.owner.first().unwrap().owner.clone();14921493 Self::add_token_index(item.collection, current_index, owner.clone())?;14941495 <ItemListIndex>::insert(item.collection, current_index);1496 <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);14971498 // Add current block1499 let block_number: T::BlockNumber = 0.into();1500 <ReFungibleTransferBasket<T>>::insert(item.collection, current_index, block_number);15011502 // Update balance1503 let new_balance = <Balance<T>>::get(item.collection, owner.clone())1504 .checked_add(value)1505 .ok_or(Error::<T>::NumOverflow)?;1506 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);15071508 Ok(())1509 }15101511 fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {1512 let current_index = <ItemListIndex>::get(item.collection)1513 .checked_add(1)1514 .ok_or(Error::<T>::NumOverflow)?;15151516 let item_owner = item.owner.clone();1517 let collection_id = item.collection.clone();1518 Self::add_token_index(collection_id, current_index, item.owner.clone())?;15191520 <ItemListIndex>::insert(collection_id, current_index);1521 <NftItemList<T>>::insert(collection_id, current_index, item);15221523 // Add current block1524 let block_number: T::BlockNumber = 0.into();1525 <NftTransferBasket<T>>::insert(collection_id, current_index, block_number);15261527 // Update balance1528 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1529 .checked_add(1)1530 .ok_or(Error::<T>::NumOverflow)?;1531 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);15321533 Ok(())1534 }15351536 fn burn_refungible_item(1537 collection_id: u64,1538 item_id: u64,1539 owner: T::AccountId,1540 ) -> DispatchResult {1541 ensure!(1542 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1543 Error::<T>::TokenNotFound1544 );1545 let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);1546 let item = collection1547 .owner1548 .iter()1549 .filter(|&i| i.owner == owner)1550 .next()1551 .unwrap();1552 Self::remove_token_index(collection_id, item_id, owner.clone())?;15531554 // remove approve list1555 <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));15561557 // update balance1558 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1559 .checked_sub(item.fraction as u64)1560 .ok_or(Error::<T>::NumOverflow)?;1561 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);15621563 <ReFungibleItemList<T>>::remove(collection_id, item_id);15641565 Ok(())1566 }15671568 fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {1569 ensure!(1570 <NftItemList<T>>::contains_key(collection_id, item_id),1571 Error::<T>::TokenNotFound1572 );1573 let item = <NftItemList<T>>::get(collection_id, item_id);1574 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;15751576 // remove approve list1577 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));15781579 // update balance1580 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1581 .checked_sub(1)1582 .ok_or(Error::<T>::NumOverflow)?;1583 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1584 <NftItemList<T>>::remove(collection_id, item_id);15851586 Ok(())1587 }15881589 fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {1590 ensure!(1591 <FungibleItemList<T>>::contains_key(collection_id, item_id),1592 Error::<T>::TokenNotFound1593 );1594 let item = <FungibleItemList<T>>::get(collection_id, item_id);1595 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;15961597 // remove approve list1598 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));15991600 // update balance1601 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1602 .checked_sub(item.value as u64)1603 .ok_or(Error::<T>::NumOverflow)?;1604 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);16051606 <FungibleItemList<T>>::remove(collection_id, item_id);16071608 Ok(())1609 }16101611 fn collection_exists(collection_id: u64) -> DispatchResult {1612 ensure!(1613 <Collection<T>>::contains_key(collection_id),1614 Error::<T>::CollectionNotFound1615 );1616 Ok(())1617 }16181619 fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {1620 Self::collection_exists(collection_id)?;16211622 let target_collection = <Collection<T>>::get(collection_id);1623 ensure!(1624 subject == target_collection.owner,1625 Error::<T>::NoPermission1626 );16271628 Ok(())1629 }16301631 fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {1632 let target_collection = <Collection<T>>::get(collection_id);1633 let mut result: bool = subject == target_collection.owner;1634 let exists = <AdminList<T>>::contains_key(collection_id);16351636 if !result & exists {1637 if <AdminList<T>>::get(collection_id).contains(&subject) {1638 result = true1639 }1640 }16411642 result1643 }16441645 fn check_owner_or_admin_permissions(1646 collection_id: u64,1647 subject: T::AccountId,1648 ) -> DispatchResult {1649 Self::collection_exists(collection_id)?;1650 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());16511652 ensure!(1653 result,1654 Error::<T>::NoPermission1655 );1656 Ok(())1657 }16581659 fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {1660 let target_collection = <Collection<T>>::get(collection_id);16611662 match target_collection.mode {1663 CollectionMode::NFT => {1664 <NftItemList<T>>::get(collection_id, item_id).owner == subject1665 }1666 CollectionMode::Fungible(_) => {1667 <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1668 }1669 CollectionMode::ReFungible(_) => {1670 <ReFungibleItemList<T>>::get(collection_id, item_id)1671 .owner1672 .iter()1673 .any(|i| i.owner == subject)1674 }1675 CollectionMode::Invalid => false,1676 }1677 }16781679 fn check_white_list(collection_id: u64, address: &T::AccountId) -> DispatchResult {1680 let mes = Error::<T>::AddresNotInWhiteList;1681 ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1682 let wl = <WhiteList<T>>::get(collection_id);1683 ensure!(wl.contains(address), mes);16841685 Ok(())1686 }16871688 fn transfer_fungible(1689 collection_id: u64,1690 item_id: u64,1691 value: u64,1692 owner: T::AccountId,1693 new_owner: T::AccountId,1694 ) -> DispatchResult {1695 ensure!(1696 <FungibleItemList<T>>::contains_key(collection_id, item_id),1697 Error::<T>::TokenNotFound1698 );16991700 let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1701 let amount = full_item.value;17021703 ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);17041705 // update balance1706 let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1707 .checked_sub(value)1708 .ok_or(Error::<T>::NumOverflow)?;1709 <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);17101711 let mut new_owner_account_id = 0;1712 let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());1713 if new_owner_items.len() > 0 {1714 new_owner_account_id = new_owner_items[0];1715 }17161717 let val64 = value.into();17181719 // transfer1720 if amount == val64 && new_owner_account_id == 0 {1721 // change owner1722 // new owner do not have account1723 let mut new_full_item = full_item.clone();1724 new_full_item.owner = new_owner.clone();1725 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);17261727 // update balance1728 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1729 .checked_add(value)1730 .ok_or(Error::<T>::NumOverflow)?;1731 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17321733 // update index collection1734 Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1735 } else {1736 let mut new_full_item = full_item.clone();1737 new_full_item.value -= val64;17381739 // separate amount1740 if new_owner_account_id > 0 {1741 // new owner has account1742 let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1743 item.value += val64;17441745 // update balance1746 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1747 .checked_add(value)1748 .ok_or(Error::<T>::NumOverflow)?;1749 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17501751 <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);1752 } else {1753 // new owner do not have account1754 let item = FungibleItemType {1755 collection: collection_id,1756 owner: new_owner.clone(),1757 value: val64,1758 };17591760 Self::add_fungible_item(item)?;1761 }17621763 if amount == val64 {1764 Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;17651766 // remove approve list1767 <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));1768 <FungibleItemList<T>>::remove(collection_id, item_id);1769 }17701771 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1772 }17731774 Ok(())1775 }17761777 fn transfer_refungible(1778 collection_id: u64,1779 item_id: u64,1780 value: u64,1781 owner: T::AccountId,1782 new_owner: T::AccountId,1783 ) -> DispatchResult {1784 ensure!(1785 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1786 Error::<T>::TokenNotFound1787 );17881789 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1790 let item = full_item1791 .owner1792 .iter()1793 .filter(|i| i.owner == owner)1794 .next()1795 .ok_or(Error::<T>::NumOverflow)?;1796 let amount = item.fraction;17971798 ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);17991800 // update balance1801 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1802 .checked_sub(value)1803 .ok_or(Error::<T>::NumOverflow)?;1804 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);18051806 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1807 .checked_add(value)1808 .ok_or(Error::<T>::NumOverflow)?;1809 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18101811 let old_owner = item.owner.clone();1812 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);1813 let val64 = value.into();18141815 // transfer1816 if amount == val64 && !new_owner_has_account {1817 // change owner1818 // new owner do not have account1819 let mut new_full_item = full_item.clone();1820 new_full_item1821 .owner1822 .iter_mut()1823 .find(|i| i.owner == owner)1824 .unwrap()1825 .owner = new_owner.clone();1826 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);18271828 // update index collection1829 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1830 } else {1831 let mut new_full_item = full_item.clone();1832 new_full_item1833 .owner1834 .iter_mut()1835 .find(|i| i.owner == owner)1836 .unwrap()1837 .fraction -= val64;18381839 // separate amount1840 if new_owner_has_account {1841 // new owner has account1842 new_full_item1843 .owner1844 .iter_mut()1845 .find(|i| i.owner == new_owner)1846 .unwrap()1847 .fraction += val64;1848 } else {1849 // new owner do not have account1850 new_full_item.owner.push(Ownership {1851 owner: new_owner.clone(),1852 fraction: val64,1853 });1854 Self::add_token_index(collection_id, item_id, new_owner.clone())?;1855 }18561857 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1858 }18591860 Ok(())1861 }18621863 fn transfer_nft(1864 collection_id: u64,1865 item_id: u64,1866 sender: T::AccountId,1867 new_owner: T::AccountId,1868 ) -> DispatchResult {1869 ensure!(1870 <NftItemList<T>>::contains_key(collection_id, item_id),1871 Error::<T>::TokenNotFound1872 );18731874 let mut item = <NftItemList<T>>::get(collection_id, item_id);18751876 ensure!(1877 sender == item.owner,1878 Error::<T>::MustBeTokenOwner1879 );18801881 // update balance1882 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1883 .checked_sub(1)1884 .ok_or(Error::<T>::NumOverflow)?;1885 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);18861887 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1888 .checked_add(1)1889 .ok_or(Error::<T>::NumOverflow)?;1890 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18911892 // change owner1893 let old_owner = item.owner.clone();1894 item.owner = new_owner.clone();1895 <NftItemList<T>>::insert(collection_id, item_id, item);18961897 // update index collection1898 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;18991900 // reset approved list1901 <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1902 Ok(())1903 }1904 1905 fn item_exists(1906 collection_id: u64,1907 item_id: u64,1908 mode: &CollectionMode1909 ) -> DispatchResult {1910 match mode {1911 CollectionMode::NFT => ensure!(<NftItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1912 CollectionMode::ReFungible(_) => ensure!(<ReFungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1913 CollectionMode::Fungible(_) => ensure!(<FungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1914 _ => ()1915 };1916 1917 Ok(())1918 }19191920 fn set_re_fungible_variable_data(1921 collection_id: u64,1922 item_id: u64,1923 data: Vec<u8>1924 ) -> DispatchResult {1925 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);19261927 item.variable_data = data;19281929 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);19301931 Ok(())1932 }19331934 fn set_nft_variable_data(1935 collection_id: u64,1936 item_id: u64,1937 data: Vec<u8>1938 ) -> DispatchResult {1939 let mut item = <NftItemList<T>>::get(collection_id, item_id);1940 1941 item.variable_data = data;19421943 <NftItemList<T>>::insert(collection_id, item_id, item);1944 1945 Ok(())1946 }19471948 fn init_collection(item: &CollectionType<T::AccountId>) {1949 // check params1950 assert!(1951 item.decimal_points <= 4,1952 "decimal_points parameter must be lower than 4"1953 );1954 assert!(1955 item.name.len() <= 64,1956 "Collection name can not be longer than 63 char"1957 );1958 assert!(1959 item.name.len() <= 256,1960 "Collection description can not be longer than 255 char"1961 );1962 assert!(1963 item.token_prefix.len() <= 16,1964 "Token prefix can not be longer than 15 char"1965 );19661967 // Generate next collection ID1968 let next_id = CreatedCollectionCount::get()1969 .checked_add(1)1970 .unwrap();19711972 CreatedCollectionCount::put(next_id);1973 }19741975 fn init_nft_token(item: &NftItemType<T::AccountId>) {1976 let current_index = <ItemListIndex>::get(item.collection)1977 .checked_add(1)1978 .unwrap();19791980 let item_owner = item.owner.clone();1981 let collection_id = item.collection.clone();1982 Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();19831984 <ItemListIndex>::insert(collection_id, current_index);19851986 // Update balance1987 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1988 .checked_add(1)1989 .unwrap();1990 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);1991 }19921993 fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {1994 let current_index = <ItemListIndex>::get(item.collection)1995 .checked_add(1)1996 .unwrap();1997 let owner = item.owner.clone();1998 let value = item.value as u64;19992000 Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();20012002 <ItemListIndex>::insert(item.collection, current_index);20032004 // Update balance2005 let new_balance = <Balance<T>>::get(item.collection, owner.clone())2006 .checked_add(value)2007 .unwrap();2008 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2009 }20102011 fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {2012 let current_index = <ItemListIndex>::get(item.collection)2013 .checked_add(1)2014 .unwrap();20152016 let value = item.owner.first().unwrap().fraction as u64;2017 let owner = item.owner.first().unwrap().owner.clone();20182019 Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();20202021 <ItemListIndex>::insert(item.collection, current_index);20222023 // Update balance2024 let new_balance = <Balance<T>>::get(item.collection, owner.clone())2025 .checked_add(value)2026 .unwrap();2027 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2028 }20292030 fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {20312032 // add to account limit2033 if <AccountItemCount<T>>::contains_key(owner.clone()) {20342035 // bound Owned tokens by a single address2036 let count = <AccountItemCount<T>>::get(owner.clone());2037 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);20382039 <AccountItemCount<T>>::insert(owner.clone(), count2040 .checked_add(1)2041 .ok_or(Error::<T>::NumOverflow)?);2042 }2043 else {2044 <AccountItemCount<T>>::insert(owner.clone(), 1);2045 }20462047 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2048 if list_exists {2049 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2050 let item_contains = list.contains(&item_index.clone());20512052 if !item_contains {2053 list.push(item_index.clone());2054 }20552056 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2057 } else {2058 let mut itm = Vec::new();2059 itm.push(item_index.clone());2060 <AddressTokens<T>>::insert(collection_id, owner, itm);2061 2062 }20632064 Ok(())2065 }20662067 fn remove_token_index(2068 collection_id: u64,2069 item_index: u64,2070 owner: T::AccountId,2071 ) -> DispatchResult {20722073 // update counter2074 <AccountItemCount<T>>::insert(owner.clone(), 2075 <AccountItemCount<T>>::get(owner.clone())2076 .checked_sub(1)2077 .ok_or(Error::<T>::NumOverflow)?);207820792080 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2081 if list_exists {2082 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2083 let item_contains = list.contains(&item_index.clone());20842085 if item_contains {2086 list.retain(|&item| item != item_index);2087 <AddressTokens<T>>::insert(collection_id, owner, list);2088 }2089 }20902091 Ok(())2092 }20932094 fn move_token_index(2095 collection_id: u64,2096 item_index: u64,2097 old_owner: T::AccountId,2098 new_owner: T::AccountId,2099 ) -> DispatchResult {2100 Self::remove_token_index(collection_id, item_index, old_owner)?;2101 Self::add_token_index(collection_id, item_index, new_owner)?;21022103 Ok(())2104 }2105}21062107////////////////////////////////////////////////////////////////////////////////////////////////////2108// Economic models2109// #region21102111/// Fee multiplier.2112pub type Multiplier = FixedU128;21132114type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2115 <T as system::Trait>::AccountId,2116>>::Balance;2117type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2118 <T as system::Trait>::AccountId,2119>>::NegativeImbalance;21202121/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2122/// in the queue.2123#[derive(Encode, Decode, Clone, Eq, PartialEq)]2124pub struct ChargeTransactionPayment<T: Trait + Send + Sync>(2125 #[codec(compact)] BalanceOf<T>2126);21272128impl<T: Trait + Send + Sync> sp_std::fmt::Debug2129 for ChargeTransactionPayment<T>2130{2131 #[cfg(feature = "std")]2132 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2133 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2134 }2135 #[cfg(not(feature = "std"))]2136 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2137 Ok(())2138 }2139}21402141impl<T: Trait + Send + Sync> ChargeTransactionPayment<T>2142where2143 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2144 BalanceOf<T>: Send + Sync + FixedPointOperand,2145{2146 /// utility constructor. Used only in client/factory code.2147 pub fn from(fee: BalanceOf<T>) -> Self {2148 Self(fee)2149 }21502151 pub fn traditional_fee(2152 len: usize,2153 info: &DispatchInfoOf<T::Call>,2154 tip: BalanceOf<T>,2155 ) -> BalanceOf<T>2156 where2157 T::Call: Dispatchable<Info = DispatchInfo>,2158 {2159 <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2160 }21612162 fn withdraw_fee(2163 &self,2164 who: &T::AccountId,2165 call: &T::Call,2166 info: &DispatchInfoOf<T::Call>,2167 len: usize,2168 ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {2169 let tip = self.0;21702171 // Set fee based on call type. Creating collection costs 1 Unique.2172 // All other transactions have traditional fees so far2173 // let fee = match call.is_sub_type() {2174 // Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2175 // _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2176 // // _ => <BalanceOf<T>>::from(100)2177 // };2178 let fee = Self::traditional_fee(len, info, tip);21792180 // Determine who is paying transaction fee based on ecnomic model2181 // Parse call to extract collection ID and access collection sponsor2182 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2183 Some(Call::create_item(collection_id, _properties, _owner)) => {2184 <Collection<T>>::get(collection_id).sponsor2185 }2186 Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {2187 let _collection_mode = <Collection<T>>::get(collection_id).mode;21882189 // sponsor timeout2190 let sponsor_transfer = match _collection_mode {2191 CollectionMode::NFT => {2192 let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);2193 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2194 let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2195 if block_number >= limit_time {2196 <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);2197 true2198 }2199 else {2200 false2201 }2202 }2203 CollectionMode::Fungible(_) => {2204 let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);2205 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2206 if basket.iter().any(|i| i.address == _new_owner.clone())2207 {2208 let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();2209 let limit_time = item.start_block + ChainLimit::get().fungible_sponsor_transfer_timeout.into();2210 if block_number >= limit_time {2211 basket.retain(|x| x.address == item.address);2212 basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });2213 <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);2214 true2215 }2216 else {2217 false2218 }2219 }2220 else {2221 basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});2222 true2223 }2224 }2225 CollectionMode::ReFungible(_) => {2226 let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);2227 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2228 let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2229 if block_number >= limit_time {2230 <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);2231 true2232 } else {2233 false2234 }2235 }2236 _ => {2237 false2238 },2239 };22402241 if !sponsor_transfer {2242 T::AccountId::default()2243 } else {2244 <Collection<T>>::get(collection_id).sponsor2245 }2246 }22472248 _ => T::AccountId::default(),2249 };22502251 // Sponsor smart contracts2252 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {22532254 // On instantiation: set the contract owner2255 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, data)) => {22562257 let new_contract_address = <T as pallet_contracts::Trait>::DetermineContractAddress::contract_address_for(2258 code_hash,2259 &data,2260 &who,2261 );2262 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());22632264 T::AccountId::default()2265 },22662267 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2268 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {22692270 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());22712272 let mut sponsor_transfer = false;2273 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2274 let last_tx_block = <ContractSponsorBasket<T>>::get(&called_contract);2275 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2276 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2277 let limit_time = last_tx_block + rate_limit;22782279 if block_number >= limit_time {2280 <ContractSponsorBasket<T>>::insert(called_contract.clone(), block_number);2281 sponsor_transfer = true;2282 }2283 } else {2284 sponsor_transfer = false;2285 }2286 2287 2288 let mut sp = T::AccountId::default();2289 if sponsor_transfer {2290 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2291 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2292 sp = called_contract;2293 }2294 }2295 }22962297 sp2298 },22992300 _ => sponsor,2301 };23022303 let mut who_pays_fee: T::AccountId = sponsor.clone();2304 if sponsor == T::AccountId::default() {2305 who_pays_fee = who.clone();2306 }23072308 // Only mess with balances if fee is not zero.2309 if fee.is_zero() {2310 return Ok((fee, None));2311 }23122313 match <T as transaction_payment::Trait>::Currency::withdraw(2314 &who_pays_fee,2315 fee,2316 if tip.is_zero() {2317 WithdrawReason::TransactionPayment.into()2318 } else {2319 WithdrawReason::TransactionPayment | WithdrawReason::Tip2320 },2321 ExistenceRequirement::KeepAlive,2322 ) {2323 Ok(imbalance) => Ok((fee, Some(imbalance))),2324 Err(_) => Err(InvalidTransaction::Payment.into()),2325 }2326 }2327}232823292330impl<T: Trait + Send + Sync> SignedExtension2331 for ChargeTransactionPayment<T>2332where2333 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2334 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2335{2336 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2337 type AccountId = T::AccountId;2338 type Call = T::Call;2339 type AdditionalSigned = ();2340 type Pre = (2341 BalanceOf<T>,2342 Self::AccountId,2343 Option<NegativeImbalanceOf<T>>,2344 BalanceOf<T>,2345 );2346 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2347 Ok(())2348 }23492350 fn validate(2351 &self,2352 _who: &Self::AccountId,2353 _call: &Self::Call,2354 _info: &DispatchInfoOf<Self::Call>,2355 _len: usize,2356 ) -> TransactionValidity {2357 Ok(ValidTransaction::default())2358 }23592360 fn pre_dispatch(2361 self,2362 who: &Self::AccountId,2363 call: &Self::Call,2364 info: &DispatchInfoOf<Self::Call>,2365 len: usize,2366 ) -> Result<Self::Pre, TransactionValidityError> {2367 let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2368 Ok((self.0, who.clone(), imbalance, fee))2369 }23702371 fn post_dispatch(2372 pre: Self::Pre,2373 info: &DispatchInfoOf<Self::Call>,2374 post_info: &PostDispatchInfoOf<Self::Call>,2375 len: usize,2376 _result: &DispatchResult,2377 ) -> Result<(), TransactionValidityError> {2378 let (tip, who, imbalance, fee) = pre;2379 if let Some(payed) = imbalance {2380 let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(2381 len as u32, info, post_info, tip,2382 );2383 let refund = fee.saturating_sub(actual_fee);2384 let actual_payment =2385 match <T as transaction_payment::Trait>::Currency::deposit_into_existing(2386 &who, refund,2387 ) {2388 Ok(refund_imbalance) => {2389 // The refund cannot be larger than the up front payed max weight.2390 // `PostDispatchInfo::calc_unspent` guards against such a case.2391 match payed.offset(refund_imbalance) {2392 Ok(actual_payment) => actual_payment,2393 Err(_) => return Err(InvalidTransaction::Payment.into()),2394 }2395 }2396 // We do not recreate the account using the refund. The up front payment2397 // is gone in that case.2398 Err(_) => payed,2399 };2400 let imbalances = actual_payment.split(tip);2401 <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(2402 Some(imbalances.0).into_iter().chain(Some(imbalances.1)),2403 );2404 }2405 Ok(())2406 }2407}24082409// #endregionruntime/Cargo.tomldiffbeforeafterboth--- a/runtime/Cargo.toml
+++ b/runtime/Cargo.toml
@@ -73,6 +73,7 @@
'frame-system-benchmarking',
'frame-system/runtime-benchmarks',
'pallet-balances/runtime-benchmarks',
+ 'pallet-collective/runtime-benchmarks',
'pallet-timestamp/runtime-benchmarks',
'pallet-nft/runtime-benchmarks',
'sp-runtime/runtime-benchmarks',
runtime/src/nft_weights.rsdiffbeforeafterboth--- a/runtime/src/nft_weights.rs
+++ b/runtime/src/nft_weights.rs
@@ -113,11 +113,11 @@
// .saturating_add(DbWeight::get().reads(1 as Weight))
// .saturating_add(DbWeight::get().writes(1 as Weight))
// }
- // fn enable_contract_sponsoring() -> Weight {
- // (0 as Weight)
- // .saturating_add(DbWeight::get().reads(1 as Weight))
- // .saturating_add(DbWeight::get().writes(1 as Weight))
- // }
+ fn enable_contract_sponsoring() -> Weight {
+ (13_000_000 as Weight)
+ .saturating_add(DbWeight::get().reads(1 as Weight))
+ .saturating_add(DbWeight::get().writes(1 as Weight))
+ }
// fn set_contract_sponsoring_rate_limit() -> Weight {
// (0 as Weight)
// .saturating_add(DbWeight::get().reads(1 as Weight))