From abb3797345daa1d805d44e68f9627e709aa582c2 Mon Sep 17 00:00:00 2001 From: Igor Kozyrev Date: Tue, 05 Jul 2022 13:50:25 +0000 Subject: [PATCH] Merge branch 'develop' into feature/prop-check-root-owner --- --- a/pallets/nonfungible/src/lib.rs +++ b/pallets/nonfungible/src/lib.rs @@ -380,11 +380,7 @@ ) -> DispatchResult { let token_data = >::get((collection.id, token)).ok_or(>::TokenNotFound)?; - ensure!( - &token_data.owner == sender - || (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(sender)), - >::NoPermission - ); + ensure!(&token_data.owner == sender, >::NoPermission); if collection.permissions.access() == AccessMode::AllowList { collection.check_allowlist(sender)?; @@ -696,12 +692,7 @@ let token_data = >::get((collection.id, token)).ok_or(>::TokenNotFound)?; - // TODO: require sender to be token, owner, require admins to go through transfer_from - ensure!( - &token_data.owner == from - || (collection.limits.owner_can_transfer() && collection.is_owner_or_admin(from)), - >::NoPermission - ); + ensure!(&token_data.owner == from, >::NoPermission); if collection.permissions.access() == AccessMode::AllowList { collection.check_allowlist(from)?; @@ -1008,8 +999,12 @@ // `from`, `to` checked in [`transfer`] collection.check_allowlist(spender)?; } + + if collection.limits.owner_can_transfer() && collection.is_owner_or_admin(spender) { + return Ok(()); + } + if let Some(source) = T::CrossTokenAddressMapping::address_to_token(from) { - // TODO: should collection owner be allowed to perform this transfer? ensure!( >::check_indirectly_owned( spender.clone(), --- a/pallets/proxy-rmrk-core/src/lib.rs +++ b/pallets/proxy-rmrk-core/src/lib.rs @@ -19,7 +19,10 @@ use frame_support::{pallet_prelude::*, transactional, BoundedVec, dispatch::DispatchResult}; use frame_system::{pallet_prelude::*, ensure_signed}; use sp_runtime::{DispatchError, Permill, traits::StaticLookup}; -use sp_std::vec::Vec; +use sp_std::{ + vec::Vec, + collections::{btree_set::BTreeSet, btree_map::BTreeMap}, +}; use up_data_structs::{*, mapping::TokenAddressMapping}; use pallet_common::{ Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations, @@ -48,6 +51,12 @@ pub const NESTING_BUDGET: u32 = 5; +type PendingTarget = (CollectionId, TokenId); +type PendingChild = (RmrkCollectionId, RmrkNftId); +type PendingChildrenSet = BTreeSet; + +type BasesMap = BTreeMap; + #[frame_support::pallet] pub mod pallet { use super::*; @@ -383,12 +392,14 @@ [ Self::rmrk_property(TokenType, &NftType::Regular)?, Self::rmrk_property(Transferable, &transferable)?, - Self::rmrk_property(PendingNftAccept, &false)?, + Self::rmrk_property(PendingNftAccept, &None::)?, Self::rmrk_property(RoyaltyInfo, &royalty_info)?, Self::rmrk_property(Metadata, &metadata)?, Self::rmrk_property(Equipped, &false)?, Self::rmrk_property(ResourcePriorities, &>::new())?, Self::rmrk_property(NextResourceId, &(0 as RmrkResourceId))?, + Self::rmrk_property(PendingChildren, &PendingChildrenSet::new())?, + Self::rmrk_property(AssociatedBases, &BasesMap::new())?, ] .into_iter(), ) @@ -483,11 +494,12 @@ ); ensure!( - !Self::get_nft_property_decoded( + Self::get_nft_property_decoded::>( collection_id, nft_id, RmrkProperty::PendingNftAccept - )?, + )? + .is_none(), >::NoPermission ); @@ -524,7 +536,15 @@ collection.id, nft_id, PropertyScope::Rmrk, - Self::rmrk_property(PendingNftAccept, &approval_required)?, + Self::rmrk_property::>( + PendingNftAccept, + &Some((target_collection_id, target_nft_id.into())), + )?, + )?; + + Self::insert_pending_child( + (target_collection_id, target_nft_id.into()), + (rmrk_collection_id, rmrk_nft_id), )?; } else { target_owner = T::CrossTokenAddressMapping::token_to_address( @@ -618,13 +638,23 @@ } })?; - >::set_scoped_token_property( - collection.id, + let pending_target = Self::get_nft_property_decoded::>( + collection_id, nft_id, - PropertyScope::Rmrk, - Self::rmrk_property(PendingNftAccept, &false)?, + RmrkProperty::PendingNftAccept, )?; + if let Some(pending_target) = pending_target { + Self::remove_pending_child(pending_target, (rmrk_collection_id, rmrk_nft_id))?; + + >::set_scoped_token_property( + collection.id, + nft_id, + PropertyScope::Rmrk, + Self::rmrk_property(PendingNftAccept, &None::)?, + )?; + } + Self::deposit_event(Event::NFTAccepted { sender, recipient: new_owner, @@ -663,14 +693,18 @@ >::NoAvailableNftId ); - ensure!( - Self::get_nft_property_decoded( - collection_id, - nft_id, - RmrkProperty::PendingNftAccept - )?, - >::CannotRejectNonPendingNft - ); + let pending_target = Self::get_nft_property_decoded::>( + collection_id, + nft_id, + RmrkProperty::PendingNftAccept, + )?; + + match pending_target { + Some(pending_target) => { + Self::remove_pending_child(pending_target, (rmrk_collection_id, rmrk_nft_id))? + } + None => return Err(>::CannotRejectNonPendingNft.into()), + } Self::destroy_nft( cross_sender, @@ -785,6 +819,12 @@ resource_id_key, ); + if let RmrkResourceTypes::Composable(resource) = resource_info.resource { + let base_id = resource.base; + + Self::remove_associated_base_id(collection_id, nft_id, base_id)?; + } + Self::deposit_event(Event::::ResourceRemovalAccepted { nft_id: rmrk_nft_id, resource_id, @@ -938,6 +978,8 @@ Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?; collection.check_is_external()?; + let base_id = resource.base; + let resource_id = Self::resource_add( sender, collection_id, @@ -945,6 +987,24 @@ RmrkResourceTypes::Composable(resource), )?; + >::try_mutate_token_aux_property( + collection_id, + nft_id.into(), + PropertyScope::Rmrk, + Self::rmrk_property_key(AssociatedBases)?, + |value| -> DispatchResult { + let mut bases: BasesMap = match value { + Some(value) => Self::decode_property(value)?, + None => BasesMap::new(), + }; + + *bases.entry(base_id).or_insert(0) += 1; + + *value = Some(Self::encode_property(&bases)?); + Ok(()) + }, + )?; + Self::deposit_event(Event::ResourceAdded { nft_id, resource_id, @@ -1147,6 +1207,67 @@ ) } + fn insert_pending_child( + target: (CollectionId, TokenId), + child: (RmrkCollectionId, RmrkNftId), + ) -> DispatchResult { + Self::mutate_pending_child(target, |pending_children| { + pending_children.insert(child); + }) + } + + fn remove_pending_child( + target: (CollectionId, TokenId), + child: (RmrkCollectionId, RmrkNftId), + ) -> DispatchResult { + Self::mutate_pending_child(target, |pending_children| { + pending_children.remove(&child); + }) + } + + fn mutate_pending_child( + (target_collection_id, target_nft_id): (CollectionId, TokenId), + f: impl FnOnce(&mut PendingChildrenSet), + ) -> DispatchResult { + >::try_mutate_token_aux_property( + target_collection_id, + target_nft_id, + PropertyScope::Rmrk, + Self::rmrk_property_key(PendingChildren)?, + |pending_children| -> DispatchResult { + let mut map = match pending_children { + Some(map) => Self::decode_property(map)?, + None => PendingChildrenSet::new(), + }; + + f(&mut map); + + *pending_children = Some(Self::encode_property(&map)?); + + Ok(()) + }, + ) + } + + fn iterate_pending_children( + collection_id: CollectionId, + nft_id: TokenId, + ) -> Result, DispatchError> { + let property = >::token_aux_property(( + collection_id, + nft_id, + PropertyScope::Rmrk, + Self::rmrk_property_key(PendingChildren)?, + )); + + let pending_children = match property { + Some(map) => Self::decode_property(&map)?, + None => PendingChildrenSet::new(), + }; + + Ok(pending_children.into_iter()) + } + fn acquire_next_resource_id( collection_id: CollectionId, nft_id: TokenId, @@ -1223,16 +1344,15 @@ let resource_id_key = Self::rmrk_property_key(ResourceId(resource_id))?; let scope = PropertyScope::Rmrk; - ensure!( - >::token_aux_property(( - collection_id, - nft_id, - scope, - resource_id_key.clone() - )) - .is_some(), - >::ResourceDoesntExist - ); + let resource = >::token_aux_property(( + collection_id, + nft_id, + scope, + resource_id_key.clone(), + )) + .ok_or(>::ResourceDoesntExist)?; + + let resource_info: RmrkResourceInfo = Self::decode_property(&resource)?; let budget = up_data_structs::budget::Value::new(NESTING_BUDGET); let topmost_owner = @@ -1246,6 +1366,12 @@ PropertyScope::Rmrk, Self::rmrk_property_key(ResourceId(resource_id))?, ); + + if let RmrkResourceTypes::Composable(resource) = resource_info.resource { + let base_id = resource.base; + + Self::remove_associated_base_id(collection_id, nft_id, base_id)?; + } } else { Self::try_mutate_resource_info(collection_id, nft_id, resource_id, |res| { res.pending_removal = true; @@ -1257,6 +1383,36 @@ Ok(()) } + fn remove_associated_base_id( + collection_id: CollectionId, + nft_id: TokenId, + base_id: RmrkBaseId, + ) -> DispatchResult { + >::try_mutate_token_aux_property( + collection_id, + nft_id, + PropertyScope::Rmrk, + Self::rmrk_property_key(AssociatedBases)?, + |value| -> DispatchResult { + let mut bases: BasesMap = match value { + Some(value) => Self::decode_property(value)?, + None => BasesMap::new(), + }; + + let remaining = bases.get(&base_id); + + if let Some(remaining) = remaining { + if let Some(0) | None = remaining.checked_sub(1) { + bases.remove(&base_id); + } + } + + *value = Some(Self::encode_property(&bases)?); + Ok(()) + }, + ) + } + fn try_mutate_resource_info( collection_id: CollectionId, nft_id: TokenId, @@ -1526,15 +1682,13 @@ Value: Decode + Default, Mapper: Fn(Key, Value) -> R, { - let key_prefix = Self::rmrk_property_key(UserProperty(b""))?; - let properties = match token_id { Some(token_id) => >::token_properties((collection_id, token_id)), None => >::collection_properties(collection_id), }; let properties = properties.into_iter().filter_map(move |(key, value)| { - let key = key.as_slice().strip_prefix(key_prefix.as_slice())?; + let key = strip_key_prefix(&key, USER_PROPERTY_PREFIX)?; let key: Key = key.to_vec().try_into().ok()?; let value: Value = value.decode().ok()?; --- a/pallets/proxy-rmrk-core/src/property.rs +++ b/pallets/proxy-rmrk-core/src/property.rs @@ -15,9 +15,11 @@ // along with Unique Network. If not, see . use super::*; +use up_data_structs::PropertyScope; use core::convert::AsRef; -const RESOURCE_ID_PREFIX: &str = "rsid-"; +pub const RESOURCE_ID_PREFIX: &str = "rsid-"; +pub const USER_PROPERTY_PREFIX: &str = "userprop-"; pub enum RmrkProperty<'r> { Metadata, @@ -31,6 +33,8 @@ NextResourceId, ResourceId(RmrkResourceId), PendingNftAccept, + PendingChildren, + AssociatedBases, Parts, Base, Src, @@ -73,6 +77,8 @@ Self::NextResourceId => key!("next-resource-id"), Self::ResourceId(id) => key!(RESOURCE_ID_PREFIX, id.to_le_bytes()), Self::PendingNftAccept => key!("pending-nft-accept"), + Self::PendingChildren => key!("pending-children"), + Self::AssociatedBases => key!("assoc-bases"), Self::Parts => key!("parts"), Self::Base => key!("base"), Self::Src => key!("src"), @@ -83,7 +89,22 @@ Self::ZIndex => key!("z-index"), Self::ThemeName => key!("theme-name"), Self::ThemeInherit => key!("theme-inherit"), - Self::UserProperty(name) => key!("userprop-", name), + Self::UserProperty(name) => key!(USER_PROPERTY_PREFIX, name), } } } + +pub fn strip_key_prefix(key: &PropertyKey, prefix: &str) -> Option { + let key_prefix = PropertyKey::try_from(prefix.as_bytes().to_vec()).ok()?; + let key_prefix = PropertyScope::Rmrk.apply(key_prefix).ok()?; + + key.as_slice() + .strip_prefix(key_prefix.as_slice())? + .to_vec() + .try_into() + .ok() +} + +pub fn is_valid_key_prefix(key: &PropertyKey, prefix: &str) -> bool { + strip_key_prefix(key, prefix).is_some() +} --- a/pallets/proxy-rmrk-core/src/rpc.rs +++ b/pallets/proxy-rmrk-core/src/rpc.rs @@ -132,17 +132,6 @@ Ok( pallet_nonfungible::TokenChildren::::iter_prefix((collection_id, nft_id)) .filter_map(|((child_collection, child_token), _)| { - let is_pending = >::get_nft_property_decoded( - child_collection, - child_token, - RmrkProperty::PendingNftAccept, - ) - .ok()?; - - if is_pending { - return None; - } - let rmrk_child_collection = >::rmrk_collection_id(child_collection).ok()?; @@ -151,6 +140,14 @@ nft_id: child_token.0, }) }) + .chain( + >::iterate_pending_children(collection_id, nft_id)?.map( + |(child_collection, child_nft_id)| RmrkNftChild { + collection_id: child_collection, + nft_id: child_nft_id, + }, + ), + ) .collect(), ) } @@ -224,7 +221,11 @@ nft_id, PropertyScope::Rmrk, ) - .filter_map(|(_, value)| { + .filter_map(|(key, value)| { + if !is_valid_key_prefix(&key, RESOURCE_ID_PREFIX) { + return None; + } + let resource_info: RmrkResourceInfo = >::decode_property(&value).ok()?; Some(resource_info) --- a/pallets/proxy-rmrk-core/src/weights.rs +++ b/pallets/proxy-rmrk-core/src/weights.rs @@ -3,7 +3,7 @@ //! Autogenerated weights for pallet_proxy_rmrk_core //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2022-06-21, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2022-07-01, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]` //! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024 // Executed Command: @@ -64,7 +64,7 @@ // Storage: Common CollectionById (r:0 w:1) // Storage: RmrkCore UniqueCollectionId (r:0 w:1) fn create_collection() -> Weight { - (49_986_000 as Weight) + (49_365_000 as Weight) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(8 as Weight)) } @@ -77,7 +77,7 @@ // Storage: Nonfungible TokensBurnt (r:0 w:1) // Storage: Common AdminAmount (r:0 w:1) fn destroy_collection() -> Weight { - (50_177_000 as Weight) + (49_903_000 as Weight) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(6 as Weight)) } @@ -85,7 +85,7 @@ // Storage: Common CollectionById (r:1 w:1) // Storage: Common CollectionProperties (r:1 w:0) fn change_collection_issuer() -> Weight { - (25_949_000 as Weight) + (26_134_000 as Weight) .saturating_add(T::DbWeight::get().reads(3 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -95,7 +95,7 @@ // Storage: Nonfungible TokensMinted (r:1 w:0) // Storage: Nonfungible TokensBurnt (r:1 w:0) fn lock_collection() -> Weight { - (27_183_000 as Weight) + (28_020_000 as Weight) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -109,9 +109,9 @@ // Storage: Nonfungible Owned (r:0 w:1) // Storage: Nonfungible TokenAuxProperties (r:2 w:2) fn mint_nft(b: u32, ) -> Weight { - (65_512_000 as Weight) - // Standard Error: 12_000 - .saturating_add((11_525_000 as Weight).saturating_mul(b as Weight)) + (67_476_000 as Weight) + // Standard Error: 19_000 + .saturating_add((12_373_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(6 as Weight)) .saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight))) .saturating_add(T::DbWeight::get().writes(5 as Weight)) @@ -129,8 +129,8 @@ // Storage: Nonfungible TokenProperties (r:0 w:1) fn burn_nft(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_472_000 - .saturating_add((296_221_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_500_000 + .saturating_add((300_520_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(9 as Weight)) .saturating_add(T::DbWeight::get().reads((4 as Weight).saturating_mul(b as Weight))) .saturating_add(T::DbWeight::get().writes(6 as Weight)) @@ -146,7 +146,7 @@ // Storage: Nonfungible TokenChildren (r:0 w:1) // Storage: Nonfungible Owned (r:0 w:2) fn send() -> Weight { - (82_778_000 as Weight) + (84_023_000 as Weight) .saturating_add(T::DbWeight::get().reads(12 as Weight)) .saturating_add(T::DbWeight::get().writes(6 as Weight)) } @@ -157,27 +157,29 @@ // Storage: Nonfungible AccountBalance (r:2 w:2) // Storage: Nonfungible Allowance (r:1 w:0) // Storage: Nonfungible TokenProperties (r:1 w:1) + // Storage: Nonfungible TokenAuxProperties (r:1 w:1) // Storage: Nonfungible TokenChildren (r:0 w:1) // Storage: Nonfungible Owned (r:0 w:2) fn accept_nft() -> Weight { - (90_190_000 as Weight) - .saturating_add(T::DbWeight::get().reads(15 as Weight)) - .saturating_add(T::DbWeight::get().writes(7 as Weight)) + (98_502_000 as Weight) + .saturating_add(T::DbWeight::get().reads(16 as Weight)) + .saturating_add(T::DbWeight::get().writes(8 as Weight)) } // Storage: RmrkCore UniqueCollectionId (r:1 w:0) // Storage: Common CollectionProperties (r:1 w:0) // Storage: Common CollectionById (r:1 w:0) // Storage: Nonfungible TokenData (r:5 w:5) // Storage: Nonfungible TokenProperties (r:1 w:5) + // Storage: Nonfungible TokenAuxProperties (r:1 w:1) // Storage: Nonfungible TokenChildren (r:9 w:4) // Storage: Nonfungible TokensBurnt (r:1 w:1) // Storage: Nonfungible AccountBalance (r:5 w:5) // Storage: Nonfungible Allowance (r:5 w:0) // Storage: Nonfungible Owned (r:0 w:5) fn reject_nft() -> Weight { - (262_238_000 as Weight) - .saturating_add(T::DbWeight::get().reads(29 as Weight)) - .saturating_add(T::DbWeight::get().writes(25 as Weight)) + (277_017_000 as Weight) + .saturating_add(T::DbWeight::get().reads(30 as Weight)) + .saturating_add(T::DbWeight::get().writes(26 as Weight)) } // Storage: RmrkCore UniqueCollectionId (r:1 w:0) // Storage: Common CollectionProperties (r:1 w:0) @@ -185,7 +187,7 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) // Storage: Nonfungible TokenData (r:5 w:0) fn set_property() -> Weight { - (55_187_000 as Weight) + (55_408_000 as Weight) .saturating_add(T::DbWeight::get().reads(9 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -195,7 +197,7 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) // Storage: Nonfungible TokenData (r:5 w:0) fn set_priority() -> Weight { - (54_092_000 as Weight) + (55_063_000 as Weight) .saturating_add(T::DbWeight::get().reads(9 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -206,7 +208,7 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) // Storage: Nonfungible TokenAuxProperties (r:1 w:1) fn add_basic_resource() -> Weight { - (62_551_000 as Weight) + (64_656_000 as Weight) .saturating_add(T::DbWeight::get().reads(10 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) } @@ -215,11 +217,11 @@ // Storage: Common CollectionById (r:1 w:0) // Storage: Nonfungible TokenData (r:5 w:0) // Storage: Nonfungible TokenProperties (r:1 w:1) - // Storage: Nonfungible TokenAuxProperties (r:1 w:1) + // Storage: Nonfungible TokenAuxProperties (r:2 w:2) fn add_composable_resource() -> Weight { - (61_778_000 as Weight) - .saturating_add(T::DbWeight::get().reads(10 as Weight)) - .saturating_add(T::DbWeight::get().writes(2 as Weight)) + (67_593_000 as Weight) + .saturating_add(T::DbWeight::get().reads(11 as Weight)) + .saturating_add(T::DbWeight::get().writes(3 as Weight)) } // Storage: RmrkCore UniqueCollectionId (r:1 w:0) // Storage: Common CollectionProperties (r:1 w:0) @@ -228,7 +230,7 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) // Storage: Nonfungible TokenAuxProperties (r:1 w:1) fn add_slot_resource() -> Weight { - (62_700_000 as Weight) + (63_845_000 as Weight) .saturating_add(T::DbWeight::get().reads(10 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) } @@ -238,7 +240,7 @@ // Storage: Nonfungible TokenAuxProperties (r:1 w:1) // Storage: Nonfungible TokenData (r:5 w:0) fn remove_resource() -> Weight { - (52_920_000 as Weight) + (53_414_000 as Weight) .saturating_add(T::DbWeight::get().reads(9 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -248,7 +250,7 @@ // Storage: Nonfungible TokenData (r:5 w:0) // Storage: Nonfungible TokenAuxProperties (r:1 w:1) fn accept_resource() -> Weight { - (52_450_000 as Weight) + (51_869_000 as Weight) .saturating_add(T::DbWeight::get().reads(9 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -258,7 +260,7 @@ // Storage: Nonfungible TokenData (r:5 w:0) // Storage: Nonfungible TokenAuxProperties (r:1 w:1) fn accept_resource_removal() -> Weight { - (50_901_000 as Weight) + (53_168_000 as Weight) .saturating_add(T::DbWeight::get().reads(9 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -275,7 +277,7 @@ // Storage: Common CollectionById (r:0 w:1) // Storage: RmrkCore UniqueCollectionId (r:0 w:1) fn create_collection() -> Weight { - (49_986_000 as Weight) + (49_365_000 as Weight) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(8 as Weight)) } @@ -288,7 +290,7 @@ // Storage: Nonfungible TokensBurnt (r:0 w:1) // Storage: Common AdminAmount (r:0 w:1) fn destroy_collection() -> Weight { - (50_177_000 as Weight) + (49_903_000 as Weight) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(6 as Weight)) } @@ -296,7 +298,7 @@ // Storage: Common CollectionById (r:1 w:1) // Storage: Common CollectionProperties (r:1 w:0) fn change_collection_issuer() -> Weight { - (25_949_000 as Weight) + (26_134_000 as Weight) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -306,7 +308,7 @@ // Storage: Nonfungible TokensMinted (r:1 w:0) // Storage: Nonfungible TokensBurnt (r:1 w:0) fn lock_collection() -> Weight { - (27_183_000 as Weight) + (28_020_000 as Weight) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -320,9 +322,9 @@ // Storage: Nonfungible Owned (r:0 w:1) // Storage: Nonfungible TokenAuxProperties (r:2 w:2) fn mint_nft(b: u32, ) -> Weight { - (65_512_000 as Weight) - // Standard Error: 12_000 - .saturating_add((11_525_000 as Weight).saturating_mul(b as Weight)) + (67_476_000 as Weight) + // Standard Error: 19_000 + .saturating_add((12_373_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(6 as Weight)) .saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(b as Weight))) .saturating_add(RocksDbWeight::get().writes(5 as Weight)) @@ -340,8 +342,8 @@ // Storage: Nonfungible TokenProperties (r:0 w:1) fn burn_nft(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_472_000 - .saturating_add((296_221_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_500_000 + .saturating_add((300_520_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(9 as Weight)) .saturating_add(RocksDbWeight::get().reads((4 as Weight).saturating_mul(b as Weight))) .saturating_add(RocksDbWeight::get().writes(6 as Weight)) @@ -357,7 +359,7 @@ // Storage: Nonfungible TokenChildren (r:0 w:1) // Storage: Nonfungible Owned (r:0 w:2) fn send() -> Weight { - (82_778_000 as Weight) + (84_023_000 as Weight) .saturating_add(RocksDbWeight::get().reads(12 as Weight)) .saturating_add(RocksDbWeight::get().writes(6 as Weight)) } @@ -368,27 +370,29 @@ // Storage: Nonfungible AccountBalance (r:2 w:2) // Storage: Nonfungible Allowance (r:1 w:0) // Storage: Nonfungible TokenProperties (r:1 w:1) + // Storage: Nonfungible TokenAuxProperties (r:1 w:1) // Storage: Nonfungible TokenChildren (r:0 w:1) // Storage: Nonfungible Owned (r:0 w:2) fn accept_nft() -> Weight { - (90_190_000 as Weight) - .saturating_add(RocksDbWeight::get().reads(15 as Weight)) - .saturating_add(RocksDbWeight::get().writes(7 as Weight)) + (98_502_000 as Weight) + .saturating_add(RocksDbWeight::get().reads(16 as Weight)) + .saturating_add(RocksDbWeight::get().writes(8 as Weight)) } // Storage: RmrkCore UniqueCollectionId (r:1 w:0) // Storage: Common CollectionProperties (r:1 w:0) // Storage: Common CollectionById (r:1 w:0) // Storage: Nonfungible TokenData (r:5 w:5) // Storage: Nonfungible TokenProperties (r:1 w:5) + // Storage: Nonfungible TokenAuxProperties (r:1 w:1) // Storage: Nonfungible TokenChildren (r:9 w:4) // Storage: Nonfungible TokensBurnt (r:1 w:1) // Storage: Nonfungible AccountBalance (r:5 w:5) // Storage: Nonfungible Allowance (r:5 w:0) // Storage: Nonfungible Owned (r:0 w:5) fn reject_nft() -> Weight { - (262_238_000 as Weight) - .saturating_add(RocksDbWeight::get().reads(29 as Weight)) - .saturating_add(RocksDbWeight::get().writes(25 as Weight)) + (277_017_000 as Weight) + .saturating_add(RocksDbWeight::get().reads(30 as Weight)) + .saturating_add(RocksDbWeight::get().writes(26 as Weight)) } // Storage: RmrkCore UniqueCollectionId (r:1 w:0) // Storage: Common CollectionProperties (r:1 w:0) @@ -396,7 +400,7 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) // Storage: Nonfungible TokenData (r:5 w:0) fn set_property() -> Weight { - (55_187_000 as Weight) + (55_408_000 as Weight) .saturating_add(RocksDbWeight::get().reads(9 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -406,7 +410,7 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) // Storage: Nonfungible TokenData (r:5 w:0) fn set_priority() -> Weight { - (54_092_000 as Weight) + (55_063_000 as Weight) .saturating_add(RocksDbWeight::get().reads(9 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -417,7 +421,7 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) // Storage: Nonfungible TokenAuxProperties (r:1 w:1) fn add_basic_resource() -> Weight { - (62_551_000 as Weight) + (64_656_000 as Weight) .saturating_add(RocksDbWeight::get().reads(10 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) } @@ -426,11 +430,11 @@ // Storage: Common CollectionById (r:1 w:0) // Storage: Nonfungible TokenData (r:5 w:0) // Storage: Nonfungible TokenProperties (r:1 w:1) - // Storage: Nonfungible TokenAuxProperties (r:1 w:1) + // Storage: Nonfungible TokenAuxProperties (r:2 w:2) fn add_composable_resource() -> Weight { - (61_778_000 as Weight) - .saturating_add(RocksDbWeight::get().reads(10 as Weight)) - .saturating_add(RocksDbWeight::get().writes(2 as Weight)) + (67_593_000 as Weight) + .saturating_add(RocksDbWeight::get().reads(11 as Weight)) + .saturating_add(RocksDbWeight::get().writes(3 as Weight)) } // Storage: RmrkCore UniqueCollectionId (r:1 w:0) // Storage: Common CollectionProperties (r:1 w:0) @@ -439,7 +443,7 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) // Storage: Nonfungible TokenAuxProperties (r:1 w:1) fn add_slot_resource() -> Weight { - (62_700_000 as Weight) + (63_845_000 as Weight) .saturating_add(RocksDbWeight::get().reads(10 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) } @@ -449,7 +453,7 @@ // Storage: Nonfungible TokenAuxProperties (r:1 w:1) // Storage: Nonfungible TokenData (r:5 w:0) fn remove_resource() -> Weight { - (52_920_000 as Weight) + (53_414_000 as Weight) .saturating_add(RocksDbWeight::get().reads(9 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -459,7 +463,7 @@ // Storage: Nonfungible TokenData (r:5 w:0) // Storage: Nonfungible TokenAuxProperties (r:1 w:1) fn accept_resource() -> Weight { - (52_450_000 as Weight) + (51_869_000 as Weight) .saturating_add(RocksDbWeight::get().reads(9 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -469,7 +473,7 @@ // Storage: Nonfungible TokenData (r:5 w:0) // Storage: Nonfungible TokenAuxProperties (r:1 w:1) fn accept_resource_removal() -> Weight { - (50_901_000 as Weight) + (53_168_000 as Weight) .saturating_add(RocksDbWeight::get().reads(9 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } --- a/pallets/proxy-rmrk-equip/src/weights.rs +++ b/pallets/proxy-rmrk-equip/src/weights.rs @@ -3,7 +3,7 @@ //! Autogenerated weights for pallet_proxy_rmrk_equip //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2022-06-21, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2022-07-01, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]` //! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024 // Executed Command: @@ -54,9 +54,9 @@ // Storage: Nonfungible TokenData (r:0 w:1) // Storage: Nonfungible Owned (r:0 w:1) fn create_base(b: u32, ) -> Weight { - (62_832_000 as Weight) - // Standard Error: 22_000 - .saturating_add((20_106_000 as Weight).saturating_mul(b as Weight)) + (57_871_000 as Weight) + // Standard Error: 21_000 + .saturating_add((19_870_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(6 as Weight)) .saturating_add(T::DbWeight::get().reads((2 as Weight).saturating_mul(b as Weight))) .saturating_add(T::DbWeight::get().writes(8 as Weight)) @@ -71,9 +71,9 @@ // Storage: Nonfungible TokenData (r:0 w:1) // Storage: Nonfungible Owned (r:0 w:1) fn theme_add(b: u32, ) -> Weight { - (46_793_000 as Weight) - // Standard Error: 61_000 - .saturating_add((3_061_000 as Weight).saturating_mul(b as Weight)) + (46_121_000 as Weight) + // Standard Error: 31_000 + .saturating_add((2_988_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(6 as Weight)) .saturating_add(T::DbWeight::get().writes(5 as Weight)) } @@ -82,7 +82,7 @@ // Storage: RmrkEquip InernalPartId (r:1 w:0) // Storage: Nonfungible TokenProperties (r:1 w:1) fn equippable() -> Weight { - (32_495_000 as Weight) + (32_032_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -103,9 +103,9 @@ // Storage: Nonfungible TokenData (r:0 w:1) // Storage: Nonfungible Owned (r:0 w:1) fn create_base(b: u32, ) -> Weight { - (62_832_000 as Weight) - // Standard Error: 22_000 - .saturating_add((20_106_000 as Weight).saturating_mul(b as Weight)) + (57_871_000 as Weight) + // Standard Error: 21_000 + .saturating_add((19_870_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(6 as Weight)) .saturating_add(RocksDbWeight::get().reads((2 as Weight).saturating_mul(b as Weight))) .saturating_add(RocksDbWeight::get().writes(8 as Weight)) @@ -120,9 +120,9 @@ // Storage: Nonfungible TokenData (r:0 w:1) // Storage: Nonfungible Owned (r:0 w:1) fn theme_add(b: u32, ) -> Weight { - (46_793_000 as Weight) - // Standard Error: 61_000 - .saturating_add((3_061_000 as Weight).saturating_mul(b as Weight)) + (46_121_000 as Weight) + // Standard Error: 31_000 + .saturating_add((2_988_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(6 as Weight)) .saturating_add(RocksDbWeight::get().writes(5 as Weight)) } @@ -131,7 +131,7 @@ // Storage: RmrkEquip InernalPartId (r:1 w:0) // Storage: Nonfungible TokenProperties (r:1 w:1) fn equippable() -> Weight { - (32_495_000 as Weight) + (32_032_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } --- a/runtime/quartz/src/lib.rs +++ b/runtime/quartz/src/lib.rs @@ -924,6 +924,7 @@ type Event = Event; type WeightInfo = pallet_unique::weights::SubstrateWeight; type CommonWeightInfo = CommonWeights; + type RefungibleExtensionsWeightInfo = CommonWeights; } parameter_types! { --- a/runtime/unique/src/lib.rs +++ b/runtime/unique/src/lib.rs @@ -913,6 +913,7 @@ type Event = Event; type WeightInfo = pallet_unique::weights::SubstrateWeight; type CommonWeightInfo = CommonWeights; + type RefungibleExtensionsWeightInfo = CommonWeights; } parameter_types! { --- a/tests/package.json +++ b/tests/package.json @@ -60,6 +60,7 @@ "testAddToContractAllowList": "mocha --timeout 9999999 -r ts-node/register ./**/addToContractAllowList.test.ts", "testTransfer": "mocha --timeout 9999999 -r ts-node/register ./**/transfer.test.ts", "testBurnItem": "mocha --timeout 9999999 -r ts-node/register ./**/burnItem.test.ts", + "testAdminTransferAndBurn": "mocha --timeout 9999999 -r ts-node/register ./**/adminTransferAndBurn.test.ts", "testSetMintPermission": "mocha --timeout 9999999 -r ts-node/register ./**/setMintPermission.test.ts", "testCreditFeesToTreasury": "mocha --timeout 9999999 -r ts-node/register ./**/creditFeesToTreasury.test.ts", "testContractSponsoring": "mocha --timeout 9999999 -r ts-node/register ./**/contractSponsoring.test.ts", --- /dev/null +++ b/tests/src/adminTransferAndBurn.test.ts @@ -0,0 +1,72 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +import {IKeyringPair} from '@polkadot/types/types'; +import chai from 'chai'; +import chaiAsPromised from 'chai-as-promised'; +import {default as usingApi} from './substrate/substrate-api'; +import { + createCollectionExpectSuccess, + createItemExpectSuccess, + transferExpectFailure, + transferFromExpectSuccess, + burnItemExpectFailure, + burnFromExpectSuccess, + setCollectionLimitsExpectSuccess, +} from './util/helpers'; + +chai.use(chaiAsPromised); +const expect = chai.expect; + +describe('Integration Test: ownerCanTransfer allows admins to use only transferFrom/burnFrom:', () => { + let alice: IKeyringPair; + let bob: IKeyringPair; + let charlie: IKeyringPair; + + before(async () => { + await usingApi(async (api, privateKeyWrapper) => { + alice = privateKeyWrapper('//Alice'); + bob = privateKeyWrapper('//Bob'); + charlie = privateKeyWrapper('//Charlie'); + }); + }); + + it('admin transfers other user\'s token', async () => { + await usingApi(async () => { + const collectionId = await createCollectionExpectSuccess(); + await setCollectionLimitsExpectSuccess(alice, collectionId, {ownerCanTransfer: true}); + + const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', {Substrate: bob.address}); + + await transferExpectFailure(collectionId, tokenId, alice, charlie); + + await transferFromExpectSuccess(collectionId, tokenId, alice, bob, charlie, 1); + }); + }); + + it('admin burns other user\'s token', async () => { + await usingApi(async () => { + const collectionId = await createCollectionExpectSuccess(); + await setCollectionLimitsExpectSuccess(alice, collectionId, {ownerCanTransfer: true}); + + const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', {Substrate: bob.address}); + + await burnItemExpectFailure(alice, collectionId, tokenId); + + await burnFromExpectSuccess(alice, bob, collectionId, tokenId); + }); + }); +}); --- a/tests/src/burnItem.test.ts +++ b/tests/src/burnItem.test.ts @@ -155,7 +155,7 @@ await addCollectionAdminExpectSuccess(alice, collectionId, bob.address); await usingApi(async (api) => { - const tx = api.tx.unique.burnItem(collectionId, tokenId, 1); + const tx = api.tx.unique.burnFrom(collectionId, {Substrate: alice.address}, tokenId, 1); const events = await submitTransactionAsync(bob, tx); const result = getGenericResult(events); --- a/tests/src/interfaces/augment-api-events.ts +++ b/tests/src/interfaces/augment-api-events.ts @@ -13,45 +13,45 @@ /** * A balance was set by root. **/ - BalanceSet: AugmentedEvent; + BalanceSet: AugmentedEvent; /** * Some amount was deposited (e.g. for transaction fees). **/ - Deposit: AugmentedEvent; + Deposit: AugmentedEvent; /** * An account was removed whose balance was non-zero but below ExistentialDeposit, * resulting in an outright loss. **/ - DustLost: AugmentedEvent; + DustLost: AugmentedEvent; /** * An account was created with some free balance. **/ - Endowed: AugmentedEvent; + Endowed: AugmentedEvent; /** * Some balance was reserved (moved from free to reserved). **/ - Reserved: AugmentedEvent; + Reserved: AugmentedEvent; /** * Some balance was moved from the reserve of the first account to the second account. * Final argument indicates the destination balance type. **/ - ReserveRepatriated: AugmentedEvent; + ReserveRepatriated: AugmentedEvent; /** * Some amount was removed from the account (e.g. for misbehavior). **/ - Slashed: AugmentedEvent; + Slashed: AugmentedEvent; /** * Transfer succeeded. **/ - Transfer: AugmentedEvent; + Transfer: AugmentedEvent; /** * Some balance was unreserved (moved from reserved to free). **/ - Unreserved: AugmentedEvent; + Unreserved: AugmentedEvent; /** * Some amount was withdrawn from the account (e.g. for transaction fees). **/ - Withdraw: AugmentedEvent; + Withdraw: AugmentedEvent; /** * Generic event **/ @@ -167,27 +167,27 @@ /** * Downward message executed with the given outcome. **/ - ExecutedDownward: AugmentedEvent; + ExecutedDownward: AugmentedEvent; /** * Downward message is invalid XCM. **/ - InvalidFormat: AugmentedEvent; + InvalidFormat: AugmentedEvent; /** * Downward message is overweight and was placed in the overweight queue. **/ - OverweightEnqueued: AugmentedEvent; + OverweightEnqueued: AugmentedEvent; /** * Downward message from the overweight queue was executed. **/ - OverweightServiced: AugmentedEvent; + OverweightServiced: AugmentedEvent; /** * Downward message is unsupported version of XCM. **/ - UnsupportedVersion: AugmentedEvent; + UnsupportedVersion: AugmentedEvent; /** * The weight limit for handling downward messages was reached. **/ - WeightExhausted: AugmentedEvent; + WeightExhausted: AugmentedEvent; /** * Generic event **/ @@ -241,19 +241,19 @@ /** * Downward messages were processed using the given weight. **/ - DownwardMessagesProcessed: AugmentedEvent; + DownwardMessagesProcessed: AugmentedEvent; /** * Some downward messages have been received and will be processed. **/ - DownwardMessagesReceived: AugmentedEvent; + DownwardMessagesReceived: AugmentedEvent; /** * An upgrade has been authorized. **/ - UpgradeAuthorized: AugmentedEvent; + UpgradeAuthorized: AugmentedEvent; /** * The validation function was applied as of the contained relay chain block number. **/ - ValidationFunctionApplied: AugmentedEvent; + ValidationFunctionApplied: AugmentedEvent; /** * The relay-chain aborted the upgrade process. **/ @@ -390,29 +390,29 @@ [key: string]: AugmentedEvent; }; rmrkCore: { - CollectionCreated: AugmentedEvent; - CollectionDestroyed: AugmentedEvent; - CollectionLocked: AugmentedEvent; - IssuerChanged: AugmentedEvent; - NFTAccepted: AugmentedEvent; - NFTBurned: AugmentedEvent; - NftMinted: AugmentedEvent; - NFTRejected: AugmentedEvent; - NFTSent: AugmentedEvent; - PrioritySet: AugmentedEvent; - PropertySet: AugmentedEvent, key: Bytes, value: Bytes], { collectionId: u32, maybeNftId: Option, key: Bytes, value: Bytes }>; - ResourceAccepted: AugmentedEvent; - ResourceAdded: AugmentedEvent; - ResourceRemoval: AugmentedEvent; - ResourceRemovalAccepted: AugmentedEvent; + CollectionCreated: AugmentedEvent; + CollectionDestroyed: AugmentedEvent; + CollectionLocked: AugmentedEvent; + IssuerChanged: AugmentedEvent; + NFTAccepted: AugmentedEvent; + NFTBurned: AugmentedEvent; + NftMinted: AugmentedEvent; + NFTRejected: AugmentedEvent; + NFTSent: AugmentedEvent; + PrioritySet: AugmentedEvent; + PropertySet: AugmentedEvent, Bytes, Bytes]>; + ResourceAccepted: AugmentedEvent; + ResourceAdded: AugmentedEvent; + ResourceRemoval: AugmentedEvent; + ResourceRemovalAccepted: AugmentedEvent; /** * Generic event **/ [key: string]: AugmentedEvent; }; rmrkEquip: { - BaseCreated: AugmentedEvent; - EquippablesUpdated: AugmentedEvent; + BaseCreated: AugmentedEvent; + EquippablesUpdated: AugmentedEvent; /** * Generic event **/ @@ -422,19 +422,19 @@ /** * The call for the provided hash was not found so the task has been aborted. **/ - CallLookupFailed: AugmentedEvent, id: Option, error: FrameSupportScheduleLookupError], { task: ITuple<[u32, u32]>, id: Option, error: FrameSupportScheduleLookupError }>; + CallLookupFailed: AugmentedEvent, Option, FrameSupportScheduleLookupError]>; /** * Canceled some task. **/ - Canceled: AugmentedEvent; + Canceled: AugmentedEvent; /** * Dispatched some task. **/ - Dispatched: AugmentedEvent, id: Option, result: Result], { task: ITuple<[u32, u32]>, id: Option, result: Result }>; + Dispatched: AugmentedEvent, Option, Result]>; /** * Scheduled some task. **/ - Scheduled: AugmentedEvent; + Scheduled: AugmentedEvent; /** * Generic event **/ @@ -454,15 +454,15 @@ /** * The \[sudoer\] just switched identity; the old key is supplied if one existed. **/ - KeyChanged: AugmentedEvent], { oldSudoer: Option }>; + KeyChanged: AugmentedEvent]>; /** * A sudo just took place. \[result\] **/ - Sudid: AugmentedEvent], { sudoResult: Result }>; + Sudid: AugmentedEvent]>; /** * A sudo just took place. \[result\] **/ - SudoAsDone: AugmentedEvent], { sudoResult: Result }>; + SudoAsDone: AugmentedEvent]>; /** * Generic event **/ @@ -476,23 +476,23 @@ /** * An extrinsic failed. **/ - ExtrinsicFailed: AugmentedEvent; + ExtrinsicFailed: AugmentedEvent; /** * An extrinsic completed successfully. **/ - ExtrinsicSuccess: AugmentedEvent; + ExtrinsicSuccess: AugmentedEvent; /** * An account was reaped. **/ - KilledAccount: AugmentedEvent; + KilledAccount: AugmentedEvent; /** * A new account was created. **/ - NewAccount: AugmentedEvent; + NewAccount: AugmentedEvent; /** * On on-chain remark happened. **/ - Remarked: AugmentedEvent; + Remarked: AugmentedEvent; /** * Generic event **/ @@ -502,31 +502,31 @@ /** * Some funds have been allocated. **/ - Awarded: AugmentedEvent; + Awarded: AugmentedEvent; /** * Some of our funds have been burnt. **/ - Burnt: AugmentedEvent; + Burnt: AugmentedEvent; /** * Some funds have been deposited. **/ - Deposit: AugmentedEvent; + Deposit: AugmentedEvent; /** * New proposal. **/ - Proposed: AugmentedEvent; + Proposed: AugmentedEvent; /** * A proposal was rejected; funds were slashed. **/ - Rejected: AugmentedEvent; + Rejected: AugmentedEvent; /** * Spending has finished; this is the amount that rolls over until next spend. **/ - Rollover: AugmentedEvent; + Rollover: AugmentedEvent; /** * We have ended a spend period and will now allocate funds. **/ - Spending: AugmentedEvent; + Spending: AugmentedEvent; /** * Generic event **/ @@ -629,15 +629,15 @@ /** * Claimed vesting. **/ - Claimed: AugmentedEvent; + Claimed: AugmentedEvent; /** * Added new vesting schedule. **/ - VestingScheduleAdded: AugmentedEvent; + VestingScheduleAdded: AugmentedEvent; /** * Updated vesting schedules. **/ - VestingSchedulesUpdated: AugmentedEvent; + VestingSchedulesUpdated: AugmentedEvent; /** * Generic event **/ --- a/tests/src/interfaces/augment-api-tx.ts +++ b/tests/src/interfaces/augment-api-tx.ts @@ -907,7 +907,7 @@ deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic, [u32, Vec]>; deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic, [u32, u32, Vec]>; /** - * **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money. + * Destroys collection if no tokens within this collection * * # Permissions * --- a/tests/src/nesting/graphs.test.ts +++ b/tests/src/nesting/graphs.test.ts @@ -36,7 +36,7 @@ await usingApi(async (api, privateKeyWrapper) => { const alice = privateKeyWrapper('//Alice'); const collection = await buildComplexObjectGraph(api, alice); - await setCollectionLimitsExpectSuccess(alice, collection, {ownerCanTransfer: true}); + const tokenTwoParent = tokenIdToCross(collection, 1); // to self await expect( @@ -49,7 +49,7 @@ 'second transaction', ).to.be.rejectedWith(/structure\.OuroborosDetected/); await expect( - executeTransaction(api, alice, api.tx.unique.transfer(tokenIdToCross(collection, 8), collection, 2, 1)), + executeTransaction(api, alice, api.tx.unique.transferFrom(tokenTwoParent, tokenIdToCross(collection, 8), collection, 2, 1)), 'third transaction', ).to.be.rejectedWith(/structure\.OuroborosDetected/); }); --- a/tests/src/nesting/nest.test.ts +++ b/tests/src/nesting/nest.test.ts @@ -123,7 +123,7 @@ ], 'Children contents check at nesting #2'); // Move token B to a different user outside the nesting tree - await transferExpectSuccess(collectionA, tokenB, alice, bob); + await transferFromExpectSuccess(collectionA, tokenB, alice, targetAddress, bob); children = await getTokenChildren(api, collectionA, targetToken); expect(children.length).to.be.equal(1, 'Children length check at unnesting'); expect(children).to.be.have.deep.members([ @@ -470,7 +470,7 @@ await expect(executeTransaction( api, alice, - api.tx.unique.transfer(targetAddress, collection, newToken, 1), + api.tx.unique.transferFrom(targetAddress, {Substrate: bob.address}, collection, newToken, 1), ), 'while nesting another\'s token token').to.be.rejectedWith(/common\.AddressNotInAllowlist/); expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address}); --- /dev/null +++ b/tests/src/rmrk/acceptNft.test.ts @@ -0,0 +1,103 @@ +import {expect} from 'chai'; +import {getApiConnection} from '../substrate/substrate-api'; +import { + createCollection, + mintNft, + sendNft, + acceptNft, +} from './util/tx'; +import {NftIdTuple} from './util/fetch'; +import {isNftChildOfAnother, expectTxFailure} from './util/helpers'; + +describe('integration test: accept NFT', () => { + let api: any; + before(async () => { api = await getApiConnection(); }); + + const alice = '//Alice'; + const bob = '//Bob'; + + const createTestCollection = async (issuerUri: string) => { + return await createCollection( + api, + issuerUri, + 'accept-metadata', + null, + 'acpt', + ); + }; + + it('accept NFT', async () => { + const ownerAlice = alice; + const ownerBob = bob; + + const aliceCollectionId = await createTestCollection(alice); + const bobCollectionId = await createTestCollection(bob); + + const parentNftId = await mintNft(api, alice, ownerAlice, aliceCollectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, bob, ownerBob, bobCollectionId, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [aliceCollectionId, parentNftId]; + + await sendNft(api, 'pending', ownerBob, bobCollectionId, childNftId, newOwnerNFT); + await acceptNft(api, alice, bobCollectionId, childNftId, newOwnerNFT); + + const isChild = await isNftChildOfAnother(api, bobCollectionId, childNftId, newOwnerNFT); + expect(isChild).to.be.true; + }); + + it('[negative] unable to accept NFT by a not-an-owner', async () => { + const ownerAlice = alice; + const ownerBob = bob; + + const aliceCollectionId = await createTestCollection(alice); + const bobCollectionId = await createTestCollection(bob); + + const parentNftId = await mintNft(api, alice, ownerAlice, aliceCollectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, bob, ownerBob, bobCollectionId, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [aliceCollectionId, parentNftId]; + + await sendNft(api, 'pending', ownerBob, bobCollectionId, childNftId, newOwnerNFT); + const tx = acceptNft(api, bob, bobCollectionId, childNftId, newOwnerNFT); + + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + it('[negative] unable to accept non-existing NFT', async () => { + const collectionId = 0; + const maxNftId = 0xFFFFFFFF; + + const owner = alice; + const aliceCollectionId = await createTestCollection(alice); + + const parentNftId = await mintNft(api, alice, owner, aliceCollectionId, 'parent-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [aliceCollectionId, parentNftId]; + + const tx = acceptNft(api, alice, collectionId, maxNftId, newOwnerNFT); + + await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx); + }); + + it('[negative] unable to accept NFT which is not sent', async () => { + const ownerAlice = alice; + const ownerBob = bob; + + const aliceCollectionId = await createTestCollection(alice); + const bobCollectionId = await createTestCollection(bob); + + const parentNftId = await mintNft(api, alice, ownerAlice, aliceCollectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, bob, ownerBob, bobCollectionId, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [aliceCollectionId, parentNftId]; + + const tx = acceptNft(api, alice, bobCollectionId, childNftId, newOwnerNFT); + + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + + const isChild = await isNftChildOfAnother(api, bobCollectionId, childNftId, newOwnerNFT); + expect(isChild).to.be.false; + }); + + after(() => { api.disconnect(); }); +}); --- /dev/null +++ b/tests/src/rmrk/addResource.test.ts @@ -0,0 +1,436 @@ +import {expect} from 'chai'; +import {getApiConnection} from '../substrate/substrate-api'; +import {NftIdTuple} from './util/fetch'; +import {expectTxFailure, getResourceById} from './util/helpers'; +import { + addNftBasicResource, + acceptNftResource, + createCollection, + mintNft, + sendNft, + addNftSlotResource, + addNftComposableResource, +} from './util/tx'; +import {RmrkTraitsResourceResourceInfo as ResourceInfo} from '@polkadot/types/lookup'; + +describe('integration test: add NFT resource', () => { + const Alice = '//Alice'; + const Bob = '//Bob'; + const src = 'test-res-src'; + const metadata = 'test-res-metadata'; + const license = 'test-res-license'; + const thumb = 'test-res-thumb'; + + const nonexistentId = 99999; + + let api: any; + before(async () => { + api = await getApiConnection(); + }); + + it('add resource', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Alice, + Alice, + collectionIdAlice, + 'nft-metadata', + ); + + await addNftBasicResource( + api, + Alice, + 'added', + collectionIdAlice, + nftAlice, + src, + metadata, + license, + thumb, + ); + }); + + it('add a resource to the nested NFT', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const parentNftId = await mintNft(api, Alice, Alice, collectionIdAlice, 'parent-nft-metadata'); + const childNftId = await mintNft(api, Alice, Alice, collectionIdAlice, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [collectionIdAlice, parentNftId]; + + await sendNft(api, 'sent', Alice, collectionIdAlice, childNftId, newOwnerNFT); + + await addNftBasicResource( + api, + Alice, + 'added', + collectionIdAlice, + childNftId, + src, + metadata, + license, + thumb, + ); + }); + + it('add multiple resources', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Alice, + Alice, + collectionIdAlice, + 'nft-metadata', + ); + + const baseId = 42; + const slotId = 10; + const parts = [0, 5, 2]; + + const resourcesInfo = []; + const resourceNum = 4; + + const checkResource = async (resource: ResourceInfo, resType: string, expectedId: number, expected: { + src: string, + metadata: string, + license: string, + thumb: string + }) => { + + // FIXME A workaround. It seems it is a PolkadotJS bug. + // All of the following are `false`. + // + // console.log('>>> basic:', resource.resource.isBasic); + // console.log('>>> composable:', resource.resource.isComposable); + // console.log('>>> slot:', resource.resource.isSlot); + const resourceJson = (resource.resource.toHuman() as any)[resType]; + + expect(resource.id.toNumber(), 'Error: Invalid resource Id') + .to.be.eq(expectedId); + + expect(resourceJson.src, 'Error: Invalid resource src') + .to.be.eq(expected.src); + expect(resourceJson.metadata, 'Error: Invalid resource metadata') + .to.be.eq(expected.metadata); + expect(resourceJson.license, 'Error: Invalid resource license') + .to.be.eq(expected.license); + expect(resourceJson.thumb, 'Error: Invalid resource thumb') + .to.be.eq(expected.thumb); + }; + + for (let i = 0; i < resourceNum; i++) { + resourcesInfo.push({ + src: src + 'r-' + i, + metadata: metadata + 'r-' + i, + license: license + 'r-' + i, + thumb: thumb + 'r-' + i, + }); + } + + const firstBasicResourceId = await addNftBasicResource( + api, + Alice, + 'added', + collectionIdAlice, + nftAlice, + resourcesInfo[0].src, + resourcesInfo[0].metadata, + resourcesInfo[0].license, + resourcesInfo[0].thumb, + ); + + const secondBasicResourceId = await addNftBasicResource( + api, + Alice, + 'added', + collectionIdAlice, + nftAlice, + resourcesInfo[1].src, + resourcesInfo[1].metadata, + resourcesInfo[1].license, + resourcesInfo[1].thumb, + ); + + const composableResourceId = await addNftComposableResource( + api, + Alice, + 'added', + collectionIdAlice, + nftAlice, + parts, + baseId, + resourcesInfo[2].src, + resourcesInfo[2].metadata, + resourcesInfo[2].license, + resourcesInfo[2].thumb, + ); + + const slotResourceId = await addNftSlotResource( + api, + Alice, + 'added', + collectionIdAlice, + nftAlice, + baseId, + slotId, + resourcesInfo[3].src, + resourcesInfo[3].metadata, + resourcesInfo[3].license, + resourcesInfo[3].thumb, + ); + + const firstResource = await getResourceById(api, collectionIdAlice, nftAlice, firstBasicResourceId); + await checkResource(firstResource, 'Basic', firstBasicResourceId, resourcesInfo[0]); + + const secondResource = await getResourceById(api, collectionIdAlice, nftAlice, secondBasicResourceId); + await checkResource(secondResource, 'Basic', secondBasicResourceId, resourcesInfo[1]); + + const composableResource = await getResourceById(api, collectionIdAlice, nftAlice, composableResourceId); + await checkResource(composableResource, 'Composable', composableResourceId, resourcesInfo[2]); + + const slotResource = await getResourceById(api, collectionIdAlice, nftAlice, slotResourceId); + await checkResource(slotResource, 'Slot', slotResourceId, resourcesInfo[3]); + }); + + it('[negative]: unable to add a resource to the non-existing NFT', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const tx = addNftBasicResource( + api, + Alice, + 'added', + collectionIdAlice, + nonexistentId, + src, + metadata, + license, + thumb, + ); + + await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx); + }); + + it('[negative]: unable to add a resource by a not-an-owner user', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Alice, + Alice, + collectionIdAlice, + 'nft-metadata', + ); + + const tx = addNftBasicResource( + api, + Bob, + 'added', + collectionIdAlice, + nftAlice, + src, + metadata, + license, + thumb, + ); + + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + it('[negative]: unable to add a resource to the nested NFT if it isnt root owned by the caller', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const parentNftId = await mintNft(api, Alice, Alice, collectionIdAlice, 'parent-nft-metadata'); + const childNftId = await mintNft(api, Alice, Alice, collectionIdAlice, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [collectionIdAlice, parentNftId]; + + await sendNft(api, 'sent', Alice, collectionIdAlice, childNftId, newOwnerNFT); + + const tx = addNftBasicResource( + api, + Bob, + 'added', + collectionIdAlice, + childNftId, + src, + metadata, + license, + thumb, + ); + + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + it('accept resource', async () => { + const collectionIdBob = await createCollection( + api, + Bob, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Bob, + Alice, + collectionIdBob, + 'nft-metadata', + ); + + const resourceId = await addNftBasicResource( + api, + Bob, + 'pending', + collectionIdBob, + nftAlice, + src, + metadata, + license, + thumb, + ); + + await acceptNftResource(api, Alice, collectionIdBob, nftAlice, resourceId); + }); + + it('[negative]: unable to accept a non-existing resource', async () => { + const collectionIdBob = await createCollection( + api, + Bob, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Bob, + Alice, + collectionIdBob, + 'nft-metadata', + ); + + const tx = acceptNftResource(api, Alice, collectionIdBob, nftAlice, nonexistentId); + await expectTxFailure(/rmrkCore\.ResourceDoesntExist/, tx); + }); + + it('[negative]: unable to accept a resource by a not-an-NFT-owner user', async () => { + const collectionIdBob = await createCollection( + api, + Bob, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Bob, + Alice, + collectionIdBob, + 'nft-metadata', + ); + + const resourceId = await addNftBasicResource( + api, + Bob, + 'pending', + collectionIdBob, + nftAlice, + src, + metadata, + license, + thumb, + ); + + const tx = acceptNftResource(api, Bob, collectionIdBob, nftAlice, resourceId); + + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + it('[negative]: unable to accept a resource to a non-target NFT', async () => { + const collectionIdBob = await createCollection( + api, + Bob, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Bob, + Alice, + collectionIdBob, + 'nft-metadata', + ); + + const wrongNft = await mintNft( + api, + Bob, + Alice, + collectionIdBob, + 'nft-metadata', + ); + + const resourceId = await addNftBasicResource( + api, + Bob, + 'pending', + collectionIdBob, + nftAlice, + src, + metadata, + license, + thumb, + ); + + const tx = acceptNftResource(api, Bob, collectionIdBob, wrongNft, resourceId); + + await expectTxFailure(/rmrkCore\.ResourceDoesntExist/, tx); + }); + + + after(() => { + api.disconnect(); + }); +}); --- /dev/null +++ b/tests/src/rmrk/addTheme.test.ts @@ -0,0 +1,126 @@ +import {expect} from 'chai'; +import {getApiConnection} from '../substrate/substrate-api'; +import {createBase, addTheme} from './util/tx'; +import {expectTxFailure} from './util/helpers'; +import {getThemeNames} from './util/fetch'; + +describe('integration test: add Theme to Base', () => { + let api: any; + before(async () => { api = await getApiConnection(); }); + + const alice = '//Alice'; + const bob = '//Bob'; + + it('add default theme', async () => { + const baseId = await createBase(api, alice, 'default-themed-base', 'DTBase', []); + await addTheme(api, alice, baseId, { + name: 'default', + properties: [ + { + key: 'some-key', + value: 'some-key-value', + }, + { + key: 'another-key', + value: 'another-key-value', + }, + ], + }); + }); + + it('add default theme and a custom one', async () => { + const baseId = await createBase(api, alice, '2-themed-base', '2TBase', []); + await addTheme(api, alice, baseId, { + name: 'default', + properties: [ + { + key: 'default-key', + value: 'default-key-value', + }, + ], + }); + await addTheme(api, alice, baseId, { + name: 'custom-theme', + properties: [ + { + key: 'custom-key-0', + value: 'custom-key-value-0', + }, + { + key: 'custom-key-1', + value: 'custom-key-value-1', + }, + ], + }); + }); + + it('fetch filtered theme keys', async () => { + const baseId = await createBase(api, alice, '2-themed-base', '2TBase', []); + await addTheme(api, alice, baseId, { + name: 'default', + properties: [ + { + key: 'first-key', + value: 'first-key-value', + }, + { + key: 'second-key', + value: 'second-key-value', + }, + ], + }, ['second-key']); + }); + + it('fetch theme names', async() => { + const baseId = await createBase(api, alice, '3-themed-base', '3TBase', []); + const names = [ + 'default', + 'first-theme', + 'second-theme', + ]; + + for (let i = 0; i < names.length; i++) { + await addTheme(api, alice, baseId, {name: names[i], properties: [{key: 'dummy', value: 'dummy'}]}); + } + + const fetchedNames = await getThemeNames(api, baseId); + + for (let i = 0; i < names.length; i++) { + const isFound = fetchedNames.find((name) => name === names[i]) !== undefined; + + expect(isFound, 'Error: invalid theme names').to.be.true; + } + }); + + it('[negative] unable to add theme to non-existing base', async () => { + const maxBaseId = 0xFFFFFFFF; + const tx = addTheme(api, alice, maxBaseId, { + name: 'default', + properties: [], + }); + + await expectTxFailure(/rmrkEquip\.BaseDoesntExist/, tx); + }); + + it('[negative] unable to add custom theme if no default theme', async () => { + const baseId = await createBase(api, alice, 'no-default-themed-base', 'NDTBase', []); + const tx = addTheme(api, alice, baseId, { + name: 'custom-theme', + properties: [], + }); + + await expectTxFailure(/rmrkEquip\.NeedsDefaultThemeFirst/, tx); + }); + + it('[negative] unable to add theme by a not-an-owner', async () => { + const baseId = await createBase(api, alice, 'no-default-themed-base', 'NDTBase', []); + const tx = addTheme(api, bob, baseId, { + name: 'default', + properties: [], + }); + + await expectTxFailure(/rmrkEquip\.PermissionError/, tx); + }); + + after(() => { api.disconnect(); }); +}); --- /dev/null +++ b/tests/src/rmrk/burnNft.test.ts @@ -0,0 +1,170 @@ +import {getApiConnection} from '../substrate/substrate-api'; +import {expectTxFailure} from './util/helpers'; +import {NftIdTuple, getChildren} from './util/fetch'; +import {burnNft, createCollection, sendNft, mintNft} from './util/tx'; + +import chai from 'chai'; +import chaiAsPromised from 'chai-as-promised'; + +chai.use(chaiAsPromised); +const expect = chai.expect; + +describe('integration test: burn nft', () => { + const Alice = '//Alice'; + const Bob = '//Bob'; + + let api: any; + before(async () => { + api = await getApiConnection(); + }); + + it('burn nft', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ).then(async (collectionId) => { + const nftId = await mintNft( + api, + Alice, + Alice, + collectionId, + 'nft-metadata', + ); + await burnNft(api, Alice, collectionId, nftId); + }); + }); + + it('burn nft with children', async () => { + const collectionId = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const parentNftId = await mintNft( + api, + Alice, + Alice, + collectionId, + 'nft-metadata', + ); + + const childNftId = await mintNft( + api, + Alice, + Alice, + collectionId, + 'nft-metadata', + ); + + const newOwnerNFT: NftIdTuple = [collectionId, parentNftId]; + + await sendNft(api, 'sent', Alice, collectionId, childNftId, newOwnerNFT); + + const childrenBefore = await getChildren(api, collectionId, parentNftId); + expect(childrenBefore.length === 1, 'Error: parent NFT should have children') + .to.be.true; + + const child = childrenBefore[0]; + expect(child.collectionId.eq(collectionId), 'Error: invalid child collection Id') + .to.be.true; + + expect(child.nftId.eq(childNftId), 'Error: invalid child NFT Id') + .to.be.true; + + await burnNft(api, Alice, collectionId, parentNftId); + + const childrenAfter = await getChildren(api, collectionId, parentNftId); + + expect(childrenAfter.length === 0, 'Error: children should be burned').to.be.true; + }); + + it('burn child nft', async () => { + const collectionId = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const parentNftId = await mintNft( + api, + Alice, + Alice, + collectionId, + 'nft-metadata', + ); + + const childNftId = await mintNft( + api, + Alice, + Alice, + collectionId, + 'nft-metadata', + ); + + const newOwnerNFT: NftIdTuple = [collectionId, parentNftId]; + + await sendNft(api, 'sent', Alice, collectionId, childNftId, newOwnerNFT); + + const childrenBefore = await getChildren(api, collectionId, parentNftId); + expect(childrenBefore.length === 1, 'Error: parent NFT should have children') + .to.be.true; + + const child = childrenBefore[0]; + expect(child.collectionId.eq(collectionId), 'Error: invalid child collection Id') + .to.be.true; + + expect(child.nftId.eq(childNftId), 'Error: invalid child NFT Id') + .to.be.true; + + await burnNft(api, Alice, collectionId, childNftId); + + const childrenAfter = await getChildren(api, collectionId, parentNftId); + + expect(childrenAfter.length === 0, 'Error: children should be burned').to.be.true; + }); + + it('[negative] burn non-existing NFT', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ).then(async (collectionId) => { + const tx = burnNft(api, Alice, collectionId, 99999); + await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx); + }); + }); + + it('[negative] burn not an owner NFT user', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ).then(async (collectionId) => { + const nftId = await mintNft( + api, + Alice, + Alice, + collectionId, + 'nft-metadata', + ); + const tx = burnNft(api, Bob, collectionId, nftId); + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + }); + + after(() => { + api.disconnect(); + }); +}); --- /dev/null +++ b/tests/src/rmrk/changeCollectionIssuer.test.ts @@ -0,0 +1,52 @@ +import {getApiConnection} from '../substrate/substrate-api'; +import {expectTxFailure} from './util/helpers'; +import { + changeIssuer, + createCollection, +} from './util/tx'; + +describe('integration test: collection issuer', () => { + const Alice = '//Alice'; + const Bob = '//Bob'; + + let api: any; + before(async () => { + api = await getApiConnection(); + }); + + it('change collection issuer', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ).then(async (collectionId) => { + await changeIssuer(api, Alice, collectionId, Bob); + }); + }); + + it('[negative] change not an owner NFT collection issuer', async () => { + await createCollection(api, Bob, 'test-metadata', null, 'test-symbol').then(async (collectionId) => { + const tx = changeIssuer(api, Alice, collectionId, Bob); + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + }); + + it('[negative] change non-existigit NFT collection issuer', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ).then(async () => { + const tx = changeIssuer(api, Alice, 99999, Bob); + await expectTxFailure(/rmrkCore\.CollectionUnknown/, tx); + }); + }); + + after(() => { + api.disconnect(); + }); +}); --- /dev/null +++ b/tests/src/rmrk/createBase.test.ts @@ -0,0 +1,84 @@ +import {getApiConnection} from '../substrate/substrate-api'; +import {createCollection, createBase} from './util/tx'; + +describe('integration test: create new Base', () => { + let api: any; + before(async () => { api = await getApiConnection(); }); + + const alice = '//Alice'; + + it('create empty Base', async () => { + await createBase(api, alice, 'empty-base-type', 'EBase', []); + }); + + it('create Base with fixed part', async () => { + await createBase(api, alice, 'fixedpart-base-type', 'FPBase', [ + { + 'FixedPart': { + id: 42, + z: 0, + src: 'some-fixed-url', + }, + }, + ]); + }); + + it('create Base with slot part (no collection)', async () => { + await createBase(api, alice, 'slotpart-base-type', 'SPBase', [ + { + 'SlotPart': { + id: 112, + equippable: 'Empty', + z: 0, + src: 'some-fallback-slot-url', + }, + }, + ]); + }); + + it('create Base with slot part (any collection)', async () => { + await createBase(api, alice, 'slotpartany-base-type', 'SPABase', [ + { + 'SlotPart': { + id: 222, + equippable: 'All', + z: 1, + src: 'some-fallback-slot-url', + }, + }, + ]); + }); + + it('create Base with slot part (custom collections)', async () => { + const firstCollectionId = await createCollection( + api, + alice, + 'first-collection-meta', + null, + 'first-collection', + ); + + const secondCollectionId = await createCollection( + api, + alice, + 'first-collection-meta', + null, + 'first-collection', + ); + + await createBase(api, alice, 'slotpartcustom-base-type', 'SPCBase', [ + { + 'SlotPart': { + id: 1024, + equippable: { + 'Custom': [firstCollectionId, secondCollectionId], + }, + z: 2, + src: 'some-fallback-slot-url', + }, + }, + ]); + }); + + after(() => { api.disconnect(); }); +}); --- /dev/null +++ b/tests/src/rmrk/createCollection.test.ts @@ -0,0 +1,19 @@ +import {getApiConnection} from '../substrate/substrate-api'; +import {createCollection} from './util/tx'; + +describe('Integration test: create new collection', () => { + let api: any; + before(async () => { api = await getApiConnection(); }); + + const alice = '//Alice'; + + it('create NFT collection', async () => { + await createCollection(api, alice, 'test-metadata', 42, 'test-symbol'); + }); + + it('create NFT collection without token limit', async () => { + await createCollection(api, alice, 'no-limit-metadata', null, 'no-limit-symbol'); + }); + + after(() => { api.disconnect(); }); +}); --- /dev/null +++ b/tests/src/rmrk/deleteCollection.test.ts @@ -0,0 +1,47 @@ +import {getApiConnection} from '../substrate/substrate-api'; +import {expectTxFailure} from './util/helpers'; +import {createCollection, deleteCollection} from './util/tx'; + +describe('integration test: delete collection', () => { + let api: any; + before(async () => { + api = await getApiConnection(); + }); + + const Alice = '//Alice'; + const Bob = '//Bob'; + + it('delete NFT collection', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ).then(async (collectionId) => { + await deleteCollection(api, Alice, collectionId.toString()); + }); + }); + + it('[negative] delete non-existing NFT collection', async () => { + const tx = deleteCollection(api, Alice, '99999'); + await expectTxFailure(/rmrkCore\.CollectionUnknown/, tx); + }); + + it('[negative] delete not an owner NFT collection', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ).then(async (collectionId) => { + const tx = deleteCollection(api, Bob, collectionId.toString()); + await expectTxFailure(/rmrkCore.NoPermission/, tx); + }); + }); + + after(() => { + api.disconnect(); + }); +}); --- /dev/null +++ b/tests/src/rmrk/equipNft.test.ts @@ -0,0 +1,340 @@ +import {ApiPromise} from '@polkadot/api'; +import {expect} from 'chai'; +import {getApiConnection} from '../substrate/substrate-api'; +import {getNft, getParts, NftIdTuple} from './util/fetch'; +import {expectTxFailure} from './util/helpers'; +import { + addNftComposableResource, + addNftSlotResource, + createBase, + createCollection, + equipNft, + mintNft, + sendNft, + unequipNft, +} from './util/tx'; + +const Alice = '//Alice'; +const Bob = '//Bob'; + +const composableParts: number[] = [5, 2, 7]; +const composableSrc = 'test-cmp-src'; +const composableMetadata = 'test-cmp-metadata'; +const composableLicense = 'test-comp-license'; +const composableThumb = 'test-comp-thumb'; + +const slotSrc = 'test-slot-src'; +const slotLicense = 'test-slot-license'; +const slotMetadata = 'test-slot-metadata'; +const slotThumb = 'test-slot-thumb'; + +const slotId = 1; + +async function createTestCollection(api: ApiPromise): Promise { + return createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); +} + +async function mintTestNft(api: ApiPromise, collectionId: number): Promise { + return await mintNft( + api, + Alice, + Alice, + collectionId, + 'nft-metadata', + ); +} + +async function mintChildNft(api: ApiPromise, collectionId: number, parentNftId: number): Promise { + const nftChildId = await mintTestNft(api, collectionId); + + const parentNFT: NftIdTuple = [collectionId, parentNftId]; + + await sendNft(api, 'sent', Alice, collectionId, nftChildId, parentNFT); + + return nftChildId; +} + +async function createTestBase(api: ApiPromise): Promise { + return createBase(api, Alice, 'test-base', 'DTBase', [ + { + SlotPart: { + id: slotId, + equippable: 'All', + z: 1, + src: slotSrc, + }, + }, + ]); +} + +async function addTestComposable(api: ApiPromise, collectionId: number, nftId: number, baseId: number) { + await addNftComposableResource( + api, + Alice, + 'added', + collectionId, + nftId, + composableParts, + baseId, + composableSrc, + composableMetadata, + composableLicense, + composableThumb, + ); +} + +async function addTestSlot(api: ApiPromise, collectionId: number, nftId: number, baseId: number, slotId: number): Promise { + return await addNftSlotResource( + api, + Alice, + 'added', + collectionId, + nftId, + baseId, + slotId, + slotSrc, + slotMetadata, + slotLicense, + slotThumb, + ); +} + +async function checkEquipStatus( + api: ApiPromise, + expectedStatus: 'equipped' | 'unequipped', + collectionId: number, + nftId: number, +) { + const itemNftDataOpt = await getNft(api, collectionId, nftId); + expect(itemNftDataOpt.isSome, 'Error: unable to fetch item NFT data'); + + const itemNftData = itemNftDataOpt.unwrap(); + expect(itemNftData.equipped.isTrue, `Error: item NFT should be ${expectedStatus}`) + .to.be.equal(expectedStatus === 'equipped'); +} + +describe.skip('integration test: Equip NFT', () => { + + let api: any; + before(async () => { + api = await getApiConnection(); + }); + + it('equip nft', async () => { + const collectionId = await createTestCollection(api); + const nftParentId = await mintTestNft(api, collectionId); + const nftChildId = await mintChildNft(api, collectionId, nftParentId); + + const baseId = await createTestBase(api); + + await addTestComposable(api, collectionId, nftParentId, baseId); + const resourceId = await addTestSlot(api, collectionId, nftChildId, baseId, slotId); + + const equipperNFT: NftIdTuple = [collectionId, nftParentId]; + const itemNFT: NftIdTuple = [collectionId, nftChildId]; + + await equipNft(api, Alice, itemNFT, equipperNFT, resourceId, baseId, slotId); + + await checkEquipStatus(api, 'equipped', collectionId, nftChildId); + }); + + it('unequip nft', async () => { + const collectionId = await createTestCollection(api); + const nftParentId = await mintTestNft(api, collectionId); + const nftChildId = await mintChildNft(api, collectionId, nftParentId); + + const baseId = await createTestBase(api); + + await addTestComposable(api, collectionId, nftParentId, baseId); + const resourceId = await addTestSlot(api, collectionId, nftChildId, baseId, slotId); + + const equipperNFT: NftIdTuple = [collectionId, nftParentId]; + const itemNFT: NftIdTuple = [collectionId, nftChildId]; + + await equipNft(api, Alice, itemNFT, equipperNFT, resourceId, baseId, slotId); + + await checkEquipStatus(api, 'equipped', collectionId, nftChildId); + + await unequipNft(api, Alice, itemNFT, equipperNFT, resourceId, baseId, slotId); + await checkEquipStatus(api, 'unequipped', collectionId, nftChildId); + }); + + it('[negative] equip NFT onto non-existing NFT', async () => { + const collectionId = await createTestCollection(api); + + const nftChildId = await mintNft( + api, + Alice, + Alice, + collectionId, + 'nft-metadata', + ); + + const itemNFT: NftIdTuple = [collectionId, nftChildId]; + const invalidEquipperNFT: NftIdTuple = [collectionId, 9999999]; + + const baseId = 0; + const resourceId = 0; + + const tx = equipNft(api, Alice, itemNFT, invalidEquipperNFT, resourceId, baseId, slotId); + await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx); + }); + + it('[negative] equip non-existing NFT', async () => { + const collectionId = await createTestCollection(api); + const nftParentId = await mintNft( + api, + Alice, + Alice, + collectionId, + 'nft-metadata', + ); + + const baseId = await createTestBase(api); + + await addTestComposable(api, collectionId, nftParentId, baseId); + + const equipperNFT: NftIdTuple = [collectionId, nftParentId]; + const invalidItemNFT: NftIdTuple = [collectionId, 99999999]; + + const resourceId = 0; + + const tx = equipNft(api, Alice, invalidItemNFT, equipperNFT, resourceId, baseId, slotId); + await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx); + }); + + it('[negative] equip NFT by a not-an-owner user', async () => { + const collectionId = await createTestCollection(api); + const nftParentId = await mintTestNft(api, collectionId); + const nftChildId = await mintChildNft(api, collectionId, nftParentId); + + const baseId = await createTestBase(api); + + await addTestComposable(api, collectionId, nftParentId, baseId); + + const equipperNFT: NftIdTuple = [collectionId, nftParentId]; + const itemNFT: NftIdTuple = [collectionId, nftChildId]; + + const resourceId = await addTestSlot(api, collectionId, nftChildId, baseId, slotId); + + const tx = equipNft(api, Bob, itemNFT, equipperNFT, resourceId, baseId, slotId); + await expectTxFailure(/rmrkEquip\.PermissionError/, tx); + }); + + it('[negative] unable to equip NFT onto indirect parent NFT', async () => { + const collectionId = await createTestCollection(api); + const nftParentId = await mintTestNft(api, collectionId); + const nftChildId = await mintChildNft(api, collectionId, nftParentId); + const nftGrandchildId = await mintChildNft(api, collectionId, nftChildId); + + const baseId = await createTestBase(api); + + await addTestComposable(api, collectionId, nftParentId, baseId); + const resourceId = await addTestSlot(api, collectionId, nftGrandchildId, baseId, slotId); + + const equipperNFT: NftIdTuple = [collectionId, nftParentId]; + const itemNFT: NftIdTuple = [collectionId, nftGrandchildId]; + + const tx = equipNft(api, Alice, itemNFT, equipperNFT, resourceId, baseId, slotId); + await expectTxFailure(/rmrkEquip\.MustBeDirectParent/, tx); + }); + + it('[negative] unable to equip NFT onto parent NFT with another base', async () => { + const collectionId = await createTestCollection(api); + const nftParentId = await mintTestNft(api, collectionId); + const nftChildId = await mintChildNft(api, collectionId, nftParentId); + + const baseId = await createTestBase(api); + + await addTestComposable(api, collectionId, nftParentId, baseId); + const resourceId = await addTestSlot(api, collectionId, nftChildId, baseId, slotId); + + const equipperNFT: NftIdTuple = [collectionId, nftParentId]; + const itemNFT: NftIdTuple = [collectionId, nftChildId]; + + const invalidBaseId = 99999; + + const tx = equipNft(api, Alice, itemNFT, equipperNFT, resourceId, invalidBaseId, slotId); + await expectTxFailure(/rmrkEquip\.NoResourceForThisBaseFoundOnNft/, tx); + }); + + it('[negative] unable to equip NFT into slot with another id', async () => { + const collectionId = await createTestCollection(api); + const nftParentId = await mintTestNft(api, collectionId); + const nftChildId = await mintChildNft(api, collectionId, nftParentId); + + const baseId = await createTestBase(api); + + await addTestComposable(api, collectionId, nftParentId, baseId); + const resourceId = await addTestSlot(api, collectionId, nftChildId, baseId, slotId); + + const equipperNFT: NftIdTuple = [collectionId, nftParentId]; + const itemNFT: NftIdTuple = [collectionId, nftChildId]; + + const incorrectSlotId = slotId + 1; + const tx = equipNft(api, Alice, itemNFT, equipperNFT, resourceId, baseId, incorrectSlotId); + await expectTxFailure(/rmrkEquip\.ItemHasNoResourceToEquipThere/, tx); + }); + + it('[negative] unable to equip NFT with incorrect slot (fixed part)', async () => { + const collectionId = await createTestCollection(api); + const nftParentId = await mintTestNft(api, collectionId); + const nftChildId = await mintChildNft(api, collectionId, nftParentId); + + const baseId = await createBase(api, Alice, 'test-base', 'DTBase', [ + { + FixedPart: { + id: slotId, + equippable: 'All', + z: 1, + src: slotSrc, + }, + }, + ]); + + await addTestComposable(api, collectionId, nftParentId, baseId); + const resourceId = await addTestSlot(api, collectionId, nftChildId, baseId, slotId); + + const equipperNFT: NftIdTuple = [collectionId, nftParentId]; + const itemNFT: NftIdTuple = [collectionId, nftChildId]; + + const tx = equipNft(api, Alice, itemNFT, equipperNFT, resourceId, baseId, slotId); + await expectTxFailure(/rmrkEquip\.CantEquipFixedPart/, tx); + }); + + it('[negative] unable to equip NFT from a collection that is not allowed by the slot', async () => { + const collectionId = await createTestCollection(api); + const nftParentId = await mintTestNft(api, collectionId); + const nftChildId = await mintChildNft(api, collectionId, nftParentId); + + const baseId = await createBase(api, Alice, 'test-base', 'DTBase', [ + { + SlotPart: { + id: 1, + z: 1, + equippable: 'Empty', + src: slotSrc, + }, + }, + ]); + + await addTestComposable(api, collectionId, nftParentId, baseId); + const resourceId = await addTestSlot(api, collectionId, nftChildId, baseId, slotId); + + const equipperNFT: NftIdTuple = [collectionId, nftParentId]; + const itemNFT: NftIdTuple = [collectionId, nftChildId]; + + const tx = equipNft(api, Alice, itemNFT, equipperNFT, resourceId, baseId, slotId); + await expectTxFailure(/rmrkEquip\.CollectionNotEquippable/, tx); + }); + + after(() => { + api.disconnect(); + }); +}); --- /dev/null +++ b/tests/src/rmrk/getOwnedNfts.test.ts @@ -0,0 +1,74 @@ +import {expect} from 'chai'; +import {getApiConnection} from '../substrate/substrate-api'; +import {getOwnedNfts} from './util/fetch'; +import {mintNft, createCollection} from './util/tx'; + +describe('integration test: get owned NFTs', () => { + let api: any; + before(async () => { api = await getApiConnection(); }); + + const alice = '//Alice'; + + it('fetch all NFTs owned by a user', async () => { + const owner = alice; + const collectionMetadata = 'aliceCollectionMetadata'; + const collectionMax = null; + const collectionSymbol = 'AliceSym'; + const recipientUri = null; + const royalty = null; + const nftMetadata = 'alice-NFT-metadata'; + + const collectionId = await createCollection( + api, + alice, + collectionMetadata, + collectionMax, + collectionSymbol, + ); + + const nftIds = [ + await mintNft( + api, + alice, + owner, + collectionId, + nftMetadata + '-0', + recipientUri, + royalty, + ), + await mintNft( + api, + alice, + owner, + collectionId, + nftMetadata + '-1', + recipientUri, + royalty, + ), + await mintNft( + api, + alice, + owner, + collectionId, + nftMetadata + '-2', + recipientUri, + royalty, + ), + ]; + + const ownedNfts = await getOwnedNfts(api, alice, collectionId); + + const isFound = (nftId: number) => { + return ownedNfts.find((ownedNftId) => { + return ownedNftId === nftId; + }) !== undefined; + }; + + nftIds.forEach((nftId) => { + expect(isFound(nftId), `NFT ${nftId} should be owned by ${alice}`) + .to.be.true; + }); + }); + + after(() => { api.disconnect(); }); +}); --- /dev/null +++ b/tests/src/rmrk/lockCollection.test.ts @@ -0,0 +1,117 @@ +import {getApiConnection} from '../substrate/substrate-api'; +import {expectTxFailure} from './util/helpers'; +import {createCollection, lockCollection, mintNft} from './util/tx'; + +describe('integration test: lock collection', () => { + const Alice = '//Alice'; + const Bob = '//Bob'; + const Max = 5; + + let api: any; + before(async () => { + api = await getApiConnection(); + }); + + it('lock collection', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ).then(async (collectionId) => { + await lockCollection(api, Alice, collectionId); + }); + }); + + it('[negative] lock non-existing NFT collection', async () => { + const tx = lockCollection(api, Alice, 99999); + await expectTxFailure(/rmrkCore\.CollectionUnknown/, tx); + }); + + it('[negative] lock not an owner NFT collection issuer', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ).then(async (collectionId) => { + const tx = lockCollection(api, Bob, collectionId); + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + }); + + it('lock collection with minting', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + Max, + 'test-symbol', + ).then(async (collectionId) => { + for (let i = 0; i < 5; i++) { + await mintNft( + api, + Alice, + Alice, + collectionId, + 'test-metadata', + null, + null, + ); + } + await lockCollection(api, Alice, collectionId, Max); + }); + }); + + it('[negative] unable to mint NFT inside a locked collection', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + Max, + 'test-symbol', + ).then(async (collectionId) => { + await lockCollection(api, Alice, collectionId); + const tx = mintNft( + api, + Alice, + Alice, + collectionId, + 'test-metadata', + null, + null, + ); + await expectTxFailure(/rmrkCore\.CollectionFullOrLocked/, tx); + }); + }); + + it('[negative] unable to mint NFT inside a full collection', async () => { + await createCollection(api, Alice, 'test-metadata', 1, 'test-symbol').then(async (collectionId) => { + await mintNft( + api, + Alice, + Alice, + collectionId, + 'test-metadata', + null, + null, + ); + const tx = mintNft( + api, + Alice, + Alice, + collectionId, + 'test-metadata', + null, + null, + ); + await expectTxFailure(/rmrkCore\.CollectionFullOrLocked/, tx); + }); + }); + + after(() => { + api.disconnect(); + }); +}); --- /dev/null +++ b/tests/src/rmrk/mintNft.test.ts @@ -0,0 +1,206 @@ +import {expect} from 'chai'; +import {getApiConnection} from '../substrate/substrate-api'; +import {getNft} from './util/fetch'; +import {expectTxFailure} from './util/helpers'; +import {createCollection, mintNft} from './util/tx'; + +describe('integration test: mint new NFT', () => { + let api: any; + before(async () => { api = await getApiConnection(); }); + + const alice = '//Alice'; + const bob = '//Bob'; + const maxCollectionId = 0xFFFFFFFF; + const maxNftId = 0xFFFFFFFF; + + it('mint NFT', async () => { + const owner = null; + const collectionMetadata = 'mintingCollectionMetadata'; + const collectionMax = null; + const collectionSymbol = 'MCS'; + const recipientUri = null; + const royalty = null; + const nftMetadata = 'NFT-test-metadata'; + + const collectionId = await createCollection( + api, + alice, + collectionMetadata, + collectionMax, + collectionSymbol, + ); + + await mintNft( + api, + alice, + owner, + collectionId, + nftMetadata, + recipientUri, + royalty, + ); + }); + + it('mint NFT and set another owner', async () => { + const owner = bob; + const collectionMetadata = 'setOwnerCollectionMetadata'; + const collectionMax = null; + const collectionSymbol = 'SOCS'; + const recipientUri = null; + const royalty = null; + const nftMetadata = 'setOwner-NFT-metadata'; + + const collectionId = await createCollection( + api, + alice, + collectionMetadata, + collectionMax, + collectionSymbol, + ); + + await mintNft( + api, + alice, + owner, + collectionId, + nftMetadata, + recipientUri, + royalty, + ); + }); + + it('mint NFT with recipient and roalty', async () => { + const owner = alice; + const collectionMetadata = 'mintingCollectionMetadata'; + const collectionMax = null; + const collectionSymbol = 'MCS'; + const recipientUri = bob; + const royalty = 70000; + const nftMetadata = 'recipient-royalty-NFT-test-metadata'; + + const collectionId = await createCollection( + api, + alice, + collectionMetadata, + collectionMax, + collectionSymbol, + ); + + await mintNft( + api, + alice, + owner, + collectionId, + nftMetadata, + recipientUri, + royalty, + ); + }); + + it('mint NFT with resources', async () => { + const owner = alice; + const collectionMetadata = 'mintingCollectionMetadata'; + const collectionMax = null; + const collectionSymbol = 'MCS'; + const nftMetadata = 'NFT-with-resources-test-metadata'; + const resources = [ + { + basic: { + metadata: 'basic-resource-nft-minting', + }, + }, { + slot: { + metadata: 'slot-resource-nft-minting', + slot: 9, + }, + }, { + composable: { + metadata: 'composable-resource-nft-minting', + parts: [0, 5, 2], + }, + }, { + slot: { + metadata: 'slot-resource-nft-minting-2', + thumb: 'srnm2', + base: 5, + }, + }, + ]; + + const collectionId = await createCollection( + api, + alice, + collectionMetadata, + collectionMax, + collectionSymbol, + ); + + await mintNft( + api, + alice, + owner, + collectionId, + nftMetadata, + null, + null, + true, + resources, + ); + }); + + it('[negative] unable to mint NFT within non-existing collection', async () => { + const owner = alice; + const recipientUri = null; + const royalty = null; + const nftMetadata = 'NFT-test-metadata'; + + const tx = mintNft( + api, + alice, + owner, + maxCollectionId, + nftMetadata, + recipientUri, + royalty, + ); + + await expectTxFailure(/rmrkCore\.CollectionUnknown/, tx); + }); + + it("[negative] unable to mint NFT by a user that isn't the owner of the collection", async () => { + const owner = alice; + const collectionMetadata = 'mintingCollectionMetadata'; + const collectionMax = null; + const collectionSymbol = 'MCS'; + const recipientUri = null; + const royalty = null; + const nftMetadata = 'NFT-test-metadata'; + + const collectionId = await createCollection( + api, + alice, + collectionMetadata, + collectionMax, + collectionSymbol, + ); + + const tx = mintNft( + api, + bob, + owner, + collectionId, + nftMetadata, + recipientUri, + royalty, + ); + + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + it('[negative] unable to fetch non-existing NFT', async () => { + const nft = await getNft(api, maxCollectionId, maxNftId); + expect(nft.isSome).to.be.false; + }); + + after(() => { api.disconnect(); }); +}); --- /dev/null +++ b/tests/src/rmrk/rejectNft.test.ts @@ -0,0 +1,89 @@ +import {expect} from 'chai'; +import {getApiConnection} from '../substrate/substrate-api'; +import { + createCollection, + mintNft, + sendNft, + rejectNft, +} from './util/tx'; +import {getChildren, NftIdTuple} from './util/fetch'; +import {isNftChildOfAnother, expectTxFailure} from './util/helpers'; + +describe('integration test: reject NFT', () => { + let api: any; + before(async () => { api = await getApiConnection(); }); + + const alice = '//Alice'; + const bob = '//Bob'; + + const createTestCollection = async (issuerUri: string) => { + return await createCollection( + api, + issuerUri, + 'reject-metadata', + null, + 'rjct', + ); + }; + + it('reject NFT', async () => { + const ownerAlice = alice; + const ownerBob = bob; + + const aliceCollectionId = await createTestCollection(alice); + const bobCollectionId = await createTestCollection(bob); + + const parentNftId = await mintNft(api, alice, ownerAlice, aliceCollectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, bob, ownerBob, bobCollectionId, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [aliceCollectionId, parentNftId]; + + await sendNft(api, 'pending', ownerBob, bobCollectionId, childNftId, newOwnerNFT); + await rejectNft(api, alice, bobCollectionId, childNftId); + + const isChild = await isNftChildOfAnother(api, bobCollectionId, childNftId, newOwnerNFT); + expect(isChild, 'Error: rejected NFT is still a child of the target NFT').to.be.false; + }); + + it('[negative] unable to reject NFT by a not-an-owner', async () => { + const ownerAlice = alice; + const ownerBob = bob; + + const aliceCollectionId = await createTestCollection(alice); + const bobCollectionId = await createTestCollection(bob); + + const parentNftId = await mintNft(api, alice, ownerAlice, aliceCollectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, bob, ownerBob, bobCollectionId, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [aliceCollectionId, parentNftId]; + + await sendNft(api, 'pending', ownerBob, bobCollectionId, childNftId, newOwnerNFT); + const tx = rejectNft(api, bob, bobCollectionId, childNftId); + + await expectTxFailure(/rmrkCore\.CannotRejectNonOwnedNft/, tx); + }); + + it('[negative] unable to reject non-existing NFT', async () => { + const maxNftId = 0xFFFFFFFF; + + const collectionId = await createTestCollection(alice); + + const tx = rejectNft(api, alice, collectionId, maxNftId); + + await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx); + }); + + it('[negative] unable to reject NFT which is not sent', async () => { + const ownerAlice = alice; + + const collectionId = await createTestCollection(alice); + + const nftId = await mintNft(api, alice, ownerAlice, collectionId, 'parent-nft-metadata'); + + const tx = rejectNft(api, alice, collectionId, nftId); + + await expectTxFailure(/rmrkCore\.CannotRejectNonPendingNft/, tx); + }); + + after(() => { api.disconnect(); }); +}); --- /dev/null +++ b/tests/src/rmrk/removeResource.test.ts @@ -0,0 +1,348 @@ +import {expect} from 'chai'; +import privateKey from '../substrate/privateKey'; +import {executeTransaction, getApiConnection} from '../substrate/substrate-api'; +import {getNft, NftIdTuple} from './util/fetch'; +import {expectTxFailure} from './util/helpers'; +import { + acceptNft, acceptResourceRemoval, addNftBasicResource, + createBase, + createCollection, + mintNft, removeNftResource, sendNft, +} from './util/tx'; + + + + +describe('Integration test: remove nft resource', () => { + let api: any; + let ss58Format: string; + before(async () => { + api = await getApiConnection(); + ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + }); + + const Alice = '//Alice'; + const Bob = '//Bob'; + const src = 'test-basic-src'; + const metadata = 'test-basic-metadata'; + const license = 'test-basic-license'; + const thumb = 'test-basic-thumb'; + + it('deleting a resource directly by the NFT owner', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Alice, + Alice, + collectionIdAlice, + 'nft-metadata', + ); + + const resourceId = await addNftBasicResource( + api, + Alice, + 'added', + collectionIdAlice, + nftAlice, + src, + metadata, + license, + thumb, + ); + + await removeNftResource(api, 'removed', Alice, collectionIdAlice, nftAlice, resourceId); + }); + + it('deleting resources indirectly by the NFT owner', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const parentNftId = await mintNft(api, Alice, Alice, collectionIdAlice, 'parent-nft-metadata'); + const childNftId = await mintNft(api, Alice, Alice, collectionIdAlice, 'child-nft-metadata'); + + const resourceId = await addNftBasicResource( + api, + Alice, + 'added', + collectionIdAlice, + childNftId, + src, + metadata, + license, + thumb, + ); + + const newOwnerNFT: NftIdTuple = [collectionIdAlice, parentNftId]; + + await sendNft(api, 'sent', Alice, collectionIdAlice, childNftId, newOwnerNFT); + + await removeNftResource(api, 'removed', Alice, collectionIdAlice, childNftId, resourceId); + }); + + it('deleting a resource by the collection owner', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftBob = await mintNft( + api, + Alice, + Bob, + collectionIdAlice, + 'nft-metadata', + ); + + const resourceId = await addNftBasicResource( + api, + Alice, + 'pending', + collectionIdAlice, + nftBob, + src, + metadata, + license, + thumb, + ); + + await removeNftResource(api, 'pending', Alice, collectionIdAlice, nftBob, resourceId); + await acceptResourceRemoval(api, Bob, collectionIdAlice, nftBob, resourceId); + }); + + it('deleting a resource in a nested NFT by the collection owner', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const parentNftId = await mintNft( + api, + Alice, + Bob, + collectionIdAlice, + 'parent-nft-metadata', + ); + const childNftId = await mintNft( + api, + Alice, + Bob, + collectionIdAlice, + 'child-nft-metadata', + ); + + const resourceId = await addNftBasicResource( + api, + Alice, + 'pending', + collectionIdAlice, + childNftId, + src, + metadata, + license, + thumb, + ); + + const newOwnerNFT: NftIdTuple = [collectionIdAlice, parentNftId]; + + await sendNft(api, 'sent', Bob, collectionIdAlice, childNftId, newOwnerNFT); + + await removeNftResource(api, 'pending', Alice, collectionIdAlice, childNftId, resourceId); + await acceptResourceRemoval(api, Bob, collectionIdAlice, childNftId, resourceId); + }); + + it('[negative]: can\'t delete a resource in a non-existing collection', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Alice, + Alice, + collectionIdAlice, + 'nft-metadata', + ); + + const resourceId = await addNftBasicResource( + api, + Alice, + 'added', + collectionIdAlice, + nftAlice, + src, + metadata, + license, + thumb, + ); + + const tx = removeNftResource(api, 'removed', Alice, 0xFFFFFFFF, nftAlice, resourceId); + await expectTxFailure(/rmrkCore\.CollectionUnknown/, tx); // FIXME: inappropriate error message (NoAvailableNftId) + }); + + it('[negative]: only collection owner can delete a resource', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Alice, + Alice, + collectionIdAlice, + 'nft-metadata', + ); + + const resourceId = await addNftBasicResource( + api, + Alice, + 'added', + collectionIdAlice, + nftAlice, + src, + metadata, + license, + thumb, + ); + + const tx = removeNftResource(api, 'removed', Bob, collectionIdAlice, nftAlice, resourceId); + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + it('[negative]: cannot delete a resource that does not exist', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Alice, + Alice, + collectionIdAlice, + 'nft-metadata', + ); + + const tx = removeNftResource(api, 'removed', Alice, collectionIdAlice, nftAlice, 127); + await expectTxFailure(/rmrkCore\.ResourceDoesntExist/, tx); + }); + + it('[negative]: Cannot accept deleting resource without owner attempt do delete it', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftBob = await mintNft( + api, + Alice, + Bob, + collectionIdAlice, + 'nft-metadata', + ); + + const resourceId = await addNftBasicResource( + api, + Alice, + 'pending', + collectionIdAlice, + nftBob, + src, + metadata, + license, + thumb, + ); + + const tx = acceptResourceRemoval(api, Bob, collectionIdAlice, nftBob, resourceId); + await expectTxFailure(/rmrkCore\.ResourceNotPending/, tx); + }); + + it('[negative]: cannot confirm the deletion of a non-existing resource', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftBob = await mintNft( + api, + Alice, + Bob, + collectionIdAlice, + 'nft-metadata', + ); + + const tx = acceptResourceRemoval(api, Bob, collectionIdAlice, nftBob, 127); + await expectTxFailure(/rmrkCore\.ResourceDoesntExist/, tx); + }); + + it('[negative]: Non-owner user cannot confirm the deletion of resource', async () => { + const collectionIdAlice = await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ); + + const nftAlice = await mintNft( + api, + Alice, + Alice, + collectionIdAlice, + 'nft-metadata', + ); + + const resourceId = await addNftBasicResource( + api, + Alice, + 'added', + collectionIdAlice, + nftAlice, + src, + metadata, + license, + thumb, + ); + + const tx = acceptResourceRemoval(api, Bob, collectionIdAlice, nftAlice, resourceId); + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + after(() => { + api.disconnect(); + }); +}); --- a/tests/src/rmrk/rmrk.test.ts +++ /dev/null @@ -1,251 +0,0 @@ -import {expect} from 'chai'; -import privateKey from '../substrate/privateKey'; -import usingApi, {executeTransaction} from '../substrate/substrate-api'; -import { - createCollectionExpectSuccess, - createItemExpectSuccess, - getCreateCollectionResult, - getDetailedCollectionInfo, - getGenericResult, - normalizeAccountId, -} from '../util/helpers'; -import {IKeyringPair} from '@polkadot/types/types'; -import {ApiPromise} from '@polkadot/api'; -import {it} from 'mocha'; - -let alice: IKeyringPair; -let bob: IKeyringPair; - -async function createRmrkCollection(api: ApiPromise, sender: IKeyringPair): Promise<{uniqueId: number, rmrkId: number}> { - const tx = api.tx.rmrkCore.createCollection('metadata', null, 'symbol'); - const events = await executeTransaction(api, sender, tx); - - const uniqueResult = getCreateCollectionResult(events); - const rmrkResult = getGenericResult(events, 'rmrkCore', 'CollectionCreated', (data) => { - return parseInt(data[1].toString(), 10); - }); - - return { - uniqueId: uniqueResult.collectionId, - rmrkId: rmrkResult.data!, - }; -} - -async function createRmrkNft(api: ApiPromise, sender: IKeyringPair, collectionId: number): Promise { - const tx = api.tx.rmrkCore.mintNft( - sender.address, - collectionId, - sender.address, - null, - 'nft-metadata', - true, - null, - ); - const events = await executeTransaction(api, sender, tx); - const result = getGenericResult(events, 'rmrkCore', 'NftMinted', (data) => { - return parseInt(data[2].toString(), 10); - }); - - return result.data!; -} - -async function isUnique(): Promise { - return usingApi(async api => { - const chain = await api.rpc.system.chain(); - - return chain.eq('UNIQUE'); - }); -} - -describe('RMRK External Integration Test', async () => { - const it_rmrk = (await isUnique() ? it : it.skip); - - before(async () => { - await usingApi(async (api, privateKeyWrapper) => { - alice = privateKeyWrapper('//Alice'); - - - }); - }); - - it_rmrk('Creates a new RMRK collection that is mapped to a different ID and is tagged as external', async () => { - await usingApi(async api => { - // throwaway collection to bump last Unique collection ID to test ID mapping - await createCollectionExpectSuccess(); - - const collectionIds = await createRmrkCollection(api, alice); - - expect(collectionIds.rmrkId).to.be.lessThan(collectionIds.uniqueId, 'collection ID mapping'); - - const collection = (await getDetailedCollectionInfo(api, collectionIds.uniqueId))!; - expect(collection.readOnly.toHuman(), 'tagged external').to.be.true; - }); - }); -}); - -describe('Negative Integration Test: External Collections, Internal Ops', async () => { - let uniqueCollectionId: number; - let rmrkCollectionId: number; - let rmrkNftId: number; - - const it_rmrk = (await isUnique() ? it : it.skip); - - before(async () => { - await usingApi(async (api, privateKeyWrapper) => { - alice = privateKeyWrapper('//Alice'); - bob = privateKeyWrapper('//Bob'); - - const collectionIds = await createRmrkCollection(api, alice); - uniqueCollectionId = collectionIds.uniqueId; - rmrkCollectionId = collectionIds.rmrkId; - - rmrkNftId = await createRmrkNft(api, alice, rmrkCollectionId); - }); - }); - - it_rmrk('[Negative] Forbids Unique operations with an external collection, handled by dispatch_call', async () => { - await usingApi(async api => { - // Collection item creation - - const txCreateItem = api.tx.unique.createItem(uniqueCollectionId, normalizeAccountId(alice), 'NFT'); - await expect(executeTransaction(api, alice, txCreateItem), 'creating item') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txCreateMultipleItems = api.tx.unique.createMultipleItems(uniqueCollectionId, normalizeAccountId(alice), [{NFT: {}}, {NFT: {}}]); - await expect(executeTransaction(api, alice, txCreateMultipleItems), 'creating multiple') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txCreateMultipleItemsEx = api.tx.unique.createMultipleItemsEx(uniqueCollectionId, {NFT: [{}]}); - await expect(executeTransaction(api, alice, txCreateMultipleItemsEx), 'creating multiple ex') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - // Collection properties - - const txSetCollectionProperties = api.tx.unique.setCollectionProperties(uniqueCollectionId, [{key: 'a', value: '1'}, {key: 'b'}]); - await expect(executeTransaction(api, alice, txSetCollectionProperties), 'setting collection properties') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txDeleteCollectionProperties = api.tx.unique.deleteCollectionProperties(uniqueCollectionId, ['a']); - await expect(executeTransaction(api, alice, txDeleteCollectionProperties), 'deleting collection properties') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txsetTokenPropertyPermissions = api.tx.unique.setTokenPropertyPermissions(uniqueCollectionId, [{key: 'a', permission: {mutable: true}}]); - await expect(executeTransaction(api, alice, txsetTokenPropertyPermissions), 'setting property permissions') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - // NFT - - const txBurn = api.tx.unique.burnItem(uniqueCollectionId, rmrkNftId, 1); - await expect(executeTransaction(api, alice, txBurn), 'burning').to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txBurnFrom = api.tx.unique.burnFrom(uniqueCollectionId, normalizeAccountId(alice), rmrkNftId, 1); - await expect(executeTransaction(api, alice, txBurnFrom), 'burning-from').to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txTransfer = api.tx.unique.transfer(normalizeAccountId(bob), uniqueCollectionId, rmrkNftId, 1); - await expect(executeTransaction(api, alice, txTransfer), 'transferring').to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txApprove = api.tx.unique.approve(normalizeAccountId(bob), uniqueCollectionId, rmrkNftId, 1); - await expect(executeTransaction(api, alice, txApprove), 'approving').to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txTransferFrom = api.tx.unique.transferFrom(normalizeAccountId(alice), normalizeAccountId(bob), uniqueCollectionId, rmrkNftId, 1); - await expect(executeTransaction(api, alice, txTransferFrom), 'transferring-from').to.be.rejectedWith(/common\.CollectionIsExternal/); - - // NFT properties - - const txSetTokenProperties = api.tx.unique.setTokenProperties(uniqueCollectionId, rmrkNftId, [{key: 'a', value: '2'}]); - await expect(executeTransaction(api, alice, txSetTokenProperties), 'setting token properties') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txDeleteTokenProperties = api.tx.unique.deleteTokenProperties(uniqueCollectionId, rmrkNftId, ['a']); - await expect(executeTransaction(api, alice, txDeleteTokenProperties), 'deleting token properties') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - }); - }); - - it_rmrk('[Negative] Forbids Unique collection operations with an external collection', async () => { - await usingApi(async api => { - const txDestroyCollection = api.tx.unique.destroyCollection(uniqueCollectionId); - await expect(executeTransaction(api, alice, txDestroyCollection), 'destroying collection') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - // Allow list - - const txAddAllowList = api.tx.unique.addToAllowList(uniqueCollectionId, normalizeAccountId(bob)); - await expect(executeTransaction(api, alice, txAddAllowList), 'adding to allow list') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txRemoveAllowList = api.tx.unique.removeFromAllowList(uniqueCollectionId, normalizeAccountId(bob)); - await expect(executeTransaction(api, alice, txRemoveAllowList), 'removing from allowlist') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - // Owner / Admin / Sponsor - - const txChangeOwner = api.tx.unique.changeCollectionOwner(uniqueCollectionId, bob.address); - await expect(executeTransaction(api, alice, txChangeOwner), 'changing owner') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txAddAdmin = api.tx.unique.addCollectionAdmin(uniqueCollectionId, normalizeAccountId(bob)); - await expect(executeTransaction(api, alice, txAddAdmin), 'adding admin') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txRemoveAdmin = api.tx.unique.removeCollectionAdmin(uniqueCollectionId, normalizeAccountId(bob)); - await expect(executeTransaction(api, alice, txRemoveAdmin), 'removing admin') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txAddCollectionSponsor = api.tx.unique.setCollectionSponsor(uniqueCollectionId, bob.address); - await expect(executeTransaction(api, alice, txAddCollectionSponsor), 'setting sponsor') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txConfirmCollectionSponsor = api.tx.unique.confirmSponsorship(uniqueCollectionId); - await expect(executeTransaction(api, alice, txConfirmCollectionSponsor), 'confirming sponsor') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txRemoveCollectionSponsor = api.tx.unique.removeCollectionSponsor(uniqueCollectionId); - await expect(executeTransaction(api, alice, txRemoveCollectionSponsor), 'removing sponsor') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - // Limits / permissions / transfers - - const txSetTransfers = api.tx.unique.setTransfersEnabledFlag(uniqueCollectionId, true); - await expect(executeTransaction(api, alice, txSetTransfers), 'setting transfers enabled flag') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txSetLimits = api.tx.unique.setCollectionLimits(uniqueCollectionId, {transfersEnabled: false}); - await expect(executeTransaction(api, alice, txSetLimits), 'setting collection limits') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - - const txSetPermissions = api.tx.unique.setCollectionPermissions(uniqueCollectionId, {access: 'AllowList'}); - await expect(executeTransaction(api, alice, txSetPermissions), 'setting collection permissions') - .to.be.rejectedWith(/common\.CollectionIsExternal/); - }); - }); -}); - -describe('Negative Integration Test: Internal Collections, External Ops', async () => { - let collectionId: number; - let nftId: number; - - const it_rmrk = (await isUnique() ? it : it.skip); - - before(async () => { - await usingApi(async (api, privateKeyWrapper) => { - alice = privateKeyWrapper('//Alice'); - bob = privateKeyWrapper('//Bob'); - - collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}}); - nftId = await createItemExpectSuccess(alice, collectionId, 'NFT'); - }); - }); - - it_rmrk('[Negative] Forbids RMRK operations with the internal collection and NFT (due to the lack of mapping)', async () => { - await usingApi(async api => { - const txChangeOwner = api.tx.rmrkCore.changeCollectionIssuer(collectionId, bob.address); - await expect(executeTransaction(api, alice, txChangeOwner), 'changing collection issuer') - .to.be.rejectedWith(/rmrkCore\.CollectionUnknown/); - - const maxBurns = 10; - const txBurnItem = api.tx.rmrkCore.burnNft(collectionId, nftId, maxBurns); - await expect(executeTransaction(api, alice, txBurnItem), 'burning NFT').to.be.rejectedWith(/rmrkCore\.CollectionUnknown/); - }); - }); -}); --- /dev/null +++ b/tests/src/rmrk/rmrkIsolation.test.ts @@ -0,0 +1,250 @@ +import {expect} from 'chai'; +import usingApi, {executeTransaction} from '../substrate/substrate-api'; +import { + createCollectionExpectSuccess, + createItemExpectSuccess, + getCreateCollectionResult, + getDetailedCollectionInfo, + getGenericResult, + normalizeAccountId, +} from '../util/helpers'; +import {IKeyringPair} from '@polkadot/types/types'; +import {ApiPromise} from '@polkadot/api'; +import {it} from 'mocha'; + +let alice: IKeyringPair; +let bob: IKeyringPair; + +async function createRmrkCollection(api: ApiPromise, sender: IKeyringPair): Promise<{uniqueId: number, rmrkId: number}> { + const tx = api.tx.rmrkCore.createCollection('metadata', null, 'symbol'); + const events = await executeTransaction(api, sender, tx); + + const uniqueResult = getCreateCollectionResult(events); + const rmrkResult = getGenericResult(events, 'rmrkCore', 'CollectionCreated', (data) => { + return parseInt(data[1].toString(), 10); + }); + + return { + uniqueId: uniqueResult.collectionId, + rmrkId: rmrkResult.data!, + }; +} + +async function createRmrkNft(api: ApiPromise, sender: IKeyringPair, collectionId: number): Promise { + const tx = api.tx.rmrkCore.mintNft( + sender.address, + collectionId, + sender.address, + null, + 'nft-metadata', + true, + null, + ); + const events = await executeTransaction(api, sender, tx); + const result = getGenericResult(events, 'rmrkCore', 'NftMinted', (data) => { + return parseInt(data[2].toString(), 10); + }); + + return result.data!; +} + +async function isUnique(): Promise { + return usingApi(async api => { + const chain = await api.rpc.system.chain(); + + return chain.eq('UNIQUE'); + }); +} + +describe('RMRK External Integration Test', async () => { + const it_rmrk = (await isUnique() ? it : it.skip); + + before(async () => { + await usingApi(async (api, privateKeyWrapper) => { + alice = privateKeyWrapper('//Alice'); + + + }); + }); + + it_rmrk('Creates a new RMRK collection that is mapped to a different ID and is tagged as external', async () => { + await usingApi(async api => { + // throwaway collection to bump last Unique collection ID to test ID mapping + await createCollectionExpectSuccess(); + + const collectionIds = await createRmrkCollection(api, alice); + + expect(collectionIds.rmrkId).to.be.lessThan(collectionIds.uniqueId, 'collection ID mapping'); + + const collection = (await getDetailedCollectionInfo(api, collectionIds.uniqueId))!; + expect(collection.readOnly.toHuman(), 'tagged external').to.be.true; + }); + }); +}); + +describe('Negative Integration Test: External Collections, Internal Ops', async () => { + let uniqueCollectionId: number; + let rmrkCollectionId: number; + let rmrkNftId: number; + + const it_rmrk = (await isUnique() ? it : it.skip); + + before(async () => { + await usingApi(async (api, privateKeyWrapper) => { + alice = privateKeyWrapper('//Alice'); + bob = privateKeyWrapper('//Bob'); + + const collectionIds = await createRmrkCollection(api, alice); + uniqueCollectionId = collectionIds.uniqueId; + rmrkCollectionId = collectionIds.rmrkId; + + rmrkNftId = await createRmrkNft(api, alice, rmrkCollectionId); + }); + }); + + it_rmrk('[Negative] Forbids Unique operations with an external collection, handled by dispatch_call', async () => { + await usingApi(async api => { + // Collection item creation + + const txCreateItem = api.tx.unique.createItem(uniqueCollectionId, normalizeAccountId(alice), 'NFT'); + await expect(executeTransaction(api, alice, txCreateItem), 'creating item') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txCreateMultipleItems = api.tx.unique.createMultipleItems(uniqueCollectionId, normalizeAccountId(alice), [{NFT: {}}, {NFT: {}}]); + await expect(executeTransaction(api, alice, txCreateMultipleItems), 'creating multiple') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txCreateMultipleItemsEx = api.tx.unique.createMultipleItemsEx(uniqueCollectionId, {NFT: [{}]}); + await expect(executeTransaction(api, alice, txCreateMultipleItemsEx), 'creating multiple ex') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + // Collection properties + + const txSetCollectionProperties = api.tx.unique.setCollectionProperties(uniqueCollectionId, [{key: 'a', value: '1'}, {key: 'b'}]); + await expect(executeTransaction(api, alice, txSetCollectionProperties), 'setting collection properties') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txDeleteCollectionProperties = api.tx.unique.deleteCollectionProperties(uniqueCollectionId, ['a']); + await expect(executeTransaction(api, alice, txDeleteCollectionProperties), 'deleting collection properties') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txsetTokenPropertyPermissions = api.tx.unique.setTokenPropertyPermissions(uniqueCollectionId, [{key: 'a', permission: {mutable: true}}]); + await expect(executeTransaction(api, alice, txsetTokenPropertyPermissions), 'setting property permissions') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + // NFT + + const txBurn = api.tx.unique.burnItem(uniqueCollectionId, rmrkNftId, 1); + await expect(executeTransaction(api, alice, txBurn), 'burning').to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txBurnFrom = api.tx.unique.burnFrom(uniqueCollectionId, normalizeAccountId(alice), rmrkNftId, 1); + await expect(executeTransaction(api, alice, txBurnFrom), 'burning-from').to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txTransfer = api.tx.unique.transfer(normalizeAccountId(bob), uniqueCollectionId, rmrkNftId, 1); + await expect(executeTransaction(api, alice, txTransfer), 'transferring').to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txApprove = api.tx.unique.approve(normalizeAccountId(bob), uniqueCollectionId, rmrkNftId, 1); + await expect(executeTransaction(api, alice, txApprove), 'approving').to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txTransferFrom = api.tx.unique.transferFrom(normalizeAccountId(alice), normalizeAccountId(bob), uniqueCollectionId, rmrkNftId, 1); + await expect(executeTransaction(api, alice, txTransferFrom), 'transferring-from').to.be.rejectedWith(/common\.CollectionIsExternal/); + + // NFT properties + + const txSetTokenProperties = api.tx.unique.setTokenProperties(uniqueCollectionId, rmrkNftId, [{key: 'a', value: '2'}]); + await expect(executeTransaction(api, alice, txSetTokenProperties), 'setting token properties') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txDeleteTokenProperties = api.tx.unique.deleteTokenProperties(uniqueCollectionId, rmrkNftId, ['a']); + await expect(executeTransaction(api, alice, txDeleteTokenProperties), 'deleting token properties') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + }); + }); + + it_rmrk('[Negative] Forbids Unique collection operations with an external collection', async () => { + await usingApi(async api => { + const txDestroyCollection = api.tx.unique.destroyCollection(uniqueCollectionId); + await expect(executeTransaction(api, alice, txDestroyCollection), 'destroying collection') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + // Allow list + + const txAddAllowList = api.tx.unique.addToAllowList(uniqueCollectionId, normalizeAccountId(bob)); + await expect(executeTransaction(api, alice, txAddAllowList), 'adding to allow list') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txRemoveAllowList = api.tx.unique.removeFromAllowList(uniqueCollectionId, normalizeAccountId(bob)); + await expect(executeTransaction(api, alice, txRemoveAllowList), 'removing from allowlist') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + // Owner / Admin / Sponsor + + const txChangeOwner = api.tx.unique.changeCollectionOwner(uniqueCollectionId, bob.address); + await expect(executeTransaction(api, alice, txChangeOwner), 'changing owner') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txAddAdmin = api.tx.unique.addCollectionAdmin(uniqueCollectionId, normalizeAccountId(bob)); + await expect(executeTransaction(api, alice, txAddAdmin), 'adding admin') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txRemoveAdmin = api.tx.unique.removeCollectionAdmin(uniqueCollectionId, normalizeAccountId(bob)); + await expect(executeTransaction(api, alice, txRemoveAdmin), 'removing admin') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txAddCollectionSponsor = api.tx.unique.setCollectionSponsor(uniqueCollectionId, bob.address); + await expect(executeTransaction(api, alice, txAddCollectionSponsor), 'setting sponsor') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txConfirmCollectionSponsor = api.tx.unique.confirmSponsorship(uniqueCollectionId); + await expect(executeTransaction(api, alice, txConfirmCollectionSponsor), 'confirming sponsor') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txRemoveCollectionSponsor = api.tx.unique.removeCollectionSponsor(uniqueCollectionId); + await expect(executeTransaction(api, alice, txRemoveCollectionSponsor), 'removing sponsor') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + // Limits / permissions / transfers + + const txSetTransfers = api.tx.unique.setTransfersEnabledFlag(uniqueCollectionId, true); + await expect(executeTransaction(api, alice, txSetTransfers), 'setting transfers enabled flag') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txSetLimits = api.tx.unique.setCollectionLimits(uniqueCollectionId, {transfersEnabled: false}); + await expect(executeTransaction(api, alice, txSetLimits), 'setting collection limits') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + + const txSetPermissions = api.tx.unique.setCollectionPermissions(uniqueCollectionId, {access: 'AllowList'}); + await expect(executeTransaction(api, alice, txSetPermissions), 'setting collection permissions') + .to.be.rejectedWith(/common\.CollectionIsExternal/); + }); + }); +}); + +describe('Negative Integration Test: Internal Collections, External Ops', async () => { + let collectionId: number; + let nftId: number; + + const it_rmrk = (await isUnique() ? it : it.skip); + + before(async () => { + await usingApi(async (api, privateKeyWrapper) => { + alice = privateKeyWrapper('//Alice'); + bob = privateKeyWrapper('//Bob'); + + collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}}); + nftId = await createItemExpectSuccess(alice, collectionId, 'NFT'); + }); + }); + + it_rmrk('[Negative] Forbids RMRK operations with the internal collection and NFT (due to the lack of mapping)', async () => { + await usingApi(async api => { + const txChangeOwner = api.tx.rmrkCore.changeCollectionIssuer(collectionId, bob.address); + await expect(executeTransaction(api, alice, txChangeOwner), 'changing collection issuer') + .to.be.rejectedWith(/rmrkCore\.CollectionUnknown/); + + const maxBurns = 10; + const txBurnItem = api.tx.rmrkCore.burnNft(collectionId, nftId, maxBurns); + await expect(executeTransaction(api, alice, txBurnItem), 'burning NFT').to.be.rejectedWith(/rmrkCore\.CollectionUnknown/); + }); + }); +}); --- /dev/null +++ b/tests/src/rmrk/sendNft.test.ts @@ -0,0 +1,252 @@ +import {expect} from 'chai'; +import {getApiConnection} from '../substrate/substrate-api'; +import {createCollection, mintNft, sendNft} from './util/tx'; +import {NftIdTuple} from './util/fetch'; +import {isNftChildOfAnother, expectTxFailure} from './util/helpers'; + +describe('integration test: send NFT', () => { + let api: any; + before(async () => { api = await getApiConnection(); }); + + const maxNftId = 0xFFFFFFFF; + + const alice = '//Alice'; + const bob = '//Bob'; + + const createTestCollection = async (issuerUri: string) => { + return await createCollection( + api, + issuerUri, + 'nft-collection-metadata', + null, + 'nft-collection', + ); + }; + + + it('send NFT to another user', async () => { + const originalOwnerUri = alice; + const newOwnerUri = bob; + + const collectionId = await createTestCollection(alice); + + const nftId = await mintNft(api, alice, originalOwnerUri, collectionId, 'nft-metadata'); + + await sendNft(api, 'sent', originalOwnerUri, collectionId, nftId, newOwnerUri); + }); + + it('[negative] unable to send non-existing NFT', async () => { + const originalOwnerUri = alice; + const newOwnerUri = bob; + + const collectionId = 0; + const tx = sendNft(api, 'sent', originalOwnerUri, collectionId, maxNftId, newOwnerUri); + + await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx); + }); + + it('[negative] unable to send NFT by a not-an-owner', async () => { + const originalOwnerUri = alice; + const newOwnerUri = bob; + + const collectionId = await createTestCollection(alice); + + const nftId = await mintNft(api, alice, originalOwnerUri, collectionId, 'nft-metadata'); + + const tx = sendNft(api, 'sent', newOwnerUri, collectionId, nftId, newOwnerUri); + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + it('send NFT to another NFT (same owner)', async () => { + const originalOwnerUri = alice; + + const collectionId = await createTestCollection(alice); + + const parentNftId = await mintNft(api, alice, originalOwnerUri, collectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, alice, originalOwnerUri, collectionId, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [collectionId, parentNftId]; + + await sendNft(api, 'sent', alice, collectionId, childNftId, newOwnerNFT); + + const isChild = await isNftChildOfAnother(api, collectionId, childNftId, newOwnerNFT); + expect(isChild).to.be.true; + }); + + it('[negative] send non-existing NFT to another NFT', async () => { + const originalOwnerUri = alice; + + const collectionId = await createTestCollection(alice); + + const parentNftId = await mintNft(api, alice, originalOwnerUri, collectionId, 'parent-nft-metadata'); + const childNftId = maxNftId; + + const newOwnerNFT: NftIdTuple = [collectionId, parentNftId]; + + const tx = sendNft(api, 'sent', alice, collectionId, childNftId, newOwnerNFT); + + await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx); + + const isChild = await isNftChildOfAnother(api, collectionId, childNftId, newOwnerNFT); + expect(isChild).to.be.false; + }); + + it('send NFT to another NFT (by not-an-owner)', async () => { + const originalOwnerUri = alice; + + const collectionId = await createTestCollection(alice); + + const author = alice; + const attacker = bob; + + const parentNftId = await mintNft(api, author, originalOwnerUri, collectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, author, originalOwnerUri, collectionId, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [collectionId, parentNftId]; + + const tx = sendNft(api, 'sent', attacker, collectionId, childNftId, newOwnerNFT); + + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + + const isChild = await isNftChildOfAnother(api, collectionId, childNftId, newOwnerNFT); + expect(isChild).to.be.false; + }); + + it('[negative] send NFT to non-existing NFT', async () => { + const originalOwnerUri = alice; + + const collectionId = await createTestCollection(alice); + + const parentNftId = maxNftId; + const childNftId = await mintNft(api, alice, originalOwnerUri, collectionId, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [collectionId, parentNftId]; + + const tx = sendNft(api, 'sent', alice, collectionId, childNftId, newOwnerNFT); + + await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx); + + const isChild = await isNftChildOfAnother(api, collectionId, childNftId, newOwnerNFT); + expect(isChild).to.be.false; + }); + + it('send NFT to another NFT owned by another user', async () => { + const ownerAlice = alice; + const ownerBob = bob; + + const aliceCollectionId = await createTestCollection(alice); + const bobCollectionId = await createTestCollection(bob); + + const parentNftId = await mintNft(api, alice, ownerAlice, aliceCollectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, bob, ownerBob, bobCollectionId, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [aliceCollectionId, parentNftId]; + + await sendNft(api, 'pending', bob, bobCollectionId, childNftId, newOwnerNFT); + }); + + it('[negative] unable to send NFT to itself', async () => { + const nftOwner = alice; + const collectionId = await createTestCollection(alice); + + const nftId = await mintNft(api, alice, nftOwner, collectionId, 'ouroboros-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [collectionId, nftId]; + + const tx = sendNft(api, 'sent', alice, collectionId, nftId, newOwnerNFT); + + await expectTxFailure(/rmrkCore\.CannotSendToDescendentOrSelf/, tx); + + const isChild = await isNftChildOfAnother(api, collectionId, nftId, newOwnerNFT); + expect(isChild).to.be.false; + }); + + it('[negative] unable to send NFT to child NFT', async () => { + const originalOwnerUri = alice; + + const collectionId = await createTestCollection(alice); + + const parentNftId = await mintNft(api, alice, originalOwnerUri, collectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, alice, originalOwnerUri, collectionId, 'child-nft-metadata'); + + const newOwnerNFT: NftIdTuple = [collectionId, parentNftId]; + + await sendNft(api, 'sent', alice, collectionId, childNftId, newOwnerNFT); + + const isChild = await isNftChildOfAnother(api, collectionId, childNftId, newOwnerNFT); + expect(isChild).to.be.true; + + const descendentOwner: NftIdTuple = [collectionId, childNftId]; + const tx = sendNft(api, 'sent', alice, collectionId, parentNftId, descendentOwner); + + await expectTxFailure(/rmrkCore\.CannotSendToDescendentOrSelf/, tx); + const isOuroboros = await isNftChildOfAnother(api, collectionId, parentNftId, descendentOwner); + expect(isOuroboros).to.be.false; + }); + + it('[negative] unable to send NFT to descendent NFT', async () => { + const originalOwnerUri = alice; + + const collectionId = await createTestCollection(alice); + + const parentNftId = await mintNft(api, alice, originalOwnerUri, collectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, alice, originalOwnerUri, collectionId, 'child-nft-metadata'); + const grandsonNftId = await mintNft(api, alice, originalOwnerUri, collectionId, 'grandson-nft-metadata'); + + const ownerParentNFT: NftIdTuple = [collectionId, parentNftId]; + + await sendNft(api, 'sent', alice, collectionId, childNftId, ownerParentNFT); + + const isChild = await isNftChildOfAnother(api, collectionId, childNftId, ownerParentNFT); + expect(isChild).to.be.true; + + const ownerChildNFT: NftIdTuple = [collectionId, childNftId]; + await sendNft(api, 'sent', alice, collectionId, grandsonNftId, ownerChildNFT); + + const isGrandson = await isNftChildOfAnother(api, collectionId, grandsonNftId, ownerChildNFT); + expect(isGrandson).to.be.true; + + const ownerGrandsonNFT: NftIdTuple = [collectionId, grandsonNftId]; + const tx = sendNft(api, 'sent', alice, collectionId, parentNftId, ownerGrandsonNFT); + + await expectTxFailure(/rmrkCore\.CannotSendToDescendentOrSelf/, tx); + const isOuroboros = await isNftChildOfAnother(api, collectionId, parentNftId, ownerGrandsonNFT); + expect(isOuroboros).to.be.false; + }); + + it('send nested NFT to another user', async () => { + const originalOwner = alice; + const newOwner = bob; + + const collectionId = await createTestCollection(alice); + + const parentNftId = await mintNft(api, alice, originalOwner, collectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, alice, originalOwner, collectionId, 'child-nft-metadata'); + + const parentNftTuple: NftIdTuple = [collectionId, parentNftId]; + + await sendNft(api, 'sent', originalOwner, collectionId, childNftId, parentNftTuple); + + await sendNft(api, 'sent', originalOwner, collectionId, childNftId, newOwner); + }); + + it('[negative] send nested NFT to another user (by a not-root-owner)', async () => { + const originalOwner = alice; + const newOwner = bob; + + const collectionId = await createTestCollection(alice); + + const parentNftId = await mintNft(api, alice, originalOwner, collectionId, 'parent-nft-metadata'); + const childNftId = await mintNft(api, alice, originalOwner, collectionId, 'child-nft-metadata'); + + const parentNftTuple: NftIdTuple = [collectionId, parentNftId]; + + await sendNft(api, 'sent', originalOwner, collectionId, childNftId, parentNftTuple); + + const tx = sendNft(api, 'sent', newOwner, collectionId, childNftId, newOwner); + + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + after(() => { api.disconnect(); }); +}); --- /dev/null +++ b/tests/src/rmrk/setCollectionProperty.test.ts @@ -0,0 +1,67 @@ +import {getApiConnection} from '../substrate/substrate-api'; +import {expectTxFailure} from './util/helpers'; +import {createCollection, setPropertyCollection} from './util/tx'; + +describe('integration test: set collection property', () => { + const Alice = '//Alice'; + const Bob = '//Bob'; + + let api: any; + before(async () => { + api = await getApiConnection(); + }); + + it('set collection property', async () => { + await createCollection( + api, + Alice, + 'test-metadata', + null, + 'test-symbol', + ).then(async (collectionId) => { + await setPropertyCollection(api, Alice, collectionId, 'test_key', '42'); + await setPropertyCollection(api, Alice, collectionId, 'test_key', '10'); + await setPropertyCollection( + api, + Alice, + collectionId, + 'second_test_key', + '111', + ); + }); + }); + + it('[negative] set non-existing collection property', async () => { + const tx = setPropertyCollection( + api, + Alice, + 9999, + 'test_key', + '42', + ); + await expectTxFailure(/rmrkCore\.CollectionUnknown/, tx); + }); + + it('[negative] set property not an owner NFT collection issuer', async () => { + await createCollection( + api, + Bob, + 'test-metadata', + null, + 'test-symbol', + ).then(async (collectionId) => { + const tx = setPropertyCollection( + api, + Alice, + collectionId, + 'test_key', + '42', + ); + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + }); + + after(() => { + api.disconnect(); + }); +}); --- /dev/null +++ b/tests/src/rmrk/setEquippableList.test.ts @@ -0,0 +1,111 @@ +import {getApiConnection} from '../substrate/substrate-api'; +import {expectTxFailure} from './util/helpers'; +import {createCollection, createBase, setEquippableList} from './util/tx'; + +describe("integration test: set slot's Equippable List", () => { + let api: any; + before(async () => { api = await getApiConnection(); }); + + const alice = '//Alice'; + const bob = '//Bob'; + + it("set Base's slot Equippable List", async () => { + const collectionIds = [ + await createCollection( + api, + alice, + 'equiplist-collection-metadata', + null, + 'equiplist-0', + ), + await createCollection( + api, + alice, + 'equiplist-collection-metadata', + null, + 'equiplist-1', + ), + ]; + + const slotId = 202; + + const baseId = await createBase(api, alice, 'slotpartany-base-type', 'slotpartany', [ + { + 'SlotPart': { + id: slotId, + equippable: 'All', + z: 1, + src: 'some-fallback-slot-url', + }, + }, + ]); + + await setEquippableList(api, alice, baseId, slotId, 'All'); + await setEquippableList(api, alice, baseId, slotId, 'Empty'); + await setEquippableList(api, alice, baseId, slotId, {'Custom': collectionIds}); + }); + + it('[negative] unable to set equippable list of a slot of non-existing base', async () => { + const maxBaseId = 0xFFFFFFFF; + const slotId = 0; + + const tx = setEquippableList(api, alice, maxBaseId, slotId, 'All'); + await expectTxFailure(/rmrkEquip\.BaseDoesntExist/, tx); + }); + + it('[negative] unable to set equippable list by a not-an-owner', async () => { + const slotId = 42; + + const baseId = await createBase(api, alice, 'slotpartany-base-type', 'slotpartany', [ + { + 'SlotPart': { + id: slotId, + equippable: 'All', + z: 1, + src: 'some-fallback-slot-url', + }, + }, + ]); + + const tx = setEquippableList(api, bob, baseId, slotId, 'All'); + await expectTxFailure(/rmrkEquip\.PermissionError/, tx); + }); + + it('[negative] unable to set equippable list to a fixed part', async () => { + const fixedPartId = 42; + + const baseId = await createBase(api, alice, 'fixedpart-base-type', 'fixedpart', [ + { + 'FixedPart': { + id: fixedPartId, + z: 0, + src: 'fixed-part-url', + }, + }, + ]); + + const tx = setEquippableList(api, alice, baseId, fixedPartId, 'All'); + await expectTxFailure(/rmrkEquip\.NoEquippableOnFixedPart/, tx); + }); + + it('[negative] unable to set equippable list to non-existing slot', async () => { + const slotId = 777; + const maxSlotId = 0xFFFFFFFF; + + const baseId = await createBase(api, alice, 'slotpartany-base-type', 'slotpartany', [ + { + 'SlotPart': { + id: slotId, + equippable: 'All', + z: 1, + src: 'some-fallback-slot-url', + }, + }, + ]); + + const tx = setEquippableList(api, alice, baseId, maxSlotId, 'All'); + await expectTxFailure(/rmrkEquip\.PartDoesntExist/, tx); + }); + + after(() => { api.disconnect(); }); +}); --- /dev/null +++ b/tests/src/rmrk/setNftProperty.test.ts @@ -0,0 +1,85 @@ +import {getApiConnection} from '../substrate/substrate-api'; +import {NftIdTuple} from './util/fetch'; +import {expectTxFailure} from './util/helpers'; +import {createCollection, mintNft, sendNft, setNftProperty} from './util/tx'; + +describe('integration test: set NFT property', () => { + let api: any; + before(async () => { api = await getApiConnection(); }); + + const alice = '//Alice'; + const bob = '//Bob'; + + const createTestCollection = async (issuerUri: string) => { + return await createCollection( + api, + issuerUri, + 'setprop-nft-collection-metadata', + null, + 'setprop', + ); + }; + + it('set NFT property', async () => { + const ownerAlice = alice; + + const collectionId = await createTestCollection(alice); + const nftId = await mintNft(api, alice, ownerAlice, collectionId, 'prop-nft'); + + await setNftProperty(api, alice, collectionId, nftId, 'test-key', 'test-key-value'); + await setNftProperty(api, alice, collectionId, nftId, 'test-key', 'updated-key-value'); + await setNftProperty(api, alice, collectionId, nftId, 'second-test-key', 'second-test-key-value'); + }); + + it('[negative] unable to set a property of non-existing NFT', async () => { + const collectionId = 0; + const maxNftId = 0xFFFFFFFF; + + const tx = setNftProperty(api, alice, collectionId, maxNftId, 'test-key', 'test-value'); + + await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx); + }); + + it('[negative] unable to set a property by not-an-owner', async () => { + const ownerAlice = alice; + + const collectionId = await createTestCollection(alice); + const nftId = await mintNft(api, alice, ownerAlice, collectionId, 'prop-nft'); + + const tx = setNftProperty(api, bob, collectionId, nftId, 'test-key', 'test-key-value'); + + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + it('set a property to nested NFT', async () => { + const ownerAlice = alice; + + const collectionId = await createTestCollection(alice); + const parentNftId = await mintNft(api, alice, ownerAlice, collectionId, 'prop-parent-nft'); + const childNftId = await mintNft(api, alice, ownerAlice, collectionId, 'prop-child-nft'); + + const ownerNft: NftIdTuple = [collectionId, parentNftId]; + + await sendNft(api, 'sent', ownerAlice, collectionId, childNftId, ownerNft); + + await setNftProperty(api, alice, collectionId, childNftId, 'test-key', 'test-key-value'); + }); + + it('[negative] set a property to nested NFT (by not-root-owner)', async () => { + const ownerAlice = alice; + + const collectionId = await createTestCollection(alice); + const parentNftId = await mintNft(api, alice, ownerAlice, collectionId, 'prop-parent-nft'); + const childNftId = await mintNft(api, alice, ownerAlice, collectionId, 'prop-child-nft'); + + const ownerNft: NftIdTuple = [collectionId, parentNftId]; + + await sendNft(api, 'sent', ownerAlice, collectionId, childNftId, ownerNft); + + const tx = setNftProperty(api, bob, collectionId, childNftId, 'test-key', 'test-key-value'); + + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + after(() => { api.disconnect(); }); +}); --- /dev/null +++ b/tests/src/rmrk/setResourcePriorities.test.ts @@ -0,0 +1,55 @@ +import {getApiConnection} from '../substrate/substrate-api'; +import {expectTxFailure} from './util/helpers'; +import {mintNft, createCollection, setResourcePriorities} from './util/tx'; + +describe('integration test: set NFT resource priorities', () => { + let api: any; + before(async () => { api = await getApiConnection(); }); + + const alice = '//Alice'; + const bob = '//Bob'; + + const createTestCollection = (issuerUri: string) => { + return createCollection( + api, + issuerUri, + 'resprio-collection-metadata', + null, + 'resprio', + ); + }; + + it('set NFT resource priorities', async () => { + const owner = alice; + + const collectionId = await createTestCollection(alice); + const nftId = await mintNft(api, alice, owner, collectionId, 'resprio-nft-metadata'); + + await setResourcePriorities(api, alice, collectionId, nftId, [10, 42]); + }); + + it('[negative] set NFT resource priorities by a not-an-owner', async () => { + const owner = alice; + const attacker = bob; + + const collectionId = await createTestCollection(alice); + const nftId = await mintNft(api, alice, owner, collectionId, 'resprio-nft-metadata'); + + const tx = setResourcePriorities(api, attacker, collectionId, nftId, [10, 42]); + + await expectTxFailure(/rmrkCore\.NoPermission/, tx); + }); + + it('[negative] set NFT resource priorities to non-existing NFT', async () => { + const owner = alice; + + const collectionId = 0; + const maxNftId = 0xFFFFFFFF; + + const tx = setResourcePriorities(api, alice, collectionId, maxNftId, [10, 42]); + + await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx); + }); + + after(() => { api.disconnect(); }); +}); --- /dev/null +++ b/tests/src/rmrk/util/fetch.ts @@ -0,0 +1,130 @@ +import {ApiPromise} from '@polkadot/api'; +import type {Option, Bytes} from '@polkadot/types-codec'; +import type { + RmrkTraitsCollectionCollectionInfo as Collection, + RmrkTraitsNftNftInfo as Nft, + RmrkTraitsResourceResourceInfo as Resource, + RmrkTraitsBaseBaseInfo as Base, + RmrkTraitsPartPartType as PartType, + RmrkTraitsNftNftChild as NftChild, + RmrkTraitsTheme as Theme, + RmrkTraitsPropertyPropertyInfo as Property, +} from '../../interfaces/default/types'; // '@polkadot/types/lookup'; +import '../../interfaces/augment-api'; +import '../../interfaces/augment-api-query'; +import privateKey from '../../substrate/privateKey'; + +export type NftIdTuple = [number, number]; + +export async function getCollectionsCount(api: ApiPromise): Promise { + return (await api.rpc.rmrk.lastCollectionIdx()).toNumber(); +} + +export async function getCollection(api: ApiPromise, id: number): Promise> { + return api.rpc.rmrk.collectionById(id); +} + +export async function getOwnedNfts( + api: ApiPromise, + ownerUri: string, + collectionId: number, +): Promise { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const owner = privateKey(ownerUri, Number(ss58Format)); + + return (await api.rpc.rmrk.accountTokens(owner.address, collectionId)) + .map((value) => value.toNumber()); +} + +export async function getNft(api: ApiPromise, collectionId: number, nftId: number): Promise> { + return api.rpc.rmrk.nftById(collectionId, nftId); +} + +export async function getCollectionProperties(api: ApiPromise, collectionId: number): Promise { + return (await api.rpc.rmrk.collectionProperties(collectionId)).toArray(); +} + +export async function getNftProperties(api: ApiPromise, collectionId: number, nftId: number): Promise { + return (await api.rpc.rmrk.nftProperties(collectionId, nftId)).toArray(); +} + +export async function getChildren( + api: ApiPromise, + collectionId: number, + nftId: number, +): Promise { + return (await api.rpc.rmrk.nftChildren(collectionId, nftId)).toArray(); +} + +export async function getBase(api: ApiPromise, baseId: number): Promise> { + return api.rpc.rmrk.base(baseId); +} + +export async function getParts(api: ApiPromise, baseId: number): Promise { + return (await api.rpc.rmrk.baseParts(baseId)).toArray(); +} + +export async function getEquippableList( + api: ApiPromise, + baseId: number, + slotId: number, +): Promise<'All' | 'Empty' | { 'Custom': number[] } | null> { + const parts = await getParts(api, baseId); + + const part = parts.find((part) => { + if (part.isSlotPart) { + return part.asSlotPart.id.toNumber() === slotId; + } else { + return false; + } + }); + + if (part) { + const slot = part.asSlotPart; + if (slot.equippable.isCustom) { + return { + 'Custom': slot.equippable.asCustom + .toArray() + .map((collectionId) => collectionId.toNumber()), + }; + } else if (slot.equippable.isAll) { + return 'All'; + } else { + return 'Empty'; + } + } else { + return null; + } +} + +export async function getResourcePriority( + api: ApiPromise, + collectionId: number, + nftId: number, + resourceId: number, +): Promise { + return (await api.rpc.rmrk.nftResourcePriority(collectionId, nftId, resourceId)) + .unwrap().toNumber(); +} + +export async function getThemeNames(api: ApiPromise, baseId: number): Promise { + return (await api.rpc.rmrk.themeNames(baseId)) + .map((name) => name.toUtf8()); +} + +export async function getTheme( + api: ApiPromise, + baseId: number, + themeName: string, + keys: string[] | null = null, +): Promise> { + return api.rpc.rmrk.themes(baseId, themeName, keys); +} + +export async function getResources( + api: ApiPromise, + collectionId: number, + nftId: number, +): Promise { + return (await api.rpc.rmrk.nftResources(collectionId, nftId)).toArray(); +} --- /dev/null +++ b/tests/src/rmrk/util/helpers.ts @@ -0,0 +1,207 @@ +import {ApiPromise} from '@polkadot/api'; +import { + RmrkTraitsNftAccountIdOrCollectionNftTuple as NftOwner, + RmrkTraitsPropertyPropertyInfo as Property, + RmrkTraitsResourceResourceInfo as ResourceInfo, +} from '@polkadot/types/lookup'; +import type {EventRecord} from '@polkadot/types/interfaces'; +import type {GenericEventData} from '@polkadot/types'; +import privateKey from '../../substrate/privateKey'; +import {NftIdTuple, getChildren, getOwnedNfts, getCollectionProperties, getNftProperties, getResources} from './fetch'; +import chaiAsPromised from 'chai-as-promised'; +import chai from 'chai'; + +chai.use(chaiAsPromised); +const expect = chai.expect; + +interface TxResult { + success: boolean; + successData: T | null; +} + +export function makeNftOwner(api: ApiPromise, owner: string | NftIdTuple): NftOwner { + const isNftSending = (typeof owner !== 'string'); + + if (isNftSending) { + return api.createType('RmrkTraitsNftAccountIdOrCollectionNftTuple', { + 'CollectionAndNftTuple': owner, + }); + } else { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + return api.createType('RmrkTraitsNftAccountIdOrCollectionNftTuple', { + AccountId: privateKey(owner, Number(ss58Format)).address, + }); + } +} + +export async function isNftOwnedBy( + api: ApiPromise, + owner: string | NftIdTuple, + collectionId: number, + nftId: number, +): Promise { + if (typeof owner === 'string') { + return (await getOwnedNfts(api, owner, collectionId)) + .find(ownedNftId => { + return ownedNftId === nftId; + }) !== undefined; + } else { + return (await getChildren(api, owner[0], owner[1])) + .find(child => { + return collectionId === child.collectionId.toNumber() + && nftId === child.nftId.toNumber(); + }) !== undefined; + } +} + +export function isPropertyExists( + key: string, + value: string, + props: Property[], +): boolean { + let isPropFound = false; + for (let i = 0; i < props.length && !isPropFound; i++) { + const fetchedProp = props[i]; + + isPropFound = fetchedProp.key.eq(key) + && fetchedProp.value.eq(value); + } + + return isPropFound; +} + +export async function isCollectionPropertyExists( + api: ApiPromise, + collectionId: number, + key: string, + value: string, +): Promise { + const fetchedProps = await getCollectionProperties(api, collectionId); + return isPropertyExists(key, value, fetchedProps); +} + +export async function isNftPropertyExists( + api: ApiPromise, + collectionId: number, + nftId: number, + key: string, + value: string, +): Promise { + const fetchedProps = await getNftProperties(api, collectionId, nftId); + return isPropertyExists(key, value, fetchedProps); +} + +export async function isNftChildOfAnother( + api: ApiPromise, + collectionId: number, + nftId: number, + parentNft: NftIdTuple, +): Promise { + return (await getChildren(api, parentNft[0], parentNft[1])) + .find((childNft) => { + return childNft.collectionId.toNumber() === collectionId + && childNft.nftId.toNumber() === nftId; + }) !== undefined; +} + +export function isTxResultSuccess(events: EventRecord[]): boolean { + let success = false; + + events.forEach(({event: {data, method, section}}) => { + if (method == 'ExtrinsicSuccess') { + success = true; + } + }); + + return success; +} + +export async function expectTxFailure(expectedError: RegExp, promise: Promise) { + await expect(promise).to.be.rejectedWith(expectedError); +} + +export function extractTxResult( + events: EventRecord[], + expectSection: string, + expectMethod: string, + extractAction: (data: any) => T, +): TxResult { + let success = false; + let successData = null; + events.forEach(({event: {data, method, section}}) => { + if (method == 'ExtrinsicSuccess') { + success = true; + } else if ((expectSection == section) && (expectMethod == method)) { + successData = extractAction(data); + } + }); + const result: TxResult = { + success, + successData, + }; + return result; +} + +export function extractRmrkCoreTxResult( + events: EventRecord[], + expectMethod: string, + extractAction: (data: GenericEventData) => T, +): TxResult { + return extractTxResult(events, 'rmrkCore', expectMethod, extractAction); +} + +export function extractRmrkEquipTxResult( + events: EventRecord[], + expectMethod: string, + extractAction: (data: GenericEventData) => T, +): TxResult { + return extractTxResult(events, 'rmrkEquip', expectMethod, extractAction); +} + +export async function findResourceById( + api: ApiPromise, + collectionId: number, + nftId: number, + resourceId: number, +): Promise { + const resources = await getResources(api, collectionId, nftId); + + let resource = null; + + for (let i = 0; i < resources.length; i++) { + const res = resources[i]; + + if (res.id.eq(resourceId)) { + resource = res; + break; + } + } + + return resource!; +} + +export async function getResourceById( + api: ApiPromise, + collectionId: number, + nftId: number, + resourceId: number, +): Promise { + const resource = await findResourceById( + api, + collectionId, + nftId, + resourceId, + ); + + expect(resource !== null, 'Error: resource was not found').to.be.true; + + return resource!; +} + +export function checkResourceStatus( + resource: ResourceInfo, + expectedStatus: 'pending' | 'added', +) { + expect(resource.pending.isTrue, `Error: added resource should be ${expectedStatus}`) + .to.be.equal(expectedStatus === 'pending'); +} --- /dev/null +++ b/tests/src/rmrk/util/tx.ts @@ -0,0 +1,1132 @@ +import {ApiPromise} from '@polkadot/api'; +import {Bytes, Option, u32, Vec} from '@polkadot/types-codec'; +import { + RmrkTraitsNftAccountIdOrCollectionNftTuple as NftOwner, RmrkTraitsPartEquippableList as EquippableList, + RmrkTraitsPartPartType as PartType, RmrkTraitsResourceBasicResource as BasicResource, + RmrkTraitsResourceComposableResource as ComposableResource, RmrkTraitsResourceResourceInfo as ResourceInfo, RmrkTraitsResourceSlotResource as SlotResource, RmrkTraitsTheme as Theme, +} from '@polkadot/types/lookup'; +import {IKeyringPair} from '@polkadot/types/types'; +import chai from 'chai'; +import chaiAsPromised from 'chai-as-promised'; +import '../../interfaces/augment-api'; +import privateKey from '../../substrate/privateKey'; +import {executeTransaction} from '../../substrate/substrate-api'; +import { + getBase, + getCollection, + getCollectionsCount, + getEquippableList, + getNft, + getParts, + getResources, + getResourcePriority, + getTheme, + NftIdTuple, +} from './fetch'; +import { + extractRmrkCoreTxResult, + extractRmrkEquipTxResult, isCollectionPropertyExists, isNftOwnedBy, isNftPropertyExists, isTxResultSuccess, makeNftOwner, + findResourceById, getResourceById, checkResourceStatus, +} from './helpers'; + +chai.use(chaiAsPromised); +const expect = chai.expect; + +export async function createCollection( + api: ApiPromise, + issuerUri: string, + metadata: string, + max: number | null, + symbol: string, +): Promise { + let collectionId = 0; + + const oldCollectionCount = await getCollectionsCount(api); + const maxOptional = max ? max.toString() : null; + const ss58Format = (api.registry.getChainProperties())!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const tx = api.tx.rmrkCore.createCollection(metadata, maxOptional, symbol); + const events = await executeTransaction(api, issuer, tx); + + const collectionResult = extractRmrkCoreTxResult(events, 'CollectionCreated', (data) => { + return parseInt(data[1].toString(), 10); + }); + expect(collectionResult.success, 'Error: unable to create a collection').to.be.true; + + collectionId = collectionResult.successData!; + + const newCollectionCount = await getCollectionsCount(api); + const collectionOption = await getCollection(api, collectionId); + + expect(newCollectionCount).to.be.equal(oldCollectionCount + 1, 'Error: NFT collection count should increase'); + expect(collectionOption.isSome, 'Error: unable to fetch created NFT collection').to.be.true; + + const collection = collectionOption.unwrap(); + + expect(collection.metadata.toUtf8()).to.be.equal(metadata, 'Error: Invalid NFT collection metadata'); + expect(collection.max.isSome).to.be.equal(max !== null, 'Error: Invalid NFT collection max'); + + if (collection.max.isSome) { + expect(collection.max.unwrap().toNumber()).to.be.equal(max, 'Error: Invalid NFT collection max'); + } + expect(collection.symbol.toUtf8()).to.be.equal(symbol, "Error: Invalid NFT collection's symbol"); + expect(collection.nftsCount.toNumber()).to.be.equal(0, "Error: NFT collection shoudn't have any tokens"); + expect(collection.issuer.toString()).to.be.equal(issuer.address, 'Error: Invalid NFT collection issuer'); + + return collectionId; +} + +export async function changeIssuer( + api: ApiPromise, + issuerUri: string, + collectionId: number, + newIssuer: string, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const alice = privateKey(issuerUri, Number(ss58Format)); + const bob = privateKey(newIssuer, Number(ss58Format)); + + // This is only needed when RMRK uses `uniques` pallet by Parity + // let tx = api.tx.uniques.setAcceptOwnership( + // api.createType('Option', collectionId) + // ); + // let events = await executeTransaction(api, bob, tx); + // expect(isTxResultSuccess(events), 'Error: Unable to accept ownership').to.be.true; + + const tx = api.tx.rmrkCore.changeCollectionIssuer(collectionId, bob.address); + const events = await executeTransaction(api, alice, tx); + const changeIssuerResult = extractRmrkCoreTxResult(events, 'IssuerChanged', (data) => { + return parseInt(data[2].toString(), 10); + }); + expect(changeIssuerResult.success, 'Error: Unable to change NFT collection issuer').to.be.true; + expect(changeIssuerResult.successData!, 'Error: Invalid collection id after changing the issuer') + .to.be.eq(collectionId); + + await getCollection(api, collectionId).then((collectionOption) => { + const collection = collectionOption.unwrap(); + expect(collection.issuer.toString()) + .to.be.deep.eq(bob.address, 'Error: Invalid NFT collection issuer'); + }); +} + +export async function deleteCollection( + api: ApiPromise, + issuerUri: string, + collectionId: string, +): Promise { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const tx = api.tx.rmrkCore.destroyCollection(collectionId); + const events = await executeTransaction(api, issuer, tx); + + const collectionTxResult = extractRmrkCoreTxResult( + events, + 'CollectionDestroy', + (data) => { + return parseInt(data[1].toString(), 10); + }, + ); + expect(collectionTxResult.success, 'Error: Unable to delete NFT collection').to.be.true; + + const collection = await getCollection( + api, + parseInt(collectionId, 10), + ); + expect(collection.isEmpty, 'Error: NFT collection should be deleted').to.be.true; + + return 0; +} + +export async function negativeDeleteCollection( + api: ApiPromise, + issuerUri: string, + collectionId: string, +): Promise { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const tx = api.tx.rmrkCore.destroyCollection(collectionId); + await expect(executeTransaction(api, issuer, tx)).to.be.rejected; + + return 0; +} + +export async function setNftProperty( + api: ApiPromise, + issuerUri: string, + collectionId: number, + nftId: number, + key: string, + value: string, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const nftIdOpt = api.createType('Option', nftId); + const tx = api.tx.rmrkCore.setProperty( + collectionId, + nftIdOpt, + key, + value, + ); + const events = await executeTransaction(api, issuer, tx); + + const propResult = extractRmrkCoreTxResult(events, 'PropertySet', (data) => { + return { + collectionId: parseInt(data[0].toString(), 10), + nftId: data[1] as Option, + key: data[2] as Bytes, + value: data[3] as Bytes, + }; + }); + + expect(propResult.success, 'Error: Unable to set NFT property').to.be.true; + const eventData = propResult.successData!; + const eventDescription = 'from set NFT property event'; + + expect(eventData.collectionId, 'Error: Invalid collection ID ' + eventDescription) + .to.be.equal(collectionId); + + expect(eventData.nftId.eq(nftIdOpt), 'Error: Invalid NFT ID ' + eventDescription) + .to.be.true; + + expect(eventData.key.eq(key), 'Error: Invalid property key ' + eventDescription) + .to.be.true; + + expect(eventData.value.eq(value), 'Error: Invalid property value ' + eventDescription) + .to.be.true; + + expect( + await isNftPropertyExists(api, collectionId, nftId, key, value), + 'Error: NFT property is not found', + ).to.be.true; +} + +export async function mintNft( + api: ApiPromise, + issuerUri: string, + ownerUri: string | null, + collectionId: number, + metadata: string, + recipientUri: string | null = null, + royalty: number | null = null, + transferable = true, + resources: {basic?: any, composable?: any, slot?: any}[] | null = null, +): Promise { + let nftId = 0; + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const owner = ownerUri ? privateKey(ownerUri, Number(ss58Format)).address : null; + const recipient = recipientUri ? privateKey(recipientUri, Number(ss58Format)).address : null; + const royaltyOptional = royalty ? royalty.toString() : null; + + const actualOwnerUri = ownerUri ? ownerUri : issuerUri; + const actualOwnerAddress = ownerUri ? owner : issuer.address; + + const collectionOpt = await getCollection(api, collectionId); + + const tx = api.tx.rmrkCore.mintNft( + owner, + collectionId, + recipient, + royaltyOptional, + metadata, + transferable, + resources, + ); + + const events = await executeTransaction(api, issuer, tx); + const nftResult = extractRmrkCoreTxResult(events, 'NftMinted', (data) => { + return parseInt(data[2].toString(), 10); + }); + + expect(nftResult.success, 'Error: Unable to mint NFT').to.be.true; + + const newCollectionNftsCount = (await getCollection(api, collectionId)) + .unwrap() + .nftsCount + .toNumber(); + + const oldCollectionNftsCount = collectionOpt + .unwrap() + .nftsCount.toNumber(); + + expect(newCollectionNftsCount, 'Error: NFTs count should increase') + .to.be.equal(oldCollectionNftsCount + 1); + + nftId = nftResult.successData!; + + const nftOption = await getNft(api, collectionId, nftId); + + expect(nftOption.isSome, 'Error: Unable to fetch created NFT').to.be.true; + + const nft = nftOption.unwrap(); + + expect(nft.owner.isAccountId, 'Error: NFT owner should be some user').to.be.true; + expect(nft.owner.asAccountId.toString()).to.be.equal(actualOwnerAddress, 'Error: Invalid NFT owner'); + + const isOwnedInUniques = await isNftOwnedBy(api, actualOwnerUri, collectionId, nftId); + expect(isOwnedInUniques, `Error: created NFT is not actually owned by ${ownerUri}`) + .to.be.true; + + if (recipient === null && royalty === null) { + expect(nft.royalty.isNone, 'Error: Invalid NFT recipient') + .to.be.true; + } else { + expect(nft.royalty.isSome, 'Error: NFT royalty not found') + .to.be.true; + + const nftRoyalty = nft.royalty.unwrap(); + expect(nftRoyalty.recipient.eq(recipient), 'Error: Invalid NFT recipient') + .to.be.true; + + expect(nftRoyalty.amount.eq(royalty), 'Error: Invalid NFT royalty') + .to.be.true; + } + + expect(nft.metadata.toUtf8()).to.be.equal(metadata, 'Error: Invalid NFT metadata'); + + const nftResources = await getResources(api, collectionId, nftId); + if (resources == null) { + expect(nftResources, 'Error: Invalid NFT resources').to.be.empty; + } else { + expect(nftResources.length).to.be.equal(resources.length); + + for (let i = 0; i < resources.length; i++) { + let successFindingResource = false; + const resource = resources[i]; + // try to find the matching resource from the query + for (let j = 0; j < nftResources.length && !successFindingResource; j++) { + const nftResourceData = nftResources[j].toHuman(); + expect( + Object.prototype.hasOwnProperty.call(nftResourceData, 'resource'), + `Error: Corrupted resource data on resource #${i}`, + ).to.be.true; + const nftResource = nftResourceData.resource!; + type NftResourceKey = keyof typeof nftResource; + + let typedResource = null; + let typedNftResource = null; + + if (resource.basic && Object.prototype.hasOwnProperty.call(nftResource, 'Basic')) { + typedResource = resource.basic!; + typedNftResource = nftResource['Basic' as NftResourceKey]!; + } else if (resource.composable && Object.prototype.hasOwnProperty.call(nftResource, 'Composable')) { + typedResource = resource.composable!; + typedNftResource = nftResource['Composable' as NftResourceKey]! as any; + if (typedResource.parts != undefined && typedResource.parts.toString() != typedNftResource.parts.toString() + || typedResource.base != typedNftResource.base && typedResource.base != undefined) { + continue; + } + } else if (resource.slot && Object.prototype.hasOwnProperty.call(nftResource, 'Slot')) { + typedResource = resource.slot!; + typedNftResource = nftResource['Slot' as NftResourceKey]! as any; + if (typedResource.slot != typedNftResource.slot && typedResource.slot != undefined + || typedResource.base != typedNftResource.base && typedResource.base != undefined) { + continue; + } + } else { + continue; + } + + if (typedResource.src != typedNftResource.src + || typedResource.metadata != typedNftResource.metadata + || typedResource.thumb != typedNftResource.thumb + || typedResource.license != typedNftResource.license + ) { + continue; + } + + // do final checks since this is now established to be the resource we seek + expect(nftResourceData.pending, `Error: Resource #${i} is pending`).to.be.false; + expect(nftResourceData.pendingRemoval, `Error: Resource #${i} is pending removal`).to.be.false; + + // remove the matching resource from the resources we check + nftResources.splice(j, 1); + successFindingResource = true; + } + + expect(successFindingResource, `Error: Couldn't find resource #${i}'s counterpart among the returned`).to.be.true; + } + } + + return nftId; +} + +export async function sendNft( + api: ApiPromise, + expectedStatus: 'pending' | 'sent', + originalOwnerUri: string, + collectionId: number, + nftId: number, + newOwner: string | NftIdTuple, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const originalOwner = privateKey(originalOwnerUri, Number(ss58Format)); + const newOwnerObj = makeNftOwner(api, newOwner); + + const nftBeforeSendingOpt = await getNft(api, collectionId, nftId); + + const tx = api.tx.rmrkCore.send(collectionId, nftId, newOwnerObj); + const events = await executeTransaction(api, originalOwner, tx); + + const sendResult = extractRmrkCoreTxResult(events, 'NFTSent', (data) => { + return { + dstOwner: data[1] as NftOwner, + collectionId: parseInt(data[2].toString(), 10), + nftId: parseInt(data[3].toString(), 10), + }; + }); + + expect(sendResult.success, 'Error: Unable to send NFT').to.be.true; + const sendData = sendResult.successData!; + + expect(sendData.dstOwner.eq(newOwnerObj), 'Error: Invalid target user (from event data)') + .to.be.true; + + expect(sendData.collectionId) + .to.be.equal(collectionId, 'Error: Invalid collection ID (from event data)'); + + expect(sendData.nftId).to.be.equal(nftId, 'Error: Invalid NFT ID (from event data)'); + + expect(nftBeforeSendingOpt.isSome, 'Error: Unable to fetch NFT before sending').to.be.true; + + const nftBeforeSending = nftBeforeSendingOpt.unwrap(); + + const nftAfterSendingOpt = await getNft(api, collectionId, nftId); + + expect(nftAfterSendingOpt.isSome, 'Error: Unable to fetch NFT after sending').to.be.true; + + const nftAfterSending = nftAfterSendingOpt.unwrap(); + + const isOwnedByNewOwner = await isNftOwnedBy(api, newOwner, collectionId, nftId); + const isPending = expectedStatus === 'pending'; + + expect( + isOwnedByNewOwner, + `Error: The NFT should be owned by ${newOwner.toString()}`, + ).to.be.true; + + expect(nftAfterSending.royalty.eq(nftBeforeSending.royalty), 'Error: Invalid NFT royalty after sending') + .to.be.true; + + expect(nftAfterSending.metadata.eq(nftBeforeSending.metadata), 'Error: Invalid NFT metadata after sending') + .to.be.true; + + expect(nftAfterSending.equipped.eq(nftBeforeSending.equipped), 'Error: Invalid NFT equipped status after sending') + .to.be.true; + + expect(nftAfterSending.pending.eq(isPending), 'Error: Invalid NFT pending state') + .to.be.true; +} + +export async function acceptNft( + api: ApiPromise, + issuerUri: string, + collectionId: number, + nftId: number, + newOwner: string | [number, number], +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const newOwnerObj = makeNftOwner(api, newOwner); + + const nftBeforeOpt = await getNft(api, collectionId, nftId); + + const tx = api.tx.rmrkCore.acceptNft(collectionId, nftId, newOwnerObj); + const events = await executeTransaction(api, issuer, tx); + + const acceptResult = extractRmrkCoreTxResult(events, 'NFTAccepted', (data) => { + return { + recipient: data[1] as NftOwner, + collectionId: parseInt(data[2].toString(), 10), + nftId: parseInt(data[3].toString(), 10), + }; + }); + + expect(acceptResult.success, 'Error: Unable to accept NFT').to.be.true; + const acceptData = acceptResult.successData!; + + expect(acceptData.recipient.eq(newOwnerObj), 'Error: Invalid NFT recipient (from event data)') + .to.be.true; + + expect(acceptData.collectionId) + .to.be.equal(collectionId, 'Error: Invalid collection ID (from event data)'); + + expect(acceptData.nftId) + .to.be.equal(nftId, 'Error: Invalid NFT ID (from event data)'); + + const nftBefore = nftBeforeOpt.unwrap(); + + const isPendingBeforeAccept = nftBefore.pending.isTrue; + + const nftAfter = (await getNft(api, collectionId, nftId)).unwrap(); + const isPendingAfterAccept = nftAfter.pending.isTrue; + + expect(isPendingBeforeAccept, 'Error: NFT should be pending to be accepted') + .to.be.true; + + expect(isPendingAfterAccept, 'Error: NFT should NOT be pending after accept') + .to.be.false; + + const isOwnedInUniques = await isNftOwnedBy(api, newOwner, collectionId, nftId); + expect(isOwnedInUniques, `Error: created NFT is not actually owned by ${newOwner.toString()}`) + .to.be.true; +} + +export async function rejectNft( + api: ApiPromise, + issuerUri: string, + collectionId: number, + nftId: number, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const nftBeforeOpt = await getNft(api, collectionId, nftId); + + const tx = api.tx.rmrkCore.rejectNft(collectionId, nftId); + const events = await executeTransaction(api, issuer, tx); + const rejectResult = extractRmrkCoreTxResult(events, 'NFTRejected', (data) => { + return { + collectionId: parseInt(data[1].toString(), 10), + nftId: parseInt(data[2].toString(), 10), + }; + }); + + const rejectData = rejectResult.successData!; + + expect(rejectData.collectionId) + .to.be.equal(collectionId, 'Error: Invalid collection ID (from event data)'); + + expect(rejectData.nftId) + .to.be.equal(nftId, 'Error: Invalid NFT ID (from event data)'); + + const nftBefore = nftBeforeOpt.unwrap(); + + const isPendingBeforeReject = nftBefore.pending.isTrue; + + const nftAfter = await getNft(api, collectionId, nftId); + + expect(isPendingBeforeReject, 'Error: NFT should be pending to be rejected') + .to.be.true; + + expect(nftAfter.isNone, 'Error: NFT should be burned after reject') + .to.be.true; +} + +export async function createBase( + api: ApiPromise, + issuerUri: string, + baseType: string, + symbol: string, + parts: object[], +): Promise { + let baseId = 0; + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + + const partTypes = api.createType('Vec', parts) as Vec; + + const tx = api.tx.rmrkEquip.createBase(baseType, symbol, partTypes); + const events = await executeTransaction(api, issuer, tx); + + const baseResult = extractRmrkEquipTxResult(events, 'BaseCreated', (data) => { + return parseInt(data[1].toString(), 10); + }); + + expect(baseResult.success, 'Error: Unable to create Base') + .to.be.true; + + baseId = baseResult.successData!; + const baseOptional = await getBase(api, baseId); + + expect(baseOptional.isSome, 'Error: Unable to fetch created Base') + .to.be.true; + + const base = baseOptional.unwrap(); + const baseParts = await getParts(api, baseId); + + expect(base.issuer.toString()).to.be.equal(issuer.address, 'Error: Invalid Base issuer'); + expect(base.baseType.toUtf8()).to.be.equal(baseType, 'Error: Invalid Base type'); + expect(base.symbol.toUtf8()).to.be.equal(symbol, 'Error: Invalid Base symbol'); + expect(partTypes.eq(baseParts), 'Error: Received invalid base parts').to.be.true; + + return baseId; +} + +export async function setResourcePriorities( + api: ApiPromise, + issuerUri: string, + collectionId: number, + nftId: number, + priorities: number[], +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + + const prioritiesVec = api.createType('Vec', priorities); + const tx = api.tx.rmrkCore.setPriority(collectionId, nftId, prioritiesVec); + const events = await executeTransaction(api, issuer, tx); + + const prioResult = extractRmrkCoreTxResult(events, 'PrioritySet', (data) => { + return { + collectionId: parseInt(data[0].toString(), 10), + nftId: parseInt(data[1].toString(), 10), + }; + }); + + expect(prioResult.success, 'Error: Unable to set resource priorities').to.be.true; + const eventData = prioResult.successData!; + + expect(eventData.collectionId) + .to.be.equal(collectionId, 'Error: Invalid collection ID (set priorities event data)'); + + expect(eventData.nftId).to.be.equal(nftId, 'Error: Invalid NFT ID (set priorities event data'); + + for (let i = 0; i < priorities.length; i++) { + const resourceId = priorities[i]; + + const fetchedPrio = await getResourcePriority(api, collectionId, nftId, resourceId); + expect(fetchedPrio).to.be.equal(i, 'Error: Invalid priorities are set'); + } + +} + +export async function setEquippableList( + api: ApiPromise, + issuerUri: string, + baseId: number, + slotId: number, + equippableList: 'All' | 'Empty' | { 'Custom': number[] }, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const equippable = api.createType('RmrkTraitsPartEquippableList', equippableList) as EquippableList; + + const tx = api.tx.rmrkEquip.equippable(baseId, slotId, equippable); + const events = await executeTransaction(api, issuer, tx); + + const equipListResult = extractRmrkEquipTxResult(events, 'EquippablesUpdated', (data) => { + return { + baseId: parseInt(data[0].toString(), 10), + slotId: parseInt(data[1].toString(), 10), + }; + }); + + expect(equipListResult.success, 'Error: unable to update equippable list').to.be.true; + const updateEvent = equipListResult.successData!; + + expect(updateEvent.baseId) + .to.be.equal(baseId, 'Error: invalid base ID from update equippable event'); + + expect(updateEvent.slotId) + .to.be.equal(slotId, 'Error: invalid base ID from update equippable event'); + + const fetchedEquippableList = await getEquippableList(api, baseId, slotId); + + expect(fetchedEquippableList, 'Error: unable to fetch equippable list').to.be.not.null; + if (fetchedEquippableList) { + expect(fetchedEquippableList) + .to.be.deep.equal(equippableList, 'Error: invalid equippable list was set'); + } +} + +export async function addTheme( + api: ApiPromise, + issuerUri: string, + baseId: number, + themeObj: object, + filterKeys: string[] | null = null, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const theme = api.createType('RmrkTraitsTheme', themeObj) as Theme; + + const tx = api.tx.rmrkEquip.themeAdd(baseId, theme); + const events = await executeTransaction(api, issuer, tx); + + expect(isTxResultSuccess(events), 'Error: Unable to add Theme').to.be.true; + + const fetchedThemeOpt = await getTheme(api, baseId, theme.name.toUtf8(), null); + + expect(fetchedThemeOpt.isSome, 'Error: Unable to fetch theme').to.be.true; + + const fetchedTheme = fetchedThemeOpt.unwrap(); + + expect(theme.name.eq(fetchedTheme.name), 'Error: Invalid theme name').to.be.true; + + for (let i = 0; i < theme.properties.length; i++) { + const property = theme.properties[i]; + const propertyKey = property.key.toUtf8(); + + const propertyFoundCount = fetchedTheme.properties.filter((fetchedProp) => property.key.eq(fetchedProp.key)).length; + + expect(propertyFoundCount > 1, `Error: Too many properties with key ${propertyKey} found`) + .to.be.false; + + if (filterKeys) { + const isFiltered = fetchedTheme.properties.find((fetchedProp) => fetchedProp.key.eq(property.key)) === undefined; + + if (isFiltered) { + expect(propertyFoundCount === 0, `Error: Unexpected filtered key ${propertyKey}`) + .to.be.true; + continue; + } + } + + expect(propertyFoundCount === 1, `Error: The property with key ${propertyKey} is not found`) + .to.be.true; + } +} + +export async function lockCollection( + api: ApiPromise, + issuerUri: string, + collectionId: number, + max = 0, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const tx = api.tx.rmrkCore.lockCollection(collectionId); + const events = await executeTransaction(api, issuer, tx); + const lockResult = extractRmrkCoreTxResult(events, 'CollectionLocked', (data) => { + return parseInt(data[1].toString(), 10); + }); + expect(lockResult.success, 'Error: Unable to lock a collection').to.be.true; + expect(lockResult.successData!, 'Error: Invalid collection was locked') + .to.be.eq(collectionId); + + await getCollection(api, collectionId).then((collectionOption) => { + const collection = collectionOption.unwrap(); + expect(collection.max.unwrap().toNumber()).to.be.equal(max); + }); +} + +export async function setPropertyCollection( + api: ApiPromise, + issuerUri: string, + collectionId: number, + key: string, + value: string, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const alice = privateKey(issuerUri, Number(ss58Format)); + + const tx = api.tx.rmrkCore.setProperty(collectionId, null, key, value); + const events = await executeTransaction(api, alice, tx); + const propResult = extractRmrkCoreTxResult(events, 'PropertySet', (data) => { + return { + collectionId: parseInt(data[0].toString(), 10), + nftId: data[1] as Option, + key: data[2] as Bytes, + value: data[3] as Bytes, + }; + }); + + expect(propResult.success, 'Error: Unable to set collection property').to.be.true; + const eventData = propResult.successData!; + const eventDescription = 'from set collection property event'; + + expect(eventData.collectionId, 'Error: Invalid collection ID ' + eventDescription) + .to.be.equal(collectionId); + + expect(eventData.nftId.eq(null), 'Error: Unexpected NFT ID ' + eventDescription) + .to.be.true; + + expect(eventData.key.eq(key), 'Error: Invalid property key ' + eventDescription) + .to.be.true; + + expect(eventData.value.eq(value), 'Error: Invalid property value ' + eventDescription) + .to.be.true; + + expect(await isCollectionPropertyExists(api, collectionId, key, value)) + .to.be.true; +} + +export async function burnNft( + api: ApiPromise, + issuerUri: string, + collectionId: number, + nftId: number, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const maxBurns = 10; + const tx = api.tx.rmrkCore.burnNft(collectionId, nftId, maxBurns); + const events = await executeTransaction(api, issuer, tx); + const burnResult = extractRmrkCoreTxResult(events, 'NFTBurned', (data) => { + return parseInt(data[1].toString(), 10); + }); + + expect(burnResult.success, 'Error: Unable to burn an NFT').to.be.true; + expect(burnResult.successData!, 'Error: Invalid NFT was burned') + .to.be.eq(nftId); + + const nftBurned = await getNft(api, collectionId, nftId); + expect(nftBurned.isSome).to.be.false; +} + +export async function acceptNftResource( + api: ApiPromise, + issuerUri: string, + collectionId: number, + nftId: number, + resourceId: number, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + + const tx = api.tx.rmrkCore.acceptResource( + collectionId, + nftId, + resourceId, + ); + + const events = await executeTransaction(api, issuer, tx); + const acceptResult = extractRmrkCoreTxResult(events, 'ResourceAccepted', (data) => { + return { + nftId: parseInt(data[0].toString(), 10), + resourceId: parseInt(data[1].toString(), 10), + }; + }); + + expect(acceptResult.success, 'Error: Unable to accept a resource').to.be.true; + expect(acceptResult.successData!.nftId, 'Error: Invalid NFT ID while accepting a resource') + .to.be.eq(nftId); + expect(acceptResult.successData!.resourceId, 'Error: Invalid resource ID while accepting a resource') + .to.be.eq(resourceId); + + const resource = await getResourceById(api, collectionId, nftId, resourceId); + checkResourceStatus(resource, 'added'); +} + +async function executeResourceCreation( + api: ApiPromise, + issuer: IKeyringPair, + tx: any, + collectionId: number, + nftId: number, + expectedStatus: 'pending' | 'added', +): Promise { + const events = await executeTransaction(api, issuer, tx); + + const resourceResult = extractRmrkCoreTxResult(events, 'ResourceAdded', (data) => { + return parseInt(data[1].toString(), 10); + }); + expect(resourceResult.success, 'Error: Unable to add resource').to.be.true; + const resourceId = resourceResult.successData!; + + const resource = await getResourceById(api, collectionId, nftId, resourceId); + checkResourceStatus(resource, expectedStatus); + + return resource; +} + +export async function addNftBasicResource( + api: ApiPromise, + issuerUri: string, + expectedStatus: 'pending' | 'added', + collectionId: number, + nftId: number, + src: string | null, + metadata: string | null, + license: string | null, + thumb: string | null, +): Promise { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + + const basicResource = api.createType('RmrkTraitsResourceBasicResource', { + src: src, + metadata: metadata, + license: license, + thumb: thumb, + }) as BasicResource; + + const tx = api.tx.rmrkCore.addBasicResource( + collectionId, + nftId, + basicResource, + ); + + const resource = await executeResourceCreation(api, issuer, tx, collectionId, nftId, expectedStatus); + + // FIXME A workaround. It seems it is a PolkadotJS bug. + // All of the following are `false`. + // + // console.log('>>> basic:', resource.resource.isBasic); + // console.log('>>> composable:', resource.resource.isComposable); + // console.log('>>> slot:', resource.resource.isSlot); + const resourceJson = resource.resource.toHuman() as any; + + expect(Object.prototype.hasOwnProperty.call(resourceJson, 'Basic'), 'Error: Expected basic resource type') + .to.be.true; + + const recvBasicRes = resourceJson['Basic']; + + expect(recvBasicRes.src, 'Error: Invalid basic resource src') + .to.be.eq(src); + expect(recvBasicRes.metadata, 'Error: basic first resource metadata') + .to.be.eq(metadata); + expect(recvBasicRes.license, 'Error: basic first resource license') + .to.be.eq(license); + expect(recvBasicRes.thumb, 'Error: basic first resource thumb') + .to.be.eq(thumb); + + return resource.id.toNumber(); +} + +export async function addNftComposableResource( + api: ApiPromise, + issuerUri: string, + expectedStatus: 'pending' | 'added', + collectionId: number, + nftId: number, + parts: number[], + baseId: number, + src: string | null, + metadata: string | null, + license: string | null, + thumb: string | null, +): Promise { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + + const composableResource = api.createType('RmrkTraitsResourceComposableResource', { + parts: parts, // api.createType('Vec', parts), + base: baseId, + src: src, + metadata: metadata, + license: license, + thumb: thumb, + }) as ComposableResource; + + const tx = api.tx.rmrkCore.addComposableResource( + collectionId, + nftId, + composableResource, + ); + + const resource = await executeResourceCreation(api, issuer, tx, collectionId, nftId, expectedStatus); + + // FIXME A workaround. It seems it is a PolkadotJS bug. + // All of the following are `false`. + // + // console.log('>>> basic:', resource.resource.isBasic); + // console.log('>>> composable:', resource.resource.isComposable); + // console.log('>>> slot:', resource.resource.isSlot); + const resourceJson = resource.resource.toHuman() as any; + + expect(Object.prototype.hasOwnProperty.call(resourceJson, 'Composable'), 'Error: Expected composable resource type') + .to.be.true; + + const recvComposableRes = resourceJson['Composable']; + + expect(recvComposableRes.parts.toString(), 'Error: Invalid composable resource parts') + .to.be.eq(parts.toString()); + expect(recvComposableRes.base, 'Error: Invalid composable resource base id') + .to.be.eq(baseId.toString()); + expect(recvComposableRes.src, 'Error: Invalid composable resource src') + .to.be.eq(src); + expect(recvComposableRes.metadata, 'Error: Invalid composable resource metadata') + .to.be.eq(metadata); + expect(recvComposableRes.license, 'Error: Invalid composable resource license') + .to.be.eq(license); + expect(recvComposableRes.thumb, 'Error: Invalid composable resource thumb') + .to.be.eq(thumb); + + return resource.id.toNumber(); +} + +export async function addNftSlotResource( + api: ApiPromise, + issuerUri: string, + expectedStatus: 'pending' | 'added', + collectionId: number, + nftId: number, + baseId: number, + slotId: number, + src: string | null, + metadata: string | null, + license: string | null, + thumb: string | null, +): Promise { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + + const slotResource = api.createType('RmrkTraitsResourceSlotResource', { + base: baseId, + src: src, + metadata, + slot: slotId, + license: license, + thumb: thumb, + }) as SlotResource; + + const tx = api.tx.rmrkCore.addSlotResource( + collectionId, + nftId, + slotResource, + ); + + const resource = await executeResourceCreation(api, issuer, tx, collectionId, nftId, expectedStatus); + + // FIXME A workaround. It seems it is a PolkadotJS bug. + // All of the following are `false`. + // + // console.log('>>> basic:', resource.resource.isBasic); + // console.log('>>> composable:', resource.resource.isComposable); + // console.log('>>> slot:', resource.resource.isSlot); + const resourceJson = resource.resource.toHuman() as any; + + expect(Object.prototype.hasOwnProperty.call(resourceJson, 'Slot'), 'Error: Expected slot resource type') + .to.be.true; + + const recvSlotRes = resourceJson['Slot']; + + expect(recvSlotRes.base, 'Error: Invalid slot resource base id') + .to.be.eq(baseId.toString()); + expect(recvSlotRes.slot, 'Error: Invalid slot resource slot id') + .to.be.eq(slotId.toString()); + expect(recvSlotRes.src, 'Error: Invalid slot resource src') + .to.be.eq(src); + expect(recvSlotRes.metadata, 'Error: Invalid slot resource metadata') + .to.be.eq(metadata); + expect(recvSlotRes.license, 'Error: Invalid slot resource license') + .to.be.eq(license); + expect(recvSlotRes.thumb, 'Error: Invalid slot resource thumb') + .to.be.eq(thumb); + + return resource.id.toNumber(); +} + +export async function equipNft( + api: ApiPromise, + issuerUri: string, + item: NftIdTuple, + equipper: NftIdTuple, + resource: number, + base: number, + slot: number, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const tx = api.tx.rmrkEquip.equip(item, equipper, resource, base, slot); + const events = await executeTransaction(api, issuer, tx); + const equipResult = extractRmrkEquipTxResult(events, 'SlotEquipped', (data) => { + return { + item_collection: parseInt(data[0].toString(), 10), + item_nft: parseInt(data[1].toString(), 10), + base_id: parseInt(data[2].toString(), 10), + slot_id: parseInt(data[3].toString(), 10), + }; + }); + expect(equipResult.success, 'Error: Unable to equip an item').to.be.true; + expect(equipResult.successData!.item_collection, 'Error: Invalid item collection id') + .to.be.eq(item[0]); + expect(equipResult.successData!.item_nft, 'Error: Invalid item NFT id') + .to.be.eq(item[1]); + expect(equipResult.successData!.base_id, 'Error: Invalid base id') + .to.be.eq(base); + expect(equipResult.successData!.slot_id, 'Error: Invalid slot id') + .to.be.eq(slot); +} + +export async function unequipNft( + api: ApiPromise, + issuerUri: string, + item: any, + equipper: any, + resource: number, + base: number, + slot: number, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + const tx = api.tx.rmrkEquip.equip(item, equipper, resource, base, slot); + const events = await executeTransaction(api, issuer, tx); + + const unEquipResult = extractRmrkEquipTxResult( + events, + 'SlotUnequipped', + (data) => { + return { + item_collection: parseInt(data[0].toString(), 10), + item_nft: parseInt(data[1].toString(), 10), + base_id: parseInt(data[2].toString(), 10), + slot_id: parseInt(data[3].toString(), 10), + }; + }, + ); + + expect(unEquipResult.success, 'Error: Unable to unequip an item').to.be.true; + expect(unEquipResult.successData!.item_collection, 'Error: Invalid item collection id') + .to.be.eq(item[0]); + expect(unEquipResult.successData!.item_nft, 'Error: Invalid item NFT id') + .to.be.eq(item[1]); + expect(unEquipResult.successData!.base_id, 'Error: Invalid base id') + .to.be.eq(base); + expect(unEquipResult.successData!.slot_id, 'Error: Invalid slot id') + .to.be.eq(slot); +} + +export async function removeNftResource( + api: ApiPromise, + expectedStatus: 'pending' | 'removed', + issuerUri: string, + collectionId: number, + nftId: number, + resourceId: number, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + + const tx = api.tx.rmrkCore.removeResource(collectionId, nftId, resourceId); + const events = await executeTransaction(api, issuer, tx); + const removeResult = extractRmrkCoreTxResult(events, 'ResourceRemoval', (data) => { + return { + nftId: parseInt(data[0].toString(), 10), + resourceId: parseInt(data[1].toString(), 10), + }; + }); + expect(removeResult.success, 'Error: Unable to remove a resource').to.be.true; + expect(removeResult.successData!.nftId, 'Error: Invalid NFT Id while removing a resource') + .to.be.eq(nftId); + expect(removeResult.successData!.resourceId, 'Error: Invalid resource Id while removing a resource') + .to.be.eq(resourceId); + + const afterDeleting = await findResourceById(api, collectionId, nftId, resourceId); + + if (expectedStatus === 'pending') { + expect(afterDeleting).not.to.be.null; + expect(afterDeleting?.pendingRemoval.isTrue).to.be.equal(true); + } else { + expect(afterDeleting).to.be.null; + } +} + +export async function acceptResourceRemoval( + api: ApiPromise, + issuerUri: string, + collectionId: number, + nftId: number, + resourceId: number, +) { + const ss58Format = api.registry.getChainProperties()!.toJSON().ss58Format; + const issuer = privateKey(issuerUri, Number(ss58Format)); + + const tx = api.tx.rmrkCore.acceptResourceRemoval(collectionId, nftId, resourceId); + const events = await executeTransaction(api, issuer, tx); + const acceptResult = extractRmrkCoreTxResult(events, 'ResourceRemovalAccepted', (data) => { + return { + nftId: parseInt(data[0].toString(), 10), + resourceId: parseInt(data[1].toString(), 10), + }; + }); + expect(acceptResult.success, 'Error: Unable to accept a resource').to.be.true; + expect(acceptResult.successData!.nftId, 'Error: Invalid NFT Id while accepting a resource') + .to.be.eq(nftId); + expect(acceptResult.successData!.resourceId, 'Error: Invalid resource Id while accepting a resource') + .to.be.eq(resourceId); + + const afterDeleting = await findResourceById(api, collectionId, nftId, resourceId); + expect(afterDeleting, 'Error: resource deleting failed').to.be.null; +} --- a/tests/src/substrate/substrate-api.ts +++ b/tests/src/substrate/substrate-api.ts @@ -59,6 +59,17 @@ }; } +export async function getApiConnection(settings: ApiOptions | undefined = undefined): Promise { + settings = settings || defaultApiOptions(); + const api = new ApiPromise(settings); + + if (api) { + await api.isReadyOrError; + } + + return api; +} + export default async function usingApi(action: (api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair) => Promise, settings: ApiOptions | undefined = undefined): Promise { settings = settings || defaultApiOptions(); const api: ApiPromise = new ApiPromise(settings); --- a/tests/src/util/helpers.ts +++ b/tests/src/util/helpers.ts @@ -830,6 +830,25 @@ }); } +export async function burnItemExpectFailure(sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint = 1) { + await usingApi(async (api) => { + const tx = api.tx.unique.burnItem(collectionId, tokenId, value); + + const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected; + const result = getCreateCollectionResult(events); + // tslint:disable-next-line:no-unused-expression + expect(result.success).to.be.false; + }); +} + +export async function burnFromExpectSuccess(sender: IKeyringPair, from: IKeyringPair | CrossAccountId, collectionId: number, tokenId: number, value: number | bigint = 1) { + await usingApi(async (api) => { + const tx = api.tx.unique.burnFrom(collectionId, normalizeAccountId(from), tokenId, value); + const events = await submitTransactionAsync(sender, tx); + return getGenericResult(events).success; + }); +} + export async function approve( api: ApiPromise, @@ -1005,7 +1024,7 @@ expectedBlockNumber, repetitions > 1 ? [period, repetitions] : null, 0, - {value: operationTx as any}, + {Value: operationTx as any}, ); const events = await submitTransactionAsync(sender, scheduleTx); @@ -1032,7 +1051,7 @@ expectedBlockNumber, repetitions <= 1 ? null : [period, repetitions], 0, - {value: operationTx as any}, + {Value: operationTx as any}, ); //const events = @@ -1361,7 +1380,7 @@ let tx; if (createMode === 'NFT') { - const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}}); + const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}}) as UpDataStructsCreateItemData; tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), data); } else { tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode); -- gitstuff