difftreelog
Limits logic fixed. Tests added
in: master
4 files changed
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 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 /// Collection settings not allowing items transferring149 TransferNotAllowed,150 /// Can't transfer tokens to ethereum zero address151 AddressIsZero,152 }153}154155#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]156pub struct CollectionHandle<T: Config> {157 pub id: CollectionId,158 collection: Collection<T>,159 recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,160}161impl<T: Config> CollectionHandle<T> {162 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {163 <CollectionById<T>>::get(id).map(|collection| Self {164 id,165 collection,166 recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(167 eth::collection_id_to_address(id),168 gas_limit,169 ),170 })171 }172 pub fn get(id: CollectionId) -> Option<Self> {173 Self::get_with_gas_limit(id, u64::MAX)174 }175 pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {176 self.recorder.log_sub(log)177 }178 #[allow(dead_code)]179 fn consume_gas(&self, gas: u64) -> DispatchResult {180 self.recorder.consume_gas_sub(gas)181 }182 fn consume_sload(&self) -> DispatchResult {183 self.recorder.consume_sload_sub()184 }185 fn consume_sstore(&self) -> DispatchResult {186 self.recorder.consume_sstore_sub()187 }188 pub fn submit_logs(self) -> DispatchResult {189 self.recorder.submit_logs()190 }191 pub fn save(self) -> DispatchResult {192 self.recorder.submit_logs()?;193 <CollectionById<T>>::insert(self.id, self.collection);194 Ok(())195 }196}197impl<T: Config> Deref for CollectionHandle<T> {198 type Target = Collection<T>;199200 fn deref(&self) -> &Self::Target {201 &self.collection202 }203}204205impl<T: Config> DerefMut for CollectionHandle<T> {206 fn deref_mut(&mut self) -> &mut Self::Target {207 &mut self.collection208 }209}210211pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {212 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;213214 /// Weight information for extrinsics in this pallet.215 type WeightInfo: WeightInfo;216217 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;218 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;219220 type CrossAccountId: CrossAccountId<Self::AccountId>;221 type Currency: Currency<Self::AccountId>;222 type CollectionCreationPrice: Get<223 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,224 >;225 type TreasuryAccountId: Get<Self::AccountId>;226}227228type SelfWeightOf<T> = <T as Config>::WeightInfo;229230trait WeightInfoHelpers: WeightInfo {231 fn transfer() -> Weight {232 Self::transfer_nft()233 .max(Self::transfer_fungible())234 .max(Self::transfer_refungible())235 }236 fn transfer_from() -> Weight {237 Self::transfer_from_nft()238 .max(Self::transfer_from_fungible())239 .max(Self::transfer_from_refungible())240 }241 fn approve() -> Weight {242 // TODO: refungible, fungible243 Self::approve_nft()244 }245 fn set_variable_meta_data(data: u32) -> Weight {246 // TODO: refungible247 Self::set_variable_meta_data_nft(data)248 }249 fn create_item(data: u32) -> Weight {250 Self::create_item_nft(data)251 .max(Self::create_item_fungible())252 .max(Self::create_item_refungible(data))253 }254 fn create_multiple_items(amount: u32) -> Weight {255 Self::create_multiple_items_nft(amount)256 .max(Self::create_multiple_items_fungible(amount))257 .max(Self::create_multiple_items_refungible(amount))258 }259 fn burn_item() -> Weight {260 // TODO: refungible, fungible261 Self::burn_item_nft()262 }263}264impl<T: WeightInfo> WeightInfoHelpers for T {}265266// # Used definitions267//268// ## User control levels269//270// chain-controlled - key is uncontrolled by user271// i.e autoincrementing index272// can use non-cryptographic hash273// real - key is controlled by user274// but it is hard to generate enough colliding values, i.e owner of signed txs275// can use non-cryptographic hash276// controlled - key is completly controlled by users277// i.e maps with mutable keys278// should use cryptographic hash279//280// ## User control level downgrade reasons281//282// ?1 - chain-controlled -> controlled283// collections/tokens can be destroyed, resulting in massive holes284// ?2 - chain-controlled -> controlled285// same as ?1, but can be only added, resulting in easier exploitation286// ?3 - real -> controlled287// no confirmation required, so addresses can be easily generated288decl_storage! {289 trait Store for Module<T: Config> as Nft {290291 //#region Private members292 /// Id of next collection293 CreatedCollectionCount: u32;294 /// Used for migrations295 ChainVersion: u64;296 /// Id of last collection token297 /// Collection id (controlled?1)298 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;299 //#endregion300301 //#region Bound counters302 /// Amount of collections destroyed, used for total amount tracking with303 /// CreatedCollectionCount304 DestroyedCollectionCount: u32;305 //#endregion306307 //#region Basic collections308 /// Collection info309 /// Collection id (controlled?1)310 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;311 /// List of collection admins312 /// Collection id (controlled?2)313 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;314 /// Whitelisted collection users315 /// Collection id (controlled?2), user id (controlled?3)316 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;317 //#endregion318319 /// How many of collection items user have320 /// Collection id (controlled?2), account id (real)321 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;322323 /// Amount of items which spender can transfer out of owners account (via transferFrom)324 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))325 /// TODO: Off chain worker should remove from this map when token gets removed326 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;327328 //#region Item collections329 /// Collection id (controlled?2), token id (controlled?1)330 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;331 /// Collection id (controlled?2), owner (controlled?2)332 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;333 /// Collection id (controlled?2), token id (controlled?1)334 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;335 //#endregion336337 //#region Index list338 /// Collection id (controlled?2), tokens owner (controlled?2)339 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;340 //#endregion341342 //#region Tokens transfer rate limit baskets343 /// (Collection id (controlled?2), who created (real))344 /// TODO: Off chain worker should remove from this map when collection gets removed345 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;346 /// Collection id (controlled?2), token id (controlled?2)347 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;348 /// Collection id (controlled?2), owning user (real)349 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;350 /// Collection id (controlled?2), token id (controlled?2)351 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;352 //#endregion353354 /// Variable metadata sponsoring355 /// Collection id (controlled?2), token id (controlled?2)356 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;357 }358 add_extra_genesis {359 build(|config: &GenesisConfig<T>| {360 // Modification of storage361 for (_num, _c) in &config.collection_id {362 <Module<T>>::init_collection(_c);363 }364365 for (_num, _c, _i) in &config.nft_item_id {366 <Module<T>>::init_nft_token(*_c, _i);367 }368369 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {370 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);371 }372373 for (_num, _c, _i) in &config.refungible_item_id {374 <Module<T>>::init_refungible_token(*_c, _i);375 }376 })377 }378}379380decl_event!(381 pub enum Event<T>382 where383 AccountId = <T as frame_system::Config>::AccountId,384 CrossAccountId = <T as Config>::CrossAccountId,385 {386 /// New collection was created387 ///388 /// # Arguments389 ///390 /// * collection_id: Globally unique identifier of newly created collection.391 ///392 /// * mode: [CollectionMode] converted into u8.393 ///394 /// * account_id: Collection owner.395 CollectionCreated(CollectionId, u8, AccountId),396397 /// New item was created.398 ///399 /// # Arguments400 ///401 /// * collection_id: Id of the collection where item was created.402 ///403 /// * item_id: Id of an item. Unique within the collection.404 ///405 /// * recipient: Owner of newly created item406 ItemCreated(CollectionId, TokenId, CrossAccountId),407408 /// Collection item was burned.409 ///410 /// # Arguments411 ///412 /// collection_id.413 ///414 /// item_id: Identifier of burned NFT.415 ItemDestroyed(CollectionId, TokenId),416417 /// Item was transferred418 ///419 /// * collection_id: Id of collection to which item is belong420 ///421 /// * item_id: Id of an item422 ///423 /// * sender: Original owner of item424 ///425 /// * recipient: New owner of item426 ///427 /// * amount: Always 1 for NFT428 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),429430 /// * collection_id431 ///432 /// * item_id433 ///434 /// * sender435 ///436 /// * spender437 ///438 /// * amount439 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),440 }441);442443decl_module! {444 pub struct Module<T: Config> for enum Call445 where446 origin: T::Origin447 {448 fn deposit_event() = default;449 const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;450 type Error = Error<T>;451452 fn on_initialize(_now: T::BlockNumber) -> Weight {453 0454 }455456 /// 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.457 ///458 /// # Permissions459 ///460 /// * Anyone.461 ///462 /// # Arguments463 ///464 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.465 ///466 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.467 ///468 /// * token_prefix: UTF-8 string with token prefix.469 ///470 /// * mode: [CollectionMode] collection type and type dependent data.471 // returns collection ID472 #[weight = <SelfWeightOf<T>>::create_collection()]473 #[transactional]474 pub fn create_collection(origin,475 collection_name: Vec<u16>,476 collection_description: Vec<u16>,477 token_prefix: Vec<u8>,478 mode: CollectionMode) -> DispatchResult {479480 // Anyone can create a collection481 let who = ensure_signed(origin)?;482483 // Take a (non-refundable) deposit of collection creation484 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();485 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(486 &T::TreasuryAccountId::get(),487 T::CollectionCreationPrice::get(),488 ));489 <T as Config>::Currency::settle(490 &who,491 imbalance,492 WithdrawReasons::TRANSFER,493 ExistenceRequirement::KeepAlive,494 ).map_err(|_| Error::<T>::NoPermission)?;495496 let decimal_points = match mode {497 CollectionMode::Fungible(points) => points,498 _ => 0499 };500501 let created_count = CreatedCollectionCount::get();502 let destroyed_count = DestroyedCollectionCount::get();503504 // bound Total number of collections505 ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);506507 // check params508 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);509 ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);510 ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);511 ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);512513 // Generate next collection ID514 let next_id = created_count515 .checked_add(1)516 .ok_or(Error::<T>::NumOverflow)?;517518 CreatedCollectionCount::put(next_id);519520 let limits = CollectionLimits {521 sponsored_data_size: CUSTOM_DATA_LIMIT,522 ..Default::default()523 };524525 // Create new collection526 let new_collection = Collection {527 owner: who.clone(),528 name: collection_name,529 mode: mode.clone(),530 mint_mode: false,531 access: AccessMode::Normal,532 description: collection_description,533 decimal_points,534 token_prefix,535 offchain_schema: Vec::new(),536 schema_version: SchemaVersion::ImageURL,537 sponsorship: SponsorshipState::Disabled,538 variable_on_chain_schema: Vec::new(),539 const_on_chain_schema: Vec::new(),540 limits,541 transfers_enabled: true,542 };543544 // Add new collection to map545 <CollectionById<T>>::insert(next_id, new_collection);546547 // call event548 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));549550 Ok(())551 }552553 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.554 ///555 /// # Permissions556 ///557 /// * Collection Owner.558 ///559 /// # Arguments560 ///561 /// * collection_id: collection to destroy.562 #[weight = <SelfWeightOf<T>>::destroy_collection()]563 #[transactional]564 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {565566 let sender = ensure_signed(origin)?;567 let collection = Self::get_collection(collection_id)?;568 Self::check_owner_permissions(&collection, &sender)?;569 if !collection.limits.owner_can_destroy {570 fail!(Error::<T>::NoPermission);571 }572573 <AddressTokens<T>>::remove_prefix(collection_id, None);574 <Allowances<T>>::remove_prefix(collection_id, None);575 <Balance<T>>::remove_prefix(collection_id, None);576 <ItemListIndex>::remove(collection_id);577 <AdminList<T>>::remove(collection_id);578 <CollectionById<T>>::remove(collection_id);579 <WhiteList<T>>::remove_prefix(collection_id, None);580581 <NftItemList<T>>::remove_prefix(collection_id, None);582 <FungibleItemList<T>>::remove_prefix(collection_id, None);583 <ReFungibleItemList<T>>::remove_prefix(collection_id, None);584585 <NftTransferBasket<T>>::remove_prefix(collection_id, None);586 <FungibleTransferBasket<T>>::remove_prefix(collection_id, None);587 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);588589 <VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);590591 DestroyedCollectionCount::put(DestroyedCollectionCount::get()592 .checked_add(1)593 .ok_or(Error::<T>::NumOverflow)?);594595 Ok(())596 }597598 /// Add an address to white list.599 ///600 /// # Permissions601 ///602 /// * Collection Owner603 /// * Collection Admin604 ///605 /// # Arguments606 ///607 /// * collection_id.608 ///609 /// * address.610 #[weight = <SelfWeightOf<T>>::add_to_white_list()]611 #[transactional]612 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{613614 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);615 let collection = Self::get_collection(collection_id)?;616617 Self::toggle_white_list_internal(618 &sender,619 &collection,620 &address,621 true,622 )?;623624 Ok(())625 }626627 /// Remove an address from white list.628 ///629 /// # Permissions630 ///631 /// * Collection Owner632 /// * Collection Admin633 ///634 /// # Arguments635 ///636 /// * collection_id.637 ///638 /// * address.639 #[weight = <SelfWeightOf<T>>::remove_from_white_list()]640 #[transactional]641 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{642643 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);644 let collection = Self::get_collection(collection_id)?;645646 Self::toggle_white_list_internal(647 &sender,648 &collection,649 &address,650 false,651 )?;652653 Ok(())654 }655656 /// Toggle between normal and white list access for the methods with access for `Anyone`.657 ///658 /// # Permissions659 ///660 /// * Collection Owner.661 ///662 /// # Arguments663 ///664 /// * collection_id.665 ///666 /// * mode: [AccessMode]667 #[weight = <SelfWeightOf<T>>::set_public_access_mode()]668 #[transactional]669 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult670 {671 let sender = ensure_signed(origin)?;672673 let mut target_collection = Self::get_collection(collection_id)?;674 Self::check_owner_permissions(&target_collection, &sender)?;675 target_collection.access = mode;676 target_collection.save()677 }678679 /// Allows Anyone to create tokens if:680 /// * White List is enabled, and681 /// * Address is added to white list, and682 /// * This method was called with True parameter683 ///684 /// # Permissions685 /// * Collection Owner686 ///687 /// # Arguments688 ///689 /// * collection_id.690 ///691 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.692 #[weight = <SelfWeightOf<T>>::set_mint_permission()]693 #[transactional]694 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult695 {696 let sender = ensure_signed(origin)?;697698 let mut target_collection = Self::get_collection(collection_id)?;699 Self::check_owner_permissions(&target_collection, &sender)?;700 target_collection.mint_mode = mint_permission;701 target_collection.save()702 }703704 /// Change the owner of the collection.705 ///706 /// # Permissions707 ///708 /// * Collection Owner.709 ///710 /// # Arguments711 ///712 /// * collection_id.713 ///714 /// * new_owner.715 #[weight = <SelfWeightOf<T>>::change_collection_owner()]716 #[transactional]717 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {718719 let sender = ensure_signed(origin)?;720 let mut target_collection = Self::get_collection(collection_id)?;721 Self::check_owner_permissions(&target_collection, &sender)?;722 target_collection.owner = new_owner;723 target_collection.save()724 }725726 /// Adds an admin of the Collection.727 /// 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.728 ///729 /// # Permissions730 ///731 /// * Collection Owner.732 /// * Collection Admin.733 ///734 /// # Arguments735 ///736 /// * collection_id: ID of the Collection to add admin for.737 ///738 /// * new_admin_id: Address of new admin to add.739 #[weight = <SelfWeightOf<T>>::add_collection_admin()]740 #[transactional]741 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {742 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);743 let collection = Self::get_collection(collection_id)?;744 Self::check_owner_or_admin_permissions(&collection, &sender)?;745 let mut admin_arr = <AdminList<T>>::get(collection_id);746747 match admin_arr.binary_search(&new_admin_id) {748 Ok(_) => {},749 Err(idx) => {750 ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);751 admin_arr.insert(idx, new_admin_id);752 <AdminList<T>>::insert(collection_id, admin_arr);753 }754 }755 Ok(())756 }757758 /// 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.759 ///760 /// # Permissions761 ///762 /// * Collection Owner.763 /// * Collection Admin.764 ///765 /// # Arguments766 ///767 /// * collection_id: ID of the Collection to remove admin for.768 ///769 /// * account_id: Address of admin to remove.770 #[weight = <SelfWeightOf<T>>::remove_collection_admin()]771 #[transactional]772 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {773 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);774 let collection = Self::get_collection(collection_id)?;775 Self::check_owner_or_admin_permissions(&collection, &sender)?;776 let mut admin_arr = <AdminList<T>>::get(collection_id);777778 if let Ok(idx) = admin_arr.binary_search(&account_id) {779 admin_arr.remove(idx);780 <AdminList<T>>::insert(collection_id, admin_arr);781 }782 Ok(())783 }784785 /// # Permissions786 ///787 /// * Collection Owner788 ///789 /// # Arguments790 ///791 /// * collection_id.792 ///793 /// * new_sponsor.794 #[weight = <SelfWeightOf<T>>::set_collection_sponsor()]795 #[transactional]796 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {797 let sender = ensure_signed(origin)?;798 let mut target_collection = Self::get_collection(collection_id)?;799 Self::check_owner_permissions(&target_collection, &sender)?;800801 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);802 target_collection.save()803 }804805 /// # Permissions806 ///807 /// * Sponsor.808 ///809 /// # Arguments810 ///811 /// * collection_id.812 #[weight = <SelfWeightOf<T>>::confirm_sponsorship()]813 #[transactional]814 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {815 let sender = ensure_signed(origin)?;816817 let mut target_collection = Self::get_collection(collection_id)?;818 ensure!(819 target_collection.sponsorship.pending_sponsor() == Some(&sender),820 Error::<T>::ConfirmUnsetSponsorFail821 );822823 target_collection.sponsorship = SponsorshipState::Confirmed(sender);824 target_collection.save()825 }826827 /// Switch back to pay-per-own-transaction model.828 ///829 /// # Permissions830 ///831 /// * Collection owner.832 ///833 /// # Arguments834 ///835 /// * collection_id.836 #[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]837 #[transactional]838 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {839 let sender = ensure_signed(origin)?;840841 let mut target_collection = Self::get_collection(collection_id)?;842 Self::check_owner_permissions(&target_collection, &sender)?;843844 target_collection.sponsorship = SponsorshipState::Disabled;845 target_collection.save()846 }847848 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.849 ///850 /// # Permissions851 ///852 /// * Collection Owner.853 /// * Collection Admin.854 /// * Anyone if855 /// * White List is enabled, and856 /// * Address is added to white list, and857 /// * MintPermission is enabled (see SetMintPermission method)858 ///859 /// # Arguments860 ///861 /// * collection_id: ID of the collection.862 ///863 /// * owner: Address, initial owner of the NFT.864 ///865 /// * data: Token data to store on chain.866 // #[weight =867 // (130_000_000 as Weight)868 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))869 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))870 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]871872 #[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]873 #[transactional]874 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {875 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);876 let collection = Self::get_collection(collection_id)?;877878 Self::create_item_internal(&sender, &collection, &owner, data)?;879880 collection.submit_logs()881 }882883 /// This method creates multiple items in a collection created with CreateCollection method.884 ///885 /// # Permissions886 ///887 /// * Collection Owner.888 /// * Collection Admin.889 /// * Anyone if890 /// * White List is enabled, and891 /// * Address is added to white list, and892 /// * MintPermission is enabled (see SetMintPermission method)893 ///894 /// # Arguments895 ///896 /// * collection_id: ID of the collection.897 ///898 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].899 ///900 /// * owner: Address, initial owner of the NFT.901 #[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]902 #[transactional]903 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {904905 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);906 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);907 let collection = Self::get_collection(collection_id)?;908909 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;910911 collection.submit_logs()912 }913914 // TODO! transaction weight915916 /// Set transfers_enabled value for particular collection917 ///918 /// # Permissions919 ///920 /// * Collection Owner.921 ///922 /// # Arguments923 ///924 /// * collection_id: ID of the collection.925 ///926 /// * value: New flag value.927 #[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]928 #[transactional]929 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {930931 let sender = ensure_signed(origin)?;932 let mut target_collection = Self::get_collection(collection_id)?;933934 Self::check_owner_permissions(&target_collection, &sender)?;935936 target_collection.transfers_enabled = value;937 target_collection.save()938 }939940 /// Destroys a concrete instance of NFT.941 ///942 /// # Permissions943 ///944 /// * Collection Owner.945 /// * Collection Admin.946 /// * Current NFT Owner.947 ///948 /// # Arguments949 ///950 /// * collection_id: ID of the collection.951 ///952 /// * item_id: ID of NFT to burn.953 #[weight = <SelfWeightOf<T>>::burn_item()]954 #[transactional]955 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {956957 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);958 let target_collection = Self::get_collection(collection_id)?;959960 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;961962 target_collection.submit_logs()963 }964965 /// Change ownership of the token.966 ///967 /// # Permissions968 ///969 /// * Collection Owner970 /// * Collection Admin971 /// * Current NFT owner972 ///973 /// # Arguments974 ///975 /// * recipient: Address of token recipient.976 ///977 /// * collection_id.978 ///979 /// * item_id: ID of the item980 /// * Non-Fungible Mode: Required.981 /// * Fungible Mode: Ignored.982 /// * Re-Fungible Mode: Required.983 ///984 /// * value: Amount to transfer.985 /// * Non-Fungible Mode: Ignored986 /// * Fungible Mode: Must specify transferred amount987 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)988 #[weight = <SelfWeightOf<T>>::transfer()]989 #[transactional]990 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {991 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);992 let collection = Self::get_collection(collection_id)?;993994 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;995996 collection.submit_logs()997 }998999 /// Set, change, or remove approved address to transfer the ownership of the NFT.1000 ///1001 /// # Permissions1002 ///1003 /// * Collection Owner1004 /// * Collection Admin1005 /// * Current NFT owner1006 ///1007 /// # Arguments1008 ///1009 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1010 ///1011 /// * collection_id.1012 ///1013 /// * item_id: ID of the item.1014 #[weight = <SelfWeightOf<T>>::approve()]1015 #[transactional]1016 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1017 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1018 let collection = Self::get_collection(collection_id)?;10191020 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10211022 collection.submit_logs()1023 }10241025 /// 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.1026 ///1027 /// # Permissions1028 /// * Collection Owner1029 /// * Collection Admin1030 /// * Current NFT owner1031 /// * Address approved by current NFT owner1032 ///1033 /// # Arguments1034 ///1035 /// * from: Address that owns token.1036 ///1037 /// * recipient: Address of token recipient.1038 ///1039 /// * collection_id.1040 ///1041 /// * item_id: ID of the item.1042 ///1043 /// * value: Amount to transfer.1044 #[weight = <SelfWeightOf<T>>::transfer_from()]1045 #[transactional]1046 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1047 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1048 let collection = Self::get_collection(collection_id)?;10491050 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10511052 collection.submit_logs()1053 }1054 // #[weight = 0]1055 // // let no_perm_mes = "You do not have permissions to modify this collection";1056 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1057 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1058 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10591060 // // // on_nft_received call10611062 // // Self::transfer(origin, collection_id, item_id, new_owner)?;10631064 // Ok(())1065 // }10661067 /// Set off-chain data schema.1068 ///1069 /// # Permissions1070 ///1071 /// * Collection Owner1072 /// * Collection Admin1073 ///1074 /// # Arguments1075 ///1076 /// * collection_id.1077 ///1078 /// * schema: String representing the offchain data schema.1079 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1080 #[transactional]1081 pub fn set_variable_meta_data (1082 origin,1083 collection_id: CollectionId,1084 item_id: TokenId,1085 data: Vec<u8>1086 ) -> DispatchResult {1087 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10881089 let collection = Self::get_collection(collection_id)?;10901091 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10921093 Ok(())1094 }10951096 /// Set schema standard1097 /// ImageURL1098 /// Unique1099 ///1100 /// # Permissions1101 ///1102 /// * Collection Owner1103 /// * Collection Admin1104 ///1105 /// # Arguments1106 ///1107 /// * collection_id.1108 ///1109 /// * schema: SchemaVersion: enum1110 #[weight = <SelfWeightOf<T>>::set_schema_version()]1111 #[transactional]1112 pub fn set_schema_version(1113 origin,1114 collection_id: CollectionId,1115 version: SchemaVersion1116 ) -> DispatchResult {1117 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1118 let mut target_collection = Self::get_collection(collection_id)?;1119 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1120 target_collection.schema_version = version;1121 target_collection.save()1122 }11231124 /// Set off-chain data schema.1125 ///1126 /// # Permissions1127 ///1128 /// * Collection Owner1129 /// * Collection Admin1130 ///1131 /// # Arguments1132 ///1133 /// * collection_id.1134 ///1135 /// * schema: String representing the offchain data schema.1136 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1137 #[transactional]1138 pub fn set_offchain_schema(1139 origin,1140 collection_id: CollectionId,1141 schema: Vec<u8>1142 ) -> DispatchResult {1143 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1144 let mut target_collection = Self::get_collection(collection_id)?;1145 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11461147 // check schema limit1148 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11491150 target_collection.offchain_schema = schema;1151 target_collection.save()1152 }11531154 /// Set const on-chain data schema.1155 ///1156 /// # Permissions1157 ///1158 /// * Collection Owner1159 /// * Collection Admin1160 ///1161 /// # Arguments1162 ///1163 /// * collection_id.1164 ///1165 /// * schema: String representing the const on-chain data schema.1166 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1167 #[transactional]1168 pub fn set_const_on_chain_schema (1169 origin,1170 collection_id: CollectionId,1171 schema: Vec<u8>1172 ) -> DispatchResult {1173 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1174 let mut target_collection = Self::get_collection(collection_id)?;1175 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11761177 // check schema limit1178 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");11791180 target_collection.const_on_chain_schema = schema;1181 target_collection.save()1182 }11831184 /// Set variable on-chain data schema.1185 ///1186 /// # Permissions1187 ///1188 /// * Collection Owner1189 /// * Collection Admin1190 ///1191 /// # Arguments1192 ///1193 /// * collection_id.1194 ///1195 /// * schema: String representing the variable on-chain data schema.1196 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1197 #[transactional]1198 pub fn set_variable_on_chain_schema (1199 origin,1200 collection_id: CollectionId,1201 schema: Vec<u8>1202 ) -> DispatchResult {1203 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1204 let mut target_collection = Self::get_collection(collection_id)?;1205 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12061207 // check schema limit1208 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12091210 target_collection.variable_on_chain_schema = schema;1211 target_collection.save()1212 }12131214 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1215 #[transactional]1216 pub fn set_collection_limits(1217 origin,1218 collection_id: u32,1219 new_limits: CollectionLimits<T::BlockNumber>,1220 ) -> DispatchResult {1221 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1222 let mut target_collection = Self::get_collection(collection_id)?;1223 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1224 let old_limits = &target_collection.limits;12251226 // collection bounds1227 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1228 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1229 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1230 Error::<T>::CollectionLimitBoundsExceeded);12311232 // token_limit check prev1233 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1234 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12351236 ensure!(1237 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1238 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1239 Error::<T>::OwnerPermissionsCantBeReverted,1240 );12411242 target_collection.limits = new_limits;12431244 target_collection.save()1245 }1246 }1247}12481249impl<T: Config> Module<T> {1250 pub fn create_item_internal(1251 sender: &T::CrossAccountId,1252 collection: &CollectionHandle<T>,1253 owner: &T::CrossAccountId,1254 data: CreateItemData,1255 ) -> DispatchResult {1256 ensure!(1257 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1258 Error::<T>::AddressIsZero1259 );12601261 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1262 Self::validate_create_item_args(collection, &data)?;1263 Self::create_item_no_validation(collection, owner, data)?;12641265 Ok(())1266 }12671268 pub fn transfer_internal(1269 sender: &T::CrossAccountId,1270 recipient: &T::CrossAccountId,1271 target_collection: &CollectionHandle<T>,1272 item_id: TokenId,1273 value: u128,1274 ) -> DispatchResult {1275 ensure!(1276 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1277 Error::<T>::AddressIsZero1278 );12791280 // Limits check1281 Self::is_correct_transfer(target_collection, recipient)?;12821283 // Transfer permissions check1284 ensure!(1285 Self::is_item_owner(sender, target_collection, item_id)?1286 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1287 Error::<T>::NoPermission1288 );12891290 if target_collection.access == AccessMode::WhiteList {1291 Self::check_white_list(target_collection, sender)?;1292 Self::check_white_list(target_collection, recipient)?;1293 }12941295 match target_collection.mode {1296 CollectionMode::NFT => Self::transfer_nft(1297 target_collection,1298 item_id,1299 sender.clone(),1300 recipient.clone(),1301 )?,1302 CollectionMode::Fungible(_) => {1303 Self::transfer_fungible(target_collection, value, sender, recipient)?1304 }1305 CollectionMode::ReFungible => Self::transfer_refungible(1306 target_collection,1307 item_id,1308 value,1309 sender.clone(),1310 recipient.clone(),1311 )?,1312 _ => (),1313 };13141315 Self::deposit_event(RawEvent::Transfer(1316 target_collection.id,1317 item_id,1318 sender.clone(),1319 recipient.clone(),1320 value,1321 ));13221323 Ok(())1324 }13251326 pub fn approve_internal(1327 sender: &T::CrossAccountId,1328 spender: &T::CrossAccountId,1329 collection: &CollectionHandle<T>,1330 item_id: TokenId,1331 amount: u128,1332 ) -> DispatchResult {1333 Self::token_exists(collection, item_id)?;13341335 // Transfer permissions check1336 let bypasses_limits = collection.limits.owner_can_transfer1337 && Self::is_owner_or_admin_permissions(collection, sender)?;13381339 let allowance_limit = if bypasses_limits {1340 None1341 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1342 Some(amount)1343 } else {1344 fail!(Error::<T>::NoPermission);1345 };13461347 if collection.access == AccessMode::WhiteList {1348 Self::check_white_list(collection, sender)?;1349 Self::check_white_list(collection, spender)?;1350 }13511352 collection.consume_sload()?;1353 let allowance: u128 = amount1354 .checked_add(<Allowances<T>>::get(1355 collection.id,1356 (item_id, sender.as_sub(), spender.as_sub()),1357 ))1358 .ok_or(Error::<T>::NumOverflow)?;1359 if let Some(limit) = allowance_limit {1360 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1361 }1362 collection.consume_sstore()?;1363 <Allowances<T>>::insert(1364 collection.id,1365 (item_id, sender.as_sub(), spender.as_sub()),1366 allowance,1367 );13681369 if matches!(collection.mode, CollectionMode::NFT) {1370 // TODO: NFT: only one owner may exist for token in ERC7211371 collection.log(ERC721Events::Approval {1372 owner: *sender.as_eth(),1373 approved: *spender.as_eth(),1374 token_id: item_id.into(),1375 })?;1376 }13771378 if matches!(collection.mode, CollectionMode::Fungible(_)) {1379 // TODO: NFT: only one owner may exist for token in ERC201380 collection.log(ERC20Events::Approval {1381 owner: *sender.as_eth(),1382 spender: *spender.as_eth(),1383 value: allowance.into(),1384 })?;1385 }13861387 Self::deposit_event(RawEvent::Approved(1388 collection.id,1389 item_id,1390 sender.clone(),1391 spender.clone(),1392 allowance,1393 ));1394 Ok(())1395 }13961397 pub fn transfer_from_internal(1398 sender: &T::CrossAccountId,1399 from: &T::CrossAccountId,1400 recipient: &T::CrossAccountId,1401 collection: &CollectionHandle<T>,1402 item_id: TokenId,1403 amount: u128,1404 ) -> DispatchResult {1405 if sender == from {1406 // Transfer by `from`, because it is either equal to sender, or derived from him1407 return Self::transfer_internal(from, recipient, collection, item_id, amount);1408 }14091410 // Check approval1411 collection.consume_sload()?;1412 let approval: u128 =1413 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14141415 // Limits check1416 Self::is_correct_transfer(collection, recipient)?;14171418 // Transfer permissions check1419 ensure!(1420 approval >= amount1421 || (collection.limits.owner_can_transfer1422 && Self::is_owner_or_admin_permissions(collection, sender)?),1423 Error::<T>::NoPermission1424 );14251426 if collection.access == AccessMode::WhiteList {1427 Self::check_white_list(collection, sender)?;1428 Self::check_white_list(collection, recipient)?;1429 }14301431 // Reduce approval by transferred amount or remove if remaining approval drops to 01432 let allowance = approval.saturating_sub(amount);1433 collection.consume_sstore()?;1434 if allowance > 0 {1435 <Allowances<T>>::insert(1436 collection.id,1437 (item_id, from.as_sub(), sender.as_sub()),1438 allowance,1439 );1440 } else {1441 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1442 }14431444 match collection.mode {1445 CollectionMode::NFT => {1446 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1447 }1448 CollectionMode::Fungible(_) => {1449 Self::transfer_fungible(collection, amount, from, recipient)?1450 }1451 CollectionMode::ReFungible => Self::transfer_refungible(1452 collection,1453 item_id,1454 amount,1455 from.clone(),1456 recipient.clone(),1457 )?,1458 _ => (),1459 };14601461 if matches!(collection.mode, CollectionMode::Fungible(_)) {1462 collection.log(ERC20Events::Approval {1463 owner: *from.as_eth(),1464 spender: *sender.as_eth(),1465 value: allowance.into(),1466 })?;1467 }14681469 Ok(())1470 }14711472 pub fn set_variable_meta_data_internal(1473 sender: &T::CrossAccountId,1474 collection: &CollectionHandle<T>,1475 item_id: TokenId,1476 data: Vec<u8>,1477 ) -> DispatchResult {1478 Self::token_exists(collection, item_id)?;14791480 ensure!(1481 CUSTOM_DATA_LIMIT >= data.len() as u32,1482 Error::<T>::TokenVariableDataLimitExceeded1483 );14841485 // Modify permissions check1486 ensure!(1487 Self::is_item_owner(sender, collection, item_id)?1488 || Self::is_owner_or_admin_permissions(collection, sender)?,1489 Error::<T>::NoPermission1490 );14911492 match collection.mode {1493 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1494 CollectionMode::ReFungible => {1495 Self::set_re_fungible_variable_data(collection, item_id, data)?1496 }1497 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1498 _ => fail!(Error::<T>::UnexpectedCollectionType),1499 };15001501 Ok(())1502 }15031504 pub fn get_variable_metadata(1505 collection: &CollectionHandle<T>,1506 item_id: TokenId,1507 ) -> Result<Vec<u8>, DispatchError> {1508 Ok(match collection.mode {1509 CollectionMode::NFT => {1510 <NftItemList<T>>::get(collection.id, item_id)1511 .ok_or(Error::<T>::TokenNotFound)?1512 .variable_data1513 }1514 CollectionMode::ReFungible => {1515 <ReFungibleItemList<T>>::get(collection.id, item_id)1516 .ok_or(Error::<T>::TokenNotFound)?1517 .variable_data1518 }1519 _ => fail!(Error::<T>::UnexpectedCollectionType),1520 })1521 }15221523 pub fn create_multiple_items_internal(1524 sender: &T::CrossAccountId,1525 collection: &CollectionHandle<T>,1526 owner: &T::CrossAccountId,1527 items_data: Vec<CreateItemData>,1528 ) -> DispatchResult {1529 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15301531 for data in &items_data {1532 Self::validate_create_item_args(collection, data)?;1533 }1534 for data in &items_data {1535 Self::create_item_no_validation(collection, owner, data.clone())?;1536 }15371538 Ok(())1539 }15401541 pub fn burn_item_internal(1542 sender: &T::CrossAccountId,1543 collection: &CollectionHandle<T>,1544 item_id: TokenId,1545 value: u128,1546 ) -> DispatchResult {1547 ensure!(1548 Self::is_item_owner(sender, collection, item_id)?1549 || (collection.limits.owner_can_transfer1550 && Self::is_owner_or_admin_permissions(collection, sender)?),1551 Error::<T>::NoPermission1552 );15531554 if collection.access == AccessMode::WhiteList {1555 Self::check_white_list(collection, sender)?;1556 }15571558 match collection.mode {1559 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1560 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1561 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1562 _ => (),1563 };15641565 Ok(())1566 }15671568 pub fn toggle_white_list_internal(1569 sender: &T::CrossAccountId,1570 collection: &CollectionHandle<T>,1571 address: &T::CrossAccountId,1572 whitelisted: bool,1573 ) -> DispatchResult {1574 Self::check_owner_or_admin_permissions(collection, sender)?;15751576 if whitelisted {1577 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1578 } else {1579 <WhiteList<T>>::remove(collection.id, address.as_sub());1580 }15811582 Ok(())1583 }15841585 fn is_correct_transfer(1586 collection: &CollectionHandle<T>,1587 recipient: &T::CrossAccountId,1588 ) -> DispatchResult {1589 let collection_id = collection.id;15901591 // check token limit and account token limit1592 collection.consume_sload()?;1593 let account_items: u32 =1594 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;15951596 // zero limit means collection limit is disabled1597 // otherwise get lower value1598 let limit = if collection.limits.account_token_ownership_limit == 01599 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1600 {1601 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1602 } else {1603 collection.limits.account_token_ownership_limit1604 };16051606 ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16071608 // preliminary transfer check1609 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16101611 Ok(())1612 }16131614 fn can_create_items_in_collection(1615 collection: &CollectionHandle<T>,1616 sender: &T::CrossAccountId,1617 owner: &T::CrossAccountId,1618 amount: u32,1619 ) -> DispatchResult {1620 let collection_id = collection.id;16211622 // check token limit and account token limit1623 let total_items: u32 = ItemListIndex::get(collection_id)1624 .checked_add(amount)1625 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1626 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1627 as u32)1628 .checked_add(amount)1629 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;16301631 // zero limit means collection limit is disabled1632 // otherwise get lower value1633 let account_token_limit = if collection.limits.account_token_ownership_limit == 01634 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1635 {1636 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1637 } else {1638 collection.limits.account_token_ownership_limit1639 };16401641 ensure!(1642 collection.limits.token_limit >= total_items,1643 Error::<T>::CollectionTokenLimitExceeded1644 );1645 ensure!(1646 account_token_limit >= account_items,1647 Error::<T>::AccountTokenLimitExceeded1648 );16491650 if !Self::is_owner_or_admin_permissions(collection, sender)? {1651 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1652 Self::check_white_list(collection, owner)?;1653 Self::check_white_list(collection, sender)?;1654 }16551656 Ok(())1657 }16581659 fn validate_create_item_args(1660 target_collection: &CollectionHandle<T>,1661 data: &CreateItemData,1662 ) -> DispatchResult {1663 match target_collection.mode {1664 CollectionMode::NFT => {1665 if !matches!(data, CreateItemData::NFT(_)) {1666 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1667 }1668 }1669 CollectionMode::Fungible(_) => {1670 if !matches!(data, CreateItemData::Fungible(_)) {1671 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1672 }1673 }1674 CollectionMode::ReFungible => {1675 if let CreateItemData::ReFungible(data) = data {1676 // Check refungibility limits1677 ensure!(1678 data.pieces <= MAX_REFUNGIBLE_PIECES,1679 Error::<T>::WrongRefungiblePieces1680 );1681 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1682 } else {1683 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1684 }1685 }1686 _ => {1687 fail!(Error::<T>::UnexpectedCollectionType);1688 }1689 };16901691 Ok(())1692 }16931694 fn create_item_no_validation(1695 collection: &CollectionHandle<T>,1696 owner: &T::CrossAccountId,1697 data: CreateItemData,1698 ) -> DispatchResult {1699 match data {1700 CreateItemData::NFT(data) => {1701 let item = NftItemType {1702 owner: owner.clone(),1703 const_data: data.const_data.into_inner(),1704 variable_data: data.variable_data.into_inner(),1705 };17061707 Self::add_nft_item(collection, item)?;1708 }1709 CreateItemData::Fungible(data) => {1710 Self::add_fungible_item(collection, owner, data.value)?;1711 }1712 CreateItemData::ReFungible(data) => {1713 let owner_list = vec![Ownership {1714 owner: owner.clone(),1715 fraction: data.pieces,1716 }];17171718 let item = ReFungibleItemType {1719 owner: owner_list,1720 const_data: data.const_data.into_inner(),1721 variable_data: data.variable_data.into_inner(),1722 };17231724 Self::add_refungible_item(collection, item)?;1725 }1726 };17271728 Ok(())1729 }17301731 fn add_fungible_item(1732 collection: &CollectionHandle<T>,1733 owner: &T::CrossAccountId,1734 value: u128,1735 ) -> DispatchResult {1736 let collection_id = collection.id;17371738 // Does new owner already have an account?1739 collection.consume_sload()?;1740 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17411742 // Mint1743 let item = FungibleItemType {1744 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1745 };1746 collection.consume_sstore()?;1747 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17481749 // Update balance1750 collection.consume_sload()?;1751 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1752 .checked_add(value)1753 .ok_or(Error::<T>::NumOverflow)?;1754 collection.consume_sstore()?;1755 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17561757 collection.log(ERC20Events::Transfer {1758 from: H160::default(),1759 to: *owner.as_eth(),1760 value: value.into(),1761 })?;1762 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1763 Ok(())1764 }17651766 fn add_refungible_item(1767 collection: &CollectionHandle<T>,1768 item: ReFungibleItemType<T::CrossAccountId>,1769 ) -> DispatchResult {1770 let collection_id = collection.id;17711772 let current_index = <ItemListIndex>::get(collection_id)1773 .checked_add(1)1774 .ok_or(Error::<T>::NumOverflow)?;1775 let itemcopy = item.clone();17761777 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1778 let item_owner = item.owner.first().expect("only one owner is defined");17791780 let value = item_owner.fraction;1781 let owner = item_owner.owner.clone();17821783 Self::add_token_index(collection, current_index, &owner)?;17841785 <ItemListIndex>::insert(collection_id, current_index);1786 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17871788 // Update balance1789 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1790 .checked_add(value)1791 .ok_or(Error::<T>::NumOverflow)?;1792 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17931794 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1795 Ok(())1796 }17971798 fn add_nft_item(1799 collection: &CollectionHandle<T>,1800 item: NftItemType<T::CrossAccountId>,1801 ) -> DispatchResult {1802 let collection_id = collection.id;18031804 let current_index = <ItemListIndex>::get(collection_id)1805 .checked_add(1)1806 .ok_or(Error::<T>::NumOverflow)?;18071808 let item_owner = item.owner.clone();1809 Self::add_token_index(collection, current_index, &item.owner)?;18101811 <ItemListIndex>::insert(collection_id, current_index);1812 <NftItemList<T>>::insert(collection_id, current_index, item);18131814 // Update balance1815 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1816 .checked_add(1)1817 .ok_or(Error::<T>::NumOverflow)?;1818 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18191820 collection.log(ERC721Events::Transfer {1821 from: H160::default(),1822 to: *item_owner.as_eth(),1823 token_id: current_index.into(),1824 })?;1825 Self::deposit_event(RawEvent::ItemCreated(1826 collection_id,1827 current_index,1828 item_owner,1829 ));1830 Ok(())1831 }18321833 fn burn_refungible_item(1834 collection: &CollectionHandle<T>,1835 item_id: TokenId,1836 owner: &T::CrossAccountId,1837 ) -> DispatchResult {1838 let collection_id = collection.id;18391840 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1841 .ok_or(Error::<T>::TokenNotFound)?;1842 let rft_balance = token1843 .owner1844 .iter()1845 .find(|&i| i.owner == *owner)1846 .ok_or(Error::<T>::TokenNotFound)?;1847 Self::remove_token_index(collection, item_id, owner)?;18481849 // update balance1850 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1851 .checked_sub(rft_balance.fraction)1852 .ok_or(Error::<T>::NumOverflow)?;1853 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18541855 // Re-create owners list with sender removed1856 let index = token1857 .owner1858 .iter()1859 .position(|i| i.owner == *owner)1860 .expect("owned item is exists");1861 token.owner.remove(index);1862 let owner_count = token.owner.len();18631864 // Burn the token completely if this was the last (only) owner1865 if owner_count == 0 {1866 <ReFungibleItemList<T>>::remove(collection_id, item_id);1867 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1868 } else {1869 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1870 }18711872 Ok(())1873 }18741875 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1876 let collection_id = collection.id;18771878 let item =1879 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1880 Self::remove_token_index(collection, item_id, &item.owner)?;18811882 // update balance1883 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1884 .checked_sub(1)1885 .ok_or(Error::<T>::NumOverflow)?;1886 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1887 <NftItemList<T>>::remove(collection_id, item_id);1888 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);18891890 collection.log(ERC721Events::Transfer {1891 from: *item.owner.as_eth(),1892 to: H160::default(),1893 token_id: item_id.into(),1894 })?;1895 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1896 Ok(())1897 }18981899 fn burn_fungible_item(1900 owner: &T::CrossAccountId,1901 collection: &CollectionHandle<T>,1902 value: u128,1903 ) -> DispatchResult {1904 let collection_id = collection.id;19051906 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1907 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19081909 // update balance1910 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1911 .checked_sub(value)1912 .ok_or(Error::<T>::NumOverflow)?;1913 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19141915 if balance.value - value > 0 {1916 balance.value -= value;1917 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1918 } else {1919 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1920 }19211922 collection.log(ERC20Events::Transfer {1923 from: *owner.as_eth(),1924 to: H160::default(),1925 value: value.into(),1926 })?;1927 Ok(())1928 }19291930 pub fn get_collection(1931 collection_id: CollectionId,1932 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1933 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1934 }19351936 fn check_owner_permissions(1937 target_collection: &CollectionHandle<T>,1938 subject: &T::AccountId,1939 ) -> DispatchResult {1940 ensure!(1941 *subject == target_collection.owner,1942 Error::<T>::NoPermission1943 );19441945 Ok(())1946 }19471948 fn is_owner_or_admin_permissions(1949 collection: &CollectionHandle<T>,1950 subject: &T::CrossAccountId,1951 ) -> Result<bool, DispatchError> {1952 collection.consume_sload()?;1953 Ok(*subject.as_sub() == collection.owner1954 || <AdminList<T>>::get(collection.id).contains(subject))1955 }19561957 fn check_owner_or_admin_permissions(1958 collection: &CollectionHandle<T>,1959 subject: &T::CrossAccountId,1960 ) -> DispatchResult {1961 ensure!(1962 Self::is_owner_or_admin_permissions(collection, subject)?,1963 Error::<T>::NoPermission1964 );19651966 Ok(())1967 }19681969 fn owned_amount(1970 subject: &T::CrossAccountId,1971 collection: &CollectionHandle<T>,1972 item_id: TokenId,1973 ) -> Result<Option<u128>, DispatchError> {1974 collection.consume_sload()?;1975 Ok(Self::owned_amount_unchecked(subject, collection, item_id))1976 }19771978 fn owned_amount_unchecked(1979 subject: &T::CrossAccountId,1980 target_collection: &CollectionHandle<T>,1981 item_id: TokenId,1982 ) -> Option<u128> {1983 let collection_id = target_collection.id;19841985 match target_collection.mode {1986 CollectionMode::NFT => {1987 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1988 }1989 CollectionMode::Fungible(_) => {1990 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1991 }1992 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1993 .owner1994 .iter()1995 .find(|i| i.owner == *subject)1996 .map(|i| i.fraction),1997 CollectionMode::Invalid => None,1998 }1999 }20002001 fn is_item_owner(2002 subject: &T::CrossAccountId,2003 target_collection: &CollectionHandle<T>,2004 item_id: TokenId,2005 ) -> Result<bool, DispatchError> {2006 Ok(match target_collection.mode {2007 CollectionMode::Fungible(_) => true,2008 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2009 })2010 }20112012 fn check_white_list(2013 collection: &CollectionHandle<T>,2014 address: &T::CrossAccountId,2015 ) -> DispatchResult {2016 collection.consume_sload()?;2017 ensure!(2018 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2019 Error::<T>::AddresNotInWhiteList,2020 );2021 Ok(())2022 }20232024 /// Check if token exists. In case of Fungible, check if there is an entry for2025 /// the owner in fungible balances double map2026 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2027 let collection_id = target_collection.id;2028 let exists = match target_collection.mode {2029 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2030 CollectionMode::Fungible(_) => true,2031 CollectionMode::ReFungible => {2032 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2033 }2034 _ => false,2035 };20362037 ensure!(exists, Error::<T>::TokenNotFound);2038 Ok(())2039 }20402041 fn transfer_fungible(2042 collection: &CollectionHandle<T>,2043 value: u128,2044 owner: &T::CrossAccountId,2045 recipient: &T::CrossAccountId,2046 ) -> DispatchResult {2047 let collection_id = collection.id;20482049 collection.consume_sload()?;2050 collection.consume_sload()?;2051 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2052 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20532054 recipient_balance.value = recipient_balance2055 .value2056 .checked_add(value)2057 .ok_or(Error::<T>::NumOverflow)?;2058 balance.value = balance2059 .value2060 .checked_sub(value)2061 .ok_or(Error::<T>::TokenValueTooLow)?;20622063 // update balanceOf2064 collection.consume_sstore()?;2065 collection.consume_sstore()?;2066 if balance.value != 0 {2067 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2068 } else {2069 <Balance<T>>::remove(collection_id, owner.as_sub());2070 }2071 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20722073 // Reduce or remove sender2074 collection.consume_sstore()?;2075 collection.consume_sstore()?;2076 if balance.value != 0 {2077 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2078 } else {2079 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2080 }2081 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);20822083 collection.log(ERC20Events::Transfer {2084 from: *owner.as_eth(),2085 to: *recipient.as_eth(),2086 value: value.into(),2087 })?;2088 Self::deposit_event(RawEvent::Transfer(2089 collection.id,2090 1,2091 owner.clone(),2092 recipient.clone(),2093 value,2094 ));20952096 Ok(())2097 }20982099 fn transfer_refungible(2100 collection: &CollectionHandle<T>,2101 item_id: TokenId,2102 value: u128,2103 owner: T::CrossAccountId,2104 new_owner: T::CrossAccountId,2105 ) -> DispatchResult {2106 let collection_id = collection.id;2107 collection.consume_sload()?;2108 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2109 .ok_or(Error::<T>::TokenNotFound)?;21102111 let item = full_item2112 .owner2113 .iter()2114 .find(|i| i.owner == owner)2115 .ok_or(Error::<T>::TokenNotFound)?;2116 let amount = item.fraction;21172118 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21192120 collection.consume_sload()?;2121 // update balance2122 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2123 .checked_sub(value)2124 .ok_or(Error::<T>::NumOverflow)?;2125 collection.consume_sstore()?;2126 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21272128 collection.consume_sload()?;2129 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2130 .checked_add(value)2131 .ok_or(Error::<T>::NumOverflow)?;2132 collection.consume_sstore()?;2133 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21342135 let old_owner = item.owner.clone();2136 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21372138 let mut new_full_item = full_item.clone();2139 // transfer2140 if amount == value && !new_owner_has_account {2141 // change owner2142 // new owner do not have account2143 new_full_item2144 .owner2145 .iter_mut()2146 .find(|i| i.owner == owner)2147 .expect("old owner does present in refungible")2148 .owner = new_owner.clone();2149 collection.consume_sstore()?;2150 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21512152 // update index collection2153 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2154 } else {2155 new_full_item2156 .owner2157 .iter_mut()2158 .find(|i| i.owner == owner)2159 .expect("old owner does present in refungible")2160 .fraction -= value;21612162 // separate amount2163 if new_owner_has_account {2164 // new owner has account2165 new_full_item2166 .owner2167 .iter_mut()2168 .find(|i| i.owner == new_owner)2169 .expect("new owner has account")2170 .fraction += value;2171 } else {2172 // new owner do not have account2173 new_full_item.owner.push(Ownership {2174 owner: new_owner.clone(),2175 fraction: value,2176 });2177 Self::add_token_index(collection, item_id, &new_owner)?;2178 }21792180 collection.consume_sstore()?;2181 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2182 }21832184 Self::deposit_event(RawEvent::Transfer(2185 collection.id,2186 item_id,2187 owner,2188 new_owner,2189 amount,2190 ));21912192 Ok(())2193 }21942195 fn transfer_nft(2196 collection: &CollectionHandle<T>,2197 item_id: TokenId,2198 sender: T::CrossAccountId,2199 new_owner: T::CrossAccountId,2200 ) -> DispatchResult {2201 let collection_id = collection.id;2202 collection.consume_sload()?;2203 let mut item =2204 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22052206 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22072208 collection.consume_sload()?;2209 // update balance2210 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2211 .checked_sub(1)2212 .ok_or(Error::<T>::NumOverflow)?;2213 collection.consume_sstore()?;2214 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22152216 collection.consume_sload()?;2217 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2218 .checked_add(1)2219 .ok_or(Error::<T>::NumOverflow)?;2220 collection.consume_sstore()?;2221 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22222223 // change owner2224 let old_owner = item.owner.clone();2225 item.owner = new_owner.clone();2226 collection.consume_sstore()?;2227 <NftItemList<T>>::insert(collection_id, item_id, item);22282229 // update index collection2230 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22312232 collection.log(ERC721Events::Transfer {2233 from: *sender.as_eth(),2234 to: *new_owner.as_eth(),2235 token_id: item_id.into(),2236 })?;2237 Self::deposit_event(RawEvent::Transfer(2238 collection.id,2239 item_id,2240 sender,2241 new_owner,2242 1,2243 ));22442245 Ok(())2246 }22472248 fn set_re_fungible_variable_data(2249 collection: &CollectionHandle<T>,2250 item_id: TokenId,2251 data: Vec<u8>,2252 ) -> DispatchResult {2253 let collection_id = collection.id;2254 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2255 .ok_or(Error::<T>::TokenNotFound)?;22562257 item.variable_data = data;22582259 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22602261 Ok(())2262 }22632264 fn set_nft_variable_data(2265 collection: &CollectionHandle<T>,2266 item_id: TokenId,2267 data: Vec<u8>,2268 ) -> DispatchResult {2269 let collection_id = collection.id;2270 let mut item =2271 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22722273 item.variable_data = data;22742275 <NftItemList<T>>::insert(collection_id, item_id, item);22762277 Ok(())2278 }22792280 #[allow(dead_code)]2281 fn init_collection(item: &Collection<T>) {2282 // check params2283 assert!(2284 item.decimal_points <= MAX_DECIMAL_POINTS,2285 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2286 );2287 assert!(2288 item.name.len() <= 64,2289 "Collection name can not be longer than 63 char"2290 );2291 assert!(2292 item.name.len() <= 256,2293 "Collection description can not be longer than 255 char"2294 );2295 assert!(2296 item.token_prefix.len() <= 16,2297 "Token prefix can not be longer than 15 char"2298 );22992300 // Generate next collection ID2301 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23022303 CreatedCollectionCount::put(next_id);2304 }23052306 #[allow(dead_code)]2307 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2308 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23092310 Self::add_token_index(2311 &CollectionHandle::get(collection_id).unwrap(),2312 current_index,2313 &item.owner,2314 )2315 .unwrap();23162317 <ItemListIndex>::insert(collection_id, current_index);23182319 // Update balance2320 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2321 .checked_add(1)2322 .unwrap();2323 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2324 }23252326 #[allow(dead_code)]2327 fn init_fungible_token(2328 collection_id: CollectionId,2329 owner: &T::CrossAccountId,2330 item: &FungibleItemType,2331 ) {2332 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23332334 Self::add_token_index(2335 &CollectionHandle::get(collection_id).unwrap(),2336 current_index,2337 owner,2338 )2339 .unwrap();23402341 <ItemListIndex>::insert(collection_id, current_index);23422343 // Update balance2344 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2345 .checked_add(item.value)2346 .unwrap();2347 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2348 }23492350 #[allow(dead_code)]2351 fn init_refungible_token(2352 collection_id: CollectionId,2353 item: &ReFungibleItemType<T::CrossAccountId>,2354 ) {2355 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23562357 let value = item.owner.first().unwrap().fraction;2358 let owner = item.owner.first().unwrap().owner.clone();23592360 Self::add_token_index(2361 &CollectionHandle::get(collection_id).unwrap(),2362 current_index,2363 &owner,2364 )2365 .unwrap();23662367 <ItemListIndex>::insert(collection_id, current_index);23682369 // Update balance2370 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2371 .checked_add(value)2372 .unwrap();2373 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2374 }23752376 fn add_token_index(2377 collection: &CollectionHandle<T>,2378 item_index: TokenId,2379 owner: &T::CrossAccountId,2380 ) -> DispatchResult {2381 collection.consume_sload()?;2382 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2383 if list_exists {2384 collection.consume_sload()?;2385 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());23862387 // bound Owned tokens by a single address in collection2388 let account_items: u32 = list.len() as u32;2389 ensure!(2390 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2391 Error::<T>::AddressOwnershipLimitExceeded2392 );23932394 let item_contains = list.contains(&item_index.clone());23952396 if !item_contains {2397 list.push(item_index);2398 }23992400 collection.consume_sstore()?;2401 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2402 } else {2403 let itm = vec![item_index];2404 collection.consume_sstore()?;2405 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2406 }24072408 Ok(())2409 }24102411 fn remove_token_index(2412 collection: &CollectionHandle<T>,2413 item_index: TokenId,2414 owner: &T::CrossAccountId,2415 ) -> DispatchResult {2416 collection.consume_sload()?;2417 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2418 if list_exists {2419 collection.consume_sload()?;2420 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2421 let item_contains = list.contains(&item_index.clone());24222423 if item_contains {2424 list.retain(|&item| item != item_index);2425 collection.consume_sstore()?;2426 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2427 }2428 }24292430 Ok(())2431 }24322433 fn move_token_index(2434 collection: &CollectionHandle<T>,2435 item_index: TokenId,2436 old_owner: &T::CrossAccountId,2437 new_owner: &T::CrossAccountId,2438 ) -> DispatchResult {2439 Self::remove_token_index(collection, item_index, old_owner)?;2440 Self::add_token_index(collection, item_index, new_owner)?;24412442 Ok(())2443 }2444}24452446sp_api::decl_runtime_apis! {2447 pub trait NftApi {2448 /// Used for ethereum integration2449 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2450 }2451}pallets/nft/src/sponsorship.rsdiffbeforeafterboth--- a/pallets/nft/src/sponsorship.rs
+++ b/pallets/nft/src/sponsorship.rs
@@ -61,10 +61,15 @@
sponsor_transfer = match collection_mode {
CollectionMode::NFT => {
// get correct limit
- let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
- collection_limits.sponsor_transfer_timeout
+ let limit: u32 = if collection_limits.sponsor_transfer_timeout != 0 {
+ if collection_limits.sponsor_transfer_timeout > NFT_SPONSOR_TRANSFER_TIMEOUT
+ {
+ collection_limits.sponsor_transfer_timeout
+ } else {
+ NFT_SPONSOR_TRANSFER_TIMEOUT
+ }
} else {
- NFT_SPONSOR_TRANSFER_TIMEOUT
+ 0
};
let mut sponsored = true;
@@ -83,13 +88,18 @@
}
CollectionMode::Fungible(_) => {
// get correct limit
- let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
- collection_limits.sponsor_transfer_timeout
+ let limit: u32 = if collection_limits.sponsor_transfer_timeout != 0 {
+ if collection_limits.sponsor_transfer_timeout
+ > FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
+ {
+ collection_limits.sponsor_transfer_timeout
+ } else {
+ FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
+ }
} else {
- FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
+ 0
};
- let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;
let mut sponsored = true;
if FungibleTransferBasket::<T>::contains_key(collection_id, who) {
let last_tx_block = FungibleTransferBasket::<T>::get(collection_id, who);
@@ -106,10 +116,16 @@
}
CollectionMode::ReFungible => {
// get correct limit
- let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
- collection_limits.sponsor_transfer_timeout
+ let limit: u32 = if collection_limits.sponsor_transfer_timeout != 0 {
+ if collection_limits.sponsor_transfer_timeout
+ > REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
+ {
+ collection_limits.sponsor_transfer_timeout
+ } else {
+ REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
+ }
} else {
- REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
+ 0
};
let mut sponsored = true;
tests/src/limits.test.tsdiffbeforeafterboth--- /dev/null
+++ b/tests/src/limits.test.ts
@@ -0,0 +1,378 @@
+//
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE', which is part of this source code package.
+//
+
+import { IKeyringPair } from '@polkadot/types/types';
+import privateKey from './substrate/privateKey';
+import usingApi from './substrate/substrate-api';
+import {
+ createCollectionExpectSuccess,
+ destroyCollectionExpectSuccess,
+ setCollectionLimitsExpectSuccess,
+ setCollectionSponsorExpectSuccess,
+ confirmSponsorshipExpectSuccess,
+ createItemExpectSuccess,
+ createItemExpectFailure,
+ transferExpectSuccess,
+ getFreeBalance,
+ waitNewBlocks,
+} from './util/helpers';
+import { expect } from 'chai';
+
+describe('Number of tokens per address (NFT)', () => {
+ let Alice: IKeyringPair;
+
+ before(async () => {
+ await usingApi(async () => {
+ Alice = privateKey('//Alice');
+ });
+ });
+
+ it('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {
+
+ const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 20 });
+ for(let i = 0; i < 10; i++){
+ await createItemExpectSuccess(Alice, collectionId, 'NFT');
+ }
+ await createItemExpectFailure(Alice, collectionId, 'NFT');
+ await destroyCollectionExpectSuccess(collectionId);
+ });
+
+ it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {
+
+ const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 1 });
+ await createItemExpectSuccess(Alice, collectionId, 'NFT');
+ await createItemExpectFailure(Alice, collectionId, 'NFT');
+ await destroyCollectionExpectSuccess(collectionId);
+ });
+});
+
+describe('Number of tokens per address (ReFungible)', () => {
+ let Alice: IKeyringPair;
+
+ before(async () => {
+ await usingApi(async () => {
+ Alice = privateKey('//Alice');
+ });
+ });
+
+ it('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {
+ const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 20 });
+ for(let i = 0; i < 10; i++){
+ await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
+ }
+ await createItemExpectFailure(Alice, collectionId, 'ReFungible');
+ await destroyCollectionExpectSuccess(collectionId);
+ });
+
+ it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {
+ const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 1 });
+ await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
+ await createItemExpectFailure(Alice, collectionId, 'ReFungible');
+ await destroyCollectionExpectSuccess(collectionId);
+ });
+});
+
+describe('Sponsor timeout (NFT)', () => {
+ let Alice: IKeyringPair;
+ let Bob: IKeyringPair;
+ let Charlie: IKeyringPair;
+
+ before(async () => {
+ await usingApi(async () => {
+ Alice = privateKey('//Alice');
+ Bob = privateKey('//Bob');
+ Charlie = privateKey('//Charlie');
+ });
+ });
+
+ it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
+ const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });
+ const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
+ await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+ await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+ await transferExpectSuccess(collectionId, tokenId, Alice, Bob);
+ const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+ // check setting SponsorTimeout = 5, fail
+ await waitNewBlocks(5);
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie);
+ const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+ // check setting SponsorTimeout = 7, success
+ await waitNewBlocks(2); // 5 + 2
+ await transferExpectSuccess(collectionId, tokenId, Charlie, Bob);
+ const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+ await destroyCollectionExpectSuccess(collectionId);
+ });
+
+ it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
+
+ const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });
+ const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
+ await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+ await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+ await transferExpectSuccess(collectionId, tokenId, Alice, Bob);
+ const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+ // check setting SponsorTimeout = 1, fail
+ await waitNewBlocks(1);
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie);
+ const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+ // check setting SponsorTimeout = 5, success
+ await waitNewBlocks(4);
+ await transferExpectSuccess(collectionId, tokenId, Charlie, Bob);
+ const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+ await destroyCollectionExpectSuccess(collectionId);
+ });
+});
+
+describe('Sponsor timeout (Fungible)', () => {
+ let Alice: IKeyringPair;
+ let Bob: IKeyringPair;
+ let Charlie: IKeyringPair;
+
+ before(async () => {
+ await usingApi(async () => {
+ Alice = privateKey('//Alice');
+ Bob = privateKey('//Bob');
+ Charlie = privateKey('//Charlie');
+ });
+ });
+
+ it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
+ const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });
+ const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
+ await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+ await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+ await transferExpectSuccess(collectionId, tokenId, Alice, Bob, 10, 'Fungible');
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+ const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+ // check setting SponsorTimeout = 5, fail
+ await waitNewBlocks(5);
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+ const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+ // check setting SponsorTimeout = 7, success
+ await waitNewBlocks(2); // 5 + 2
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+ const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+
+ await destroyCollectionExpectSuccess(collectionId);
+ });
+
+ it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
+
+ const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });
+ const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
+ await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+ await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+ await transferExpectSuccess(collectionId, tokenId, Alice, Bob, 10, 'Fungible');
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+ const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+ // check setting SponsorTimeout = 1, fail
+ await waitNewBlocks(1);
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+ const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+ // check setting SponsorTimeout = 5, success
+ await waitNewBlocks(4);
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+ const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+
+ await destroyCollectionExpectSuccess(collectionId);
+ });
+});
+
+describe('Sponsor timeout (ReFungible)', () => {
+ let Alice: IKeyringPair;
+ let Bob: IKeyringPair;
+ let Charlie: IKeyringPair;
+
+ before(async () => {
+ await usingApi(async () => {
+ Alice = privateKey('//Alice');
+ Bob = privateKey('//Bob');
+ Charlie = privateKey('//Charlie');
+ });
+ });
+
+ it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
+ const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });
+ const tokenId = await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
+ await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+ await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+ await transferExpectSuccess(collectionId, tokenId, Alice, Bob, 100, 'ReFungible');
+ const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+ // check setting SponsorTimeout = 5, fail
+ await waitNewBlocks(5);
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 20, 'ReFungible');
+ const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+ // check setting SponsorTimeout = 7, success
+ await waitNewBlocks(2); // 5 + 2
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 20, 'ReFungible');
+ const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+ await destroyCollectionExpectSuccess(collectionId);
+ });
+
+ it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
+
+ const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });
+ const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
+ await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+ await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+ await transferExpectSuccess(collectionId, tokenId, Alice, Bob);
+ const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+ // check setting SponsorTimeout = 1, fail
+ await waitNewBlocks(1);
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie);
+ const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+ // check setting SponsorTimeout = 5, success
+ await waitNewBlocks(4);
+ await transferExpectSuccess(collectionId, tokenId, Charlie, Bob);
+ const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+ await destroyCollectionExpectSuccess(collectionId);
+ });
+});
+
+describe('Collection zero limits (NFT)', () => {
+ let Alice: IKeyringPair;
+ let Bob: IKeyringPair;
+ let Charlie: IKeyringPair;
+
+ before(async () => {
+ await usingApi(async () => {
+ Alice = privateKey('//Alice');
+ Bob = privateKey('//Bob');
+ Charlie = privateKey('//Charlie');
+ });
+ });
+
+ it('Limits have 0 in tokens per address field, the chain limits are applied', async () => {
+ const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 0 });
+ for(let i = 0; i < 10; i++){
+ await createItemExpectSuccess(Alice, collectionId, 'NFT');
+ }
+ await createItemExpectFailure(Alice, collectionId, 'NFT');
+ });
+
+ it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
+
+ const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });
+ const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
+ await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+ await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+ await transferExpectSuccess(collectionId, tokenId, Alice, Bob);
+ const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+ // check setting SponsorTimeout = 0, success with next block
+ await waitNewBlocks(1);
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie);
+ const aliceBalanceAfterSponsoredTransaction1 = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
+ });
+});
+
+describe.only('Collection zero limits (Fungible)', () => {
+ let Alice: IKeyringPair;
+ let Bob: IKeyringPair;
+ let Charlie: IKeyringPair;
+
+ before(async () => {
+ await usingApi(async () => {
+ Alice = privateKey('//Alice');
+ Bob = privateKey('//Bob');
+ Charlie = privateKey('//Charlie');
+ });
+ });
+
+ it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
+ const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });
+ const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
+ await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+ await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+ await transferExpectSuccess(collectionId, tokenId, Alice, Bob, 10, 'Fungible');
+ const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+
+ // check setting SponsorTimeout = 0, success with next block
+ await waitNewBlocks(1);
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+ const aliceBalanceAfterSponsoredTransaction1 = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
+ });
+});
+
+describe.only('Collection zero limits (ReFungible)', () => {
+ let Alice: IKeyringPair;
+ let Bob: IKeyringPair;
+ let Charlie: IKeyringPair;
+
+ before(async () => {
+ await usingApi(async () => {
+ Alice = privateKey('//Alice');
+ Bob = privateKey('//Bob');
+ Charlie = privateKey('//Charlie');
+ });
+ });
+
+ it('Limits have 0 in tokens per address field, the chain limits are applied', async () => {
+ const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 0 });
+ for(let i = 0; i < 10; i++){
+ await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
+ }
+ await createItemExpectFailure(Alice, collectionId, 'ReFungible');
+ });
+
+ it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
+
+ const collectionId = await createCollectionExpectSuccess({ mode: { type: 'ReFungible' } });
+ await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });
+ const tokenId = await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
+ await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+ await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+ await transferExpectSuccess(collectionId, tokenId, Alice, Bob, 100, 'ReFungible');
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 20, 'ReFungible');
+ const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+ // check setting SponsorTimeout = 0, success with next block
+ await waitNewBlocks(1);
+ await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 20, 'ReFungible');
+ const aliceBalanceAfterSponsoredTransaction1 = (await getFreeBalance(Alice)).toNumber();
+ expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
+ });
+});
tests/src/util/helpers.tsdiffbeforeafterboth--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -797,6 +797,17 @@
}
export async function
+getFreeBalance(account: IKeyringPair) : Promise<BigNumber>
+{
+ let balance = new BigNumber(0) ;
+ await usingApi(async (api) => {
+ balance = new BigNumber((await api.query.system.account(account.address)).data.free.toString());
+ });
+
+ return balance;
+}
+
+export async function
scheduleTransferExpectSuccess(
collectionId: number,
tokenId: number,
@@ -870,8 +881,11 @@
if (type === 'ReFungible') {
const nftItemData =
(await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON() as unknown as IReFungibleTokenDataType;
- expect(nftItemData.Owner[0].Owner).to.be.deep.equal(to);
- expect(nftItemData.Owner[0].Fraction.toString()).to.be.equal(value.toString());
+ const expectedOwner = toSubstrateAddress(to);
+ const ownerIndex = nftItemData.Owner.findIndex(v => toSubstrateAddress(v.Owner as any as string) == expectedOwner);
+ expect(ownerIndex).to.not.equal(-1);
+ expect(nftItemData.Owner[ownerIndex].Owner).to.be.deep.equal(normalizeAccountId(to));
+ expect(nftItemData.Owner[ownerIndex].Fraction).to.be.greaterThanOrEqual(value as number);
}
});
}
@@ -1171,4 +1185,21 @@
export async function queryNftOwner(api: ApiPromise, collectionId: number, tokenId: number): Promise<CrossAccountId> {
return normalizeAccountId((await api.query.nft.nftItemList(collectionId, tokenId) as any).toJSON().Owner);
-}
\ No newline at end of file
+}
+
+export async function waitNewBlocks(blocksCount = 1): Promise<void> {
+ await usingApi(async (api) => {
+ const promise = new Promise<void>(async (resolve) => {
+
+ const unsubscribe = await api.rpc.chain.subscribeNewHeads(() => {
+ if (blocksCount > 0) {
+ blocksCount--;
+ } else {
+ unsubscribe();
+ resolve();
+ }
+ });
+ });
+ return promise;
+ });
+}