difftreelog
Merge pull request #210 from UniqueNetwork/feature/CORE-180-v2
in: master
CORE-180. burnItem
10 files changed
launch-config.jsondiffbeforeafterboth--- a/launch-config.json
+++ b/launch-config.json
@@ -66,7 +66,9 @@
"name": "alice",
"flags": [
"--rpc-cors=all",
- "--rpc-port=9933", "--unsafe-ws-external"
+ "--rpc-port=9933",
+ "--unsafe-rpc-external",
+ "--unsafe-ws-external"
]
},
{
@@ -76,7 +78,9 @@
"name": "bob",
"flags": [
"--rpc-cors=all",
- "--rpc-port=9934", "--unsafe-rpc-external"
+ "--rpc-port=9934",
+ "--unsafe-rpc-external",
+ "--unsafe-ws-external"
]
}
]
pallets/nft/src/eth/erc.rsdiffbeforeafterboth--- a/pallets/nft/src/eth/erc.rs
+++ b/pallets/nft/src/eth/erc.rs
@@ -194,7 +194,8 @@
let caller = T::CrossAccountId::from_eth(caller);
let token_id = token_id.try_into().map_err(|_| "amount overflow")?;
- <Module<T>>::burn_item_internal(&caller, &self, token_id, 1).map_err(|_| "burn error")?;
+ <Module<T>>::burn_item_internal(&caller, &self, token_id, 1, true)
+ .map_err(|_| "burn error")?;
Ok(())
}
}
pallets/nft/src/lib.rsdiffbeforeafterboth1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9 clippy::too_many_arguments,10 clippy::unnecessary_mut_passed,11 clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue, transactional,32};3334use frame_system::{self as system, ensure_signed};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41 CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42 VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43 OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44 MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45 CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46 MetaUpdatePermission, FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70 /// Error for non-fungible-token module.71 pub enum Error for Module<T: Config> {72 /// Total collections bound exceeded.73 TotalCollectionsLimitExceeded,74 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.75 CollectionDecimalPointLimitExceeded,76 /// Collection name can not be longer than 63 char.77 CollectionNameLimitExceeded,78 /// Collection description can not be longer than 255 char.79 CollectionDescriptionLimitExceeded,80 /// Token prefix can not be longer than 15 char.81 CollectionTokenPrefixLimitExceeded,82 /// This collection does not exist.83 CollectionNotFound,84 /// Item not exists.85 TokenNotFound,86 /// Admin not found87 AdminNotFound,88 /// Arithmetic calculation overflow.89 NumOverflow,90 /// Account already has admin role.91 AlreadyAdmin,92 /// You do not own this collection.93 NoPermission,94 /// This address is not set as sponsor, use setCollectionSponsor first.95 ConfirmUnsetSponsorFail,96 /// Collection is not in mint mode.97 PublicMintingNotAllowed,98 /// Sender parameter and item owner must be equal.99 MustBeTokenOwner,100 /// Item balance not enough.101 TokenValueTooLow,102 /// Size of item is too large.103 NftSizeLimitExceeded,104 /// No approve found105 ApproveNotFound,106 /// Requested value more than approved.107 TokenValueNotEnough,108 /// Only approved addresses can call this method.109 ApproveRequired,110 /// Address is not in white list.111 AddresNotInWhiteList,112 /// Number of collection admins bound exceeded.113 CollectionAdminsLimitExceeded,114 /// Owned tokens by a single address bound exceeded.115 AddressOwnershipLimitExceeded,116 /// Length of items properties must be greater than 0.117 EmptyArgument,118 /// const_data exceeded data limit.119 TokenConstDataLimitExceeded,120 /// variable_data exceeded data limit.121 TokenVariableDataLimitExceeded,122 /// Not NFT item data used to mint in NFT collection.123 NotNftDataUsedToMintNftCollectionToken,124 /// Not Fungible item data used to mint in Fungible collection.125 NotFungibleDataUsedToMintFungibleCollectionToken,126 /// Not Re Fungible item data used to mint in Re Fungible collection.127 NotReFungibleDataUsedToMintReFungibleCollectionToken,128 /// Unexpected collection type.129 UnexpectedCollectionType,130 /// Can't store metadata in fungible tokens.131 CantStoreMetadataInFungibleTokens,132 /// Collection token limit exceeded133 CollectionTokenLimitExceeded,134 /// Account token limit exceeded per collection135 AccountTokenLimitExceeded,136 /// Collection limit bounds per collection exceeded137 CollectionLimitBoundsExceeded,138 /// Tried to enable permissions which are only permitted to be disabled139 OwnerPermissionsCantBeReverted,140 /// Schema data size limit bound exceeded141 SchemaDataLimitExceeded,142 /// Maximum refungibility exceeded143 WrongRefungiblePieces,144 /// createRefungible should be called with one owner145 BadCreateRefungibleCall,146 /// Gas limit exceeded147 OutOfGas,148 /// Metadata update denied by collection settings149 MetadataUpdateDenied,150 /// Metadata update flag become unmutable with None option151 MetadataFlagFrozen,152 /// Collection settings not allowing items transferring153 TransferNotAllowed,154 /// Can't transfer tokens to ethereum zero address155 AddressIsZero,156 }157}158159#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]160pub struct CollectionHandle<T: Config> {161 pub id: CollectionId,162 collection: Collection<T>,163 recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,164}165impl<T: Config> CollectionHandle<T> {166 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {167 <CollectionById<T>>::get(id).map(|collection| Self {168 id,169 collection,170 recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(171 eth::collection_id_to_address(id),172 gas_limit,173 ),174 })175 }176 pub fn get(id: CollectionId) -> Option<Self> {177 Self::get_with_gas_limit(id, u64::MAX)178 }179 pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {180 self.recorder.log_sub(log)181 }182 #[allow(dead_code)]183 fn consume_gas(&self, gas: u64) -> DispatchResult {184 self.recorder.consume_gas_sub(gas)185 }186 fn consume_sload(&self) -> DispatchResult {187 self.recorder.consume_sload_sub()188 }189 fn consume_sstore(&self) -> DispatchResult {190 self.recorder.consume_sstore_sub()191 }192 pub fn submit_logs(self) -> DispatchResult {193 self.recorder.submit_logs()194 }195 pub fn save(self) -> DispatchResult {196 self.recorder.submit_logs()?;197 <CollectionById<T>>::insert(self.id, self.collection);198 Ok(())199 }200}201impl<T: Config> Deref for CollectionHandle<T> {202 type Target = Collection<T>;203204 fn deref(&self) -> &Self::Target {205 &self.collection206 }207}208209impl<T: Config> DerefMut for CollectionHandle<T> {210 fn deref_mut(&mut self) -> &mut Self::Target {211 &mut self.collection212 }213}214215pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {216 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;217218 /// Weight information for extrinsics in this pallet.219 type WeightInfo: WeightInfo;220221 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;222 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;223224 type CrossAccountId: CrossAccountId<Self::AccountId>;225 type Currency: Currency<Self::AccountId>;226 type CollectionCreationPrice: Get<227 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,228 >;229 type TreasuryAccountId: Get<Self::AccountId>;230}231232type SelfWeightOf<T> = <T as Config>::WeightInfo;233234trait WeightInfoHelpers: WeightInfo {235 fn transfer() -> Weight {236 Self::transfer_nft()237 .max(Self::transfer_fungible())238 .max(Self::transfer_refungible())239 }240 fn transfer_from() -> Weight {241 Self::transfer_from_nft()242 .max(Self::transfer_from_fungible())243 .max(Self::transfer_from_refungible())244 }245 fn approve() -> Weight {246 // TODO: refungible, fungible247 Self::approve_nft()248 }249 fn set_variable_meta_data(data: u32) -> Weight {250 // TODO: refungible251 Self::set_variable_meta_data_nft(data)252 }253 fn create_item(data: u32) -> Weight {254 Self::create_item_nft(data)255 .max(Self::create_item_fungible())256 .max(Self::create_item_refungible(data))257 }258 fn create_multiple_items(amount: u32) -> Weight {259 Self::create_multiple_items_nft(amount)260 .max(Self::create_multiple_items_fungible(amount))261 .max(Self::create_multiple_items_refungible(amount))262 }263 fn burn_item() -> Weight {264 // TODO: refungible, fungible265 Self::burn_item_nft()266 }267}268impl<T: WeightInfo> WeightInfoHelpers for T {}269270// # Used definitions271//272// ## User control levels273//274// chain-controlled - key is uncontrolled by user275// i.e autoincrementing index276// can use non-cryptographic hash277// real - key is controlled by user278// but it is hard to generate enough colliding values, i.e owner of signed txs279// can use non-cryptographic hash280// controlled - key is completly controlled by users281// i.e maps with mutable keys282// should use cryptographic hash283//284// ## User control level downgrade reasons285//286// ?1 - chain-controlled -> controlled287// collections/tokens can be destroyed, resulting in massive holes288// ?2 - chain-controlled -> controlled289// same as ?1, but can be only added, resulting in easier exploitation290// ?3 - real -> controlled291// no confirmation required, so addresses can be easily generated292decl_storage! {293 trait Store for Module<T: Config> as Nft {294295 //#region Private members296 /// Id of next collection297 CreatedCollectionCount: u32;298 /// Used for migrations299 ChainVersion: u64;300 /// Id of last collection token301 /// Collection id (controlled?1)302 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;303 //#endregion304305 //#region Bound counters306 /// Amount of collections destroyed, used for total amount tracking with307 /// CreatedCollectionCount308 DestroyedCollectionCount: u32;309 //#endregion310311 //#region Basic collections312 /// Collection info313 /// Collection id (controlled?1)314 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;315 /// List of collection admins316 /// Collection id (controlled?2)317 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;318 /// Whitelisted collection users319 /// Collection id (controlled?2), user id (controlled?3)320 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;321 //#endregion322323 /// How many of collection items user have324 /// Collection id (controlled?2), account id (real)325 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;326327 /// Amount of items which spender can transfer out of owners account (via transferFrom)328 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))329 /// TODO: Off chain worker should remove from this map when token gets removed330 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;331332 //#region Item collections333 /// Collection id (controlled?2), token id (controlled?1)334 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;335 /// Collection id (controlled?2), owner (controlled?2)336 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;337 /// Collection id (controlled?2), token id (controlled?1)338 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;339 //#endregion340341 //#region Index list342 /// Collection id (controlled?2), tokens owner (controlled?2)343 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;344 //#endregion345346 //#region Tokens transfer rate limit baskets347 /// (Collection id (controlled?2), who created (real))348 /// TODO: Off chain worker should remove from this map when collection gets removed349 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;350 /// Collection id (controlled?2), token id (controlled?2)351 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;352 /// Collection id (controlled?2), owning user (real)353 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;354 /// Collection id (controlled?2), token id (controlled?2)355 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;356 //#endregion357358 /// Variable metadata sponsoring359 /// Collection id (controlled?2), token id (controlled?2)360 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;361 }362 add_extra_genesis {363 build(|config: &GenesisConfig<T>| {364 // Modification of storage365 for (_num, _c) in &config.collection_id {366 <Module<T>>::init_collection(_c);367 }368369 for (_num, _c, _i) in &config.nft_item_id {370 <Module<T>>::init_nft_token(*_c, _i);371 }372373 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {374 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);375 }376377 for (_num, _c, _i) in &config.refungible_item_id {378 <Module<T>>::init_refungible_token(*_c, _i);379 }380 })381 }382}383384decl_event!(385 pub enum Event<T>386 where387 AccountId = <T as frame_system::Config>::AccountId,388 CrossAccountId = <T as Config>::CrossAccountId,389 {390 /// New collection was created391 ///392 /// # Arguments393 ///394 /// * collection_id: Globally unique identifier of newly created collection.395 ///396 /// * mode: [CollectionMode] converted into u8.397 ///398 /// * account_id: Collection owner.399 CollectionCreated(CollectionId, u8, AccountId),400401 /// New item was created.402 ///403 /// # Arguments404 ///405 /// * collection_id: Id of the collection where item was created.406 ///407 /// * item_id: Id of an item. Unique within the collection.408 ///409 /// * recipient: Owner of newly created item410 ItemCreated(CollectionId, TokenId, CrossAccountId),411412 /// Collection item was burned.413 ///414 /// # Arguments415 ///416 /// collection_id.417 ///418 /// item_id: Identifier of burned NFT.419 ItemDestroyed(CollectionId, TokenId),420421 /// Item was transferred422 ///423 /// * collection_id: Id of collection to which item is belong424 ///425 /// * item_id: Id of an item426 ///427 /// * sender: Original owner of item428 ///429 /// * recipient: New owner of item430 ///431 /// * amount: Always 1 for NFT432 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),433434 /// * collection_id435 ///436 /// * item_id437 ///438 /// * sender439 ///440 /// * spender441 ///442 /// * amount443 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),444 }445);446447decl_module! {448 pub struct Module<T: Config> for enum Call449 where450 origin: T::Origin451 {452 fn deposit_event() = default;453 const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;454 type Error = Error<T>;455456 fn on_initialize(_now: T::BlockNumber) -> Weight {457 0458 }459460 /// 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.461 ///462 /// # Permissions463 ///464 /// * Anyone.465 ///466 /// # Arguments467 ///468 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.469 ///470 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.471 ///472 /// * token_prefix: UTF-8 string with token prefix.473 ///474 /// * mode: [CollectionMode] collection type and type dependent data.475 // returns collection ID476 #[weight = <SelfWeightOf<T>>::create_collection()]477 #[transactional]478 pub fn create_collection(origin,479 collection_name: Vec<u16>,480 collection_description: Vec<u16>,481 token_prefix: Vec<u8>,482 mode: CollectionMode) -> DispatchResult {483484 // Anyone can create a collection485 let who = ensure_signed(origin)?;486487 // Take a (non-refundable) deposit of collection creation488 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();489 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(490 &T::TreasuryAccountId::get(),491 T::CollectionCreationPrice::get(),492 ));493 <T as Config>::Currency::settle(494 &who,495 imbalance,496 WithdrawReasons::TRANSFER,497 ExistenceRequirement::KeepAlive,498 ).map_err(|_| Error::<T>::NoPermission)?;499500 let decimal_points = match mode {501 CollectionMode::Fungible(points) => points,502 _ => 0503 };504505 let created_count = CreatedCollectionCount::get();506 let destroyed_count = DestroyedCollectionCount::get();507508 // bound Total number of collections509 ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);510511 // check params512 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);513 ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);514 ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);515 ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);516517 // Generate next collection ID518 let next_id = created_count519 .checked_add(1)520 .ok_or(Error::<T>::NumOverflow)?;521522 CreatedCollectionCount::put(next_id);523524 let limits = CollectionLimits {525 sponsored_data_size: CUSTOM_DATA_LIMIT,526 ..Default::default()527 };528529 // Create new collection530 let new_collection = Collection {531 owner: who.clone(),532 name: collection_name,533 mode: mode.clone(),534 mint_mode: false,535 access: AccessMode::Normal,536 description: collection_description,537 decimal_points,538 token_prefix,539 offchain_schema: Vec::new(),540 schema_version: SchemaVersion::ImageURL,541 sponsorship: SponsorshipState::Disabled,542 variable_on_chain_schema: Vec::new(),543 const_on_chain_schema: Vec::new(),544 limits,545 meta_update_permission: MetaUpdatePermission::default(),546 transfers_enabled: true,547 };548549 // Add new collection to map550 <CollectionById<T>>::insert(next_id, new_collection);551552 // call event553 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));554555 Ok(())556 }557558 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.559 ///560 /// # Permissions561 ///562 /// * Collection Owner.563 ///564 /// # Arguments565 ///566 /// * collection_id: collection to destroy.567 #[weight = <SelfWeightOf<T>>::destroy_collection()]568 #[transactional]569 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {570571 let sender = ensure_signed(origin)?;572 let collection = Self::get_collection(collection_id)?;573 Self::check_owner_permissions(&collection, &sender)?;574 if !collection.limits.owner_can_destroy {575 fail!(Error::<T>::NoPermission);576 }577578 <AddressTokens<T>>::remove_prefix(collection_id, None);579 <Allowances<T>>::remove_prefix(collection_id, None);580 <Balance<T>>::remove_prefix(collection_id, None);581 <ItemListIndex>::remove(collection_id);582 <AdminList<T>>::remove(collection_id);583 <CollectionById<T>>::remove(collection_id);584 <WhiteList<T>>::remove_prefix(collection_id, None);585586 <NftItemList<T>>::remove_prefix(collection_id, None);587 <FungibleItemList<T>>::remove_prefix(collection_id, None);588 <ReFungibleItemList<T>>::remove_prefix(collection_id, None);589590 <NftTransferBasket<T>>::remove_prefix(collection_id, None);591 <FungibleTransferBasket<T>>::remove_prefix(collection_id, None);592 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);593594 <VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);595596 DestroyedCollectionCount::put(DestroyedCollectionCount::get()597 .checked_add(1)598 .ok_or(Error::<T>::NumOverflow)?);599600 Ok(())601 }602603 /// Add an address to white list.604 ///605 /// # Permissions606 ///607 /// * Collection Owner608 /// * Collection Admin609 ///610 /// # Arguments611 ///612 /// * collection_id.613 ///614 /// * address.615 #[weight = <SelfWeightOf<T>>::add_to_white_list()]616 #[transactional]617 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{618619 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);620 let collection = Self::get_collection(collection_id)?;621622 Self::toggle_white_list_internal(623 &sender,624 &collection,625 &address,626 true,627 )?;628629 Ok(())630 }631632 /// Remove an address from white list.633 ///634 /// # Permissions635 ///636 /// * Collection Owner637 /// * Collection Admin638 ///639 /// # Arguments640 ///641 /// * collection_id.642 ///643 /// * address.644 #[weight = <SelfWeightOf<T>>::remove_from_white_list()]645 #[transactional]646 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{647648 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);649 let collection = Self::get_collection(collection_id)?;650651 Self::toggle_white_list_internal(652 &sender,653 &collection,654 &address,655 false,656 )?;657658 Ok(())659 }660661 /// Toggle between normal and white list access for the methods with access for `Anyone`.662 ///663 /// # Permissions664 ///665 /// * Collection Owner.666 ///667 /// # Arguments668 ///669 /// * collection_id.670 ///671 /// * mode: [AccessMode]672 #[weight = <SelfWeightOf<T>>::set_public_access_mode()]673 #[transactional]674 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult675 {676 let sender = ensure_signed(origin)?;677678 let mut target_collection = Self::get_collection(collection_id)?;679 Self::check_owner_permissions(&target_collection, &sender)?;680 target_collection.access = mode;681 target_collection.save()682 }683684 /// Allows Anyone to create tokens if:685 /// * White List is enabled, and686 /// * Address is added to white list, and687 /// * This method was called with True parameter688 ///689 /// # Permissions690 /// * Collection Owner691 ///692 /// # Arguments693 ///694 /// * collection_id.695 ///696 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.697 #[weight = <SelfWeightOf<T>>::set_mint_permission()]698 #[transactional]699 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult700 {701 let sender = ensure_signed(origin)?;702703 let mut target_collection = Self::get_collection(collection_id)?;704 Self::check_owner_permissions(&target_collection, &sender)?;705 target_collection.mint_mode = mint_permission;706 target_collection.save()707 }708709 /// Change the owner of the collection.710 ///711 /// # Permissions712 ///713 /// * Collection Owner.714 ///715 /// # Arguments716 ///717 /// * collection_id.718 ///719 /// * new_owner.720 #[weight = <SelfWeightOf<T>>::change_collection_owner()]721 #[transactional]722 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {723724 let sender = ensure_signed(origin)?;725 let mut target_collection = Self::get_collection(collection_id)?;726 Self::check_owner_permissions(&target_collection, &sender)?;727 target_collection.owner = new_owner;728 target_collection.save()729 }730731 /// Adds an admin of the Collection.732 /// 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.733 ///734 /// # Permissions735 ///736 /// * Collection Owner.737 /// * Collection Admin.738 ///739 /// # Arguments740 ///741 /// * collection_id: ID of the Collection to add admin for.742 ///743 /// * new_admin_id: Address of new admin to add.744 #[weight = <SelfWeightOf<T>>::add_collection_admin()]745 #[transactional]746 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {747 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);748 let collection = Self::get_collection(collection_id)?;749 Self::check_owner_or_admin_permissions(&collection, &sender)?;750 let mut admin_arr = <AdminList<T>>::get(collection_id);751752 match admin_arr.binary_search(&new_admin_id) {753 Ok(_) => {},754 Err(idx) => {755 ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);756 admin_arr.insert(idx, new_admin_id);757 <AdminList<T>>::insert(collection_id, admin_arr);758 }759 }760 Ok(())761 }762763 /// 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.764 ///765 /// # Permissions766 ///767 /// * Collection Owner.768 /// * Collection Admin.769 ///770 /// # Arguments771 ///772 /// * collection_id: ID of the Collection to remove admin for.773 ///774 /// * account_id: Address of admin to remove.775 #[weight = <SelfWeightOf<T>>::remove_collection_admin()]776 #[transactional]777 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {778 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);779 let collection = Self::get_collection(collection_id)?;780 Self::check_owner_or_admin_permissions(&collection, &sender)?;781 let mut admin_arr = <AdminList<T>>::get(collection_id);782783 if let Ok(idx) = admin_arr.binary_search(&account_id) {784 admin_arr.remove(idx);785 <AdminList<T>>::insert(collection_id, admin_arr);786 }787 Ok(())788 }789790 /// # Permissions791 ///792 /// * Collection Owner793 ///794 /// # Arguments795 ///796 /// * collection_id.797 ///798 /// * new_sponsor.799 #[weight = <SelfWeightOf<T>>::set_collection_sponsor()]800 #[transactional]801 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {802 let sender = ensure_signed(origin)?;803 let mut target_collection = Self::get_collection(collection_id)?;804 Self::check_owner_permissions(&target_collection, &sender)?;805806 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);807 target_collection.save()808 }809810 /// # Permissions811 ///812 /// * Sponsor.813 ///814 /// # Arguments815 ///816 /// * collection_id.817 #[weight = <SelfWeightOf<T>>::confirm_sponsorship()]818 #[transactional]819 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {820 let sender = ensure_signed(origin)?;821822 let mut target_collection = Self::get_collection(collection_id)?;823 ensure!(824 target_collection.sponsorship.pending_sponsor() == Some(&sender),825 Error::<T>::ConfirmUnsetSponsorFail826 );827828 target_collection.sponsorship = SponsorshipState::Confirmed(sender);829 target_collection.save()830 }831832 /// Switch back to pay-per-own-transaction model.833 ///834 /// # Permissions835 ///836 /// * Collection owner.837 ///838 /// # Arguments839 ///840 /// * collection_id.841 #[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]842 #[transactional]843 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {844 let sender = ensure_signed(origin)?;845846 let mut target_collection = Self::get_collection(collection_id)?;847 Self::check_owner_permissions(&target_collection, &sender)?;848849 target_collection.sponsorship = SponsorshipState::Disabled;850 target_collection.save()851 }852853 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.854 ///855 /// # Permissions856 ///857 /// * Collection Owner.858 /// * Collection Admin.859 /// * Anyone if860 /// * White List is enabled, and861 /// * Address is added to white list, and862 /// * MintPermission is enabled (see SetMintPermission method)863 ///864 /// # Arguments865 ///866 /// * collection_id: ID of the collection.867 ///868 /// * owner: Address, initial owner of the NFT.869 ///870 /// * data: Token data to store on chain.871 // #[weight =872 // (130_000_000 as Weight)873 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))874 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))875 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]876877 #[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]878 #[transactional]879 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {880 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);881 let collection = Self::get_collection(collection_id)?;882883 Self::create_item_internal(&sender, &collection, &owner, data)?;884885 collection.submit_logs()886 }887888 /// This method creates multiple items in a collection created with CreateCollection method.889 ///890 /// # Permissions891 ///892 /// * Collection Owner.893 /// * Collection Admin.894 /// * Anyone if895 /// * White List is enabled, and896 /// * Address is added to white list, and897 /// * MintPermission is enabled (see SetMintPermission method)898 ///899 /// # Arguments900 ///901 /// * collection_id: ID of the collection.902 ///903 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].904 ///905 /// * owner: Address, initial owner of the NFT.906 #[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]907 #[transactional]908 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {909910 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);911 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);912 let collection = Self::get_collection(collection_id)?;913914 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;915916 collection.submit_logs()917 }918919 // TODO! transaction weight920921 /// Set transfers_enabled value for particular collection922 ///923 /// # Permissions924 ///925 /// * Collection Owner.926 ///927 /// # Arguments928 ///929 /// * collection_id: ID of the collection.930 ///931 /// * value: New flag value.932 #[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]933 #[transactional]934 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {935936 let sender = ensure_signed(origin)?;937 let mut target_collection = Self::get_collection(collection_id)?;938939 Self::check_owner_permissions(&target_collection, &sender)?;940941 target_collection.transfers_enabled = value;942 target_collection.save()943 }944945 // TODO! transaction weight946 /// Set meta_update_permission value for particular collection947 ///948 /// # Permissions949 ///950 /// * Collection Owner.951 ///952 /// # Arguments953 ///954 /// * collection_id: ID of the collection.955 ///956 /// * value: New flag value.957 #[weight = <T as Config>::WeightInfo::burn_item()]958 #[transactional]959 pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {960961 let sender = ensure_signed(origin)?;962 let mut target_collection = Self::get_collection(collection_id)?;963964 ensure!(965 target_collection.meta_update_permission != MetaUpdatePermission::None,966 Error::<T>::MetadataFlagFrozen967 );968 Self::check_owner_permissions(&target_collection, &sender)?;969970 target_collection.meta_update_permission = value;971972 target_collection.save()973 }974975 /// Destroys a concrete instance of NFT.976 ///977 /// # Permissions978 ///979 /// * Collection Owner.980 /// * Collection Admin.981 /// * Current NFT Owner.982 ///983 /// # Arguments984 ///985 /// * collection_id: ID of the collection.986 ///987 /// * item_id: ID of NFT to burn.988 #[weight = <SelfWeightOf<T>>::burn_item()]989 #[transactional]990 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {991992 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);993 let target_collection = Self::get_collection(collection_id)?;994995 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;996997 target_collection.submit_logs()998 }9991000 /// Change ownership of the token.1001 ///1002 /// # Permissions1003 ///1004 /// * Collection Owner1005 /// * Collection Admin1006 /// * Current NFT owner1007 ///1008 /// # Arguments1009 ///1010 /// * recipient: Address of token recipient.1011 ///1012 /// * collection_id.1013 ///1014 /// * item_id: ID of the item1015 /// * Non-Fungible Mode: Required.1016 /// * Fungible Mode: Ignored.1017 /// * Re-Fungible Mode: Required.1018 ///1019 /// * value: Amount to transfer.1020 /// * Non-Fungible Mode: Ignored1021 /// * Fungible Mode: Must specify transferred amount1022 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1023 #[weight = <SelfWeightOf<T>>::transfer()]1024 #[transactional]1025 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1026 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1027 let collection = Self::get_collection(collection_id)?;10281029 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10301031 collection.submit_logs()1032 }10331034 /// Set, change, or remove approved address to transfer the ownership of the NFT.1035 ///1036 /// # Permissions1037 ///1038 /// * Collection Owner1039 /// * Collection Admin1040 /// * Current NFT owner1041 ///1042 /// # Arguments1043 ///1044 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1045 ///1046 /// * collection_id.1047 ///1048 /// * item_id: ID of the item.1049 #[weight = <SelfWeightOf<T>>::approve()]1050 #[transactional]1051 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1052 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1053 let collection = Self::get_collection(collection_id)?;10541055 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10561057 collection.submit_logs()1058 }10591060 /// 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.1061 ///1062 /// # Permissions1063 /// * Collection Owner1064 /// * Collection Admin1065 /// * Current NFT owner1066 /// * Address approved by current NFT owner1067 ///1068 /// # Arguments1069 ///1070 /// * from: Address that owns token.1071 ///1072 /// * recipient: Address of token recipient.1073 ///1074 /// * collection_id.1075 ///1076 /// * item_id: ID of the item.1077 ///1078 /// * value: Amount to transfer.1079 #[weight = <SelfWeightOf<T>>::transfer_from()]1080 #[transactional]1081 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1082 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1083 let collection = Self::get_collection(collection_id)?;10841085 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10861087 collection.submit_logs()1088 }1089 // #[weight = 0]1090 // // let no_perm_mes = "You do not have permissions to modify this collection";1091 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1092 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1093 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10941095 // // // on_nft_received call10961097 // // Self::transfer(origin, collection_id, item_id, new_owner)?;10981099 // Ok(())1100 // }11011102 /// Set off-chain data schema.1103 ///1104 /// # Permissions1105 ///1106 /// * Collection Owner1107 /// * Collection Admin1108 ///1109 /// # Arguments1110 ///1111 /// * collection_id.1112 ///1113 /// * schema: String representing the offchain data schema.1114 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1115 #[transactional]1116 pub fn set_variable_meta_data (1117 origin,1118 collection_id: CollectionId,1119 item_id: TokenId,1120 data: Vec<u8>1121 ) -> DispatchResult {1122 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11231124 let collection = Self::get_collection(collection_id)?;1125 Self::meta_update_check(&sender, &collection, item_id)?;11261127 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11281129 Ok(())1130 }11311132 /// Set schema standard1133 /// ImageURL1134 /// Unique1135 ///1136 /// # Permissions1137 ///1138 /// * Collection Owner1139 /// * Collection Admin1140 ///1141 /// # Arguments1142 ///1143 /// * collection_id.1144 ///1145 /// * schema: SchemaVersion: enum1146 #[weight = <SelfWeightOf<T>>::set_schema_version()]1147 #[transactional]1148 pub fn set_schema_version(1149 origin,1150 collection_id: CollectionId,1151 version: SchemaVersion1152 ) -> DispatchResult {1153 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1154 let mut target_collection = Self::get_collection(collection_id)?;1155 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1156 target_collection.schema_version = version;1157 target_collection.save()1158 }11591160 /// Set off-chain data schema.1161 ///1162 /// # Permissions1163 ///1164 /// * Collection Owner1165 /// * Collection Admin1166 ///1167 /// # Arguments1168 ///1169 /// * collection_id.1170 ///1171 /// * schema: String representing the offchain data schema.1172 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1173 #[transactional]1174 pub fn set_offchain_schema(1175 origin,1176 collection_id: CollectionId,1177 schema: Vec<u8>1178 ) -> DispatchResult {1179 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1180 let mut target_collection = Self::get_collection(collection_id)?;1181 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11821183 // check schema limit1184 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11851186 target_collection.offchain_schema = schema;1187 target_collection.save()1188 }11891190 /// Set const on-chain data schema.1191 ///1192 /// # Permissions1193 ///1194 /// * Collection Owner1195 /// * Collection Admin1196 ///1197 /// # Arguments1198 ///1199 /// * collection_id.1200 ///1201 /// * schema: String representing the const on-chain data schema.1202 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1203 #[transactional]1204 pub fn set_const_on_chain_schema (1205 origin,1206 collection_id: CollectionId,1207 schema: Vec<u8>1208 ) -> DispatchResult {1209 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1210 let mut target_collection = Self::get_collection(collection_id)?;1211 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12121213 // check schema limit1214 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12151216 target_collection.const_on_chain_schema = schema;1217 target_collection.save()1218 }12191220 /// Set variable on-chain data schema.1221 ///1222 /// # Permissions1223 ///1224 /// * Collection Owner1225 /// * Collection Admin1226 ///1227 /// # Arguments1228 ///1229 /// * collection_id.1230 ///1231 /// * schema: String representing the variable on-chain data schema.1232 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1233 #[transactional]1234 pub fn set_variable_on_chain_schema (1235 origin,1236 collection_id: CollectionId,1237 schema: Vec<u8>1238 ) -> DispatchResult {1239 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1240 let mut target_collection = Self::get_collection(collection_id)?;1241 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12421243 // check schema limit1244 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12451246 target_collection.variable_on_chain_schema = schema;1247 target_collection.save()1248 }12491250 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1251 #[transactional]1252 pub fn set_collection_limits(1253 origin,1254 collection_id: u32,1255 new_limits: CollectionLimits<T::BlockNumber>,1256 ) -> DispatchResult {1257 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1258 let mut target_collection = Self::get_collection(collection_id)?;1259 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1260 let old_limits = &target_collection.limits;12611262 // collection bounds1263 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1264 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1265 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1266 Error::<T>::CollectionLimitBoundsExceeded);12671268 // token_limit check prev1269 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1270 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12711272 ensure!(1273 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1274 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1275 Error::<T>::OwnerPermissionsCantBeReverted,1276 );12771278 target_collection.limits = new_limits;12791280 target_collection.save()1281 }1282 }1283}12841285impl<T: Config> Module<T> {1286 pub fn create_item_internal(1287 sender: &T::CrossAccountId,1288 collection: &CollectionHandle<T>,1289 owner: &T::CrossAccountId,1290 data: CreateItemData,1291 ) -> DispatchResult {1292 ensure!(1293 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1294 Error::<T>::AddressIsZero1295 );12961297 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1298 Self::validate_create_item_args(collection, &data)?;1299 Self::create_item_no_validation(collection, owner, data)?;13001301 Ok(())1302 }13031304 pub fn transfer_internal(1305 sender: &T::CrossAccountId,1306 recipient: &T::CrossAccountId,1307 target_collection: &CollectionHandle<T>,1308 item_id: TokenId,1309 value: u128,1310 ) -> DispatchResult {1311 ensure!(1312 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1313 Error::<T>::AddressIsZero1314 );13151316 // Limits check1317 Self::is_correct_transfer(target_collection, recipient)?;13181319 // Transfer permissions check1320 ensure!(1321 Self::is_item_owner(sender, target_collection, item_id)?1322 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1323 Error::<T>::NoPermission1324 );13251326 if target_collection.access == AccessMode::WhiteList {1327 Self::check_white_list(target_collection, sender)?;1328 Self::check_white_list(target_collection, recipient)?;1329 }13301331 match target_collection.mode {1332 CollectionMode::NFT => Self::transfer_nft(1333 target_collection,1334 item_id,1335 sender.clone(),1336 recipient.clone(),1337 )?,1338 CollectionMode::Fungible(_) => {1339 Self::transfer_fungible(target_collection, value, sender, recipient)?1340 }1341 CollectionMode::ReFungible => Self::transfer_refungible(1342 target_collection,1343 item_id,1344 value,1345 sender.clone(),1346 recipient.clone(),1347 )?,1348 };13491350 Self::deposit_event(RawEvent::Transfer(1351 target_collection.id,1352 item_id,1353 sender.clone(),1354 recipient.clone(),1355 value,1356 ));13571358 Ok(())1359 }13601361 pub fn approve_internal(1362 sender: &T::CrossAccountId,1363 spender: &T::CrossAccountId,1364 collection: &CollectionHandle<T>,1365 item_id: TokenId,1366 amount: u128,1367 ) -> DispatchResult {1368 Self::token_exists(collection, item_id)?;13691370 // Transfer permissions check1371 let bypasses_limits = collection.limits.owner_can_transfer1372 && Self::is_owner_or_admin_permissions(collection, sender)?;13731374 let allowance_limit = if bypasses_limits {1375 None1376 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1377 Some(amount)1378 } else {1379 fail!(Error::<T>::NoPermission);1380 };13811382 if collection.access == AccessMode::WhiteList {1383 Self::check_white_list(collection, sender)?;1384 Self::check_white_list(collection, spender)?;1385 }13861387 collection.consume_sload()?;1388 let allowance: u128 = amount1389 .checked_add(<Allowances<T>>::get(1390 collection.id,1391 (item_id, sender.as_sub(), spender.as_sub()),1392 ))1393 .ok_or(Error::<T>::NumOverflow)?;1394 if let Some(limit) = allowance_limit {1395 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1396 }1397 collection.consume_sstore()?;1398 <Allowances<T>>::insert(1399 collection.id,1400 (item_id, sender.as_sub(), spender.as_sub()),1401 allowance,1402 );14031404 if matches!(collection.mode, CollectionMode::NFT) {1405 // TODO: NFT: only one owner may exist for token in ERC7211406 collection.log(ERC721Events::Approval {1407 owner: *sender.as_eth(),1408 approved: *spender.as_eth(),1409 token_id: item_id.into(),1410 })?;1411 }14121413 if matches!(collection.mode, CollectionMode::Fungible(_)) {1414 // TODO: NFT: only one owner may exist for token in ERC201415 collection.log(ERC20Events::Approval {1416 owner: *sender.as_eth(),1417 spender: *spender.as_eth(),1418 value: allowance.into(),1419 })?;1420 }14211422 Self::deposit_event(RawEvent::Approved(1423 collection.id,1424 item_id,1425 sender.clone(),1426 spender.clone(),1427 allowance,1428 ));1429 Ok(())1430 }14311432 pub fn transfer_from_internal(1433 sender: &T::CrossAccountId,1434 from: &T::CrossAccountId,1435 recipient: &T::CrossAccountId,1436 collection: &CollectionHandle<T>,1437 item_id: TokenId,1438 amount: u128,1439 ) -> DispatchResult {1440 if sender == from {1441 // Transfer by `from`, because it is either equal to sender, or derived from him1442 return Self::transfer_internal(from, recipient, collection, item_id, amount);1443 }14441445 // Check approval1446 collection.consume_sload()?;1447 let approval: u128 =1448 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14491450 // Limits check1451 Self::is_correct_transfer(collection, recipient)?;14521453 // Transfer permissions check1454 ensure!(1455 approval >= amount1456 || (collection.limits.owner_can_transfer1457 && Self::is_owner_or_admin_permissions(collection, sender)?),1458 Error::<T>::NoPermission1459 );14601461 if collection.access == AccessMode::WhiteList {1462 Self::check_white_list(collection, sender)?;1463 Self::check_white_list(collection, recipient)?;1464 }14651466 // Reduce approval by transferred amount or remove if remaining approval drops to 01467 let allowance = approval.saturating_sub(amount);1468 collection.consume_sstore()?;1469 if allowance > 0 {1470 <Allowances<T>>::insert(1471 collection.id,1472 (item_id, from.as_sub(), sender.as_sub()),1473 allowance,1474 );1475 } else {1476 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1477 }14781479 match collection.mode {1480 CollectionMode::NFT => {1481 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1482 }1483 CollectionMode::Fungible(_) => {1484 Self::transfer_fungible(collection, amount, from, recipient)?1485 }1486 CollectionMode::ReFungible => Self::transfer_refungible(1487 collection,1488 item_id,1489 amount,1490 from.clone(),1491 recipient.clone(),1492 )?,1493 };14941495 if matches!(collection.mode, CollectionMode::Fungible(_)) {1496 collection.log(ERC20Events::Approval {1497 owner: *from.as_eth(),1498 spender: *sender.as_eth(),1499 value: allowance.into(),1500 })?;1501 }15021503 Ok(())1504 }15051506 pub fn set_variable_meta_data_internal(1507 sender: &T::CrossAccountId,1508 collection: &CollectionHandle<T>,1509 item_id: TokenId,1510 data: Vec<u8>,1511 ) -> DispatchResult {1512 Self::token_exists(collection, item_id)?;15131514 ensure!(1515 CUSTOM_DATA_LIMIT >= data.len() as u32,1516 Error::<T>::TokenVariableDataLimitExceeded1517 );15181519 ensure!(1520 (Self::is_item_owner(sender, collection, item_id)?1521 && collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1522 || (Self::is_owner_or_admin_permissions(collection, sender)?1523 && collection.meta_update_permission == MetaUpdatePermission::Admin),1524 Error::<T>::NoPermission1525 );15261527 match collection.mode {1528 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1529 CollectionMode::ReFungible => {1530 Self::set_re_fungible_variable_data(collection, item_id, data)?1531 }1532 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1533 };15341535 Ok(())1536 }15371538 pub fn meta_update_check(1539 sender: &T::CrossAccountId,1540 collection: &CollectionHandle<T>,1541 item_id: TokenId,1542 ) -> DispatchResult {1543 match collection.meta_update_permission {1544 MetaUpdatePermission::ItemOwner => ensure!(1545 Self::is_item_owner(sender, collection, item_id)?,1546 Error::<T>::NoPermission1547 ),1548 MetaUpdatePermission::Admin => ensure!(1549 Self::is_owner_or_admin_permissions(collection, sender)?,1550 Error::<T>::NoPermission1551 ),1552 MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1553 }15541555 Ok(())1556 }15571558 pub fn get_variable_metadata(1559 collection: &CollectionHandle<T>,1560 item_id: TokenId,1561 ) -> Result<Vec<u8>, DispatchError> {1562 Ok(match collection.mode {1563 CollectionMode::NFT => {1564 <NftItemList<T>>::get(collection.id, item_id)1565 .ok_or(Error::<T>::TokenNotFound)?1566 .variable_data1567 }1568 CollectionMode::ReFungible => {1569 <ReFungibleItemList<T>>::get(collection.id, item_id)1570 .ok_or(Error::<T>::TokenNotFound)?1571 .variable_data1572 }1573 _ => fail!(Error::<T>::UnexpectedCollectionType),1574 })1575 }15761577 pub fn create_multiple_items_internal(1578 sender: &T::CrossAccountId,1579 collection: &CollectionHandle<T>,1580 owner: &T::CrossAccountId,1581 items_data: Vec<CreateItemData>,1582 ) -> DispatchResult {1583 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15841585 for data in &items_data {1586 Self::validate_create_item_args(collection, data)?;1587 }1588 for data in &items_data {1589 Self::create_item_no_validation(collection, owner, data.clone())?;1590 }15911592 Ok(())1593 }15941595 pub fn burn_item_internal(1596 sender: &T::CrossAccountId,1597 collection: &CollectionHandle<T>,1598 item_id: TokenId,1599 value: u128,1600 ) -> DispatchResult {1601 ensure!(1602 Self::is_item_owner(sender, collection, item_id)?1603 || (collection.limits.owner_can_transfer1604 && Self::is_owner_or_admin_permissions(collection, sender)?),1605 Error::<T>::NoPermission1606 );16071608 if collection.access == AccessMode::WhiteList {1609 Self::check_white_list(collection, sender)?;1610 }16111612 match collection.mode {1613 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1614 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1615 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1616 };16171618 Ok(())1619 }16201621 pub fn toggle_white_list_internal(1622 sender: &T::CrossAccountId,1623 collection: &CollectionHandle<T>,1624 address: &T::CrossAccountId,1625 whitelisted: bool,1626 ) -> DispatchResult {1627 Self::check_owner_or_admin_permissions(collection, sender)?;16281629 if whitelisted {1630 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1631 } else {1632 <WhiteList<T>>::remove(collection.id, address.as_sub());1633 }16341635 Ok(())1636 }16371638 fn is_correct_transfer(1639 collection: &CollectionHandle<T>,1640 recipient: &T::CrossAccountId,1641 ) -> DispatchResult {1642 let collection_id = collection.id;16431644 // check token limit and account token limit1645 collection.consume_sload()?;1646 let account_items: u32 =1647 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;16481649 // zero limit means collection limit is disabled1650 // otherwise get lower value1651 let limit = if collection.limits.account_token_ownership_limit == 01652 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1653 {1654 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1655 } else {1656 collection.limits.account_token_ownership_limit1657 };16581659 ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16601661 // preliminary transfer check1662 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16631664 Ok(())1665 }16661667 fn can_create_items_in_collection(1668 collection: &CollectionHandle<T>,1669 sender: &T::CrossAccountId,1670 owner: &T::CrossAccountId,1671 amount: u32,1672 ) -> DispatchResult {1673 let collection_id = collection.id;16741675 // check token limit and account token limit1676 let total_items: u32 = ItemListIndex::get(collection_id)1677 .checked_add(amount)1678 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1679 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1680 as u32)1681 .checked_add(amount)1682 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;16831684 // zero limit means collection limit is disabled1685 // otherwise get lower value1686 let account_token_limit = if collection.limits.account_token_ownership_limit == 01687 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1688 {1689 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1690 } else {1691 collection.limits.account_token_ownership_limit1692 };16931694 ensure!(1695 collection.limits.token_limit >= total_items,1696 Error::<T>::CollectionTokenLimitExceeded1697 );1698 ensure!(1699 account_token_limit >= account_items,1700 Error::<T>::AccountTokenLimitExceeded1701 );17021703 if !Self::is_owner_or_admin_permissions(collection, sender)? {1704 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1705 Self::check_white_list(collection, owner)?;1706 Self::check_white_list(collection, sender)?;1707 }17081709 Ok(())1710 }17111712 fn validate_create_item_args(1713 target_collection: &CollectionHandle<T>,1714 data: &CreateItemData,1715 ) -> DispatchResult {1716 match target_collection.mode {1717 CollectionMode::NFT => {1718 if !matches!(data, CreateItemData::NFT(_)) {1719 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1720 }1721 }1722 CollectionMode::Fungible(_) => {1723 if !matches!(data, CreateItemData::Fungible(_)) {1724 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1725 }1726 }1727 CollectionMode::ReFungible => {1728 if let CreateItemData::ReFungible(data) = data {1729 // Check refungibility limits1730 ensure!(1731 data.pieces <= MAX_REFUNGIBLE_PIECES,1732 Error::<T>::WrongRefungiblePieces1733 );1734 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1735 } else {1736 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1737 }1738 }1739 };17401741 Ok(())1742 }17431744 fn create_item_no_validation(1745 collection: &CollectionHandle<T>,1746 owner: &T::CrossAccountId,1747 data: CreateItemData,1748 ) -> DispatchResult {1749 match data {1750 CreateItemData::NFT(data) => {1751 let item = NftItemType {1752 owner: owner.clone(),1753 const_data: data.const_data.into_inner(),1754 variable_data: data.variable_data.into_inner(),1755 };17561757 Self::add_nft_item(collection, item)?;1758 }1759 CreateItemData::Fungible(data) => {1760 Self::add_fungible_item(collection, owner, data.value)?;1761 }1762 CreateItemData::ReFungible(data) => {1763 let owner_list = vec![Ownership {1764 owner: owner.clone(),1765 fraction: data.pieces,1766 }];17671768 let item = ReFungibleItemType {1769 owner: owner_list,1770 const_data: data.const_data.into_inner(),1771 variable_data: data.variable_data.into_inner(),1772 };17731774 Self::add_refungible_item(collection, item)?;1775 }1776 };17771778 Ok(())1779 }17801781 fn add_fungible_item(1782 collection: &CollectionHandle<T>,1783 owner: &T::CrossAccountId,1784 value: u128,1785 ) -> DispatchResult {1786 let collection_id = collection.id;17871788 // Does new owner already have an account?1789 collection.consume_sload()?;1790 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17911792 // Mint1793 let item = FungibleItemType {1794 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1795 };1796 collection.consume_sstore()?;1797 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17981799 // Update balance1800 collection.consume_sload()?;1801 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1802 .checked_add(value)1803 .ok_or(Error::<T>::NumOverflow)?;1804 collection.consume_sstore()?;1805 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18061807 collection.log(ERC20Events::Transfer {1808 from: H160::default(),1809 to: *owner.as_eth(),1810 value: value.into(),1811 })?;1812 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1813 Ok(())1814 }18151816 fn add_refungible_item(1817 collection: &CollectionHandle<T>,1818 item: ReFungibleItemType<T::CrossAccountId>,1819 ) -> DispatchResult {1820 let collection_id = collection.id;18211822 let current_index = <ItemListIndex>::get(collection_id)1823 .checked_add(1)1824 .ok_or(Error::<T>::NumOverflow)?;1825 let itemcopy = item.clone();18261827 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1828 let item_owner = item.owner.first().expect("only one owner is defined");18291830 let value = item_owner.fraction;1831 let owner = item_owner.owner.clone();18321833 Self::add_token_index(collection, current_index, &owner)?;18341835 <ItemListIndex>::insert(collection_id, current_index);1836 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18371838 // Update balance1839 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1840 .checked_add(value)1841 .ok_or(Error::<T>::NumOverflow)?;1842 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18431844 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1845 Ok(())1846 }18471848 fn add_nft_item(1849 collection: &CollectionHandle<T>,1850 item: NftItemType<T::CrossAccountId>,1851 ) -> DispatchResult {1852 let collection_id = collection.id;18531854 let current_index = <ItemListIndex>::get(collection_id)1855 .checked_add(1)1856 .ok_or(Error::<T>::NumOverflow)?;18571858 let item_owner = item.owner.clone();1859 Self::add_token_index(collection, current_index, &item.owner)?;18601861 <ItemListIndex>::insert(collection_id, current_index);1862 <NftItemList<T>>::insert(collection_id, current_index, item);18631864 // Update balance1865 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1866 .checked_add(1)1867 .ok_or(Error::<T>::NumOverflow)?;1868 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18691870 collection.log(ERC721Events::Transfer {1871 from: H160::default(),1872 to: *item_owner.as_eth(),1873 token_id: current_index.into(),1874 })?;1875 Self::deposit_event(RawEvent::ItemCreated(1876 collection_id,1877 current_index,1878 item_owner,1879 ));1880 Ok(())1881 }18821883 fn burn_refungible_item(1884 collection: &CollectionHandle<T>,1885 item_id: TokenId,1886 owner: &T::CrossAccountId,1887 ) -> DispatchResult {1888 let collection_id = collection.id;18891890 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1891 .ok_or(Error::<T>::TokenNotFound)?;1892 let rft_balance = token1893 .owner1894 .iter()1895 .find(|&i| i.owner == *owner)1896 .ok_or(Error::<T>::TokenNotFound)?;1897 Self::remove_token_index(collection, item_id, owner)?;18981899 // update balance1900 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1901 .checked_sub(rft_balance.fraction)1902 .ok_or(Error::<T>::NumOverflow)?;1903 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19041905 // Re-create owners list with sender removed1906 let index = token1907 .owner1908 .iter()1909 .position(|i| i.owner == *owner)1910 .expect("owned item is exists");1911 token.owner.remove(index);1912 let owner_count = token.owner.len();19131914 // Burn the token completely if this was the last (only) owner1915 if owner_count == 0 {1916 <ReFungibleItemList<T>>::remove(collection_id, item_id);1917 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1918 } else {1919 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1920 }19211922 Ok(())1923 }19241925 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1926 let collection_id = collection.id;19271928 let item =1929 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1930 Self::remove_token_index(collection, item_id, &item.owner)?;19311932 // update balance1933 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1934 .checked_sub(1)1935 .ok_or(Error::<T>::NumOverflow)?;1936 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1937 <NftItemList<T>>::remove(collection_id, item_id);1938 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);19391940 collection.log(ERC721Events::Transfer {1941 from: *item.owner.as_eth(),1942 to: H160::default(),1943 token_id: item_id.into(),1944 })?;1945 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1946 Ok(())1947 }19481949 fn burn_fungible_item(1950 owner: &T::CrossAccountId,1951 collection: &CollectionHandle<T>,1952 value: u128,1953 ) -> DispatchResult {1954 let collection_id = collection.id;19551956 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1957 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19581959 // update balance1960 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1961 .checked_sub(value)1962 .ok_or(Error::<T>::NumOverflow)?;1963 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19641965 if balance.value - value > 0 {1966 balance.value -= value;1967 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1968 } else {1969 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1970 }19711972 collection.log(ERC20Events::Transfer {1973 from: *owner.as_eth(),1974 to: H160::default(),1975 value: value.into(),1976 })?;1977 Ok(())1978 }19791980 pub fn get_collection(1981 collection_id: CollectionId,1982 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1983 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1984 }19851986 fn check_owner_permissions(1987 target_collection: &CollectionHandle<T>,1988 subject: &T::AccountId,1989 ) -> DispatchResult {1990 ensure!(1991 *subject == target_collection.owner,1992 Error::<T>::NoPermission1993 );19941995 Ok(())1996 }19971998 fn is_owner_or_admin_permissions(1999 collection: &CollectionHandle<T>,2000 subject: &T::CrossAccountId,2001 ) -> Result<bool, DispatchError> {2002 collection.consume_sload()?;2003 Ok(*subject.as_sub() == collection.owner2004 || <AdminList<T>>::get(collection.id).contains(subject))2005 }20062007 fn check_owner_or_admin_permissions(2008 collection: &CollectionHandle<T>,2009 subject: &T::CrossAccountId,2010 ) -> DispatchResult {2011 ensure!(2012 Self::is_owner_or_admin_permissions(collection, subject)?,2013 Error::<T>::NoPermission2014 );20152016 Ok(())2017 }20182019 fn owned_amount(2020 subject: &T::CrossAccountId,2021 collection: &CollectionHandle<T>,2022 item_id: TokenId,2023 ) -> Result<Option<u128>, DispatchError> {2024 collection.consume_sload()?;2025 Ok(Self::owned_amount_unchecked(subject, collection, item_id))2026 }20272028 fn owned_amount_unchecked(2029 subject: &T::CrossAccountId,2030 target_collection: &CollectionHandle<T>,2031 item_id: TokenId,2032 ) -> Option<u128> {2033 let collection_id = target_collection.id;20342035 match target_collection.mode {2036 CollectionMode::NFT => {2037 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2038 }2039 CollectionMode::Fungible(_) => {2040 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2041 }2042 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2043 .owner2044 .iter()2045 .find(|i| i.owner == *subject)2046 .map(|i| i.fraction),2047 }2048 }20492050 fn is_item_owner(2051 subject: &T::CrossAccountId,2052 target_collection: &CollectionHandle<T>,2053 item_id: TokenId,2054 ) -> Result<bool, DispatchError> {2055 Ok(match target_collection.mode {2056 CollectionMode::Fungible(_) => true,2057 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2058 })2059 }20602061 fn check_white_list(2062 collection: &CollectionHandle<T>,2063 address: &T::CrossAccountId,2064 ) -> DispatchResult {2065 collection.consume_sload()?;2066 ensure!(2067 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2068 Error::<T>::AddresNotInWhiteList,2069 );2070 Ok(())2071 }20722073 /// Check if token exists. In case of Fungible, check if there is an entry for2074 /// the owner in fungible balances double map2075 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2076 let collection_id = target_collection.id;2077 let exists = match target_collection.mode {2078 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2079 CollectionMode::Fungible(_) => true,2080 CollectionMode::ReFungible => {2081 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2082 }2083 };20842085 ensure!(exists, Error::<T>::TokenNotFound);2086 Ok(())2087 }20882089 fn transfer_fungible(2090 collection: &CollectionHandle<T>,2091 value: u128,2092 owner: &T::CrossAccountId,2093 recipient: &T::CrossAccountId,2094 ) -> DispatchResult {2095 let collection_id = collection.id;20962097 collection.consume_sload()?;2098 collection.consume_sload()?;2099 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2100 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21012102 recipient_balance.value = recipient_balance2103 .value2104 .checked_add(value)2105 .ok_or(Error::<T>::NumOverflow)?;2106 balance.value = balance2107 .value2108 .checked_sub(value)2109 .ok_or(Error::<T>::TokenValueTooLow)?;21102111 // update balanceOf2112 collection.consume_sstore()?;2113 collection.consume_sstore()?;2114 if balance.value != 0 {2115 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2116 } else {2117 <Balance<T>>::remove(collection_id, owner.as_sub());2118 }2119 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21202121 // Reduce or remove sender2122 collection.consume_sstore()?;2123 collection.consume_sstore()?;2124 if balance.value != 0 {2125 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2126 } else {2127 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2128 }2129 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21302131 collection.log(ERC20Events::Transfer {2132 from: *owner.as_eth(),2133 to: *recipient.as_eth(),2134 value: value.into(),2135 })?;2136 Self::deposit_event(RawEvent::Transfer(2137 collection.id,2138 1,2139 owner.clone(),2140 recipient.clone(),2141 value,2142 ));21432144 Ok(())2145 }21462147 fn transfer_refungible(2148 collection: &CollectionHandle<T>,2149 item_id: TokenId,2150 value: u128,2151 owner: T::CrossAccountId,2152 new_owner: T::CrossAccountId,2153 ) -> DispatchResult {2154 let collection_id = collection.id;2155 collection.consume_sload()?;2156 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2157 .ok_or(Error::<T>::TokenNotFound)?;21582159 let item = full_item2160 .owner2161 .iter()2162 .find(|i| i.owner == owner)2163 .ok_or(Error::<T>::TokenNotFound)?;2164 let amount = item.fraction;21652166 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21672168 collection.consume_sload()?;2169 // update balance2170 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2171 .checked_sub(value)2172 .ok_or(Error::<T>::NumOverflow)?;2173 collection.consume_sstore()?;2174 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21752176 collection.consume_sload()?;2177 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2178 .checked_add(value)2179 .ok_or(Error::<T>::NumOverflow)?;2180 collection.consume_sstore()?;2181 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21822183 let old_owner = item.owner.clone();2184 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21852186 let mut new_full_item = full_item.clone();2187 // transfer2188 if amount == value && !new_owner_has_account {2189 // change owner2190 // new owner do not have account2191 new_full_item2192 .owner2193 .iter_mut()2194 .find(|i| i.owner == owner)2195 .expect("old owner does present in refungible")2196 .owner = new_owner.clone();2197 collection.consume_sstore()?;2198 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21992200 // update index collection2201 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2202 } else {2203 new_full_item2204 .owner2205 .iter_mut()2206 .find(|i| i.owner == owner)2207 .expect("old owner does present in refungible")2208 .fraction -= value;22092210 // separate amount2211 if new_owner_has_account {2212 // new owner has account2213 new_full_item2214 .owner2215 .iter_mut()2216 .find(|i| i.owner == new_owner)2217 .expect("new owner has account")2218 .fraction += value;2219 } else {2220 // new owner do not have account2221 new_full_item.owner.push(Ownership {2222 owner: new_owner.clone(),2223 fraction: value,2224 });2225 Self::add_token_index(collection, item_id, &new_owner)?;2226 }22272228 collection.consume_sstore()?;2229 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2230 }22312232 Self::deposit_event(RawEvent::Transfer(2233 collection.id,2234 item_id,2235 owner,2236 new_owner,2237 amount,2238 ));22392240 Ok(())2241 }22422243 fn transfer_nft(2244 collection: &CollectionHandle<T>,2245 item_id: TokenId,2246 sender: T::CrossAccountId,2247 new_owner: T::CrossAccountId,2248 ) -> DispatchResult {2249 let collection_id = collection.id;2250 collection.consume_sload()?;2251 let mut item =2252 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22532254 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22552256 collection.consume_sload()?;2257 // update balance2258 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2259 .checked_sub(1)2260 .ok_or(Error::<T>::NumOverflow)?;2261 collection.consume_sstore()?;2262 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22632264 collection.consume_sload()?;2265 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2266 .checked_add(1)2267 .ok_or(Error::<T>::NumOverflow)?;2268 collection.consume_sstore()?;2269 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22702271 // change owner2272 let old_owner = item.owner.clone();2273 item.owner = new_owner.clone();2274 collection.consume_sstore()?;2275 <NftItemList<T>>::insert(collection_id, item_id, item);22762277 // update index collection2278 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22792280 collection.log(ERC721Events::Transfer {2281 from: *sender.as_eth(),2282 to: *new_owner.as_eth(),2283 token_id: item_id.into(),2284 })?;2285 Self::deposit_event(RawEvent::Transfer(2286 collection.id,2287 item_id,2288 sender,2289 new_owner,2290 1,2291 ));22922293 Ok(())2294 }22952296 fn set_re_fungible_variable_data(2297 collection: &CollectionHandle<T>,2298 item_id: TokenId,2299 data: Vec<u8>,2300 ) -> DispatchResult {2301 let collection_id = collection.id;2302 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2303 .ok_or(Error::<T>::TokenNotFound)?;23042305 item.variable_data = data;23062307 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23082309 Ok(())2310 }23112312 fn set_nft_variable_data(2313 collection: &CollectionHandle<T>,2314 item_id: TokenId,2315 data: Vec<u8>,2316 ) -> DispatchResult {2317 let collection_id = collection.id;2318 let mut item =2319 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23202321 item.variable_data = data;23222323 <NftItemList<T>>::insert(collection_id, item_id, item);23242325 Ok(())2326 }23272328 #[allow(dead_code)]2329 fn init_collection(item: &Collection<T>) {2330 // check params2331 assert!(2332 item.decimal_points <= MAX_DECIMAL_POINTS,2333 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2334 );2335 assert!(2336 item.name.len() <= 64,2337 "Collection name can not be longer than 63 char"2338 );2339 assert!(2340 item.name.len() <= 256,2341 "Collection description can not be longer than 255 char"2342 );2343 assert!(2344 item.token_prefix.len() <= 16,2345 "Token prefix can not be longer than 15 char"2346 );23472348 // Generate next collection ID2349 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23502351 CreatedCollectionCount::put(next_id);2352 }23532354 #[allow(dead_code)]2355 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2356 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23572358 Self::add_token_index(2359 &CollectionHandle::get(collection_id).unwrap(),2360 current_index,2361 &item.owner,2362 )2363 .unwrap();23642365 <ItemListIndex>::insert(collection_id, current_index);23662367 // Update balance2368 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2369 .checked_add(1)2370 .unwrap();2371 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2372 }23732374 #[allow(dead_code)]2375 fn init_fungible_token(2376 collection_id: CollectionId,2377 owner: &T::CrossAccountId,2378 item: &FungibleItemType,2379 ) {2380 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23812382 Self::add_token_index(2383 &CollectionHandle::get(collection_id).unwrap(),2384 current_index,2385 owner,2386 )2387 .unwrap();23882389 <ItemListIndex>::insert(collection_id, current_index);23902391 // Update balance2392 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2393 .checked_add(item.value)2394 .unwrap();2395 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2396 }23972398 #[allow(dead_code)]2399 fn init_refungible_token(2400 collection_id: CollectionId,2401 item: &ReFungibleItemType<T::CrossAccountId>,2402 ) {2403 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24042405 let value = item.owner.first().unwrap().fraction;2406 let owner = item.owner.first().unwrap().owner.clone();24072408 Self::add_token_index(2409 &CollectionHandle::get(collection_id).unwrap(),2410 current_index,2411 &owner,2412 )2413 .unwrap();24142415 <ItemListIndex>::insert(collection_id, current_index);24162417 // Update balance2418 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2419 .checked_add(value)2420 .unwrap();2421 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2422 }24232424 fn add_token_index(2425 collection: &CollectionHandle<T>,2426 item_index: TokenId,2427 owner: &T::CrossAccountId,2428 ) -> DispatchResult {2429 collection.consume_sload()?;2430 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2431 if list_exists {2432 collection.consume_sload()?;2433 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24342435 // bound Owned tokens by a single address in collection2436 let account_items: u32 = list.len() as u32;2437 ensure!(2438 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2439 Error::<T>::AddressOwnershipLimitExceeded2440 );24412442 let item_contains = list.contains(&item_index.clone());24432444 if !item_contains {2445 list.push(item_index);2446 }24472448 collection.consume_sstore()?;2449 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2450 } else {2451 let itm = vec![item_index];2452 collection.consume_sstore()?;2453 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2454 }24552456 Ok(())2457 }24582459 fn remove_token_index(2460 collection: &CollectionHandle<T>,2461 item_index: TokenId,2462 owner: &T::CrossAccountId,2463 ) -> DispatchResult {2464 collection.consume_sload()?;2465 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2466 if list_exists {2467 collection.consume_sload()?;2468 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2469 let item_contains = list.contains(&item_index.clone());24702471 if item_contains {2472 list.retain(|&item| item != item_index);2473 collection.consume_sstore()?;2474 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2475 }2476 }24772478 Ok(())2479 }24802481 fn move_token_index(2482 collection: &CollectionHandle<T>,2483 item_index: TokenId,2484 old_owner: &T::CrossAccountId,2485 new_owner: &T::CrossAccountId,2486 ) -> DispatchResult {2487 Self::remove_token_index(collection, item_index, old_owner)?;2488 Self::add_token_index(collection, item_index, new_owner)?;24892490 Ok(())2491 }2492}24932494sp_api::decl_runtime_apis! {2495 pub trait NftApi {2496 /// Used for ethereum integration2497 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2498 }2499}1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9 clippy::too_many_arguments,10 clippy::unnecessary_mut_passed,11 clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue, transactional,32};3334use frame_system::{self as system, ensure_signed};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41 CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42 VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43 OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44 MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45 CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46 MetaUpdatePermission, FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70 /// Error for non-fungible-token module.71 pub enum Error for Module<T: Config> {72 /// Total collections bound exceeded.73 TotalCollectionsLimitExceeded,74 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.75 CollectionDecimalPointLimitExceeded,76 /// Collection name can not be longer than 63 char.77 CollectionNameLimitExceeded,78 /// Collection description can not be longer than 255 char.79 CollectionDescriptionLimitExceeded,80 /// Token prefix can not be longer than 15 char.81 CollectionTokenPrefixLimitExceeded,82 /// This collection does not exist.83 CollectionNotFound,84 /// Item not exists.85 TokenNotFound,86 /// Admin not found87 AdminNotFound,88 /// Arithmetic calculation overflow.89 NumOverflow,90 /// Account already has admin role.91 AlreadyAdmin,92 /// You do not own this collection.93 NoPermission,94 /// This address is not set as sponsor, use setCollectionSponsor first.95 ConfirmUnsetSponsorFail,96 /// Collection is not in mint mode.97 PublicMintingNotAllowed,98 /// Sender parameter and item owner must be equal.99 MustBeTokenOwner,100 /// Item balance not enough.101 TokenValueTooLow,102 /// Size of item is too large.103 NftSizeLimitExceeded,104 /// No approve found105 ApproveNotFound,106 /// Requested value more than approved.107 TokenValueNotEnough,108 /// Only approved addresses can call this method.109 ApproveRequired,110 /// Address is not in white list.111 AddresNotInWhiteList,112 /// Number of collection admins bound exceeded.113 CollectionAdminsLimitExceeded,114 /// Owned tokens by a single address bound exceeded.115 AddressOwnershipLimitExceeded,116 /// Length of items properties must be greater than 0.117 EmptyArgument,118 /// const_data exceeded data limit.119 TokenConstDataLimitExceeded,120 /// variable_data exceeded data limit.121 TokenVariableDataLimitExceeded,122 /// Not NFT item data used to mint in NFT collection.123 NotNftDataUsedToMintNftCollectionToken,124 /// Not Fungible item data used to mint in Fungible collection.125 NotFungibleDataUsedToMintFungibleCollectionToken,126 /// Not Re Fungible item data used to mint in Re Fungible collection.127 NotReFungibleDataUsedToMintReFungibleCollectionToken,128 /// Unexpected collection type.129 UnexpectedCollectionType,130 /// Can't store metadata in fungible tokens.131 CantStoreMetadataInFungibleTokens,132 /// Collection token limit exceeded133 CollectionTokenLimitExceeded,134 /// Account token limit exceeded per collection135 AccountTokenLimitExceeded,136 /// Collection limit bounds per collection exceeded137 CollectionLimitBoundsExceeded,138 /// Tried to enable permissions which are only permitted to be disabled139 OwnerPermissionsCantBeReverted,140 /// Schema data size limit bound exceeded141 SchemaDataLimitExceeded,142 /// Maximum refungibility exceeded143 WrongRefungiblePieces,144 /// createRefungible should be called with one owner145 BadCreateRefungibleCall,146 /// Gas limit exceeded147 OutOfGas,148 /// Metadata update denied by collection settings149 MetadataUpdateDenied,150 /// Metadata update flag become unmutable with None option151 MetadataFlagFrozen,152 /// Collection settings not allowing items transferring153 TransferNotAllowed,154 /// Can't transfer tokens to ethereum zero address155 AddressIsZero,156 }157}158159#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]160pub struct CollectionHandle<T: Config> {161 pub id: CollectionId,162 collection: Collection<T>,163 recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,164}165impl<T: Config> CollectionHandle<T> {166 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {167 <CollectionById<T>>::get(id).map(|collection| Self {168 id,169 collection,170 recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(171 eth::collection_id_to_address(id),172 gas_limit,173 ),174 })175 }176 pub fn get(id: CollectionId) -> Option<Self> {177 Self::get_with_gas_limit(id, u64::MAX)178 }179 pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {180 self.recorder.log_sub(log)181 }182 #[allow(dead_code)]183 fn consume_gas(&self, gas: u64) -> DispatchResult {184 self.recorder.consume_gas_sub(gas)185 }186 fn consume_sload(&self) -> DispatchResult {187 self.recorder.consume_sload_sub()188 }189 fn consume_sstore(&self) -> DispatchResult {190 self.recorder.consume_sstore_sub()191 }192 pub fn submit_logs(self) -> DispatchResult {193 self.recorder.submit_logs()194 }195 pub fn save(self) -> DispatchResult {196 self.recorder.submit_logs()?;197 <CollectionById<T>>::insert(self.id, self.collection);198 Ok(())199 }200}201impl<T: Config> Deref for CollectionHandle<T> {202 type Target = Collection<T>;203204 fn deref(&self) -> &Self::Target {205 &self.collection206 }207}208209impl<T: Config> DerefMut for CollectionHandle<T> {210 fn deref_mut(&mut self) -> &mut Self::Target {211 &mut self.collection212 }213}214215pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {216 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;217218 /// Weight information for extrinsics in this pallet.219 type WeightInfo: WeightInfo;220221 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;222 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;223224 type CrossAccountId: CrossAccountId<Self::AccountId>;225 type Currency: Currency<Self::AccountId>;226 type CollectionCreationPrice: Get<227 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,228 >;229 type TreasuryAccountId: Get<Self::AccountId>;230}231232type SelfWeightOf<T> = <T as Config>::WeightInfo;233234trait WeightInfoHelpers: WeightInfo {235 fn transfer() -> Weight {236 Self::transfer_nft()237 .max(Self::transfer_fungible())238 .max(Self::transfer_refungible())239 }240 fn transfer_from() -> Weight {241 Self::transfer_from_nft()242 .max(Self::transfer_from_fungible())243 .max(Self::transfer_from_refungible())244 }245 fn approve() -> Weight {246 // TODO: refungible, fungible247 Self::approve_nft()248 }249 fn set_variable_meta_data(data: u32) -> Weight {250 // TODO: refungible251 Self::set_variable_meta_data_nft(data)252 }253 fn create_item(data: u32) -> Weight {254 Self::create_item_nft(data)255 .max(Self::create_item_fungible())256 .max(Self::create_item_refungible(data))257 }258 fn create_multiple_items(amount: u32) -> Weight {259 Self::create_multiple_items_nft(amount)260 .max(Self::create_multiple_items_fungible(amount))261 .max(Self::create_multiple_items_refungible(amount))262 }263 fn burn_item() -> Weight {264 // TODO: refungible, fungible265 Self::burn_item_nft()266 }267}268impl<T: WeightInfo> WeightInfoHelpers for T {}269270// # Used definitions271//272// ## User control levels273//274// chain-controlled - key is uncontrolled by user275// i.e autoincrementing index276// can use non-cryptographic hash277// real - key is controlled by user278// but it is hard to generate enough colliding values, i.e owner of signed txs279// can use non-cryptographic hash280// controlled - key is completly controlled by users281// i.e maps with mutable keys282// should use cryptographic hash283//284// ## User control level downgrade reasons285//286// ?1 - chain-controlled -> controlled287// collections/tokens can be destroyed, resulting in massive holes288// ?2 - chain-controlled -> controlled289// same as ?1, but can be only added, resulting in easier exploitation290// ?3 - real -> controlled291// no confirmation required, so addresses can be easily generated292decl_storage! {293 trait Store for Module<T: Config> as Nft {294295 //#region Private members296 /// Id of next collection297 CreatedCollectionCount: u32;298 /// Used for migrations299 ChainVersion: u64;300 /// Id of last collection token301 /// Collection id (controlled?1)302 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;303 //#endregion304305 //#region Bound counters306 /// Amount of collections destroyed, used for total amount tracking with307 /// CreatedCollectionCount308 DestroyedCollectionCount: u32;309 //#endregion310311 //#region Basic collections312 /// Collection info313 /// Collection id (controlled?1)314 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;315 /// List of collection admins316 /// Collection id (controlled?2)317 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;318 /// Whitelisted collection users319 /// Collection id (controlled?2), user id (controlled?3)320 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;321 //#endregion322323 /// How many of collection items user have324 /// Collection id (controlled?2), account id (real)325 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;326327 /// Amount of items which spender can transfer out of owners account (via transferFrom)328 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))329 /// TODO: Off chain worker should remove from this map when token gets removed330 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;331332 //#region Item collections333 /// Collection id (controlled?2), token id (controlled?1)334 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;335 /// Collection id (controlled?2), owner (controlled?2)336 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;337 /// Collection id (controlled?2), token id (controlled?1)338 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;339 //#endregion340341 //#region Index list342 /// Collection id (controlled?2), tokens owner (controlled?2)343 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;344 //#endregion345346 //#region Tokens transfer rate limit baskets347 /// (Collection id (controlled?2), who created (real))348 /// TODO: Off chain worker should remove from this map when collection gets removed349 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;350 /// Collection id (controlled?2), token id (controlled?2)351 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;352 /// Collection id (controlled?2), owning user (real)353 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;354 /// Collection id (controlled?2), token id (controlled?2)355 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;356 //#endregion357358 /// Variable metadata sponsoring359 /// Collection id (controlled?2), token id (controlled?2)360 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;361 }362 add_extra_genesis {363 build(|config: &GenesisConfig<T>| {364 // Modification of storage365 for (_num, _c) in &config.collection_id {366 <Module<T>>::init_collection(_c);367 }368369 for (_num, _c, _i) in &config.nft_item_id {370 <Module<T>>::init_nft_token(*_c, _i);371 }372373 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {374 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);375 }376377 for (_num, _c, _i) in &config.refungible_item_id {378 <Module<T>>::init_refungible_token(*_c, _i);379 }380 })381 }382}383384decl_event!(385 pub enum Event<T>386 where387 AccountId = <T as frame_system::Config>::AccountId,388 CrossAccountId = <T as Config>::CrossAccountId,389 {390 /// New collection was created391 ///392 /// # Arguments393 ///394 /// * collection_id: Globally unique identifier of newly created collection.395 ///396 /// * mode: [CollectionMode] converted into u8.397 ///398 /// * account_id: Collection owner.399 CollectionCreated(CollectionId, u8, AccountId),400401 /// New item was created.402 ///403 /// # Arguments404 ///405 /// * collection_id: Id of the collection where item was created.406 ///407 /// * item_id: Id of an item. Unique within the collection.408 ///409 /// * recipient: Owner of newly created item410 ItemCreated(CollectionId, TokenId, CrossAccountId),411412 /// Collection item was burned.413 ///414 /// # Arguments415 ///416 /// collection_id.417 ///418 /// item_id: Identifier of burned NFT.419 ItemDestroyed(CollectionId, TokenId),420421 /// Item was transferred422 ///423 /// * collection_id: Id of collection to which item is belong424 ///425 /// * item_id: Id of an item426 ///427 /// * sender: Original owner of item428 ///429 /// * recipient: New owner of item430 ///431 /// * amount: Always 1 for NFT432 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),433434 /// * collection_id435 ///436 /// * item_id437 ///438 /// * sender439 ///440 /// * spender441 ///442 /// * amount443 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),444 }445);446447decl_module! {448 pub struct Module<T: Config> for enum Call449 where450 origin: T::Origin451 {452 fn deposit_event() = default;453 const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;454 type Error = Error<T>;455456 fn on_initialize(_now: T::BlockNumber) -> Weight {457 0458 }459460 /// 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.461 ///462 /// # Permissions463 ///464 /// * Anyone.465 ///466 /// # Arguments467 ///468 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.469 ///470 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.471 ///472 /// * token_prefix: UTF-8 string with token prefix.473 ///474 /// * mode: [CollectionMode] collection type and type dependent data.475 // returns collection ID476 #[weight = <SelfWeightOf<T>>::create_collection()]477 #[transactional]478 pub fn create_collection(origin,479 collection_name: Vec<u16>,480 collection_description: Vec<u16>,481 token_prefix: Vec<u8>,482 mode: CollectionMode) -> DispatchResult {483484 // Anyone can create a collection485 let who = ensure_signed(origin)?;486487 // Take a (non-refundable) deposit of collection creation488 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();489 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(490 &T::TreasuryAccountId::get(),491 T::CollectionCreationPrice::get(),492 ));493 <T as Config>::Currency::settle(494 &who,495 imbalance,496 WithdrawReasons::TRANSFER,497 ExistenceRequirement::KeepAlive,498 ).map_err(|_| Error::<T>::NoPermission)?;499500 let decimal_points = match mode {501 CollectionMode::Fungible(points) => points,502 _ => 0503 };504505 let created_count = CreatedCollectionCount::get();506 let destroyed_count = DestroyedCollectionCount::get();507508 // bound Total number of collections509 ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);510511 // check params512 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);513 ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);514 ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);515 ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);516517 // Generate next collection ID518 let next_id = created_count519 .checked_add(1)520 .ok_or(Error::<T>::NumOverflow)?;521522 CreatedCollectionCount::put(next_id);523524 let limits = CollectionLimits {525 sponsored_data_size: CUSTOM_DATA_LIMIT,526 ..Default::default()527 };528529 // Create new collection530 let new_collection = Collection {531 owner: who.clone(),532 name: collection_name,533 mode: mode.clone(),534 mint_mode: false,535 access: AccessMode::Normal,536 description: collection_description,537 decimal_points,538 token_prefix,539 offchain_schema: Vec::new(),540 schema_version: SchemaVersion::ImageURL,541 sponsorship: SponsorshipState::Disabled,542 variable_on_chain_schema: Vec::new(),543 const_on_chain_schema: Vec::new(),544 limits,545 meta_update_permission: MetaUpdatePermission::default(),546 transfers_enabled: true,547 };548549 // Add new collection to map550 <CollectionById<T>>::insert(next_id, new_collection);551552 // call event553 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));554555 Ok(())556 }557558 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.559 ///560 /// # Permissions561 ///562 /// * Collection Owner.563 ///564 /// # Arguments565 ///566 /// * collection_id: collection to destroy.567 #[weight = <SelfWeightOf<T>>::destroy_collection()]568 #[transactional]569 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {570571 let sender = ensure_signed(origin)?;572 let collection = Self::get_collection(collection_id)?;573 Self::check_owner_permissions(&collection, &sender)?;574 if !collection.limits.owner_can_destroy {575 fail!(Error::<T>::NoPermission);576 }577578 <AddressTokens<T>>::remove_prefix(collection_id, None);579 <Allowances<T>>::remove_prefix(collection_id, None);580 <Balance<T>>::remove_prefix(collection_id, None);581 <ItemListIndex>::remove(collection_id);582 <AdminList<T>>::remove(collection_id);583 <CollectionById<T>>::remove(collection_id);584 <WhiteList<T>>::remove_prefix(collection_id, None);585586 <NftItemList<T>>::remove_prefix(collection_id, None);587 <FungibleItemList<T>>::remove_prefix(collection_id, None);588 <ReFungibleItemList<T>>::remove_prefix(collection_id, None);589590 <NftTransferBasket<T>>::remove_prefix(collection_id, None);591 <FungibleTransferBasket<T>>::remove_prefix(collection_id, None);592 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);593594 <VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);595596 DestroyedCollectionCount::put(DestroyedCollectionCount::get()597 .checked_add(1)598 .ok_or(Error::<T>::NumOverflow)?);599600 Ok(())601 }602603 /// Add an address to white list.604 ///605 /// # Permissions606 ///607 /// * Collection Owner608 /// * Collection Admin609 ///610 /// # Arguments611 ///612 /// * collection_id.613 ///614 /// * address.615 #[weight = <SelfWeightOf<T>>::add_to_white_list()]616 #[transactional]617 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{618619 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);620 let collection = Self::get_collection(collection_id)?;621622 Self::toggle_white_list_internal(623 &sender,624 &collection,625 &address,626 true,627 )?;628629 Ok(())630 }631632 /// Remove an address from white list.633 ///634 /// # Permissions635 ///636 /// * Collection Owner637 /// * Collection Admin638 ///639 /// # Arguments640 ///641 /// * collection_id.642 ///643 /// * address.644 #[weight = <SelfWeightOf<T>>::remove_from_white_list()]645 #[transactional]646 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{647648 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);649 let collection = Self::get_collection(collection_id)?;650651 Self::toggle_white_list_internal(652 &sender,653 &collection,654 &address,655 false,656 )?;657658 Ok(())659 }660661 /// Toggle between normal and white list access for the methods with access for `Anyone`.662 ///663 /// # Permissions664 ///665 /// * Collection Owner.666 ///667 /// # Arguments668 ///669 /// * collection_id.670 ///671 /// * mode: [AccessMode]672 #[weight = <SelfWeightOf<T>>::set_public_access_mode()]673 #[transactional]674 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult675 {676 let sender = ensure_signed(origin)?;677678 let mut target_collection = Self::get_collection(collection_id)?;679 Self::check_owner_permissions(&target_collection, &sender)?;680 target_collection.access = mode;681 target_collection.save()682 }683684 /// Allows Anyone to create tokens if:685 /// * White List is enabled, and686 /// * Address is added to white list, and687 /// * This method was called with True parameter688 ///689 /// # Permissions690 /// * Collection Owner691 ///692 /// # Arguments693 ///694 /// * collection_id.695 ///696 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.697 #[weight = <SelfWeightOf<T>>::set_mint_permission()]698 #[transactional]699 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult700 {701 let sender = ensure_signed(origin)?;702703 let mut target_collection = Self::get_collection(collection_id)?;704 Self::check_owner_permissions(&target_collection, &sender)?;705 target_collection.mint_mode = mint_permission;706 target_collection.save()707 }708709 /// Change the owner of the collection.710 ///711 /// # Permissions712 ///713 /// * Collection Owner.714 ///715 /// # Arguments716 ///717 /// * collection_id.718 ///719 /// * new_owner.720 #[weight = <SelfWeightOf<T>>::change_collection_owner()]721 #[transactional]722 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {723724 let sender = ensure_signed(origin)?;725 let mut target_collection = Self::get_collection(collection_id)?;726 Self::check_owner_permissions(&target_collection, &sender)?;727 target_collection.owner = new_owner;728 target_collection.save()729 }730731 /// Adds an admin of the Collection.732 /// 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.733 ///734 /// # Permissions735 ///736 /// * Collection Owner.737 /// * Collection Admin.738 ///739 /// # Arguments740 ///741 /// * collection_id: ID of the Collection to add admin for.742 ///743 /// * new_admin_id: Address of new admin to add.744 #[weight = <SelfWeightOf<T>>::add_collection_admin()]745 #[transactional]746 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {747 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);748 let collection = Self::get_collection(collection_id)?;749 Self::check_owner_or_admin_permissions(&collection, &sender)?;750 let mut admin_arr = <AdminList<T>>::get(collection_id);751752 match admin_arr.binary_search(&new_admin_id) {753 Ok(_) => {},754 Err(idx) => {755 ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);756 admin_arr.insert(idx, new_admin_id);757 <AdminList<T>>::insert(collection_id, admin_arr);758 }759 }760 Ok(())761 }762763 /// 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.764 ///765 /// # Permissions766 ///767 /// * Collection Owner.768 /// * Collection Admin.769 ///770 /// # Arguments771 ///772 /// * collection_id: ID of the Collection to remove admin for.773 ///774 /// * account_id: Address of admin to remove.775 #[weight = <SelfWeightOf<T>>::remove_collection_admin()]776 #[transactional]777 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {778 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);779 let collection = Self::get_collection(collection_id)?;780 Self::check_owner_or_admin_permissions(&collection, &sender)?;781 let mut admin_arr = <AdminList<T>>::get(collection_id);782783 if let Ok(idx) = admin_arr.binary_search(&account_id) {784 admin_arr.remove(idx);785 <AdminList<T>>::insert(collection_id, admin_arr);786 }787 Ok(())788 }789790 /// # Permissions791 ///792 /// * Collection Owner793 ///794 /// # Arguments795 ///796 /// * collection_id.797 ///798 /// * new_sponsor.799 #[weight = <SelfWeightOf<T>>::set_collection_sponsor()]800 #[transactional]801 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {802 let sender = ensure_signed(origin)?;803 let mut target_collection = Self::get_collection(collection_id)?;804 Self::check_owner_permissions(&target_collection, &sender)?;805806 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);807 target_collection.save()808 }809810 /// # Permissions811 ///812 /// * Sponsor.813 ///814 /// # Arguments815 ///816 /// * collection_id.817 #[weight = <SelfWeightOf<T>>::confirm_sponsorship()]818 #[transactional]819 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {820 let sender = ensure_signed(origin)?;821822 let mut target_collection = Self::get_collection(collection_id)?;823 ensure!(824 target_collection.sponsorship.pending_sponsor() == Some(&sender),825 Error::<T>::ConfirmUnsetSponsorFail826 );827828 target_collection.sponsorship = SponsorshipState::Confirmed(sender);829 target_collection.save()830 }831832 /// Switch back to pay-per-own-transaction model.833 ///834 /// # Permissions835 ///836 /// * Collection owner.837 ///838 /// # Arguments839 ///840 /// * collection_id.841 #[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]842 #[transactional]843 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {844 let sender = ensure_signed(origin)?;845846 let mut target_collection = Self::get_collection(collection_id)?;847 Self::check_owner_permissions(&target_collection, &sender)?;848849 target_collection.sponsorship = SponsorshipState::Disabled;850 target_collection.save()851 }852853 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.854 ///855 /// # Permissions856 ///857 /// * Collection Owner.858 /// * Collection Admin.859 /// * Anyone if860 /// * White List is enabled, and861 /// * Address is added to white list, and862 /// * MintPermission is enabled (see SetMintPermission method)863 ///864 /// # Arguments865 ///866 /// * collection_id: ID of the collection.867 ///868 /// * owner: Address, initial owner of the NFT.869 ///870 /// * data: Token data to store on chain.871 // #[weight =872 // (130_000_000 as Weight)873 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))874 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))875 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]876877 #[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]878 #[transactional]879 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {880 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);881 let collection = Self::get_collection(collection_id)?;882883 Self::create_item_internal(&sender, &collection, &owner, data)?;884885 collection.submit_logs()886 }887888 /// This method creates multiple items in a collection created with CreateCollection method.889 ///890 /// # Permissions891 ///892 /// * Collection Owner.893 /// * Collection Admin.894 /// * Anyone if895 /// * White List is enabled, and896 /// * Address is added to white list, and897 /// * MintPermission is enabled (see SetMintPermission method)898 ///899 /// # Arguments900 ///901 /// * collection_id: ID of the collection.902 ///903 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].904 ///905 /// * owner: Address, initial owner of the NFT.906 #[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]907 #[transactional]908 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {909910 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);911 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);912 let collection = Self::get_collection(collection_id)?;913914 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;915916 collection.submit_logs()917 }918919 // TODO! transaction weight920921 /// Set transfers_enabled value for particular collection922 ///923 /// # Permissions924 ///925 /// * Collection Owner.926 ///927 /// # Arguments928 ///929 /// * collection_id: ID of the collection.930 ///931 /// * value: New flag value.932 #[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]933 #[transactional]934 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {935936 let sender = ensure_signed(origin)?;937 let mut target_collection = Self::get_collection(collection_id)?;938939 Self::check_owner_permissions(&target_collection, &sender)?;940941 target_collection.transfers_enabled = value;942 target_collection.save()943 }944945 // TODO! transaction weight946 /// Set meta_update_permission value for particular collection947 ///948 /// # Permissions949 ///950 /// * Collection Owner.951 ///952 /// # Arguments953 ///954 /// * collection_id: ID of the collection.955 ///956 /// * value: New flag value.957 #[weight = <T as Config>::WeightInfo::burn_item()]958 #[transactional]959 pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {960961 let sender = ensure_signed(origin)?;962 let mut target_collection = Self::get_collection(collection_id)?;963964 ensure!(965 target_collection.meta_update_permission != MetaUpdatePermission::None,966 Error::<T>::MetadataFlagFrozen967 );968 Self::check_owner_permissions(&target_collection, &sender)?;969970 target_collection.meta_update_permission = value;971972 target_collection.save()973 }974975 /// Destroys a concrete instance of NFT.976 ///977 /// # Permissions978 ///979 /// * Collection Owner.980 /// * Collection Admin.981 /// * Current NFT Owner.982 ///983 /// # Arguments984 ///985 /// * collection_id: ID of the collection.986 ///987 /// * item_id: ID of NFT to burn.988 #[weight = <SelfWeightOf<T>>::burn_item()]989 #[transactional]990 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {991992 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);993 let target_collection = Self::get_collection(collection_id)?;994995 Self::burn_item_internal(&sender, &target_collection, item_id, value, true)?;996997 target_collection.submit_logs()998 }9991000 /// Destroys a concrete instance of NFT on behalf of the owner1001 /// See also: [`approve`]1002 ///1003 /// # Permissions1004 ///1005 /// * Collection Owner.1006 /// * Collection Admin.1007 /// * Current NFT Owner.1008 ///1009 /// # Arguments1010 ///1011 /// * collection_id: ID of the collection.1012 ///1013 /// * item_id: ID of NFT to burn.1014 ///1015 /// * from: owner of item1016 #[weight = <SelfWeightOf<T>>::burn_item()]1017 #[transactional]1018 pub fn burn_from(origin, collection_id: CollectionId, from: T::CrossAccountId, item_id: TokenId, value: u128) -> DispatchResult {10191020 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1021 let target_collection = Self::get_collection(collection_id)?;10221023 Self::burn_from_internal(&sender, &target_collection, &from, item_id, value)?;10241025 target_collection.submit_logs()1026 }10271028 /// Change ownership of the token.1029 ///1030 /// # Permissions1031 ///1032 /// * Collection Owner1033 /// * Collection Admin1034 /// * Current NFT owner1035 ///1036 /// # Arguments1037 ///1038 /// * recipient: Address of token recipient.1039 ///1040 /// * collection_id.1041 ///1042 /// * item_id: ID of the item1043 /// * Non-Fungible Mode: Required.1044 /// * Fungible Mode: Ignored.1045 /// * Re-Fungible Mode: Required.1046 ///1047 /// * value: Amount to transfer.1048 /// * Non-Fungible Mode: Ignored1049 /// * Fungible Mode: Must specify transferred amount1050 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1051 #[weight = <SelfWeightOf<T>>::transfer()]1052 #[transactional]1053 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1054 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1055 let collection = Self::get_collection(collection_id)?;10561057 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10581059 collection.submit_logs()1060 }10611062 /// Set, change, or remove approved address to transfer the ownership of the NFT.1063 ///1064 /// # Permissions1065 ///1066 /// * Collection Owner1067 /// * Collection Admin1068 /// * Current NFT owner1069 ///1070 /// # Arguments1071 ///1072 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1073 ///1074 /// * collection_id.1075 ///1076 /// * item_id: ID of the item.1077 #[weight = <SelfWeightOf<T>>::approve()]1078 #[transactional]1079 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1080 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1081 let collection = Self::get_collection(collection_id)?;10821083 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10841085 collection.submit_logs()1086 }10871088 /// 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.1089 ///1090 /// # Permissions1091 /// * Collection Owner1092 /// * Collection Admin1093 /// * Current NFT owner1094 /// * Address approved by current NFT owner1095 ///1096 /// # Arguments1097 ///1098 /// * from: Address that owns token.1099 ///1100 /// * recipient: Address of token recipient.1101 ///1102 /// * collection_id.1103 ///1104 /// * item_id: ID of the item.1105 ///1106 /// * value: Amount to transfer.1107 #[weight = <SelfWeightOf<T>>::transfer_from()]1108 #[transactional]1109 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1110 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1111 let collection = Self::get_collection(collection_id)?;11121113 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;11141115 collection.submit_logs()1116 }1117 // #[weight = 0]1118 // // let no_perm_mes = "You do not have permissions to modify this collection";1119 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1120 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1121 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);11221123 // // // on_nft_received call11241125 // // Self::transfer(origin, collection_id, item_id, new_owner)?;11261127 // Ok(())1128 // }11291130 /// Set off-chain data schema.1131 ///1132 /// # Permissions1133 ///1134 /// * Collection Owner1135 /// * Collection Admin1136 ///1137 /// # Arguments1138 ///1139 /// * collection_id.1140 ///1141 /// * schema: String representing the offchain data schema.1142 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1143 #[transactional]1144 pub fn set_variable_meta_data (1145 origin,1146 collection_id: CollectionId,1147 item_id: TokenId,1148 data: Vec<u8>1149 ) -> DispatchResult {1150 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11511152 let collection = Self::get_collection(collection_id)?;1153 Self::meta_update_check(&sender, &collection, item_id)?;11541155 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11561157 Ok(())1158 }11591160 /// Set schema standard1161 /// ImageURL1162 /// Unique1163 ///1164 /// # Permissions1165 ///1166 /// * Collection Owner1167 /// * Collection Admin1168 ///1169 /// # Arguments1170 ///1171 /// * collection_id.1172 ///1173 /// * schema: SchemaVersion: enum1174 #[weight = <SelfWeightOf<T>>::set_schema_version()]1175 #[transactional]1176 pub fn set_schema_version(1177 origin,1178 collection_id: CollectionId,1179 version: SchemaVersion1180 ) -> DispatchResult {1181 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1182 let mut target_collection = Self::get_collection(collection_id)?;1183 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1184 target_collection.schema_version = version;1185 target_collection.save()1186 }11871188 /// Set off-chain data schema.1189 ///1190 /// # Permissions1191 ///1192 /// * Collection Owner1193 /// * Collection Admin1194 ///1195 /// # Arguments1196 ///1197 /// * collection_id.1198 ///1199 /// * schema: String representing the offchain data schema.1200 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1201 #[transactional]1202 pub fn set_offchain_schema(1203 origin,1204 collection_id: CollectionId,1205 schema: Vec<u8>1206 ) -> DispatchResult {1207 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1208 let mut target_collection = Self::get_collection(collection_id)?;1209 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12101211 // check schema limit1212 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");12131214 target_collection.offchain_schema = schema;1215 target_collection.save()1216 }12171218 /// Set const on-chain data schema.1219 ///1220 /// # Permissions1221 ///1222 /// * Collection Owner1223 /// * Collection Admin1224 ///1225 /// # Arguments1226 ///1227 /// * collection_id.1228 ///1229 /// * schema: String representing the const on-chain data schema.1230 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1231 #[transactional]1232 pub fn set_const_on_chain_schema (1233 origin,1234 collection_id: CollectionId,1235 schema: Vec<u8>1236 ) -> DispatchResult {1237 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1238 let mut target_collection = Self::get_collection(collection_id)?;1239 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12401241 // check schema limit1242 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12431244 target_collection.const_on_chain_schema = schema;1245 target_collection.save()1246 }12471248 /// Set variable on-chain data schema.1249 ///1250 /// # Permissions1251 ///1252 /// * Collection Owner1253 /// * Collection Admin1254 ///1255 /// # Arguments1256 ///1257 /// * collection_id.1258 ///1259 /// * schema: String representing the variable on-chain data schema.1260 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1261 #[transactional]1262 pub fn set_variable_on_chain_schema (1263 origin,1264 collection_id: CollectionId,1265 schema: Vec<u8>1266 ) -> DispatchResult {1267 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1268 let mut target_collection = Self::get_collection(collection_id)?;1269 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12701271 // check schema limit1272 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12731274 target_collection.variable_on_chain_schema = schema;1275 target_collection.save()1276 }12771278 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1279 #[transactional]1280 pub fn set_collection_limits(1281 origin,1282 collection_id: u32,1283 new_limits: CollectionLimits<T::BlockNumber>,1284 ) -> DispatchResult {1285 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1286 let mut target_collection = Self::get_collection(collection_id)?;1287 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1288 let old_limits = &target_collection.limits;12891290 // collection bounds1291 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1292 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1293 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1294 Error::<T>::CollectionLimitBoundsExceeded);12951296 // token_limit check prev1297 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1298 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12991300 ensure!(1301 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1302 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1303 Error::<T>::OwnerPermissionsCantBeReverted,1304 );13051306 target_collection.limits = new_limits;13071308 target_collection.save()1309 }1310 }1311}13121313impl<T: Config> Module<T> {1314 pub fn create_item_internal(1315 sender: &T::CrossAccountId,1316 collection: &CollectionHandle<T>,1317 owner: &T::CrossAccountId,1318 data: CreateItemData,1319 ) -> DispatchResult {1320 ensure!(1321 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1322 Error::<T>::AddressIsZero1323 );13241325 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1326 Self::validate_create_item_args(collection, &data)?;1327 Self::create_item_no_validation(collection, owner, data)?;13281329 Ok(())1330 }13311332 pub fn transfer_internal(1333 sender: &T::CrossAccountId,1334 recipient: &T::CrossAccountId,1335 target_collection: &CollectionHandle<T>,1336 item_id: TokenId,1337 value: u128,1338 ) -> DispatchResult {1339 ensure!(1340 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1341 Error::<T>::AddressIsZero1342 );13431344 // Limits check1345 Self::is_correct_transfer(target_collection, recipient)?;13461347 // Transfer permissions check1348 ensure!(1349 Self::is_item_owner(sender, target_collection, item_id)?1350 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1351 Error::<T>::NoPermission1352 );13531354 if target_collection.access == AccessMode::WhiteList {1355 Self::check_white_list(target_collection, sender)?;1356 Self::check_white_list(target_collection, recipient)?;1357 }13581359 match target_collection.mode {1360 CollectionMode::NFT => Self::transfer_nft(1361 target_collection,1362 item_id,1363 sender.clone(),1364 recipient.clone(),1365 )?,1366 CollectionMode::Fungible(_) => {1367 Self::transfer_fungible(target_collection, value, sender, recipient)?1368 }1369 CollectionMode::ReFungible => Self::transfer_refungible(1370 target_collection,1371 item_id,1372 value,1373 sender.clone(),1374 recipient.clone(),1375 )?,1376 };13771378 Self::deposit_event(RawEvent::Transfer(1379 target_collection.id,1380 item_id,1381 sender.clone(),1382 recipient.clone(),1383 value,1384 ));13851386 Ok(())1387 }13881389 pub fn approve_internal(1390 sender: &T::CrossAccountId,1391 spender: &T::CrossAccountId,1392 collection: &CollectionHandle<T>,1393 item_id: TokenId,1394 amount: u128,1395 ) -> DispatchResult {1396 Self::token_exists(collection, item_id)?;13971398 // Transfer permissions check1399 let bypasses_limits = collection.limits.owner_can_transfer1400 && Self::is_owner_or_admin_permissions(collection, sender)?;14011402 let allowance_limit = if bypasses_limits {1403 None1404 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1405 Some(amount)1406 } else {1407 fail!(Error::<T>::NoPermission);1408 };14091410 if collection.access == AccessMode::WhiteList {1411 Self::check_white_list(collection, sender)?;1412 Self::check_white_list(collection, spender)?;1413 }14141415 collection.consume_sload()?;1416 let allowance: u128 = amount1417 .checked_add(<Allowances<T>>::get(1418 collection.id,1419 (item_id, sender.as_sub(), spender.as_sub()),1420 ))1421 .ok_or(Error::<T>::NumOverflow)?;1422 if let Some(limit) = allowance_limit {1423 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1424 }1425 collection.consume_sstore()?;1426 <Allowances<T>>::insert(1427 collection.id,1428 (item_id, sender.as_sub(), spender.as_sub()),1429 allowance,1430 );14311432 if matches!(collection.mode, CollectionMode::NFT) {1433 // TODO: NFT: only one owner may exist for token in ERC7211434 collection.log(ERC721Events::Approval {1435 owner: *sender.as_eth(),1436 approved: *spender.as_eth(),1437 token_id: item_id.into(),1438 })?;1439 }14401441 if matches!(collection.mode, CollectionMode::Fungible(_)) {1442 // TODO: NFT: only one owner may exist for token in ERC201443 collection.log(ERC20Events::Approval {1444 owner: *sender.as_eth(),1445 spender: *spender.as_eth(),1446 value: allowance.into(),1447 })?;1448 }14491450 Self::deposit_event(RawEvent::Approved(1451 collection.id,1452 item_id,1453 sender.clone(),1454 spender.clone(),1455 allowance,1456 ));1457 Ok(())1458 }14591460 pub fn transfer_from_internal(1461 sender: &T::CrossAccountId,1462 from: &T::CrossAccountId,1463 recipient: &T::CrossAccountId,1464 collection: &CollectionHandle<T>,1465 item_id: TokenId,1466 amount: u128,1467 ) -> DispatchResult {1468 if sender == from {1469 // Transfer by `from`, because it is either equal to sender, or derived from him1470 return Self::transfer_internal(from, recipient, collection, item_id, amount);1471 }14721473 // Check approval1474 collection.consume_sload()?;1475 let approval: u128 =1476 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14771478 // Limits check1479 Self::is_correct_transfer(collection, recipient)?;14801481 // Transfer permissions check1482 ensure!(1483 approval >= amount1484 || (collection.limits.owner_can_transfer1485 && Self::is_owner_or_admin_permissions(collection, sender)?),1486 Error::<T>::NoPermission1487 );14881489 if collection.access == AccessMode::WhiteList {1490 Self::check_white_list(collection, sender)?;1491 Self::check_white_list(collection, recipient)?;1492 }14931494 // Reduce approval by transferred amount or remove if remaining approval drops to 01495 let allowance = approval.saturating_sub(amount);1496 collection.consume_sstore()?;1497 if allowance > 0 {1498 <Allowances<T>>::insert(1499 collection.id,1500 (item_id, from.as_sub(), sender.as_sub()),1501 allowance,1502 );1503 } else {1504 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1505 }15061507 match collection.mode {1508 CollectionMode::NFT => {1509 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1510 }1511 CollectionMode::Fungible(_) => {1512 Self::transfer_fungible(collection, amount, from, recipient)?1513 }1514 CollectionMode::ReFungible => Self::transfer_refungible(1515 collection,1516 item_id,1517 amount,1518 from.clone(),1519 recipient.clone(),1520 )?,1521 };15221523 if matches!(collection.mode, CollectionMode::Fungible(_)) {1524 collection.log(ERC20Events::Approval {1525 owner: *from.as_eth(),1526 spender: *sender.as_eth(),1527 value: allowance.into(),1528 })?;1529 }15301531 Ok(())1532 }15331534 pub fn set_variable_meta_data_internal(1535 sender: &T::CrossAccountId,1536 collection: &CollectionHandle<T>,1537 item_id: TokenId,1538 data: Vec<u8>,1539 ) -> DispatchResult {1540 Self::token_exists(collection, item_id)?;15411542 ensure!(1543 CUSTOM_DATA_LIMIT >= data.len() as u32,1544 Error::<T>::TokenVariableDataLimitExceeded1545 );15461547 ensure!(1548 (Self::is_item_owner(sender, collection, item_id)?1549 && collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1550 || (Self::is_owner_or_admin_permissions(collection, sender)?1551 && collection.meta_update_permission == MetaUpdatePermission::Admin),1552 Error::<T>::NoPermission1553 );15541555 match collection.mode {1556 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1557 CollectionMode::ReFungible => {1558 Self::set_re_fungible_variable_data(collection, item_id, data)?1559 }1560 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1561 };15621563 Ok(())1564 }15651566 pub fn meta_update_check(1567 sender: &T::CrossAccountId,1568 collection: &CollectionHandle<T>,1569 item_id: TokenId,1570 ) -> DispatchResult {1571 match collection.meta_update_permission {1572 MetaUpdatePermission::ItemOwner => ensure!(1573 Self::is_item_owner(sender, collection, item_id)?,1574 Error::<T>::NoPermission1575 ),1576 MetaUpdatePermission::Admin => ensure!(1577 Self::is_owner_or_admin_permissions(collection, sender)?,1578 Error::<T>::NoPermission1579 ),1580 MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1581 }15821583 Ok(())1584 }15851586 pub fn get_variable_metadata(1587 collection: &CollectionHandle<T>,1588 item_id: TokenId,1589 ) -> Result<Vec<u8>, DispatchError> {1590 Ok(match collection.mode {1591 CollectionMode::NFT => {1592 <NftItemList<T>>::get(collection.id, item_id)1593 .ok_or(Error::<T>::TokenNotFound)?1594 .variable_data1595 }1596 CollectionMode::ReFungible => {1597 <ReFungibleItemList<T>>::get(collection.id, item_id)1598 .ok_or(Error::<T>::TokenNotFound)?1599 .variable_data1600 }1601 _ => fail!(Error::<T>::UnexpectedCollectionType),1602 })1603 }16041605 pub fn create_multiple_items_internal(1606 sender: &T::CrossAccountId,1607 collection: &CollectionHandle<T>,1608 owner: &T::CrossAccountId,1609 items_data: Vec<CreateItemData>,1610 ) -> DispatchResult {1611 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;16121613 for data in &items_data {1614 Self::validate_create_item_args(collection, data)?;1615 }1616 for data in &items_data {1617 Self::create_item_no_validation(collection, owner, data.clone())?;1618 }16191620 Ok(())1621 }16221623 pub fn burn_item_internal(1624 owner: &T::CrossAccountId,1625 collection: &CollectionHandle<T>,1626 item_id: TokenId,1627 value: u128,1628 allow_escalation: bool,1629 ) -> DispatchResult {1630 ensure!(1631 Self::is_item_owner(owner, collection, item_id)?1632 || (allow_escalation1633 && collection.limits.owner_can_transfer1634 && Self::is_owner_or_admin_permissions(collection, owner)?),1635 Error::<T>::NoPermission1636 );16371638 if collection.access == AccessMode::WhiteList {1639 Self::check_white_list(collection, owner)?;1640 }16411642 match collection.mode {1643 CollectionMode::NFT => match value {1644 1 => Self::burn_nft_item(collection, item_id)?,1645 0 => (),1646 _ => fail!(<Error<T>>::TokenValueTooLow),1647 },1648 CollectionMode::Fungible(_) => Self::burn_fungible_item(collection, owner, value)?,1649 CollectionMode::ReFungible => {1650 Self::burn_refungible_item(collection, item_id, owner, value)?1651 }1652 _ => (),1653 };16541655 Ok(())1656 }16571658 pub fn burn_from_internal(1659 sender: &T::CrossAccountId,1660 collection: &CollectionHandle<T>,1661 from: &T::CrossAccountId,1662 item_id: TokenId,1663 amount: u128,1664 ) -> DispatchResult {1665 if sender == from {1666 // Transfer by `from`, because it is either equal to sender, or derived from him1667 return Self::burn_item_internal(from, collection, item_id, amount, true);1668 }16691670 // Check approval1671 collection.consume_sload()?;1672 let approval: u128 =1673 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));16741675 // Transfer permissions check1676 ensure!(1677 approval >= amount1678 || (collection.limits.owner_can_transfer1679 && Self::is_owner_or_admin_permissions(collection, sender)?),1680 Error::<T>::NoPermission1681 );16821683 if collection.access == AccessMode::WhiteList {1684 Self::check_white_list(collection, sender)?;1685 }16861687 // Reduce approval by transferred amount or remove if remaining approval drops to 01688 let allowance = approval.saturating_sub(amount);1689 collection.consume_sstore()?;1690 if allowance > 0 {1691 <Allowances<T>>::insert(1692 collection.id,1693 (item_id, from.as_sub(), sender.as_sub()),1694 allowance,1695 );1696 } else {1697 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1698 }16991700 // Escalation is disallowed here, because we need to be sure that passed owner is real1701 Self::burn_item_internal(from, collection, item_id, amount, false)?;17021703 if matches!(collection.mode, CollectionMode::Fungible(_)) {1704 collection.log(ERC20Events::Approval {1705 owner: *from.as_eth(),1706 spender: *sender.as_eth(),1707 value: allowance.into(),1708 })?;1709 }17101711 Ok(())1712 }17131714 pub fn toggle_white_list_internal(1715 sender: &T::CrossAccountId,1716 collection: &CollectionHandle<T>,1717 address: &T::CrossAccountId,1718 whitelisted: bool,1719 ) -> DispatchResult {1720 Self::check_owner_or_admin_permissions(collection, sender)?;17211722 if whitelisted {1723 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1724 } else {1725 <WhiteList<T>>::remove(collection.id, address.as_sub());1726 }17271728 Ok(())1729 }17301731 fn is_correct_transfer(1732 collection: &CollectionHandle<T>,1733 recipient: &T::CrossAccountId,1734 ) -> DispatchResult {1735 let collection_id = collection.id;17361737 // check token limit and account token limit1738 collection.consume_sload()?;1739 let account_items: u32 =1740 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;17411742 // zero limit means collection limit is disabled1743 // otherwise get lower value1744 let limit = if collection.limits.account_token_ownership_limit == 01745 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1746 {1747 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1748 } else {1749 collection.limits.account_token_ownership_limit1750 };17511752 ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);17531754 // preliminary transfer check1755 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);17561757 Ok(())1758 }17591760 fn can_create_items_in_collection(1761 collection: &CollectionHandle<T>,1762 sender: &T::CrossAccountId,1763 owner: &T::CrossAccountId,1764 amount: u32,1765 ) -> DispatchResult {1766 let collection_id = collection.id;17671768 // check token limit and account token limit1769 let total_items: u32 = ItemListIndex::get(collection_id)1770 .checked_add(amount)1771 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1772 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1773 as u32)1774 .checked_add(amount)1775 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;17761777 // zero limit means collection limit is disabled1778 // otherwise get lower value1779 let account_token_limit = if collection.limits.account_token_ownership_limit == 01780 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1781 {1782 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1783 } else {1784 collection.limits.account_token_ownership_limit1785 };17861787 ensure!(1788 collection.limits.token_limit >= total_items,1789 Error::<T>::CollectionTokenLimitExceeded1790 );1791 ensure!(1792 account_token_limit >= account_items,1793 Error::<T>::AccountTokenLimitExceeded1794 );17951796 if !Self::is_owner_or_admin_permissions(collection, sender)? {1797 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1798 Self::check_white_list(collection, owner)?;1799 Self::check_white_list(collection, sender)?;1800 }18011802 Ok(())1803 }18041805 fn validate_create_item_args(1806 target_collection: &CollectionHandle<T>,1807 data: &CreateItemData,1808 ) -> DispatchResult {1809 match target_collection.mode {1810 CollectionMode::NFT => {1811 if !matches!(data, CreateItemData::NFT(_)) {1812 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1813 }1814 }1815 CollectionMode::Fungible(_) => {1816 if !matches!(data, CreateItemData::Fungible(_)) {1817 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1818 }1819 }1820 CollectionMode::ReFungible => {1821 if let CreateItemData::ReFungible(data) = data {1822 // Check refungibility limits1823 ensure!(1824 data.pieces <= MAX_REFUNGIBLE_PIECES,1825 Error::<T>::WrongRefungiblePieces1826 );1827 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1828 } else {1829 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1830 }1831 }1832 };18331834 Ok(())1835 }18361837 fn create_item_no_validation(1838 collection: &CollectionHandle<T>,1839 owner: &T::CrossAccountId,1840 data: CreateItemData,1841 ) -> DispatchResult {1842 match data {1843 CreateItemData::NFT(data) => {1844 let item = NftItemType {1845 owner: owner.clone(),1846 const_data: data.const_data.into_inner(),1847 variable_data: data.variable_data.into_inner(),1848 };18491850 Self::add_nft_item(collection, item)?;1851 }1852 CreateItemData::Fungible(data) => {1853 Self::add_fungible_item(collection, owner, data.value)?;1854 }1855 CreateItemData::ReFungible(data) => {1856 let owner_list = vec![Ownership {1857 owner: owner.clone(),1858 fraction: data.pieces,1859 }];18601861 let item = ReFungibleItemType {1862 owner: owner_list,1863 const_data: data.const_data.into_inner(),1864 variable_data: data.variable_data.into_inner(),1865 };18661867 Self::add_refungible_item(collection, item)?;1868 }1869 };18701871 Ok(())1872 }18731874 fn add_fungible_item(1875 collection: &CollectionHandle<T>,1876 owner: &T::CrossAccountId,1877 value: u128,1878 ) -> DispatchResult {1879 let collection_id = collection.id;18801881 // Does new owner already have an account?1882 collection.consume_sload()?;1883 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;18841885 // Mint1886 let item = FungibleItemType {1887 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1888 };1889 collection.consume_sstore()?;1890 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);18911892 // Update balance1893 collection.consume_sload()?;1894 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1895 .checked_add(value)1896 .ok_or(Error::<T>::NumOverflow)?;1897 collection.consume_sstore()?;1898 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18991900 collection.log(ERC20Events::Transfer {1901 from: H160::default(),1902 to: *owner.as_eth(),1903 value: value.into(),1904 })?;1905 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1906 Ok(())1907 }19081909 fn add_refungible_item(1910 collection: &CollectionHandle<T>,1911 item: ReFungibleItemType<T::CrossAccountId>,1912 ) -> DispatchResult {1913 let collection_id = collection.id;19141915 let current_index = <ItemListIndex>::get(collection_id)1916 .checked_add(1)1917 .ok_or(Error::<T>::NumOverflow)?;1918 let itemcopy = item.clone();19191920 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1921 let item_owner = item.owner.first().expect("only one owner is defined");19221923 let value = item_owner.fraction;1924 let owner = item_owner.owner.clone();19251926 Self::add_token_index(collection, current_index, &owner)?;19271928 <ItemListIndex>::insert(collection_id, current_index);1929 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19301931 // Update balance1932 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1933 .checked_add(value)1934 .ok_or(Error::<T>::NumOverflow)?;1935 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19361937 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1938 Ok(())1939 }19401941 fn add_nft_item(1942 collection: &CollectionHandle<T>,1943 item: NftItemType<T::CrossAccountId>,1944 ) -> DispatchResult {1945 let collection_id = collection.id;19461947 let current_index = <ItemListIndex>::get(collection_id)1948 .checked_add(1)1949 .ok_or(Error::<T>::NumOverflow)?;19501951 let item_owner = item.owner.clone();1952 Self::add_token_index(collection, current_index, &item.owner)?;19531954 <ItemListIndex>::insert(collection_id, current_index);1955 <NftItemList<T>>::insert(collection_id, current_index, item);19561957 // Update balance1958 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1959 .checked_add(1)1960 .ok_or(Error::<T>::NumOverflow)?;1961 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);19621963 collection.log(ERC721Events::Transfer {1964 from: H160::default(),1965 to: *item_owner.as_eth(),1966 token_id: current_index.into(),1967 })?;1968 Self::deposit_event(RawEvent::ItemCreated(1969 collection_id,1970 current_index,1971 item_owner,1972 ));1973 Ok(())1974 }19751976 fn burn_refungible_item(1977 collection: &CollectionHandle<T>,1978 item_id: TokenId,1979 owner: &T::CrossAccountId,1980 value: u128,1981 ) -> DispatchResult {1982 let collection_id = collection.id;19831984 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1985 .ok_or(Error::<T>::TokenNotFound)?;1986 let mut rft_balance = token1987 .owner1988 .iter()1989 .find(|&i| i.owner == *owner)1990 .ok_or(Error::<T>::TokenNotFound)?1991 .clone();1992 Self::remove_token_index(collection, item_id, owner)?;19931994 // update balance1995 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1996 .checked_sub(value)1997 .ok_or(Error::<T>::NumOverflow)?;1998 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19992000 rft_balance.fraction = (rft_balance.fraction)2001 .checked_sub(value)2002 .ok_or(Error::<T>::NumOverflow)?;20032004 let index = token2005 .owner2006 .iter()2007 .position(|i| i.owner == *owner)2008 .expect("owned item is exists");2009 if rft_balance.fraction == 0 {2010 // Re-create owners list with sender removed2011 token.owner.remove(index);2012 } else {2013 token.owner[index] = rft_balance;2014 }20152016 let owner_count = token.owner.len();20172018 // Burn the token completely if this was the last (only) owner2019 if owner_count == 0 {2020 <ReFungibleItemList<T>>::remove(collection_id, item_id);2021 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2022 } else {2023 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2024 }20252026 Ok(())2027 }20282029 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2030 let collection_id = collection.id;20312032 let item =2033 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;2034 Self::remove_token_index(collection, item_id, &item.owner)?;20352036 // update balance2037 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2038 .checked_sub(1)2039 .ok_or(Error::<T>::NumOverflow)?;2040 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2041 <NftItemList<T>>::remove(collection_id, item_id);2042 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20432044 collection.log(ERC721Events::Transfer {2045 from: *item.owner.as_eth(),2046 to: H160::default(),2047 token_id: item_id.into(),2048 })?;2049 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));2050 Ok(())2051 }20522053 fn burn_fungible_item(2054 collection: &CollectionHandle<T>,2055 owner: &T::CrossAccountId,2056 value: u128,2057 ) -> DispatchResult {2058 let collection_id = collection.id;20592060 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2061 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20622063 // update balance2064 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2065 .checked_sub(value)2066 .ok_or(Error::<T>::NumOverflow)?;2067 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20682069 if balance.value - value > 0 {2070 balance.value -= value;2071 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2072 } else {2073 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2074 }20752076 collection.log(ERC20Events::Transfer {2077 from: *owner.as_eth(),2078 to: H160::default(),2079 value: value.into(),2080 })?;2081 Ok(())2082 }20832084 pub fn get_collection(2085 collection_id: CollectionId,2086 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2087 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)2088 }20892090 fn check_owner_permissions(2091 target_collection: &CollectionHandle<T>,2092 subject: &T::AccountId,2093 ) -> DispatchResult {2094 ensure!(2095 *subject == target_collection.owner,2096 Error::<T>::NoPermission2097 );20982099 Ok(())2100 }21012102 fn is_owner_or_admin_permissions(2103 collection: &CollectionHandle<T>,2104 subject: &T::CrossAccountId,2105 ) -> Result<bool, DispatchError> {2106 collection.consume_sload()?;2107 Ok(*subject.as_sub() == collection.owner2108 || <AdminList<T>>::get(collection.id).contains(subject))2109 }21102111 fn check_owner_or_admin_permissions(2112 collection: &CollectionHandle<T>,2113 subject: &T::CrossAccountId,2114 ) -> DispatchResult {2115 ensure!(2116 Self::is_owner_or_admin_permissions(collection, subject)?,2117 Error::<T>::NoPermission2118 );21192120 Ok(())2121 }21222123 fn owned_amount(2124 subject: &T::CrossAccountId,2125 collection: &CollectionHandle<T>,2126 item_id: TokenId,2127 ) -> Result<Option<u128>, DispatchError> {2128 collection.consume_sload()?;2129 Ok(Self::owned_amount_unchecked(subject, collection, item_id))2130 }21312132 fn owned_amount_unchecked(2133 subject: &T::CrossAccountId,2134 target_collection: &CollectionHandle<T>,2135 item_id: TokenId,2136 ) -> Option<u128> {2137 let collection_id = target_collection.id;21382139 match target_collection.mode {2140 CollectionMode::NFT => {2141 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2142 }2143 CollectionMode::Fungible(_) => {2144 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2145 }2146 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2147 .owner2148 .iter()2149 .find(|i| i.owner == *subject)2150 .map(|i| i.fraction),2151 }2152 }21532154 fn is_item_owner(2155 subject: &T::CrossAccountId,2156 target_collection: &CollectionHandle<T>,2157 item_id: TokenId,2158 ) -> Result<bool, DispatchError> {2159 Ok(match target_collection.mode {2160 CollectionMode::Fungible(_) => true,2161 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2162 })2163 }21642165 fn check_white_list(2166 collection: &CollectionHandle<T>,2167 address: &T::CrossAccountId,2168 ) -> DispatchResult {2169 collection.consume_sload()?;2170 ensure!(2171 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2172 Error::<T>::AddresNotInWhiteList,2173 );2174 Ok(())2175 }21762177 /// Check if token exists. In case of Fungible, check if there is an entry for2178 /// the owner in fungible balances double map2179 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2180 let collection_id = target_collection.id;2181 let exists = match target_collection.mode {2182 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2183 CollectionMode::Fungible(_) => true,2184 CollectionMode::ReFungible => {2185 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2186 }2187 };21882189 ensure!(exists, Error::<T>::TokenNotFound);2190 Ok(())2191 }21922193 fn transfer_fungible(2194 collection: &CollectionHandle<T>,2195 value: u128,2196 owner: &T::CrossAccountId,2197 recipient: &T::CrossAccountId,2198 ) -> DispatchResult {2199 let collection_id = collection.id;22002201 collection.consume_sload()?;2202 collection.consume_sload()?;2203 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2204 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());22052206 recipient_balance.value = recipient_balance2207 .value2208 .checked_add(value)2209 .ok_or(Error::<T>::NumOverflow)?;2210 balance.value = balance2211 .value2212 .checked_sub(value)2213 .ok_or(Error::<T>::TokenValueTooLow)?;22142215 // update balanceOf2216 collection.consume_sstore()?;2217 collection.consume_sstore()?;2218 if balance.value != 0 {2219 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2220 } else {2221 <Balance<T>>::remove(collection_id, owner.as_sub());2222 }2223 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);22242225 // Reduce or remove sender2226 collection.consume_sstore()?;2227 collection.consume_sstore()?;2228 if balance.value != 0 {2229 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2230 } else {2231 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2232 }2233 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);22342235 collection.log(ERC20Events::Transfer {2236 from: *owner.as_eth(),2237 to: *recipient.as_eth(),2238 value: value.into(),2239 })?;2240 Self::deposit_event(RawEvent::Transfer(2241 collection.id,2242 1,2243 owner.clone(),2244 recipient.clone(),2245 value,2246 ));22472248 Ok(())2249 }22502251 fn transfer_refungible(2252 collection: &CollectionHandle<T>,2253 item_id: TokenId,2254 value: u128,2255 owner: T::CrossAccountId,2256 new_owner: T::CrossAccountId,2257 ) -> DispatchResult {2258 let collection_id = collection.id;2259 collection.consume_sload()?;2260 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2261 .ok_or(Error::<T>::TokenNotFound)?;22622263 let item = full_item2264 .owner2265 .iter()2266 .find(|i| i.owner == owner)2267 .ok_or(Error::<T>::TokenNotFound)?;2268 let amount = item.fraction;22692270 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22712272 collection.consume_sload()?;2273 // update balance2274 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2275 .checked_sub(value)2276 .ok_or(Error::<T>::NumOverflow)?;2277 collection.consume_sstore()?;2278 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22792280 collection.consume_sload()?;2281 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2282 .checked_add(value)2283 .ok_or(Error::<T>::NumOverflow)?;2284 collection.consume_sstore()?;2285 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22862287 let old_owner = item.owner.clone();2288 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22892290 let mut new_full_item = full_item.clone();2291 // transfer2292 if amount == value && !new_owner_has_account {2293 // change owner2294 // new owner do not have account2295 new_full_item2296 .owner2297 .iter_mut()2298 .find(|i| i.owner == owner)2299 .expect("old owner does present in refungible")2300 .owner = new_owner.clone();2301 collection.consume_sstore()?;2302 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);23032304 // update index collection2305 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2306 } else {2307 new_full_item2308 .owner2309 .iter_mut()2310 .find(|i| i.owner == owner)2311 .expect("old owner does present in refungible")2312 .fraction -= value;23132314 // separate amount2315 if new_owner_has_account {2316 // new owner has account2317 new_full_item2318 .owner2319 .iter_mut()2320 .find(|i| i.owner == new_owner)2321 .expect("new owner has account")2322 .fraction += value;2323 } else {2324 // new owner do not have account2325 new_full_item.owner.push(Ownership {2326 owner: new_owner.clone(),2327 fraction: value,2328 });2329 Self::add_token_index(collection, item_id, &new_owner)?;2330 }23312332 collection.consume_sstore()?;2333 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2334 }23352336 Self::deposit_event(RawEvent::Transfer(2337 collection.id,2338 item_id,2339 owner,2340 new_owner,2341 amount,2342 ));23432344 Ok(())2345 }23462347 fn transfer_nft(2348 collection: &CollectionHandle<T>,2349 item_id: TokenId,2350 sender: T::CrossAccountId,2351 new_owner: T::CrossAccountId,2352 ) -> DispatchResult {2353 let collection_id = collection.id;2354 collection.consume_sload()?;2355 let mut item =2356 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23572358 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);23592360 collection.consume_sload()?;2361 // update balance2362 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2363 .checked_sub(1)2364 .ok_or(Error::<T>::NumOverflow)?;2365 collection.consume_sstore()?;2366 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);23672368 collection.consume_sload()?;2369 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2370 .checked_add(1)2371 .ok_or(Error::<T>::NumOverflow)?;2372 collection.consume_sstore()?;2373 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);23742375 // change owner2376 let old_owner = item.owner.clone();2377 item.owner = new_owner.clone();2378 collection.consume_sstore()?;2379 <NftItemList<T>>::insert(collection_id, item_id, item);23802381 // update index collection2382 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;23832384 collection.log(ERC721Events::Transfer {2385 from: *sender.as_eth(),2386 to: *new_owner.as_eth(),2387 token_id: item_id.into(),2388 })?;2389 Self::deposit_event(RawEvent::Transfer(2390 collection.id,2391 item_id,2392 sender,2393 new_owner,2394 1,2395 ));23962397 Ok(())2398 }23992400 fn set_re_fungible_variable_data(2401 collection: &CollectionHandle<T>,2402 item_id: TokenId,2403 data: Vec<u8>,2404 ) -> DispatchResult {2405 let collection_id = collection.id;2406 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2407 .ok_or(Error::<T>::TokenNotFound)?;24082409 item.variable_data = data;24102411 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);24122413 Ok(())2414 }24152416 fn set_nft_variable_data(2417 collection: &CollectionHandle<T>,2418 item_id: TokenId,2419 data: Vec<u8>,2420 ) -> DispatchResult {2421 let collection_id = collection.id;2422 let mut item =2423 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;24242425 item.variable_data = data;24262427 <NftItemList<T>>::insert(collection_id, item_id, item);24282429 Ok(())2430 }24312432 #[allow(dead_code)]2433 fn init_collection(item: &Collection<T>) {2434 // check params2435 assert!(2436 item.decimal_points <= MAX_DECIMAL_POINTS,2437 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2438 );2439 assert!(2440 item.name.len() <= 64,2441 "Collection name can not be longer than 63 char"2442 );2443 assert!(2444 item.name.len() <= 256,2445 "Collection description can not be longer than 255 char"2446 );2447 assert!(2448 item.token_prefix.len() <= 16,2449 "Token prefix can not be longer than 15 char"2450 );24512452 // Generate next collection ID2453 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();24542455 CreatedCollectionCount::put(next_id);2456 }24572458 #[allow(dead_code)]2459 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2460 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24612462 Self::add_token_index(2463 &CollectionHandle::get(collection_id).unwrap(),2464 current_index,2465 &item.owner,2466 )2467 .unwrap();24682469 <ItemListIndex>::insert(collection_id, current_index);24702471 // Update balance2472 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2473 .checked_add(1)2474 .unwrap();2475 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2476 }24772478 #[allow(dead_code)]2479 fn init_fungible_token(2480 collection_id: CollectionId,2481 owner: &T::CrossAccountId,2482 item: &FungibleItemType,2483 ) {2484 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24852486 Self::add_token_index(2487 &CollectionHandle::get(collection_id).unwrap(),2488 current_index,2489 owner,2490 )2491 .unwrap();24922493 <ItemListIndex>::insert(collection_id, current_index);24942495 // Update balance2496 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2497 .checked_add(item.value)2498 .unwrap();2499 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2500 }25012502 #[allow(dead_code)]2503 fn init_refungible_token(2504 collection_id: CollectionId,2505 item: &ReFungibleItemType<T::CrossAccountId>,2506 ) {2507 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();25082509 let value = item.owner.first().unwrap().fraction;2510 let owner = item.owner.first().unwrap().owner.clone();25112512 Self::add_token_index(2513 &CollectionHandle::get(collection_id).unwrap(),2514 current_index,2515 &owner,2516 )2517 .unwrap();25182519 <ItemListIndex>::insert(collection_id, current_index);25202521 // Update balance2522 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2523 .checked_add(value)2524 .unwrap();2525 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2526 }25272528 fn add_token_index(2529 collection: &CollectionHandle<T>,2530 item_index: TokenId,2531 owner: &T::CrossAccountId,2532 ) -> DispatchResult {2533 collection.consume_sload()?;2534 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2535 if list_exists {2536 collection.consume_sload()?;2537 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());25382539 // bound Owned tokens by a single address in collection2540 let account_items: u32 = list.len() as u32;2541 ensure!(2542 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2543 Error::<T>::AddressOwnershipLimitExceeded2544 );25452546 let item_contains = list.contains(&item_index.clone());25472548 if !item_contains {2549 list.push(item_index);2550 }25512552 collection.consume_sstore()?;2553 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2554 } else {2555 let itm = vec![item_index];2556 collection.consume_sstore()?;2557 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2558 }25592560 Ok(())2561 }25622563 fn remove_token_index(2564 collection: &CollectionHandle<T>,2565 item_index: TokenId,2566 owner: &T::CrossAccountId,2567 ) -> DispatchResult {2568 collection.consume_sload()?;2569 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2570 if list_exists {2571 collection.consume_sload()?;2572 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2573 let item_contains = list.contains(&item_index.clone());25742575 if item_contains {2576 list.retain(|&item| item != item_index);2577 collection.consume_sstore()?;2578 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2579 }2580 }25812582 Ok(())2583 }25842585 fn move_token_index(2586 collection: &CollectionHandle<T>,2587 item_index: TokenId,2588 old_owner: &T::CrossAccountId,2589 new_owner: &T::CrossAccountId,2590 ) -> DispatchResult {2591 Self::remove_token_index(collection, item_index, old_owner)?;2592 Self::add_token_index(collection, item_index, new_owner)?;25932594 Ok(())2595 }2596}25972598sp_api::decl_runtime_apis! {2599 pub trait NftApi {2600 /// Used for ethereum integration2601 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2602 }2603}pallets/nft/src/tests.rsdiffbeforeafterboth--- a/pallets/nft/src/tests.rs
+++ b/pallets/nft/src/tests.rs
@@ -707,9 +707,15 @@
assert_eq!(TemplateModule::balance_count(1, 1), 1);
// burn item
- assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 5));
+ assert_ok!(TemplateModule::burn_item(
+ origin1.clone(),
+ 1,
+ 1,
+ account(1),
+ 5
+ ));
assert_noop!(
- TemplateModule::burn_item(origin1, 1, 1, 5),
+ TemplateModule::burn_item(origin1, 1, 1, account(1), 5),
Error::<Test>::TokenNotFound
);
@@ -736,9 +742,15 @@
assert_eq!(TemplateModule::balance_count(1, 1), 5);
// burn item
- assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 5));
+ assert_ok!(TemplateModule::burn_item(
+ origin1.clone(),
+ 1,
+ 1,
+ account(1),
+ 5
+ ));
assert_noop!(
- TemplateModule::burn_item(origin1, 1, 1, 5),
+ TemplateModule::burn_item(origin1, 1, 1, account(1), 5),
Error::<Test>::TokenValueNotEnough
);
@@ -781,9 +793,15 @@
assert_eq!(TemplateModule::balance_count(1, 1), 1023);
// burn item
- assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 1023));
+ assert_ok!(TemplateModule::burn_item(
+ origin1.clone(),
+ 1,
+ 1,
+ account(1),
+ 1023
+ ));
assert_noop!(
- TemplateModule::burn_item(origin1, 1, 1, 1023),
+ TemplateModule::burn_item(origin1, 1, 1, account(1), 1023),
Error::<Test>::TokenNotFound
);
@@ -1378,7 +1396,7 @@
AccessMode::WhiteList
));
assert_noop!(
- TemplateModule::burn_item(origin1, 1, 1, 5),
+ TemplateModule::burn_item(origin1.clone(), 1, 1, account(1), 5),
Error::<Test>::AddresNotInWhiteList
);
});
tests/.vscode/settings.jsondiffbeforeafterboth--- a/tests/.vscode/settings.json
+++ b/tests/.vscode/settings.json
@@ -1,3 +1,5 @@
{
- "mocha.enabled": true
-}
\ No newline at end of file
+ "mocha.enabled": true,
+ "mochaExplorer.files": "**/*.test.ts",
+ "mochaExplorer.require": "ts-node/register"
+}
tests/package.jsondiffbeforeafterboth--- a/tests/package.json
+++ b/tests/package.json
@@ -20,6 +20,10 @@
"tslint": "^6.1.3",
"typescript": "^4.2.4"
},
+ "mocha": {
+ "timeout": 9999999,
+ "require": "ts-node/register"
+ },
"scripts": {
"lint": "eslint --ext .ts,.js src/",
"fix": "eslint --ext .ts,.js src/ --fix",
tests/src/burnItem.test.tsdiffbeforeafterboth--- a/tests/src/burnItem.test.ts
+++ b/tests/src/burnItem.test.ts
@@ -38,7 +38,7 @@
const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
await usingApi(async (api) => {
- const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
+ const tx = api.tx.nft.burnItem(collectionId, tokenId, 1);
const events = await submitTransactionAsync(alice, tx);
const result = getGenericResult(events);
// Get the item
@@ -79,7 +79,7 @@
const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
await usingApi(async (api) => {
- const tx = api.tx.nft.burnItem(collectionId, tokenId, 1);
+ const tx = api.tx.nft.burnItem(collectionId, tokenId, 100);
const events = await submitTransactionAsync(alice, tx);
const result = getGenericResult(events);
@@ -107,14 +107,14 @@
const balanceBefore: any = (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON();
// Bob burns his portion
- const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
+ const tx = api.tx.nft.burnItem(collectionId, tokenId, 1);
const events2 = await submitTransactionAsync(bob, tx);
const result2 = getGenericResult(events2);
- // Get balances
+ // Get balances
const balance: any = (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON();
// console.log(balance);
-
+
// What to expect before burning
expect(result1.success).to.be.true;
expect(balanceBefore).to.be.not.null;
@@ -152,7 +152,7 @@
await addCollectionAdminExpectSuccess(alice, collectionId, bob);
await usingApi(async (api) => {
- const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
+ const tx = api.tx.nft.burnItem(collectionId, tokenId, 1);
const events = await submitTransactionAsync(bob, tx);
const result = getGenericResult(events);
// Get the item
@@ -164,6 +164,48 @@
expect(item).to.be.null;
});
});
+
+
+ it('Burn item in Fungible collection', async () => {
+ const createMode = 'Fungible';
+ const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0 }});
+ const tokenId = await createItemExpectSuccess(alice, collectionId, createMode); // Helper creates 10 fungible tokens
+ await addCollectionAdminExpectSuccess(alice, collectionId, bob);
+
+ await usingApi(async (api) => {
+ // Destroy 1 of 10
+ const tx = api.tx.nft.burnFrom(collectionId, normalizeAccountId(alice.address), tokenId, 1);
+ const events = await submitTransactionAsync(bob, tx);
+ const result = getGenericResult(events);
+
+ // Get alice balance
+ const balance: any = (await api.query.nft.fungibleItemList(collectionId, alice.address)).toJSON();
+
+ // What to expect
+ expect(result.success).to.be.true;
+ expect(balance).to.be.not.null;
+ expect(balance.Value).to.be.equal(9);
+ });
+ });
+
+ it('Burn item in ReFungible collection', async () => {
+ const createMode = 'ReFungible';
+ const collectionId = await createCollectionExpectSuccess({mode: {type: createMode }});
+ const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
+ await addCollectionAdminExpectSuccess(alice, collectionId, bob);
+
+ await usingApi(async (api) => {
+ const tx = api.tx.nft.burnFrom(collectionId, normalizeAccountId(alice.address), tokenId, 100);
+ const events = await submitTransactionAsync(bob, tx);
+ const result = getGenericResult(events);
+ // Get alice balance
+ const balance: any = (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON();
+
+ // What to expect
+ expect(result.success).to.be.true;
+ expect(balance).to.be.null;
+ });
+ });
});
describe('Negative integration test: ext. burnItem():', () => {
@@ -197,7 +239,7 @@
const tokenId = 10;
await usingApi(async (api) => {
- const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
+ const tx = api.tx.nft.burnItem(collectionId, tokenId, 1);
const badTransaction = async function () {
await submitTransactionExpectFailAsync(alice, tx);
};
@@ -228,7 +270,7 @@
await usingApi(async (api) => {
- const burntx = api.tx.nft.burnItem(collectionId, tokenId, 0);
+ const burntx = api.tx.nft.burnItem(collectionId, tokenId, 1);
const events1 = await submitTransactionAsync(alice, burntx);
const result1 = getGenericResult(events1);
expect(result1.success).to.be.true;
tests/src/transfer.test.tsdiffbeforeafterboth--- a/tests/src/transfer.test.ts
+++ b/tests/src/transfer.test.ts
@@ -199,7 +199,7 @@
const reFungibleCollectionId = await
createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
- await burnItemExpectSuccess(Alice, reFungibleCollectionId, newReFungibleTokenId, 1);
+ await burnItemExpectSuccess(Alice, reFungibleCollectionId, newReFungibleTokenId, 100);
await transferExpectFailure(
reFungibleCollectionId,
newReFungibleTokenId,
tests/src/transferFrom.test.tsdiffbeforeafterboth--- a/tests/src/transferFrom.test.ts
+++ b/tests/src/transferFrom.test.ts
@@ -248,7 +248,7 @@
const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
await burnItemExpectSuccess(Alice, nftCollectionId, newNftTokenId, 1);
await approveExpectFail(nftCollectionId, newNftTokenId, Alice, Bob);
- await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1);
+ await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1);
});
});
it( 'transferFrom burnt token before approve Fungible', async () => {
@@ -258,20 +258,20 @@
await burnItemExpectSuccess(Alice, fungibleCollectionId, 1, 10);
await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1);
-
+
});
- });
+ });
it( 'transferFrom burnt token before approve ReFungible', async () => {
await usingApi(async () => {
const reFungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
- await burnItemExpectSuccess(Alice, reFungibleCollectionId, newReFungibleTokenId, 1);
+ await burnItemExpectSuccess(Alice, reFungibleCollectionId, newReFungibleTokenId, 100);
await approveExpectFail(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
await transferFromExpectFail(reFungibleCollectionId, newReFungibleTokenId, Bob, Alice, Charlie, 1);
-
+
});
});
-
+
it( 'transferFrom burnt token after approve NFT', async () => {
await usingApi(async () => {
// nft
@@ -279,7 +279,7 @@
const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
await burnItemExpectSuccess(Alice, nftCollectionId, newNftTokenId, 1);
- await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1);
+ await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1);
});
});
it( 'transferFrom burnt token after approve Fungible', async () => {
@@ -289,17 +289,17 @@
await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
await burnItemExpectSuccess(Alice, fungibleCollectionId, 1, 10);
await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1);
-
+
});
- });
+ });
it( 'transferFrom burnt token after approve ReFungible', async () => {
await usingApi(async () => {
const reFungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
- await burnItemExpectSuccess(Alice, reFungibleCollectionId, newReFungibleTokenId, 1);
+ await burnItemExpectSuccess(Alice, reFungibleCollectionId, newReFungibleTokenId, 100);
await transferFromExpectFail(reFungibleCollectionId, newReFungibleTokenId, Bob, Alice, Charlie, 1);
-
+
});
});
tests/src/util/helpers.tsdiffbeforeafterboth--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -700,10 +700,10 @@
ReFungible: CreateReFungibleData;
};
-export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {
+export async function burnItemExpectSuccess(sender: IKeyringPair, collectionId: number, tokenId: number, value = 1) {
await usingApi(async (api) => {
const tx = api.tx.nft.burnItem(collectionId, tokenId, value);
- const events = await submitTransactionAsync(owner, tx);
+ const events = await submitTransactionAsync(sender, tx);
const result = getGenericResult(events);
// Get the item
const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();