From fe32b30721a10a728dfaf3953a02ac79582e9b2f Mon Sep 17 00:00:00 2001 From: Yaroslav Bolyukin Date: Thu, 11 Aug 2022 18:32:47 +0000 Subject: [PATCH] Merge remote-tracking branch 'origin/feature/fractionalizer-contract' into develop --- --- a/pallets/common/src/erc.rs +++ b/pallets/common/src/erc.rs @@ -25,7 +25,8 @@ use pallet_evm_coder_substrate::dispatch_to_evm; use sp_std::vec::Vec; use up_data_structs::{ - Property, SponsoringRateLimit, OwnerRestrictedSet, AccessMode, CollectionPermissions, + AccessMode, CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property, + SponsoringRateLimit, }; use alloc::format; @@ -408,6 +409,28 @@ save(self) } + + /// Check that account is the owner or admin of the collection + /// + /// @param user account to verify + /// @return "true" if account is the owner or admin + fn verify_owner_or_admin(&self, user: address) -> Result { + Ok(check_is_owner_or_admin(user, self) + .map(|_| true) + .unwrap_or(false)) + } + + /// Returns collection type + /// + /// @return `Fungible` or `NFT` or `ReFungible` + fn unique_collection_type(&mut self) -> Result { + let mode = match self.collection.mode { + CollectionMode::Fungible(_) => "Fungible", + CollectionMode::NFT => "NFT", + CollectionMode::ReFungible => "ReFungible", + }; + Ok(mode.into()) + } } fn check_is_owner_or_admin( @@ -462,6 +485,11 @@ pub fn suffix() -> up_data_structs::PropertyKey { property_key_from_bytes(b"suffix").expect(EXPECT_CONVERT_ERROR) } + + /// Key "parentNft". + pub fn parent_nft() -> up_data_structs::PropertyKey { + property_key_from_bytes(b"parentNft").expect(EXPECT_CONVERT_ERROR) + } } /// Values. --- a/pallets/common/src/lib.rs +++ b/pallets/common/src/lib.rs @@ -1113,6 +1113,26 @@ sender: &T::CrossAccountId, property_permission: PropertyKeyPermission, ) -> DispatchResult { + Self::set_scoped_property_permission( + collection, + sender, + PropertyScope::None, + property_permission, + ) + } + + /// Set collection property permission with scope. + /// + /// * `collection` - Collection handler. + /// * `sender` - The owner or administrator of the collection. + /// * `scope` - Property scope. + /// * `property_permission` - Property permission. + pub fn set_scoped_property_permission( + collection: &CollectionHandle, + sender: &T::CrossAccountId, + scope: PropertyScope, + property_permission: PropertyKeyPermission, + ) -> DispatchResult { collection.check_is_owner_or_admin(sender)?; let all_permissions = CollectionPropertyPermissions::::get(collection.id); @@ -1126,7 +1146,11 @@ CollectionPropertyPermissions::::try_mutate(collection.id, |permissions| { let property_permission = property_permission.clone(); - permissions.try_set(property_permission.key, property_permission.permission) + permissions.try_scoped_set( + scope, + property_permission.key, + property_permission.permission, + ) }) .map_err(>::from)?; @@ -1149,8 +1173,29 @@ sender: &T::CrossAccountId, property_permissions: Vec, ) -> DispatchResult { + Self::set_scoped_token_property_permissions( + collection, + sender, + PropertyScope::None, + property_permissions, + ) + } + + /// Set token property permission with scope. + /// + /// * `collection` - Collection handler. + /// * `sender` - The owner or administrator of the collection. + /// * `scope` - Property scope. + /// * `property_permissions` - Property permissions. + #[transactional] + pub fn set_scoped_token_property_permissions( + collection: &CollectionHandle, + sender: &T::CrossAccountId, + scope: PropertyScope, + property_permissions: Vec, + ) -> DispatchResult { for prop_pemission in property_permissions { - Self::set_property_permission(collection, sender, prop_pemission)?; + Self::set_scoped_property_permission(collection, sender, scope, prop_pemission)?; } Ok(()) @@ -1430,6 +1475,9 @@ .saturating_mul(max_selfs.max(1) as u64) .saturating_add(Self::burn_recursively_breadth_raw(max_breadth)) } + + /// The price of retrieving token owner + fn token_owner() -> Weight; } /// Weight info extension trait for refungible pallet. @@ -1568,7 +1616,7 @@ /// /// * `sender` - Must be either the owner of the token or its admin. /// * `token_id` - The token for which the properties are being set. - /// * `properties` - Properties to be set. + /// * `property_permissions` - Property permissions to be set. /// * `budget` - Budget for setting properties. fn set_token_property_permissions( &self, --- a/pallets/fungible/src/common.rs +++ b/pallets/fungible/src/common.rs @@ -103,6 +103,10 @@ // Fungible tokens can't have children 0 } + + fn token_owner() -> Weight { + 0 + } } /// Implementation of `CommonCollectionOperations` for `FungibleHandle`. It wraps FungibleHandle Pallete --- a/pallets/fungible/src/stubs/UniqueFungible.sol +++ b/pallets/fungible/src/stubs/UniqueFungible.sol @@ -31,19 +31,7 @@ ); } -// Selector: 79cc6790 -contract ERC20UniqueExtensions is Dummy, ERC165 { - // Selector: burnFrom(address,uint256) 79cc6790 - function burnFrom(address from, uint256 amount) public returns (bool) { - require(false, stub_error); - from; - amount; - dummy = 0; - return false; - } -} - -// Selector: 7d9262e6 +// Selector: 6cf113cd contract Collection is Dummy, ERC165 { // Set collection property. // @@ -268,6 +256,42 @@ mode; dummy = 0; } + + // Check that account is the owner or admin of the collection + // + // @param user account to verify + // @return "true" if account is the owner or admin + // + // Selector: verifyOwnerOrAdmin(address) c2282493 + function verifyOwnerOrAdmin(address user) public view returns (bool) { + require(false, stub_error); + user; + dummy; + return false; + } + + // Returns collection type + // + // @return `Fungible` or `NFT` or `ReFungible` + // + // Selector: uniqueCollectionType() d34b55b8 + function uniqueCollectionType() public returns (string memory) { + require(false, stub_error); + dummy = 0; + return ""; + } +} + +// Selector: 79cc6790 +contract ERC20UniqueExtensions is Dummy, ERC165 { + // Selector: burnFrom(address,uint256) 79cc6790 + function burnFrom(address from, uint256 amount) public returns (bool) { + require(false, stub_error); + from; + amount; + dummy = 0; + return false; + } } // Selector: 942e8b22 --- a/pallets/nonfungible/src/benchmarking.rs +++ b/pallets/nonfungible/src/benchmarking.rs @@ -17,11 +17,14 @@ use super::*; use crate::{Pallet, Config, NonfungibleHandle}; -use sp_std::prelude::*; -use pallet_common::benchmarking::{create_collection_raw, property_key, property_value}; use frame_benchmarking::{benchmarks, account}; +use pallet_common::{ + bench_init, + benchmarking::{create_collection_raw, property_key, property_value}, + CommonCollectionOperations, +}; +use sp_std::prelude::*; use up_data_structs::{CollectionMode, MAX_ITEMS_PER_BATCH, MAX_PROPERTIES_PER_ITEM, budget::Unlimited}; -use pallet_common::bench_init; const SEED: u32 = 1; @@ -208,4 +211,13 @@ >::set_token_properties(&collection, &owner, item, props.into_iter(), false, &Unlimited)?; let to_delete = (0..b).map(|k| property_key(k as usize)).collect::>(); }: {>::delete_token_properties(&collection, &owner, item, to_delete.into_iter(), &Unlimited)?} + + token_owner { + bench_init!{ + owner: sub; collection: collection(owner); + owner: cross_from_sub; + }; + let item = create_max_item(&collection, &owner, owner.clone())?; + + }: {collection.token_owner(item)} } --- a/pallets/nonfungible/src/common.rs +++ b/pallets/nonfungible/src/common.rs @@ -118,6 +118,10 @@ >::burn_recursively_breadth_plus_self_plus_self_per_each_raw(amount) .saturating_sub(Self::burn_recursively_self_raw().saturating_mul(amount as u64 + 1)) } + + fn token_owner() -> Weight { + >::token_owner() + } } fn map_create_data( --- a/pallets/nonfungible/src/lib.rs +++ b/pallets/nonfungible/src/lib.rs @@ -784,6 +784,23 @@ >::set_token_property_permissions(collection, sender, property_permissions) } + /// Set property permissions for the token with scope. + /// + /// Sender should be the owner or admin of token's collection. + pub fn set_scoped_token_property_permissions( + collection: &CollectionHandle, + sender: &T::CrossAccountId, + scope: PropertyScope, + property_permissions: Vec, + ) -> DispatchResult { + >::set_scoped_token_property_permissions( + collection, + sender, + scope, + property_permissions, + ) + } + /// Set property permissions for the collection. /// /// Sender should be the owner or admin of the collection. --- a/pallets/nonfungible/src/stubs/UniqueNFT.sol +++ b/pallets/nonfungible/src/stubs/UniqueNFT.sol @@ -373,49 +373,7 @@ } } -// Selector: 780e9d63 -contract ERC721Enumerable is Dummy, ERC165 { - // @notice Enumerate valid NFTs - // @param index A counter less than `totalSupply()` - // @return The token identifier for the `index`th NFT, - // (sort order not specified) - // - // Selector: tokenByIndex(uint256) 4f6ccce7 - function tokenByIndex(uint256 index) public view returns (uint256) { - require(false, stub_error); - index; - dummy; - return 0; - } - - // @dev Not implemented - // - // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59 - function tokenOfOwnerByIndex(address owner, uint256 index) - public - view - returns (uint256) - { - require(false, stub_error); - owner; - index; - dummy; - return 0; - } - - // @notice Count NFTs tracked by this contract - // @return A count of valid NFTs tracked by this contract, where each one of - // them has an assigned and queryable owner not equal to the zero address - // - // Selector: totalSupply() 18160ddd - function totalSupply() public view returns (uint256) { - require(false, stub_error); - dummy; - return 0; - } -} - -// Selector: 7d9262e6 +// Selector: 6cf113cd contract Collection is Dummy, ERC165 { // Set collection property. // @@ -640,6 +598,72 @@ mode; dummy = 0; } + + // Check that account is the owner or admin of the collection + // + // @param user account to verify + // @return "true" if account is the owner or admin + // + // Selector: verifyOwnerOrAdmin(address) c2282493 + function verifyOwnerOrAdmin(address user) public view returns (bool) { + require(false, stub_error); + user; + dummy; + return false; + } + + // Returns collection type + // + // @return `Fungible` or `NFT` or `ReFungible` + // + // Selector: uniqueCollectionType() d34b55b8 + function uniqueCollectionType() public returns (string memory) { + require(false, stub_error); + dummy = 0; + return ""; + } +} + +// Selector: 780e9d63 +contract ERC721Enumerable is Dummy, ERC165 { + // @notice Enumerate valid NFTs + // @param index A counter less than `totalSupply()` + // @return The token identifier for the `index`th NFT, + // (sort order not specified) + // + // Selector: tokenByIndex(uint256) 4f6ccce7 + function tokenByIndex(uint256 index) public view returns (uint256) { + require(false, stub_error); + index; + dummy; + return 0; + } + + // @dev Not implemented + // + // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59 + function tokenOfOwnerByIndex(address owner, uint256 index) + public + view + returns (uint256) + { + require(false, stub_error); + owner; + index; + dummy; + return 0; + } + + // @notice Count NFTs tracked by this contract + // @return A count of valid NFTs tracked by this contract, where each one of + // them has an assigned and queryable owner not equal to the zero address + // + // Selector: totalSupply() 18160ddd + function totalSupply() public view returns (uint256) { + require(false, stub_error); + dummy; + return 0; + } } // Selector: d74d154f --- a/pallets/nonfungible/src/weights.rs +++ b/pallets/nonfungible/src/weights.rs @@ -3,7 +3,7 @@ //! Autogenerated weights for pallet_nonfungible //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2022-07-20, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2022-08-01, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]` //! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024 // Executed Command: @@ -46,6 +46,7 @@ fn set_token_property_permissions(b: u32, ) -> Weight; fn set_token_properties(b: u32, ) -> Weight; fn delete_token_properties(b: u32, ) -> Weight; + fn token_owner() -> Weight; } /// Weights for pallet_nonfungible using the Substrate node and recommended hardware. @@ -56,7 +57,7 @@ // Storage: Nonfungible TokenData (r:0 w:1) // Storage: Nonfungible Owned (r:0 w:1) fn create_item() -> Weight { - (20_328_000 as Weight) + (20_909_000 as Weight) .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(4 as Weight)) } @@ -65,9 +66,9 @@ // Storage: Nonfungible TokenData (r:0 w:4) // Storage: Nonfungible Owned (r:0 w:4) fn create_multiple_items(b: u32, ) -> Weight { - (10_134_000 as Weight) - // Standard Error: 3_000 - .saturating_add((4_927_000 as Weight).saturating_mul(b as Weight)) + (12_601_000 as Weight) + // Standard Error: 1_000 + .saturating_add((4_920_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) .saturating_add(T::DbWeight::get().writes((2 as Weight).saturating_mul(b as Weight))) @@ -77,9 +78,9 @@ // Storage: Nonfungible TokenData (r:0 w:4) // Storage: Nonfungible Owned (r:0 w:4) fn create_multiple_items_ex(b: u32, ) -> Weight { - (5_710_000 as Weight) - // Standard Error: 4_000 - .saturating_add((7_578_000 as Weight).saturating_mul(b as Weight)) + (0 as Weight) + // Standard Error: 3_000 + .saturating_add((7_734_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(1 as Weight)) .saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight))) .saturating_add(T::DbWeight::get().writes(1 as Weight)) @@ -93,7 +94,7 @@ // Storage: Nonfungible Owned (r:0 w:1) // Storage: Nonfungible TokenProperties (r:0 w:1) fn burn_item() -> Weight { - (28_433_000 as Weight) + (29_746_000 as Weight) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(5 as Weight)) } @@ -105,7 +106,7 @@ // Storage: Nonfungible Owned (r:0 w:1) // Storage: Nonfungible TokenProperties (r:0 w:1) fn burn_recursively_self_raw() -> Weight { - (34_435_000 as Weight) + (36_077_000 as Weight) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(5 as Weight)) } @@ -119,8 +120,8 @@ // Storage: Common CollectionById (r:1 w:0) fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_539_000 - .saturating_add((304_456_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_605_000 + .saturating_add((312_391_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(7 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)) @@ -131,14 +132,14 @@ // Storage: Nonfungible Allowance (r:1 w:0) // Storage: Nonfungible Owned (r:0 w:2) fn transfer() -> Weight { - (24_376_000 as Weight) + (25_248_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(5 as Weight)) } // Storage: Nonfungible TokenData (r:1 w:0) // Storage: Nonfungible Allowance (r:1 w:1) fn approve() -> Weight { - (15_890_000 as Weight) + (16_321_000 as Weight) .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -147,7 +148,7 @@ // Storage: Nonfungible AccountBalance (r:2 w:2) // Storage: Nonfungible Owned (r:0 w:2) fn transfer_from() -> Weight { - (28_634_000 as Weight) + (29_325_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(6 as Weight)) } @@ -159,15 +160,15 @@ // Storage: Nonfungible Owned (r:0 w:1) // Storage: Nonfungible TokenProperties (r:0 w:1) fn burn_from() -> Weight { - (32_201_000 as Weight) + (33_323_000 as Weight) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(6 as Weight)) } // Storage: Common CollectionPropertyPermissions (r:1 w:1) fn set_token_property_permissions(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 57_000 - .saturating_add((15_232_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 62_000 + .saturating_add((16_222_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(1 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -175,8 +176,8 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) fn set_token_properties(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_648_000 - .saturating_add((288_654_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_750_000 + .saturating_add((304_476_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -184,11 +185,16 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) fn delete_token_properties(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_632_000 - .saturating_add((289_190_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_638_000 + .saturating_add((294_096_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } + // Storage: Nonfungible TokenData (r:1 w:0) + fn token_owner() -> Weight { + (2_986_000 as Weight) + .saturating_add(T::DbWeight::get().reads(1 as Weight)) + } } // For backwards compatibility and tests @@ -198,7 +204,7 @@ // Storage: Nonfungible TokenData (r:0 w:1) // Storage: Nonfungible Owned (r:0 w:1) fn create_item() -> Weight { - (20_328_000 as Weight) + (20_909_000 as Weight) .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(4 as Weight)) } @@ -207,9 +213,9 @@ // Storage: Nonfungible TokenData (r:0 w:4) // Storage: Nonfungible Owned (r:0 w:4) fn create_multiple_items(b: u32, ) -> Weight { - (10_134_000 as Weight) - // Standard Error: 3_000 - .saturating_add((4_927_000 as Weight).saturating_mul(b as Weight)) + (12_601_000 as Weight) + // Standard Error: 1_000 + .saturating_add((4_920_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) .saturating_add(RocksDbWeight::get().writes((2 as Weight).saturating_mul(b as Weight))) @@ -219,9 +225,9 @@ // Storage: Nonfungible TokenData (r:0 w:4) // Storage: Nonfungible Owned (r:0 w:4) fn create_multiple_items_ex(b: u32, ) -> Weight { - (5_710_000 as Weight) - // Standard Error: 4_000 - .saturating_add((7_578_000 as Weight).saturating_mul(b as Weight)) + (0 as Weight) + // Standard Error: 3_000 + .saturating_add((7_734_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) .saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(b as Weight))) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) @@ -235,7 +241,7 @@ // Storage: Nonfungible Owned (r:0 w:1) // Storage: Nonfungible TokenProperties (r:0 w:1) fn burn_item() -> Weight { - (28_433_000 as Weight) + (29_746_000 as Weight) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(5 as Weight)) } @@ -247,7 +253,7 @@ // Storage: Nonfungible Owned (r:0 w:1) // Storage: Nonfungible TokenProperties (r:0 w:1) fn burn_recursively_self_raw() -> Weight { - (34_435_000 as Weight) + (36_077_000 as Weight) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(5 as Weight)) } @@ -261,8 +267,8 @@ // Storage: Common CollectionById (r:1 w:0) fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_539_000 - .saturating_add((304_456_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_605_000 + .saturating_add((312_391_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(7 as Weight)) .saturating_add(RocksDbWeight::get().reads((4 as Weight).saturating_mul(b as Weight))) .saturating_add(RocksDbWeight::get().writes(6 as Weight)) @@ -273,14 +279,14 @@ // Storage: Nonfungible Allowance (r:1 w:0) // Storage: Nonfungible Owned (r:0 w:2) fn transfer() -> Weight { - (24_376_000 as Weight) + (25_248_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(5 as Weight)) } // Storage: Nonfungible TokenData (r:1 w:0) // Storage: Nonfungible Allowance (r:1 w:1) fn approve() -> Weight { - (15_890_000 as Weight) + (16_321_000 as Weight) .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -289,7 +295,7 @@ // Storage: Nonfungible AccountBalance (r:2 w:2) // Storage: Nonfungible Owned (r:0 w:2) fn transfer_from() -> Weight { - (28_634_000 as Weight) + (29_325_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(6 as Weight)) } @@ -301,15 +307,15 @@ // Storage: Nonfungible Owned (r:0 w:1) // Storage: Nonfungible TokenProperties (r:0 w:1) fn burn_from() -> Weight { - (32_201_000 as Weight) + (33_323_000 as Weight) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(6 as Weight)) } // Storage: Common CollectionPropertyPermissions (r:1 w:1) fn set_token_property_permissions(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 57_000 - .saturating_add((15_232_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 62_000 + .saturating_add((16_222_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -317,8 +323,8 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) fn set_token_properties(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_648_000 - .saturating_add((288_654_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_750_000 + .saturating_add((304_476_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -326,9 +332,14 @@ // Storage: Nonfungible TokenProperties (r:1 w:1) fn delete_token_properties(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_632_000 - .saturating_add((289_190_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_638_000 + .saturating_add((294_096_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } + // Storage: Nonfungible TokenData (r:1 w:0) + fn token_owner() -> Weight { + (2_986_000 as Weight) + .saturating_add(RocksDbWeight::get().reads(1 as Weight)) + } } --- a/pallets/refungible/src/benchmarking.rs +++ b/pallets/refungible/src/benchmarking.rs @@ -17,25 +17,26 @@ use super::*; use crate::{Pallet, Config, RefungibleHandle}; +use core::convert::TryInto; +use core::iter::IntoIterator; +use frame_benchmarking::{benchmarks, account}; +use pallet_common::{ + bench_init, + benchmarking::{create_collection_raw, property_key, property_value, create_data}, +}; +use sp_core::H160; use sp_std::prelude::*; -use pallet_common::benchmarking::{create_collection_raw, property_key, property_value, create_data}; -use frame_benchmarking::{benchmarks, account}; use up_data_structs::{ CollectionMode, MAX_ITEMS_PER_BATCH, MAX_PROPERTIES_PER_ITEM, CUSTOM_DATA_LIMIT, budget::Unlimited, }; -use pallet_common::bench_init; -use core::convert::TryInto; -use core::iter::IntoIterator; const SEED: u32 = 1; fn create_max_item_data( users: impl IntoIterator, ) -> CreateRefungibleExData { - let const_data = create_data::(); CreateRefungibleExData { - const_data, users: users .into_iter() .collect::>() @@ -44,6 +45,7 @@ properties: Default::default(), } } + fn create_max_item( collection: &RefungibleHandle, sender: &T::CrossAccountId, @@ -59,11 +61,12 @@ ) -> Result, DispatchError> { create_collection_raw( owner, - CollectionMode::NFT, + CollectionMode::ReFungible, >::init_collection, RefungibleHandle::cast, ) } + benchmarks! { create_item { bench_init!{ @@ -277,4 +280,21 @@ }; let item = create_max_item(&collection, &sender, [(owner.clone(), 100)])?; }: {>::repartition(&collection, &owner, item, 200)?} + + set_parent_nft_unchecked { + bench_init!{ + owner: sub; collection: collection(owner); + sender: cross_from_sub(owner); owner: cross_sub; + }; + let item = create_max_item(&collection, &sender, [(owner.clone(), 100)])?; + + }: {>::set_parent_nft_unchecked(&collection, item, owner, T::CrossAccountId::from_eth(H160::default()))?} + + token_owner { + bench_init!{ + owner: sub; collection: collection(owner); + sender: cross_from_sub(owner); owner: cross_sub; + }; + let item = create_max_item(&collection, &sender, [(owner.clone(), 100)])?; + }: {>::token_owner(collection.id, item)} } --- a/pallets/refungible/src/common.rs +++ b/pallets/refungible/src/common.rs @@ -148,6 +148,10 @@ // Refungible token can't have children 0 } + + fn token_owner() -> Weight { + >::token_owner() + } } fn map_create_data( --- a/pallets/refungible/src/erc.rs +++ b/pallets/refungible/src/erc.rs @@ -41,8 +41,8 @@ use sp_core::H160; use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec}; use up_data_structs::{ - CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission, - PropertyPermission, TokenId, + CollectionId, CollectionPropertiesVec, mapping::TokenAddressMapping, Property, PropertyKey, + PropertyKeyPermission, PropertyPermission, TokenId, }; use crate::{ @@ -413,7 +413,7 @@ } /// Returns amount of pieces of `token` that `owner` have -fn balance( +pub fn balance( collection: &RefungibleHandle, token: TokenId, owner: &T::CrossAccountId, @@ -424,7 +424,7 @@ } /// Throws if `owner_balance` is lower than total amount of `token` pieces -fn ensure_single_owner( +pub fn ensure_single_owner( collection: &RefungibleHandle, token: TokenId, owner_balance: u128, @@ -788,6 +788,16 @@ .map_err(dispatch_to_evm::)?; Ok(true) } + + /// Returns EVM address for refungible token + /// + /// @param token ID of the token + fn token_contract_address(&self, token: uint256) -> Result
{ + Ok(T::EvmTokenAddressMapping::token_to_address( + self.id, + token.try_into().map_err(|_| "token id overflow")?, + )) + } } #[solidity_interface( --- a/pallets/refungible/src/erc_token.rs +++ b/pallets/refungible/src/erc_token.rs @@ -20,29 +20,95 @@ //! Method implementations are mostly doing parameter conversion and calling Nonfungible Pallet methods. extern crate alloc; + +#[cfg(not(feature = "std"))] +use alloc::format; + use core::{ char::{REPLACEMENT_CHARACTER, decode_utf16}, convert::TryInto, ops::Deref, }; -use evm_coder::{ToLog, execution::*, generate_stubgen, solidity_interface, types::*, weight}; +use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight}; use pallet_common::{ CommonWeightInfo, - erc::{CommonEvmHandler, PrecompileResult}, + erc::{CommonEvmHandler, PrecompileResult, static_property::key}, + eth::map_eth_to_id, }; use pallet_evm::{account::CrossAccountId, PrecompileHandle}; use pallet_evm_coder_substrate::{call, dispatch_to_evm, WithRecorder}; use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _}; +use sp_core::H160; use sp_std::vec::Vec; -use up_data_structs::TokenId; +use up_data_structs::{mapping::TokenAddressMapping, PropertyScope, TokenId}; use crate::{ Allowance, Balance, common::CommonWeights, Config, Pallet, RefungibleHandle, SelfWeightOf, - weights::WeightInfo, TotalSupply, + TokenProperties, TotalSupply, weights::WeightInfo, }; pub struct RefungibleTokenHandle(pub RefungibleHandle, pub TokenId); +#[solidity_interface(name = "ERC1633")] +impl RefungibleTokenHandle { + fn parent_token(&self) -> Result
{ + self.consume_store_reads(2)?; + let props = >::get((self.id, self.1)); + let key = key::parent_nft(); + + let key_scoped = PropertyScope::Eth + .apply(key) + .expect("property key shouldn't exceed length limit"); + if let Some(value) = props.get(&key_scoped) { + Ok(H160::from_slice(value.as_slice())) + } else { + Ok(*T::CrossTokenAddressMapping::token_to_address(self.id, self.1).as_eth()) + } + } + + fn parent_token_id(&self) -> Result { + self.consume_store_reads(2)?; + let props = >::get((self.id, self.1)); + let key = key::parent_nft(); + + let key_scoped = PropertyScope::Eth + .apply(key) + .expect("property key shouldn't exceed length limit"); + if let Some(value) = props.get(&key_scoped) { + let nft_token_address = H160::from_slice(value.as_slice()); + let nft_token_account = T::CrossAccountId::from_eth(nft_token_address); + let (_, token_id) = T::CrossTokenAddressMapping::address_to_token(&nft_token_account) + .ok_or("parent NFT should contain NFT token address")?; + + Ok(token_id.into()) + } else { + Ok(self.1.into()) + } + } +} + +#[solidity_interface(name = "ERC1633UniqueExtensions")] +impl RefungibleTokenHandle { + #[solidity(rename_selector = "setParentNFT")] + #[weight(>::token_owner() + >::set_parent_nft_unchecked())] + fn set_parent_nft( + &mut self, + caller: caller, + collection: address, + nft_id: uint256, + ) -> Result { + self.consume_store_reads(1)?; + let caller = T::CrossAccountId::from_eth(caller); + let nft_collection = map_eth_to_id(&collection).ok_or("collection not found")?; + let nft_token = nft_id.try_into()?; + + >::set_parent_nft(&self.0, self.1, caller, nft_collection, nft_token) + .map_err(dispatch_to_evm::)?; + + Ok(true) + } +} + #[derive(ToLog)] pub enum ERC20Events { /// @dev This event is emitted when the amount of tokens (value) is sent @@ -120,7 +186,7 @@ .weight_calls_budget(>::find_parent()); >::transfer(self, &caller, &to, self.1, amount, &budget) - .map_err(|_| "transfer error")?; + .map_err(dispatch_to_evm::)?; Ok(true) } @@ -239,7 +305,10 @@ } } -#[solidity_interface(name = "UniqueRefungibleToken", is(ERC20, ERC20UniqueExtensions,))] +#[solidity_interface( + name = "UniqueRefungibleToken", + is(ERC20, ERC20UniqueExtensions, ERC1633, ERC1633UniqueExtensions) +)] impl RefungibleTokenHandle where T::AccountId: From<[u8; 32]> {} generate_stubgen!(gen_impl, UniqueRefungibleTokenCall<()>, true); --- a/pallets/refungible/src/lib.rs +++ b/pallets/refungible/src/lib.rs @@ -99,8 +99,12 @@ use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm}; use pallet_evm_coder_substrate::WithRecorder; use pallet_common::{ - CommonCollectionOperations, Error as CommonError, Event as CommonEvent, - eth::collection_id_to_address, Pallet as PalletCommon, + CollectionHandle, CommonCollectionOperations, + dispatch::CollectionDispatch, + erc::static_property::{key, property_value_from_bytes}, + Error as CommonError, + eth::collection_id_to_address, + Event as CommonEvent, Pallet as PalletCommon, }; use pallet_structure::Pallet as PalletStructure; use scale_info::TypeInfo; @@ -108,10 +112,10 @@ use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome}; use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap}; use up_data_structs::{ - AccessMode, budget::Budget, CollectionId, CreateCollectionData, CustomDataLimit, - mapping::TokenAddressMapping, MAX_REFUNGIBLE_PIECES, MAX_ITEMS_PER_BATCH, TokenId, Property, - PropertyKey, PropertyKeyPermission, PropertyPermission, PropertyScope, PropertyValue, - TrySetProperty, CollectionPropertiesVec, + AccessMode, budget::Budget, CollectionId, CollectionMode, CollectionPropertiesVec, + CreateCollectionData, CustomDataLimit, mapping::TokenAddressMapping, MAX_ITEMS_PER_BATCH, + MAX_REFUNGIBLE_PIECES, Property, PropertyKey, PropertyKeyPermission, PropertyPermission, + PropertyScope, PropertyValue, TokenId, TrySetProperty, }; use frame_support::BoundedBTreeMap; use derivative::Derivative; @@ -1341,6 +1345,20 @@ >::set_token_property_permissions(collection, sender, property_permissions) } + pub fn set_scoped_token_property_permissions( + collection: &RefungibleHandle, + sender: &T::CrossAccountId, + scope: PropertyScope, + property_permissions: Vec, + ) -> DispatchResult { + >::set_scoped_token_property_permissions( + collection, + sender, + scope, + property_permissions, + ) + } + /// Returns 10 token in no particular order. /// /// There is no direct way to get token holders in ascending order, @@ -1362,4 +1380,68 @@ Some(res) } } + + /// Sets the NFT token as a parent for the RFT token + /// + /// Throws if `sender` is not the owner of the NFT token. + /// Throws if `sender` is not the owner of all of the RFT token pieces. + pub fn set_parent_nft( + collection: &RefungibleHandle, + rft_token_id: TokenId, + sender: T::CrossAccountId, + nft_collection: CollectionId, + nft_token: TokenId, + ) -> DispatchResult { + let handle = >::try_get(nft_collection)?; + if handle.mode != CollectionMode::NFT { + return Err("Only NFT token could be parent to RFT".into()); + } + let dispatch = T::CollectionDispatch::dispatch(handle); + let dispatch = dispatch.as_dyn(); + + let owner = dispatch.token_owner(nft_token).ok_or("owner not found")?; + if owner != sender { + return Err("Only owned token could be set as parent".into()); + } + + let nft_token_address = + T::CrossTokenAddressMapping::token_to_address(nft_collection, nft_token); + + Self::set_parent_nft_unchecked(collection, rft_token_id, sender, nft_token_address) + } + + /// Sets the NFT token as a parent for the RFT token + /// + /// `sender` should be the owner of the NFT token. + /// Throws if `sender` is not the owner of all of the RFT token pieces. + pub fn set_parent_nft_unchecked( + collection: &RefungibleHandle, + rft_token_id: TokenId, + sender: T::CrossAccountId, + nft_token_address: T::CrossAccountId, + ) -> DispatchResult { + let owner_balance = >::get((collection.id, rft_token_id, &sender)); + let total_supply = >::get((collection.id, rft_token_id)); + if total_supply != owner_balance { + return Err("token has multiple owners".into()); + } + + let parent_nft_property_key = key::parent_nft(); + + let parent_nft_property_value = + property_value_from_bytes(&nft_token_address.as_eth().to_fixed_bytes()) + .expect("address should fit in value length limit"); + + >::set_scoped_token_property( + collection.id, + rft_token_id, + PropertyScope::Eth, + Property { + key: parent_nft_property_key, + value: parent_nft_property_value, + }, + )?; + + Ok(()) + } } --- a/pallets/refungible/src/stubs/UniqueRefungible.sol +++ b/pallets/refungible/src/stubs/UniqueRefungible.sol @@ -371,49 +371,7 @@ } } -// Selector: 780e9d63 -contract ERC721Enumerable is Dummy, ERC165 { - // @notice Enumerate valid RFTs - // @param index A counter less than `totalSupply()` - // @return The token identifier for the `index`th NFT, - // (sort order not specified) - // - // Selector: tokenByIndex(uint256) 4f6ccce7 - function tokenByIndex(uint256 index) public view returns (uint256) { - require(false, stub_error); - index; - dummy; - return 0; - } - - // Not implemented - // - // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59 - function tokenOfOwnerByIndex(address owner, uint256 index) - public - view - returns (uint256) - { - require(false, stub_error); - owner; - index; - dummy; - return 0; - } - - // @notice Count RFTs tracked by this contract - // @return A count of valid RFTs tracked by this contract, where each one of - // them has an assigned and queryable owner not equal to the zero address - // - // Selector: totalSupply() 18160ddd - function totalSupply() public view returns (uint256) { - require(false, stub_error); - dummy; - return 0; - } -} - -// Selector: 7d9262e6 +// Selector: 6cf113cd contract Collection is Dummy, ERC165 { // Set collection property. // @@ -638,9 +596,75 @@ mode; dummy = 0; } + + // Check that account is the owner or admin of the collection + // + // @param user account to verify + // @return "true" if account is the owner or admin + // + // Selector: verifyOwnerOrAdmin(address) c2282493 + function verifyOwnerOrAdmin(address user) public view returns (bool) { + require(false, stub_error); + user; + dummy; + return false; + } + + // Returns collection type + // + // @return `Fungible` or `NFT` or `ReFungible` + // + // Selector: uniqueCollectionType() d34b55b8 + function uniqueCollectionType() public returns (string memory) { + require(false, stub_error); + dummy = 0; + return ""; + } +} + +// Selector: 780e9d63 +contract ERC721Enumerable is Dummy, ERC165 { + // @notice Enumerate valid RFTs + // @param index A counter less than `totalSupply()` + // @return The token identifier for the `index`th NFT, + // (sort order not specified) + // + // Selector: tokenByIndex(uint256) 4f6ccce7 + function tokenByIndex(uint256 index) public view returns (uint256) { + require(false, stub_error); + index; + dummy; + return 0; + } + + // Not implemented + // + // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59 + function tokenOfOwnerByIndex(address owner, uint256 index) + public + view + returns (uint256) + { + require(false, stub_error); + owner; + index; + dummy; + return 0; + } + + // @notice Count RFTs tracked by this contract + // @return A count of valid RFTs tracked by this contract, where each one of + // them has an assigned and queryable owner not equal to the zero address + // + // Selector: totalSupply() 18160ddd + function totalSupply() public view returns (uint256) { + require(false, stub_error); + dummy; + return 0; + } } -// Selector: d74d154f +// Selector: 7c3bef89 contract ERC721UniqueExtensions is Dummy, ERC165 { // @notice Transfer ownership of an RFT // @dev Throws unless `msg.sender` is the current owner. Throws if `to` @@ -719,6 +743,18 @@ dummy = 0; return false; } + + // Returns EVM address for refungible token + // + // @param token ID of the token + // + // Selector: tokenContractAddress(uint256) ab76fac6 + function tokenContractAddress(uint256 token) public view returns (address) { + require(false, stub_error); + token; + dummy; + return 0x0000000000000000000000000000000000000000; + } } contract UniqueRefungible is --- a/pallets/refungible/src/stubs/UniqueRefungibleToken.sol +++ b/pallets/refungible/src/stubs/UniqueRefungibleToken.sol @@ -31,6 +31,38 @@ ); } +// Selector: 042f1106 +contract ERC1633UniqueExtensions is Dummy, ERC165 { + // Selector: setParentNFT(address,uint256) 042f1106 + function setParentNFT(address collection, uint256 nftId) + public + returns (bool) + { + require(false, stub_error); + collection; + nftId; + dummy = 0; + return false; + } +} + +// Selector: 5755c3f2 +contract ERC1633 is Dummy, ERC165 { + // Selector: parentToken() 80a54001 + function parentToken() public view returns (address) { + require(false, stub_error); + dummy; + return 0x0000000000000000000000000000000000000000; + } + + // Selector: parentTokenId() d7f083f3 + function parentTokenId() public view returns (uint256) { + require(false, stub_error); + dummy; + return 0; + } +} + // Selector: 942e8b22 contract ERC20 is Dummy, ERC165, ERC20Events { // @return the name of the token. @@ -178,4 +210,11 @@ } } -contract UniqueRefungibleToken is Dummy, ERC165, ERC20, ERC20UniqueExtensions {} +contract UniqueRefungibleToken is + Dummy, + ERC165, + ERC20, + ERC20UniqueExtensions, + ERC1633, + ERC1633UniqueExtensions +{} --- a/pallets/refungible/src/weights.rs +++ b/pallets/refungible/src/weights.rs @@ -3,7 +3,7 @@ //! Autogenerated weights for pallet_refungible //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2022-07-20, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2022-08-01, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]` //! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024 // Executed Command: @@ -53,6 +53,8 @@ fn set_token_properties(b: u32, ) -> Weight; fn delete_token_properties(b: u32, ) -> Weight; fn repartition_item() -> Weight; + fn set_parent_nft_unchecked() -> Weight; + fn token_owner() -> Weight; } /// Weights for pallet_refungible using the Substrate node and recommended hardware. @@ -65,7 +67,7 @@ // Storage: Refungible TokenData (r:0 w:1) // Storage: Refungible Owned (r:0 w:1) fn create_item() -> Weight { - (21_310_000 as Weight) + (25_197_000 as Weight) .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(6 as Weight)) } @@ -76,9 +78,9 @@ // Storage: Refungible TokenData (r:0 w:4) // Storage: Refungible Owned (r:0 w:4) fn create_multiple_items(b: u32, ) -> Weight { - (9_552_000 as Weight) + (10_852_000 as Weight) // Standard Error: 2_000 - .saturating_add((7_056_000 as Weight).saturating_mul(b as Weight)) + .saturating_add((8_087_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) .saturating_add(T::DbWeight::get().writes((4 as Weight).saturating_mul(b as Weight))) @@ -90,9 +92,9 @@ // Storage: Refungible TokenData (r:0 w:4) // Storage: Refungible Owned (r:0 w:4) fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight { - (4_857_000 as Weight) + (9_978_000 as Weight) // Standard Error: 2_000 - .saturating_add((9_838_000 as Weight).saturating_mul(b as Weight)) + .saturating_add((10_848_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(1 as Weight)) .saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight))) .saturating_add(T::DbWeight::get().writes(1 as Weight)) @@ -105,9 +107,9 @@ // Storage: Refungible Balance (r:0 w:4) // Storage: Refungible Owned (r:0 w:4) fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight { - (11_335_000 as Weight) + (15_419_000 as Weight) // Standard Error: 2_000 - .saturating_add((6_784_000 as Weight).saturating_mul(b as Weight)) + .saturating_add((7_813_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(1 as Weight)) .saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(b as Weight))) .saturating_add(T::DbWeight::get().writes(3 as Weight)) @@ -118,7 +120,7 @@ // Storage: Refungible AccountBalance (r:1 w:1) // Storage: Refungible Owned (r:0 w:1) fn burn_item_partial() -> Weight { - (21_239_000 as Weight) + (25_578_000 as Weight) .saturating_add(T::DbWeight::get().reads(3 as Weight)) .saturating_add(T::DbWeight::get().writes(4 as Weight)) } @@ -130,13 +132,13 @@ // Storage: Refungible Owned (r:0 w:1) // Storage: Refungible TokenProperties (r:0 w:1) fn burn_item_fully() -> Weight { - (29_426_000 as Weight) + (33_593_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(7 as Weight)) } // Storage: Refungible Balance (r:2 w:2) fn transfer_normal() -> Weight { - (17_743_000 as Weight) + (21_049_000 as Weight) .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) } @@ -144,7 +146,7 @@ // Storage: Refungible AccountBalance (r:1 w:1) // Storage: Refungible Owned (r:0 w:1) fn transfer_creating() -> Weight { - (20_699_000 as Weight) + (24_646_000 as Weight) .saturating_add(T::DbWeight::get().reads(3 as Weight)) .saturating_add(T::DbWeight::get().writes(4 as Weight)) } @@ -152,7 +154,7 @@ // Storage: Refungible AccountBalance (r:1 w:1) // Storage: Refungible Owned (r:0 w:1) fn transfer_removing() -> Weight { - (22_833_000 as Weight) + (26_570_000 as Weight) .saturating_add(T::DbWeight::get().reads(3 as Weight)) .saturating_add(T::DbWeight::get().writes(4 as Weight)) } @@ -160,21 +162,21 @@ // Storage: Refungible AccountBalance (r:2 w:2) // Storage: Refungible Owned (r:0 w:2) fn transfer_creating_removing() -> Weight { - (24_936_000 as Weight) + (28_906_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(6 as Weight)) } // Storage: Refungible Balance (r:1 w:0) // Storage: Refungible Allowance (r:0 w:1) fn approve() -> Weight { - (13_446_000 as Weight) + (16_451_000 as Weight) .saturating_add(T::DbWeight::get().reads(1 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } // Storage: Refungible Allowance (r:1 w:1) // Storage: Refungible Balance (r:2 w:2) fn transfer_from_normal() -> Weight { - (24_777_000 as Weight) + (29_545_000 as Weight) .saturating_add(T::DbWeight::get().reads(3 as Weight)) .saturating_add(T::DbWeight::get().writes(3 as Weight)) } @@ -183,7 +185,7 @@ // Storage: Refungible AccountBalance (r:1 w:1) // Storage: Refungible Owned (r:0 w:1) fn transfer_from_creating() -> Weight { - (28_483_000 as Weight) + (33_392_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(5 as Weight)) } @@ -192,7 +194,7 @@ // Storage: Refungible AccountBalance (r:1 w:1) // Storage: Refungible Owned (r:0 w:1) fn transfer_from_removing() -> Weight { - (29_896_000 as Weight) + (35_446_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(5 as Weight)) } @@ -201,7 +203,7 @@ // Storage: Refungible AccountBalance (r:2 w:2) // Storage: Refungible Owned (r:0 w:2) fn transfer_from_creating_removing() -> Weight { - (32_070_000 as Weight) + (37_762_000 as Weight) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(7 as Weight)) } @@ -214,15 +216,15 @@ // Storage: Refungible Owned (r:0 w:1) // Storage: Refungible TokenProperties (r:0 w:1) fn burn_from() -> Weight { - (36_789_000 as Weight) + (42_620_000 as Weight) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(8 as Weight)) } // Storage: Common CollectionPropertyPermissions (r:1 w:1) fn set_token_property_permissions(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 62_000 - .saturating_add((15_803_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 65_000 + .saturating_add((16_513_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(1 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -230,8 +232,8 @@ // Storage: Refungible TokenProperties (r:1 w:1) fn set_token_properties(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_668_000 - .saturating_add((302_308_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_583_000 + .saturating_add((291_392_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -239,18 +241,31 @@ // Storage: Refungible TokenProperties (r:1 w:1) fn delete_token_properties(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_619_000 - .saturating_add((294_574_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_699_000 + .saturating_add((293_270_000 as Weight).saturating_mul(b as Weight)) .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } // Storage: Refungible TotalSupply (r:1 w:1) // Storage: Refungible Balance (r:1 w:1) fn repartition_item() -> Weight { - (8_325_000 as Weight) + (19_206_000 as Weight) .saturating_add(T::DbWeight::get().reads(2 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) } + // Storage: Refungible Balance (r:1 w:0) + // Storage: Refungible TotalSupply (r:1 w:0) + // Storage: Refungible TokenProperties (r:1 w:1) + fn set_parent_nft_unchecked() -> Weight { + (10_189_000 as Weight) + .saturating_add(T::DbWeight::get().reads(3 as Weight)) + .saturating_add(T::DbWeight::get().writes(1 as Weight)) + } + // Storage: Refungible Balance (r:2 w:0) + fn token_owner() -> Weight { + (8_205_000 as Weight) + .saturating_add(T::DbWeight::get().reads(2 as Weight)) + } } // For backwards compatibility and tests @@ -262,7 +277,7 @@ // Storage: Refungible TokenData (r:0 w:1) // Storage: Refungible Owned (r:0 w:1) fn create_item() -> Weight { - (21_310_000 as Weight) + (25_197_000 as Weight) .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(6 as Weight)) } @@ -273,9 +288,9 @@ // Storage: Refungible TokenData (r:0 w:4) // Storage: Refungible Owned (r:0 w:4) fn create_multiple_items(b: u32, ) -> Weight { - (9_552_000 as Weight) + (10_852_000 as Weight) // Standard Error: 2_000 - .saturating_add((7_056_000 as Weight).saturating_mul(b as Weight)) + .saturating_add((8_087_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) .saturating_add(RocksDbWeight::get().writes((4 as Weight).saturating_mul(b as Weight))) @@ -287,9 +302,9 @@ // Storage: Refungible TokenData (r:0 w:4) // Storage: Refungible Owned (r:0 w:4) fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight { - (4_857_000 as Weight) + (9_978_000 as Weight) // Standard Error: 2_000 - .saturating_add((9_838_000 as Weight).saturating_mul(b as Weight)) + .saturating_add((10_848_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) .saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(b as Weight))) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) @@ -302,9 +317,9 @@ // Storage: Refungible Balance (r:0 w:4) // Storage: Refungible Owned (r:0 w:4) fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight { - (11_335_000 as Weight) + (15_419_000 as Weight) // Standard Error: 2_000 - .saturating_add((6_784_000 as Weight).saturating_mul(b as Weight)) + .saturating_add((7_813_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) .saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(b as Weight))) .saturating_add(RocksDbWeight::get().writes(3 as Weight)) @@ -315,7 +330,7 @@ // Storage: Refungible AccountBalance (r:1 w:1) // Storage: Refungible Owned (r:0 w:1) fn burn_item_partial() -> Weight { - (21_239_000 as Weight) + (25_578_000 as Weight) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) .saturating_add(RocksDbWeight::get().writes(4 as Weight)) } @@ -327,13 +342,13 @@ // Storage: Refungible Owned (r:0 w:1) // Storage: Refungible TokenProperties (r:0 w:1) fn burn_item_fully() -> Weight { - (29_426_000 as Weight) + (33_593_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(7 as Weight)) } // Storage: Refungible Balance (r:2 w:2) fn transfer_normal() -> Weight { - (17_743_000 as Weight) + (21_049_000 as Weight) .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) } @@ -341,7 +356,7 @@ // Storage: Refungible AccountBalance (r:1 w:1) // Storage: Refungible Owned (r:0 w:1) fn transfer_creating() -> Weight { - (20_699_000 as Weight) + (24_646_000 as Weight) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) .saturating_add(RocksDbWeight::get().writes(4 as Weight)) } @@ -349,7 +364,7 @@ // Storage: Refungible AccountBalance (r:1 w:1) // Storage: Refungible Owned (r:0 w:1) fn transfer_removing() -> Weight { - (22_833_000 as Weight) + (26_570_000 as Weight) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) .saturating_add(RocksDbWeight::get().writes(4 as Weight)) } @@ -357,21 +372,21 @@ // Storage: Refungible AccountBalance (r:2 w:2) // Storage: Refungible Owned (r:0 w:2) fn transfer_creating_removing() -> Weight { - (24_936_000 as Weight) + (28_906_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(6 as Weight)) } // Storage: Refungible Balance (r:1 w:0) // Storage: Refungible Allowance (r:0 w:1) fn approve() -> Weight { - (13_446_000 as Weight) + (16_451_000 as Weight) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } // Storage: Refungible Allowance (r:1 w:1) // Storage: Refungible Balance (r:2 w:2) fn transfer_from_normal() -> Weight { - (24_777_000 as Weight) + (29_545_000 as Weight) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) .saturating_add(RocksDbWeight::get().writes(3 as Weight)) } @@ -380,7 +395,7 @@ // Storage: Refungible AccountBalance (r:1 w:1) // Storage: Refungible Owned (r:0 w:1) fn transfer_from_creating() -> Weight { - (28_483_000 as Weight) + (33_392_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(5 as Weight)) } @@ -389,7 +404,7 @@ // Storage: Refungible AccountBalance (r:1 w:1) // Storage: Refungible Owned (r:0 w:1) fn transfer_from_removing() -> Weight { - (29_896_000 as Weight) + (35_446_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(5 as Weight)) } @@ -398,7 +413,7 @@ // Storage: Refungible AccountBalance (r:2 w:2) // Storage: Refungible Owned (r:0 w:2) fn transfer_from_creating_removing() -> Weight { - (32_070_000 as Weight) + (37_762_000 as Weight) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(7 as Weight)) } @@ -411,15 +426,15 @@ // Storage: Refungible Owned (r:0 w:1) // Storage: Refungible TokenProperties (r:0 w:1) fn burn_from() -> Weight { - (36_789_000 as Weight) + (42_620_000 as Weight) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(8 as Weight)) } // Storage: Common CollectionPropertyPermissions (r:1 w:1) fn set_token_property_permissions(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 62_000 - .saturating_add((15_803_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 65_000 + .saturating_add((16_513_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -427,8 +442,8 @@ // Storage: Refungible TokenProperties (r:1 w:1) fn set_token_properties(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_668_000 - .saturating_add((302_308_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_583_000 + .saturating_add((291_392_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -436,16 +451,29 @@ // Storage: Refungible TokenProperties (r:1 w:1) fn delete_token_properties(b: u32, ) -> Weight { (0 as Weight) - // Standard Error: 1_619_000 - .saturating_add((294_574_000 as Weight).saturating_mul(b as Weight)) + // Standard Error: 1_699_000 + .saturating_add((293_270_000 as Weight).saturating_mul(b as Weight)) .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } // Storage: Refungible TotalSupply (r:1 w:1) // Storage: Refungible Balance (r:1 w:1) fn repartition_item() -> Weight { - (8_325_000 as Weight) + (19_206_000 as Weight) .saturating_add(RocksDbWeight::get().reads(2 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) } + // Storage: Refungible Balance (r:1 w:0) + // Storage: Refungible TotalSupply (r:1 w:0) + // Storage: Refungible TokenProperties (r:1 w:1) + fn set_parent_nft_unchecked() -> Weight { + (10_189_000 as Weight) + .saturating_add(RocksDbWeight::get().reads(3 as Weight)) + .saturating_add(RocksDbWeight::get().writes(1 as Weight)) + } + // Storage: Refungible Balance (r:2 w:0) + fn token_owner() -> Weight { + (8_205_000 as Weight) + .saturating_add(RocksDbWeight::get().reads(2 as Weight)) + } } --- a/pallets/unique/src/eth/mod.rs +++ b/pallets/unique/src/eth/mod.rs @@ -17,26 +17,29 @@ //! Implementation of CollectionHelpers contract. use core::marker::PhantomData; -use evm_coder::{execution::*, generate_stubgen, solidity_interface, solidity, weight, types::*}; use ethereum as _; -use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder}; -use pallet_evm::{OnMethodCall, PrecompileResult, account::CrossAccountId, PrecompileHandle}; -use up_data_structs::{ - CollectionName, CollectionDescription, CollectionTokenPrefix, CreateCollectionData, - CollectionMode, PropertyValue, -}; +use evm_coder::{execution::*, generate_stubgen, solidity_interface, solidity, weight, types::*}; use frame_support::traits::Get; use pallet_common::{ - CollectionById, + CollectionById, CollectionHandle, + dispatch::CollectionDispatch, erc::{ + CollectionHelpersEvents, static_property::{key, value as property_value}, - CollectionHelpersEvents, }, - dispatch::CollectionDispatch, + Pallet as PalletCommon, }; -use crate::{SelfWeightOf, Config, weights::WeightInfo}; +use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder}; +use pallet_evm::{account::CrossAccountId, OnMethodCall, PrecompileHandle, PrecompileResult}; +use pallet_evm_coder_substrate::dispatch_to_evm; +use up_data_structs::{ + CollectionName, CollectionDescription, CollectionTokenPrefix, CreateCollectionData, + CollectionMode, PropertyKeyPermission, PropertyPermission, PropertyScope, PropertyValue, +}; + +use crate::{Config, SelfWeightOf, weights::WeightInfo}; -use sp_std::vec::Vec; +use sp_std::{vec, vec::Vec}; use alloc::format; /// See [`CollectionHelpersCall`] @@ -151,6 +154,54 @@ Ok(data) } +fn parent_nft_property_permissions() -> PropertyKeyPermission { + PropertyKeyPermission { + key: key::parent_nft(), + permission: PropertyPermission { + mutable: false, + collection_admin: false, + token_owner: true, + }, + } +} + +fn create_refungible_collection_internal< + T: Config + pallet_nonfungible::Config + pallet_refungible::Config, +>( + caller: caller, + name: string, + description: string, + token_prefix: string, + base_uri: string, + add_properties: bool, +) -> Result
{ + let (caller, name, description, token_prefix, base_uri_value) = + convert_data::(caller, name, description, token_prefix, base_uri)?; + let data = make_data::( + name, + CollectionMode::ReFungible, + description, + token_prefix, + base_uri_value, + add_properties, + )?; + + let collection_id = T::CollectionDispatch::create(caller.clone(), data) + .map_err(pallet_evm_coder_substrate::dispatch_to_evm::)?; + + let handle = >::try_get(collection_id).map_err(dispatch_to_evm::)?; + >::set_scoped_token_property_permissions( + &handle, + &caller, + PropertyScope::Eth, + vec![parent_nft_property_permissions()], + ) + .map_err(dispatch_to_evm::)?; + + let address = pallet_common::eth::collection_id_to_address(collection_id); + Ok(address) +} + /// @title Contract, which allows users to operate with collections #[solidity_interface(name = "CollectionHelpers", events(CollectionHelpersEvents))] impl EvmCollectionHelpers @@ -216,27 +267,20 @@ #[weight(>::create_collection())] fn create_refungible_collection( - &self, + &mut self, caller: caller, name: string, description: string, token_prefix: string, ) -> Result
{ - let (caller, name, description, token_prefix, _base_uri) = - convert_data::(caller, name, description, token_prefix, "".into())?; - let data = make_data::( + create_refungible_collection_internal::( + caller, name, - CollectionMode::ReFungible, description, token_prefix, Default::default(), false, - )?; - let collection_id = T::CollectionDispatch::create(caller, data) - .map_err(pallet_evm_coder_substrate::dispatch_to_evm::)?; - - let address = pallet_common::eth::collection_id_to_address(collection_id); - Ok(address) + ) } #[weight(>::create_collection())] @@ -249,21 +293,14 @@ token_prefix: string, base_uri: string, ) -> Result
{ - let (caller, name, description, token_prefix, base_uri_value) = - convert_data::(caller, name, description, token_prefix, base_uri)?; - let data = make_data::( + create_refungible_collection_internal::( + caller, name, - CollectionMode::NFT, description, token_prefix, - base_uri_value, + base_uri, true, - )?; - let collection_id = T::CollectionDispatch::create(caller, data) - .map_err(pallet_evm_coder_substrate::dispatch_to_evm::)?; - - let address = pallet_common::eth::collection_id_to_address(collection_id); - Ok(address) + ) } /// Check if a collection exists --- a/pallets/unique/src/eth/stubs/CollectionHelpers.sol +++ b/pallets/unique/src/eth/stubs/CollectionHelpers.sol @@ -72,12 +72,12 @@ string memory name, string memory description, string memory tokenPrefix - ) public view returns (address) { + ) public returns (address) { require(false, stub_error); name; description; tokenPrefix; - dummy; + dummy = 0; return 0x0000000000000000000000000000000000000000; } --- a/primitives/data-structs/src/lib.rs +++ b/primitives/data-structs/src/lib.rs @@ -1050,6 +1050,7 @@ pub enum PropertyScope { None, Rmrk, + Eth, } impl PropertyScope { @@ -1058,6 +1059,7 @@ let scope_str: &[u8] = match self { Self::None => return Ok(key), Self::Rmrk => b"rmrk", + Self::Eth => b"eth", }; [scope_str, b":", key.as_slice()] --- a/runtime/common/weights.rs +++ b/runtime/common/weights.rs @@ -116,6 +116,10 @@ fn burn_recursively_breadth_raw(amount: u32) -> Weight { max_weight_of!(burn_recursively_breadth_raw(amount)) } + + fn token_owner() -> Weight { + max_weight_of!(token_owner()) + } } #[cfg(feature = "refungible")] --- a/tests/package.json +++ b/tests/package.json @@ -8,6 +8,7 @@ "@polkadot/typegen": "8.7.2-15", "@types/chai": "^4.3.1", "@types/chai-as-promised": "^7.1.5", + "@types/chai-like": "^1.1.1", "@types/mocha": "^9.1.1", "@types/node": "^17.0.35", "@typescript-eslint/eslint-plugin": "^5.26.0", @@ -96,6 +97,7 @@ "@polkadot/util-crypto": "9.4.1", "bignumber.js": "^9.0.2", "chai-as-promised": "^7.1.1", + "chai-like": "^1.1.1", "find-process": "^1.4.7", "solc": "0.8.14-fixed", "web3": "^1.7.3" --- a/tests/src/eth/api/CollectionHelpers.sol +++ b/tests/src/eth/api/CollectionHelpers.sol @@ -48,7 +48,7 @@ string memory name, string memory description, string memory tokenPrefix - ) external view returns (address); + ) external returns (address); // Selector: createERC721MetadataCompatibleRFTCollection(string,string,string,string) a5596388 function createERC721MetadataCompatibleRFTCollection( --- a/tests/src/eth/api/UniqueFungible.sol +++ b/tests/src/eth/api/UniqueFungible.sol @@ -22,13 +22,7 @@ ); } -// Selector: 79cc6790 -interface ERC20UniqueExtensions is Dummy, ERC165 { - // Selector: burnFrom(address,uint256) 79cc6790 - function burnFrom(address from, uint256 amount) external returns (bool); -} - -// Selector: 7d9262e6 +// Selector: 6cf113cd interface Collection is Dummy, ERC165 { // Set collection property. // @@ -174,6 +168,27 @@ // // Selector: setCollectionMintMode(bool) 00018e84 function setCollectionMintMode(bool mode) external; + + // Check that account is the owner or admin of the collection + // + // @param user account to verify + // @return "true" if account is the owner or admin + // + // Selector: verifyOwnerOrAdmin(address) c2282493 + function verifyOwnerOrAdmin(address user) external view returns (bool); + + // Returns collection type + // + // @return `Fungible` or `NFT` or `ReFungible` + // + // Selector: uniqueCollectionType() d34b55b8 + function uniqueCollectionType() external returns (string memory); +} + +// Selector: 79cc6790 +interface ERC20UniqueExtensions is Dummy, ERC165 { + // Selector: burnFrom(address,uint256) 79cc6790 + function burnFrom(address from, uint256 amount) external returns (bool); } // Selector: 942e8b22 --- a/tests/src/eth/api/UniqueNFT.sol +++ b/tests/src/eth/api/UniqueNFT.sol @@ -250,33 +250,7 @@ function finishMinting() external returns (bool); } -// Selector: 780e9d63 -interface ERC721Enumerable is Dummy, ERC165 { - // @notice Enumerate valid NFTs - // @param index A counter less than `totalSupply()` - // @return The token identifier for the `index`th NFT, - // (sort order not specified) - // - // Selector: tokenByIndex(uint256) 4f6ccce7 - function tokenByIndex(uint256 index) external view returns (uint256); - - // @dev Not implemented - // - // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59 - function tokenOfOwnerByIndex(address owner, uint256 index) - external - view - returns (uint256); - - // @notice Count NFTs tracked by this contract - // @return A count of valid NFTs tracked by this contract, where each one of - // them has an assigned and queryable owner not equal to the zero address - // - // Selector: totalSupply() 18160ddd - function totalSupply() external view returns (uint256); -} - -// Selector: 7d9262e6 +// Selector: 6cf113cd interface Collection is Dummy, ERC165 { // Set collection property. // @@ -422,6 +396,47 @@ // // Selector: setCollectionMintMode(bool) 00018e84 function setCollectionMintMode(bool mode) external; + + // Check that account is the owner or admin of the collection + // + // @param user account to verify + // @return "true" if account is the owner or admin + // + // Selector: verifyOwnerOrAdmin(address) c2282493 + function verifyOwnerOrAdmin(address user) external view returns (bool); + + // Returns collection type + // + // @return `Fungible` or `NFT` or `ReFungible` + // + // Selector: uniqueCollectionType() d34b55b8 + function uniqueCollectionType() external returns (string memory); +} + +// Selector: 780e9d63 +interface ERC721Enumerable is Dummy, ERC165 { + // @notice Enumerate valid NFTs + // @param index A counter less than `totalSupply()` + // @return The token identifier for the `index`th NFT, + // (sort order not specified) + // + // Selector: tokenByIndex(uint256) 4f6ccce7 + function tokenByIndex(uint256 index) external view returns (uint256); + + // @dev Not implemented + // + // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59 + function tokenOfOwnerByIndex(address owner, uint256 index) + external + view + returns (uint256); + + // @notice Count NFTs tracked by this contract + // @return A count of valid NFTs tracked by this contract, where each one of + // them has an assigned and queryable owner not equal to the zero address + // + // Selector: totalSupply() 18160ddd + function totalSupply() external view returns (uint256); } // Selector: d74d154f --- a/tests/src/eth/api/UniqueRefungible.sol +++ b/tests/src/eth/api/UniqueRefungible.sol @@ -248,33 +248,7 @@ function finishMinting() external returns (bool); } -// Selector: 780e9d63 -interface ERC721Enumerable is Dummy, ERC165 { - // @notice Enumerate valid RFTs - // @param index A counter less than `totalSupply()` - // @return The token identifier for the `index`th NFT, - // (sort order not specified) - // - // Selector: tokenByIndex(uint256) 4f6ccce7 - function tokenByIndex(uint256 index) external view returns (uint256); - - // Not implemented - // - // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59 - function tokenOfOwnerByIndex(address owner, uint256 index) - external - view - returns (uint256); - - // @notice Count RFTs tracked by this contract - // @return A count of valid RFTs tracked by this contract, where each one of - // them has an assigned and queryable owner not equal to the zero address - // - // Selector: totalSupply() 18160ddd - function totalSupply() external view returns (uint256); -} - -// Selector: 7d9262e6 +// Selector: 6cf113cd interface Collection is Dummy, ERC165 { // Set collection property. // @@ -420,9 +394,50 @@ // // Selector: setCollectionMintMode(bool) 00018e84 function setCollectionMintMode(bool mode) external; + + // Check that account is the owner or admin of the collection + // + // @param user account to verify + // @return "true" if account is the owner or admin + // + // Selector: verifyOwnerOrAdmin(address) c2282493 + function verifyOwnerOrAdmin(address user) external view returns (bool); + + // Returns collection type + // + // @return `Fungible` or `NFT` or `ReFungible` + // + // Selector: uniqueCollectionType() d34b55b8 + function uniqueCollectionType() external returns (string memory); +} + +// Selector: 780e9d63 +interface ERC721Enumerable is Dummy, ERC165 { + // @notice Enumerate valid RFTs + // @param index A counter less than `totalSupply()` + // @return The token identifier for the `index`th NFT, + // (sort order not specified) + // + // Selector: tokenByIndex(uint256) 4f6ccce7 + function tokenByIndex(uint256 index) external view returns (uint256); + + // Not implemented + // + // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59 + function tokenOfOwnerByIndex(address owner, uint256 index) + external + view + returns (uint256); + + // @notice Count RFTs tracked by this contract + // @return A count of valid RFTs tracked by this contract, where each one of + // them has an assigned and queryable owner not equal to the zero address + // + // Selector: totalSupply() 18160ddd + function totalSupply() external view returns (uint256); } -// Selector: d74d154f +// Selector: 7c3bef89 interface ERC721UniqueExtensions is Dummy, ERC165 { // @notice Transfer ownership of an RFT // @dev Throws unless `msg.sender` is the current owner. Throws if `to` @@ -473,6 +488,16 @@ function mintBulkWithTokenURI(address to, Tuple0[] memory tokens) external returns (bool); + + // Returns EVM address for refungible token + // + // @param token ID of the token + // + // Selector: tokenContractAddress(uint256) ab76fac6 + function tokenContractAddress(uint256 token) + external + view + returns (address); } interface UniqueRefungible is --- a/tests/src/eth/api/UniqueRefungibleToken.sol +++ b/tests/src/eth/api/UniqueRefungibleToken.sol @@ -22,6 +22,23 @@ ); } +// Selector: 042f1106 +interface ERC1633UniqueExtensions is Dummy, ERC165 { + // Selector: setParentNFT(address,uint256) 042f1106 + function setParentNFT(address collection, uint256 nftId) + external + returns (bool); +} + +// Selector: 5755c3f2 +interface ERC1633 is Dummy, ERC165 { + // Selector: parentToken() 80a54001 + function parentToken() external view returns (address); + + // Selector: parentTokenId() d7f083f3 + function parentTokenId() external view returns (uint256); +} + // Selector: 942e8b22 interface ERC20 is Dummy, ERC165, ERC20Events { // @return the name of the token. @@ -115,5 +132,7 @@ Dummy, ERC165, ERC20, - ERC20UniqueExtensions + ERC20UniqueExtensions, + ERC1633, + ERC1633UniqueExtensions {} --- a/tests/src/eth/collectionAdmin.test.ts +++ b/tests/src/eth/collectionAdmin.test.ts @@ -59,6 +59,22 @@ expect(adminList[0].asSubstrate.toString().toLocaleLowerCase()) .to.be.eq(newAdmin.address.toLocaleLowerCase()); }); + + itWeb3('Verify owner or admin', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const collectionHelper = evmCollectionHelpers(web3, owner); + + const result = await collectionHelper.methods + .createNonfungibleCollection('A', 'B', 'C') + .send(); + const {collectionIdAddress} = await getCollectionAddressFromResult(api, result); + + const newAdmin = createEthAccount(web3); + const collectionEvm = evmCollection(web3, owner, collectionIdAddress); + expect(await collectionEvm.methods.verifyOwnerOrAdmin(newAdmin).call()).to.be.false; + await collectionEvm.methods.addCollectionAdmin(newAdmin).send(); + expect(await collectionEvm.methods.verifyOwnerOrAdmin(newAdmin).call()).to.be.true; + }); itWeb3('(!negative tests!) Add admin by ADMIN is not allowed', async ({api, web3, privateKeyWrapper}) => { const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); --- a/tests/src/eth/collectionHelpersAbi.json +++ b/tests/src/eth/collectionHelpersAbi.json @@ -61,7 +61,7 @@ ], "name": "createRefungibleCollection", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], - "stateMutability": "view", + "stateMutability": "nonpayable", "type": "function" }, { --- /dev/null +++ b/tests/src/eth/fractionalizer/Fractionalizer.bin @@ -0,0 +1 @@ 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 \ No newline at end of file --- /dev/null +++ b/tests/src/eth/fractionalizer/Fractionalizer.sol @@ -0,0 +1,189 @@ +// SPDX-License-Identifier: Apache License +pragma solidity >=0.8.0; +import {CollectionHelpers} from "../api/CollectionHelpers.sol"; +import {ContractHelpers} from "../api/ContractHelpers.sol"; +import {UniqueRefungibleToken} from "../api/UniqueRefungibleToken.sol"; +import {UniqueRefungible} from "../api/UniqueRefungible.sol"; +import {UniqueNFT} from "../api/UniqueNFT.sol"; + +/// @dev Fractionalization contract. It stores mappings between NFT and RFT tokens, +/// stores allowlist of NFT tokens available for fractionalization, has methods +/// for fractionalization and defractionalization of NFT tokens. +contract Fractionalizer { + struct Token { + address _collection; + uint256 _tokenId; + } + address rftCollection; + mapping(address => bool) nftCollectionAllowList; + mapping(address => mapping(uint256 => uint256)) nft2rftMapping; + mapping(address => Token) rft2nftMapping; + bytes32 refungibleCollectionType = keccak256(bytes("ReFungible")); + + receive() external payable onlyOwner {} + + /// @dev Method modifier to only allow contract owner to call it. + modifier onlyOwner() { + address contracthelpersAddress = 0x842899ECF380553E8a4de75bF534cdf6fBF64049; + ContractHelpers contractHelpers = ContractHelpers(contracthelpersAddress); + address contractOwner = contractHelpers.contractOwner(address(this)); + require(msg.sender == contractOwner, "Only owner can"); + _; + } + + /// @dev This emits when RFT collection setting is changed. + event RFTCollectionSet(address _collection); + + /// @dev This emits when NFT collection is allowed or disallowed. + event AllowListSet(address _collection, bool _status); + + /// @dev This emits when NFT token is fractionalized by contract. + event Fractionalized(address _collection, uint256 _tokenId, address _rftToken, uint128 _amount); + + /// @dev This emits when NFT token is defractionalized by contract. + event Defractionalized(address _rftToken, address _nftCollection, uint256 _nftTokenId); + + /// Set RFT collection that contract will work with. RFT tokens for fractionalized NFT tokens + /// would be created in this collection. + /// @dev Throws if RFT collection is already configured for this contract. + /// Throws if collection of wrong type (NFT, Fungible) is provided instead + /// of RFT collection. + /// Throws if `msg.sender` is not owner or admin of provided RFT collection. + /// Can only be called by contract owner. + /// @param _collection address of RFT collection. + function setRFTCollection(address _collection) public onlyOwner { + require( + rftCollection == address(0), + "RFT collection is already set" + ); + UniqueRefungible refungibleContract = UniqueRefungible(_collection); + string memory collectionType = refungibleContract.uniqueCollectionType(); + + require( + keccak256(bytes(collectionType)) == refungibleCollectionType, + "Wrong collection type. Collection is not refungible." + ); + require( + refungibleContract.verifyOwnerOrAdmin(address(this)), + "Fractionalizer contract should be an admin of the collection" + ); + rftCollection = _collection; + emit RFTCollectionSet(rftCollection); + } + + /// Creates and sets RFT collection that contract will work with. RFT tokens for fractionalized NFT tokens + /// would be created in this collection. + /// @dev Throws if RFT collection is already configured for this contract. + /// Can only be called by contract owner. + /// @param _name name for created RFT collection. + /// @param _description description for created RFT collection. + /// @param _tokenPrefix token prefix for created RFT collection. + function createAndSetRFTCollection(string calldata _name, string calldata _description, string calldata _tokenPrefix) public onlyOwner { + require( + rftCollection == address(0), + "RFT collection is already set" + ); + address collectionHelpers = 0x6C4E9fE1AE37a41E93CEE429e8E1881aBdcbb54F; + rftCollection = CollectionHelpers(collectionHelpers).createRefungibleCollection(_name, _description, _tokenPrefix); + emit RFTCollectionSet(rftCollection); + } + + /// Allow or disallow NFT collection tokens from being fractionalized by this contract. + /// @dev Can only be called by contract owner. + /// @param collection NFT token address. + /// @param status `true` to allow and `false` to disallow NFT token. + function setNftCollectionIsAllowed(address collection, bool status) public onlyOwner { + nftCollectionAllowList[collection] = status; + emit AllowListSet(collection, status); + } + + /// Fractionilize NFT token. + /// @dev Takes NFT token from `msg.sender` and transfers RFT token to `msg.sender` + /// instead. Creates new RFT token if provided NFT token never was fractionalized + /// by this contract or existing RFT token if it was. + /// Throws if RFT collection isn't configured for this contract. + /// Throws if fractionalization of provided NFT token is not allowed + /// Throws if `msg.sender` is not owner of provided NFT token + /// @param _collection NFT collection address + /// @param _token id of NFT token to be fractionalized + /// @param _pieces number of pieces new RFT token would have + function nft2rft(address _collection, uint256 _token, uint128 _pieces) public { + require( + rftCollection != address(0), + "RFT collection is not set" + ); + UniqueRefungible rftCollectionContract = UniqueRefungible(rftCollection); + require( + nftCollectionAllowList[_collection] == true, + "Fractionalization of this collection is not allowed by admin" + ); + require( + UniqueNFT(_collection).ownerOf(_token) == msg.sender, + "Only token owner could fractionalize it" + ); + UniqueNFT(_collection).transferFrom( + msg.sender, + address(this), + _token + ); + uint256 rftTokenId; + address rftTokenAddress; + UniqueRefungibleToken rftTokenContract; + if (nft2rftMapping[_collection][_token] == 0) { + rftTokenId = rftCollectionContract.nextTokenId(); + rftCollectionContract.mint(address(this), rftTokenId); + rftTokenAddress = rftCollectionContract.tokenContractAddress(rftTokenId); + nft2rftMapping[_collection][_token] = rftTokenId; + rft2nftMapping[rftTokenAddress] = Token(_collection, _token); + + rftTokenContract = UniqueRefungibleToken(rftTokenAddress); + rftTokenContract.setParentNFT(_collection, _token); + } else { + rftTokenId = nft2rftMapping[_collection][_token]; + rftTokenAddress = rftCollectionContract.tokenContractAddress(rftTokenId); + rftTokenContract = UniqueRefungibleToken(rftTokenAddress); + } + rftTokenContract.repartition(_pieces); + rftTokenContract.transfer(msg.sender, _pieces); + emit Fractionalized(_collection, _token, rftTokenAddress, _pieces); + } + + /// Defrationalize NFT token. + /// @dev Takes RFT token from `msg.sender` and transfers corresponding NFT token + /// to `msg.sender` instead. + /// Throws if RFT collection isn't configured for this contract. + /// Throws if provided RFT token is no from configured RFT collection. + /// Throws if RFT token was not created by this contract. + /// Throws if `msg.sender` isn't owner of all RFT token pieces. + /// @param _collection RFT collection address + /// @param _token id of RFT token + function rft2nft(address _collection, uint256 _token) public { + require( + rftCollection != address(0), + "RFT collection is not set" + ); + require( + rftCollection == _collection, + "Wrong RFT collection" + ); + UniqueRefungible rftCollectionContract = UniqueRefungible(rftCollection); + address rftTokenAddress = rftCollectionContract.tokenContractAddress(_token); + Token memory nftToken = rft2nftMapping[rftTokenAddress]; + require( + nftToken._collection != address(0), + "No corresponding NFT token found" + ); + UniqueRefungibleToken rftTokenContract = UniqueRefungibleToken(rftTokenAddress); + require( + rftTokenContract.balanceOf(msg.sender) == rftTokenContract.totalSupply(), + "Not all pieces are owned by the caller" + ); + rftCollectionContract.transferFrom(msg.sender, address(this), _token); + UniqueNFT(nftToken._collection).transferFrom( + address(this), + msg.sender, + nftToken._tokenId + ); + emit Defractionalized(rftTokenAddress, nftToken._collection, nftToken._tokenId); + } +} \ No newline at end of file --- /dev/null +++ b/tests/src/eth/fractionalizer/FractionalizerAbi.json @@ -0,0 +1,142 @@ +[ + { "inputs": [], "stateMutability": "nonpayable", "type": "constructor" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "_collection", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "_status", + "type": "bool" + } + ], + "name": "AllowListSet", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "_rftToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "_nftCollection", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "_nftTokenId", + "type": "uint256" + } + ], + "name": "Defractionalized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "_collection", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "_tokenId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "_rftToken", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint128", + "name": "_amount", + "type": "uint128" + } + ], + "name": "Fractionalized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "_collection", + "type": "address" + } + ], + "name": "RFTCollectionSet", + "type": "event" + }, + { + "inputs": [ + { "internalType": "string", "name": "_name", "type": "string" }, + { "internalType": "string", "name": "_description", "type": "string" }, + { "internalType": "string", "name": "_tokenPrefix", "type": "string" } + ], + "name": "createAndSetRFTCollection", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "_collection", "type": "address" }, + { "internalType": "uint256", "name": "_token", "type": "uint256" }, + { "internalType": "uint128", "name": "_pieces", "type": "uint128" } + ], + "name": "nft2rft", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "_collection", "type": "address" }, + { "internalType": "uint256", "name": "_token", "type": "uint256" } + ], + "name": "rft2nft", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "collection", "type": "address" }, + { "internalType": "bool", "name": "status", "type": "bool" } + ], + "name": "setNftCollectionIsAllowed", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "_collection", "type": "address" } + ], + "name": "setRFTCollection", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +] --- /dev/null +++ b/tests/src/eth/fractionalizer/fractionalizer.test.ts @@ -0,0 +1,470 @@ +// 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 Web3 from 'web3'; +import {ApiPromise} from '@polkadot/api'; +import {evmToAddress} from '@polkadot/util-crypto'; +import {readFile} from 'fs/promises'; +import {executeTransaction, submitTransactionAsync} from '../../substrate/substrate-api'; +import {getCreateCollectionResult, getCreateItemResult, UNIQUE} from '../../util/helpers'; +import {collectionIdToAddress, CompiledContract, createEthAccountWithBalance, createNonfungibleCollection, createRefungibleCollection, GAS_ARGS, itWeb3, tokenIdFromAddress, uniqueNFT, uniqueRefungible, uniqueRefungibleToken} from '../util/helpers'; +import {Contract} from 'web3-eth-contract'; +import * as solc from 'solc'; + +import chai from 'chai'; +import chaiLike from 'chai-like'; +import {IKeyringPair} from '@polkadot/types/types'; +chai.use(chaiLike); +const expect = chai.expect; +let fractionalizer: CompiledContract; + +async function compileFractionalizer() { + if (!fractionalizer) { + const input = { + language: 'Solidity', + sources: { + ['Fractionalizer.sol']: { + content: (await readFile(`${__dirname}/Fractionalizer.sol`)).toString(), + }, + }, + settings: { + outputSelection: { + '*': { + '*': ['*'], + }, + }, + }, + }; + const json = JSON.parse(solc.compile(JSON.stringify(input), {import: await findImports()})); + const out = json.contracts['Fractionalizer.sol']['Fractionalizer']; + + fractionalizer = { + abi: out.abi, + object: '0x' + out.evm.bytecode.object, + }; + } + return fractionalizer; +} + +async function findImports() { + const collectionHelpers = (await readFile(`${__dirname}/../api/CollectionHelpers.sol`)).toString(); + const contractHelpers = (await readFile(`${__dirname}/../api/ContractHelpers.sol`)).toString(); + const uniqueRefungibleToken = (await readFile(`${__dirname}/../api/UniqueRefungibleToken.sol`)).toString(); + const uniqueRefungible = (await readFile(`${__dirname}/../api/UniqueRefungible.sol`)).toString(); + const uniqueNFT = (await readFile(`${__dirname}/../api/UniqueNFT.sol`)).toString(); + + return function(path: string) { + switch (path) { + case 'api/CollectionHelpers.sol': return {contents: `${collectionHelpers}`}; + case 'api/ContractHelpers.sol': return {contents: `${contractHelpers}`}; + case 'api/UniqueRefungibleToken.sol': return {contents: `${uniqueRefungibleToken}`}; + case 'api/UniqueRefungible.sol': return {contents: `${uniqueRefungible}`}; + case 'api/UniqueNFT.sol': return {contents: `${uniqueNFT}`}; + default: return {error: 'File not found'}; + } + }; +} + +async function deployFractionalizer(web3: Web3, owner: string) { + const compiled = await compileFractionalizer(); + const fractionalizerContract = new web3.eth.Contract(compiled.abi, undefined, { + data: compiled.object, + from: owner, + ...GAS_ARGS, + }); + return await fractionalizerContract.deploy({data: compiled.object}).send({from: owner}); +} + +async function initFractionalizer(api: ApiPromise, web3: Web3, privateKeyWrapper: (account: string) => IKeyringPair, owner: string) { + const fractionalizer = await deployFractionalizer(web3, owner); + const amount = 10n * UNIQUE; + await web3.eth.sendTransaction({from: owner, to: fractionalizer.options.address, value: `${amount}`, ...GAS_ARGS}); + const result = await fractionalizer.methods.createAndSetRFTCollection('A', 'B', 'C').send(); + const rftCollectionAddress = result.events.RFTCollectionSet.returnValues._collection; + return {fractionalizer, rftCollectionAddress}; +} + +async function createRFTToken(api: ApiPromise, web3: Web3, owner: string, fractionalizer: Contract, amount: bigint) { + const {collectionIdAddress: nftCollectionAddress} = await createNonfungibleCollection(api, web3, owner); + const nftContract = uniqueNFT(web3, nftCollectionAddress, owner); + const nftTokenId = await nftContract.methods.nextTokenId().call(); + await nftContract.methods.mint(owner, nftTokenId).send(); + + await fractionalizer.methods.setNftCollectionIsAllowed(nftCollectionAddress, true).send(); + await nftContract.methods.approve(fractionalizer.options.address, nftTokenId).send(); + const result = await fractionalizer.methods.nft2rft(nftCollectionAddress, nftTokenId, amount).send(); + const {_collection, _tokenId, _rftToken} = result.events.Fractionalized.returnValues; + return { + nftCollectionAddress: _collection, + nftTokenId: _tokenId, + rftTokenAddress: _rftToken, + }; +} + +describe('Fractionalizer contract usage', () => { + itWeb3('Set RFT collection', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const fractionalizer = await deployFractionalizer(web3, owner); + const {collectionIdAddress} = await createRefungibleCollection(api, web3, owner); + const refungibleContract = uniqueRefungible(web3, collectionIdAddress, owner); + await refungibleContract.methods.addCollectionAdmin(fractionalizer.options.address).send(); + const result = await fractionalizer.methods.setRFTCollection(collectionIdAddress).send(); + expect(result.events).to.be.like({ + RFTCollectionSet: { + returnValues: { + _collection: collectionIdAddress, + }, + }, + }); + }); + + itWeb3('Mint RFT collection', async ({api, web3, privateKeyWrapper}) => { + const alice = privateKeyWrapper('//Alice'); + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const fractionalizer = await deployFractionalizer(web3, owner); + const tx = api.tx.balances.transfer(evmToAddress(fractionalizer.options.address), 10n * UNIQUE); + await submitTransactionAsync(alice, tx); + + const result = await fractionalizer.methods.createAndSetRFTCollection('A', 'B', 'C').send({from: owner}); + expect(result.events).to.be.like({ + RFTCollectionSet: {}, + }); + expect(result.events.RFTCollectionSet.returnValues._collection).to.be.ok; + }); + + itWeb3('Set Allowlist', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const {fractionalizer} = await initFractionalizer(api, web3, privateKeyWrapper, owner); + const {collectionIdAddress: nftCollectionAddress} = await createNonfungibleCollection(api, web3, owner); + const result1 = await fractionalizer.methods.setNftCollectionIsAllowed(nftCollectionAddress, true).send({from: owner}); + expect(result1.events).to.be.like({ + AllowListSet: { + returnValues: { + _collection: nftCollectionAddress, + _status: true, + }, + }, + }); + const result2 = await fractionalizer.methods.setNftCollectionIsAllowed(nftCollectionAddress, false).send({from: owner}); + expect(result2.events).to.be.like({ + AllowListSet: { + returnValues: { + _collection: nftCollectionAddress, + _status: false, + }, + }, + }); + }); + + itWeb3('NFT to RFT', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const {collectionIdAddress: nftCollectionAddress} = await createNonfungibleCollection(api, web3, owner); + const nftContract = uniqueNFT(web3, nftCollectionAddress, owner); + const nftTokenId = await nftContract.methods.nextTokenId().call(); + await nftContract.methods.mint(owner, nftTokenId).send(); + + const {fractionalizer} = await initFractionalizer(api, web3, privateKeyWrapper, owner); + + await fractionalizer.methods.setNftCollectionIsAllowed(nftCollectionAddress, true).send(); + await nftContract.methods.approve(fractionalizer.options.address, nftTokenId).send(); + const result = await fractionalizer.methods.nft2rft(nftCollectionAddress, nftTokenId, 100).send(); + expect(result.events).to.be.like({ + Fractionalized: { + returnValues: { + _collection: nftCollectionAddress, + _tokenId: nftTokenId, + _amount: '100', + }, + }, + }); + const rftTokenAddress = result.events.Fractionalized.returnValues._rftToken; + const rftTokenContract = uniqueRefungibleToken(web3, rftTokenAddress, owner); + expect(await rftTokenContract.methods.balanceOf(owner).call()).to.equal('100'); + }); + + itWeb3('RFT to NFT', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const {fractionalizer, rftCollectionAddress} = await initFractionalizer(api, web3, privateKeyWrapper, owner); + const {rftTokenAddress, nftCollectionAddress, nftTokenId} = await createRFTToken(api, web3, owner, fractionalizer, 100n); + + const {collectionId, tokenId} = tokenIdFromAddress(rftTokenAddress); + const refungibleAddress = collectionIdToAddress(collectionId); + expect(rftCollectionAddress).to.be.equal(refungibleAddress); + const refungibleTokenContract = uniqueRefungibleToken(web3, rftTokenAddress, owner); + await refungibleTokenContract.methods.approve(fractionalizer.options.address, 100).send(); + const result = await fractionalizer.methods.rft2nft(refungibleAddress, tokenId).send(); + expect(result.events).to.be.like({ + Defractionalized: { + returnValues: { + _rftToken: rftTokenAddress, + _nftCollection: nftCollectionAddress, + _nftTokenId: nftTokenId, + }, + }, + }); + }); +}); + + + +describe('Negative Integration Tests for fractionalizer', () => { + itWeb3('call setRFTCollection twice', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const {collectionIdAddress} = await createRefungibleCollection(api, web3, owner); + const refungibleContract = uniqueRefungible(web3, collectionIdAddress, owner); + + const fractionalizer = await deployFractionalizer(web3, owner); + await refungibleContract.methods.addCollectionAdmin(fractionalizer.options.address).send(); + await fractionalizer.methods.setRFTCollection(collectionIdAddress).send(); + + await expect(fractionalizer.methods.setRFTCollection(collectionIdAddress).call()) + .to.be.rejectedWith(/RFT collection is already set$/g); + }); + + itWeb3('call setRFTCollection with NFT collection', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const {collectionIdAddress} = await createNonfungibleCollection(api, web3, owner); + const nftContract = uniqueNFT(web3, collectionIdAddress, owner); + + const fractionalizer = await deployFractionalizer(web3, owner); + await nftContract.methods.addCollectionAdmin(fractionalizer.options.address).send(); + + await expect(fractionalizer.methods.setRFTCollection(collectionIdAddress).call()) + .to.be.rejectedWith(/Wrong collection type. Collection is not refungible.$/g); + }); + + itWeb3('call setRFTCollection while not collection admin', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const fractionalizer = await deployFractionalizer(web3, owner); + const {collectionIdAddress} = await createRefungibleCollection(api, web3, owner); + + await expect(fractionalizer.methods.setRFTCollection(collectionIdAddress).call()) + .to.be.rejectedWith(/Fractionalizer contract should be an admin of the collection$/g); + }); + + itWeb3('call setRFTCollection after createAndSetRFTCollection', async ({api, web3, privateKeyWrapper}) => { + const alice = privateKeyWrapper('//Alice'); + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const fractionalizer = await deployFractionalizer(web3, owner); + const tx = api.tx.balances.transfer(evmToAddress(fractionalizer.options.address), 10n * UNIQUE); + await submitTransactionAsync(alice, tx); + + const result = await fractionalizer.methods.createAndSetRFTCollection('A', 'B', 'C').send({from: owner}); + const collectionIdAddress = result.events.RFTCollectionSet.returnValues._collection; + + await expect(fractionalizer.methods.setRFTCollection(collectionIdAddress).call()) + .to.be.rejectedWith(/RFT collection is already set$/g); + }); + + itWeb3('call nft2rft without setting RFT collection for contract', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const {collectionIdAddress: nftCollectionAddress} = await createNonfungibleCollection(api, web3, owner); + const nftContract = uniqueNFT(web3, nftCollectionAddress, owner); + const nftTokenId = await nftContract.methods.nextTokenId().call(); + await nftContract.methods.mint(owner, nftTokenId).send(); + + const fractionalizer = await deployFractionalizer(web3, owner); + + await expect(fractionalizer.methods.nft2rft(nftCollectionAddress, nftTokenId, 100).call()) + .to.be.rejectedWith(/RFT collection is not set$/g); + }); + + itWeb3('call nft2rft while not owner of NFT token', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const nftOwner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const {collectionIdAddress: nftCollectionAddress} = await createNonfungibleCollection(api, web3, owner); + const nftContract = uniqueNFT(web3, nftCollectionAddress, owner); + const nftTokenId = await nftContract.methods.nextTokenId().call(); + await nftContract.methods.mint(owner, nftTokenId).send(); + await nftContract.methods.transfer(nftOwner, 1).send(); + + + const {fractionalizer} = await initFractionalizer(api, web3, privateKeyWrapper, owner); + await fractionalizer.methods.setNftCollectionIsAllowed(nftCollectionAddress, true).send(); + + await expect(fractionalizer.methods.nft2rft(nftCollectionAddress, nftTokenId, 100).call()) + .to.be.rejectedWith(/Only token owner could fractionalize it$/g); + }); + + itWeb3('call nft2rft while not in list of allowed accounts', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const {collectionIdAddress: nftCollectionAddress} = await createNonfungibleCollection(api, web3, owner); + const nftContract = uniqueNFT(web3, nftCollectionAddress, owner); + const nftTokenId = await nftContract.methods.nextTokenId().call(); + await nftContract.methods.mint(owner, nftTokenId).send(); + + const {fractionalizer} = await initFractionalizer(api, web3, privateKeyWrapper, owner); + + await nftContract.methods.approve(fractionalizer.options.address, nftTokenId).send(); + await expect(fractionalizer.methods.nft2rft(nftCollectionAddress, nftTokenId, 100).call()) + .to.be.rejectedWith(/Fractionalization of this collection is not allowed by admin$/g); + }); + + itWeb3('call nft2rft while fractionalizer doesnt have approval for nft token', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const {collectionIdAddress: nftCollectionAddress} = await createNonfungibleCollection(api, web3, owner); + const nftContract = uniqueNFT(web3, nftCollectionAddress, owner); + const nftTokenId = await nftContract.methods.nextTokenId().call(); + await nftContract.methods.mint(owner, nftTokenId).send(); + + const {fractionalizer} = await initFractionalizer(api, web3, privateKeyWrapper, owner); + + await fractionalizer.methods.setNftCollectionIsAllowed(nftCollectionAddress, true).send(); + await expect(fractionalizer.methods.nft2rft(nftCollectionAddress, nftTokenId, 100).call()) + .to.be.rejectedWith(/ApprovedValueTooLow$/g); + }); + + itWeb3('call rft2nft without setting RFT collection for contract', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const fractionalizer = await deployFractionalizer(web3, owner); + const {collectionIdAddress: rftCollectionAddress} = await createRefungibleCollection(api, web3, owner); + const refungibleContract = uniqueRefungible(web3, rftCollectionAddress, owner); + const rftTokenId = await refungibleContract.methods.nextTokenId().call(); + await refungibleContract.methods.mint(owner, rftTokenId).send(); + + await expect(fractionalizer.methods.rft2nft(rftCollectionAddress, rftTokenId).call()) + .to.be.rejectedWith(/RFT collection is not set$/g); + }); + + itWeb3('call rft2nft for RFT token that is not from configured RFT collection', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const {fractionalizer} = await initFractionalizer(api, web3, privateKeyWrapper, owner); + const {collectionIdAddress: rftCollectionAddress} = await createRefungibleCollection(api, web3, owner); + const refungibleContract = uniqueRefungible(web3, rftCollectionAddress, owner); + const rftTokenId = await refungibleContract.methods.nextTokenId().call(); + await refungibleContract.methods.mint(owner, rftTokenId).send(); + + await expect(fractionalizer.methods.rft2nft(rftCollectionAddress, rftTokenId).call()) + .to.be.rejectedWith(/Wrong RFT collection$/g); + }); + + itWeb3('call rft2nft for RFT token that was not minted by fractionalizer contract', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const {collectionIdAddress: rftCollectionAddress} = await createRefungibleCollection(api, web3, owner); + + const fractionalizer = await deployFractionalizer(web3, owner); + const refungibleContract = uniqueRefungible(web3, rftCollectionAddress, owner); + + await refungibleContract.methods.addCollectionAdmin(fractionalizer.options.address).send(); + await fractionalizer.methods.setRFTCollection(rftCollectionAddress).send(); + + const rftTokenId = await refungibleContract.methods.nextTokenId().call(); + await refungibleContract.methods.mint(owner, rftTokenId).send(); + + await expect(fractionalizer.methods.rft2nft(rftCollectionAddress, rftTokenId).call()) + .to.be.rejectedWith(/No corresponding NFT token found$/g); + }); + + itWeb3('call rft2nft without owning all RFT pieces', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const receiver = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const {fractionalizer, rftCollectionAddress} = await initFractionalizer(api, web3, privateKeyWrapper, owner); + const {rftTokenAddress} = await createRFTToken(api, web3, owner, fractionalizer, 100n); + + const {tokenId} = tokenIdFromAddress(rftTokenAddress); + const refungibleTokenContract = uniqueRefungibleToken(web3, rftTokenAddress, owner); + await refungibleTokenContract.methods.transfer(receiver, 50).send(); + await refungibleTokenContract.methods.approve(fractionalizer.options.address, 50).send(); + await expect(fractionalizer.methods.rft2nft(rftCollectionAddress, tokenId).call()) + .to.be.rejectedWith(/Not all pieces are owned by the caller$/g); + }); + + itWeb3('send QTZ/UNQ to contract from non owner', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const payer = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const fractionalizer = await deployFractionalizer(web3, owner); + const amount = 10n * UNIQUE; + await expect(web3.eth.sendTransaction({from: payer, to: fractionalizer.options.address, value: `${amount}`, ...GAS_ARGS})).to.be.rejected; + }); + + itWeb3('fractionalize NFT with NFT transfers disallowed', async ({api, web3, privateKeyWrapper}) => { + const alice = privateKeyWrapper('//Alice'); + let collectionId; + { + const tx = api.tx.unique.createCollectionEx({name: 'A', description: 'B', tokenPrefix: 'C', mode: 'NFT'}); + const events = await submitTransactionAsync(alice, tx); + const result = getCreateCollectionResult(events); + collectionId = result.collectionId; + } + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + let nftTokenId; + { + const createData = {nft: {}}; + const tx = api.tx.unique.createItem(collectionId, {Ethereum: owner}, createData as any); + const events = await executeTransaction(api, alice, tx); + const result = getCreateItemResult(events); + nftTokenId = result.itemId; + } + { + const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, false); + await executeTransaction(api, alice, tx); + } + const nftCollectionAddress = collectionIdToAddress(collectionId); + const {fractionalizer} = await initFractionalizer(api, web3, privateKeyWrapper, owner); + await fractionalizer.methods.setNftCollectionIsAllowed(nftCollectionAddress, true).send(); + + const nftContract = uniqueNFT(web3, nftCollectionAddress, owner); + await nftContract.methods.approve(fractionalizer.options.address, nftTokenId).send(); + await expect(fractionalizer.methods.nft2rft(nftCollectionAddress, nftTokenId, 100).call()) + .to.be.rejectedWith(/TransferNotAllowed$/g); + }); + + itWeb3('fractionalize NFT with RFT transfers disallowed', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + const alice = privateKeyWrapper('//Alice'); + + let collectionId; + { + const tx = api.tx.unique.createCollectionEx({name: 'A', description: 'B', tokenPrefix: 'C', mode: 'ReFungible'}); + const events = await submitTransactionAsync(alice, tx); + const result = getCreateCollectionResult(events); + collectionId = result.collectionId; + } + const rftCollectionAddress = collectionIdToAddress(collectionId); + const fractionalizer = await deployFractionalizer(web3, owner); + { + const changeAdminTx = api.tx.unique.addCollectionAdmin(collectionId, {Ethereum: fractionalizer.options.address}); + await submitTransactionAsync(alice, changeAdminTx); + } + await fractionalizer.methods.setRFTCollection(rftCollectionAddress).send(); + { + const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, false); + await executeTransaction(api, alice, tx); + } + + const {collectionIdAddress: nftCollectionAddress} = await createNonfungibleCollection(api, web3, owner); + const nftContract = uniqueNFT(web3, nftCollectionAddress, owner); + const nftTokenId = await nftContract.methods.nextTokenId().call(); + await nftContract.methods.mint(owner, nftTokenId).send(); + + await fractionalizer.methods.setNftCollectionIsAllowed(nftCollectionAddress, true).send(); + await nftContract.methods.approve(fractionalizer.options.address, nftTokenId).send(); + + await expect(fractionalizer.methods.nft2rft(nftCollectionAddress, nftTokenId, 100n).call()) + .to.be.rejectedWith(/TransferNotAllowed$/g); + }); +}); \ No newline at end of file --- a/tests/src/eth/fungibleAbi.json +++ b/tests/src/eth/fungibleAbi.json @@ -301,5 +301,21 @@ "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "nonpayable", "type": "function" + }, + { + "inputs": [], + "name": "uniqueCollectionType", + "outputs": [{ "internalType": "string", "name": "", "type": "string" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "user", "type": "address" } + ], + "name": "verifyOwnerOrAdmin", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "view", + "type": "function" } ] --- a/tests/src/eth/nonFungibleAbi.json +++ b/tests/src/eth/nonFungibleAbi.json @@ -526,5 +526,21 @@ "outputs": [], "stateMutability": "nonpayable", "type": "function" + }, + { + "inputs": [], + "name": "uniqueCollectionType", + "outputs": [{ "internalType": "string", "name": "", "type": "string" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "user", "type": "address" } + ], + "name": "verifyOwnerOrAdmin", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "view", + "type": "function" } ] --- a/tests/src/eth/reFungible.test.ts +++ b/tests/src/eth/reFungible.test.ts @@ -15,8 +15,7 @@ // along with Unique Network. If not, see . import {createCollectionExpectSuccess, UNIQUE, requirePallets, Pallets} from '../util/helpers'; -import {collectionIdToAddress, createEthAccount, createEthAccountWithBalance, evmCollection, evmCollectionHelpers, GAS_ARGS, getCollectionAddressFromResult, itWeb3, normalizeEvents, recordEthFee, recordEvents, tokenIdToAddress} from './util/helpers'; -import reFungibleTokenAbi from './reFungibleTokenAbi.json'; +import {collectionIdToAddress, createEthAccount, createEthAccountWithBalance, evmCollection, evmCollectionHelpers, getCollectionAddressFromResult, itWeb3, normalizeEvents, recordEthFee, recordEvents, tokenIdToAddress, uniqueRefungibleToken} from './util/helpers'; import {expect} from 'chai'; describe('Refungible: Information getting', () => { @@ -88,7 +87,7 @@ await contract.methods.mint(caller, tokenId).send(); const tokenAddress = tokenIdToAddress(collectionId, tokenId); - const tokenContract = new web3.eth.Contract(reFungibleTokenAbi as any, tokenAddress, {from: caller, ...GAS_ARGS}); + const tokenContract = uniqueRefungibleToken(web3, tokenAddress, caller); await tokenContract.methods.repartition(2).send(); await tokenContract.methods.transfer(receiver, 1).send(); @@ -112,7 +111,7 @@ await contract.methods.mint(caller, tokenId).send(); const tokenAddress = tokenIdToAddress(collectionId, tokenId); - const tokenContract = new web3.eth.Contract(reFungibleTokenAbi as any, tokenAddress, {from: caller, ...GAS_ARGS}); + const tokenContract = uniqueRefungibleToken(web3, tokenAddress, caller); await tokenContract.methods.repartition(2).send(); await tokenContract.methods.transfer(receiver, 1).send(); @@ -258,7 +257,7 @@ await contract.methods.mint(caller, tokenId).send(); const address = tokenIdToAddress(collectionId, tokenId); - const tokenContract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: caller, ...GAS_ARGS}); + const tokenContract = uniqueRefungibleToken(web3, address, caller); await tokenContract.methods.repartition(15).send(); { @@ -277,7 +276,7 @@ }, ]); }); - + expect(erc20Events).to.include.deep.members([ { address, @@ -353,12 +352,12 @@ await contract.methods.mint(caller, tokenId).send(); const tokenAddress = tokenIdToAddress(collectionId, tokenId); - const tokenContract = new web3.eth.Contract(reFungibleTokenAbi as any, tokenAddress, {from: caller, ...GAS_ARGS}); + const tokenContract = uniqueRefungibleToken(web3, tokenAddress, caller); await tokenContract.methods.repartition(2).send(); await tokenContract.methods.transfer(receiver, 1).send(); - const events = await recordEvents(contract, async () => + const events = await recordEvents(contract, async () => await tokenContract.methods.transfer(receiver, 1).send()); expect(events).to.deep.equal([ { @@ -385,13 +384,13 @@ await contract.methods.mint(caller, tokenId).send(); const tokenAddress = tokenIdToAddress(collectionId, tokenId); - const tokenContract = new web3.eth.Contract(reFungibleTokenAbi as any, tokenAddress, {from: caller, ...GAS_ARGS}); + const tokenContract = uniqueRefungibleToken(web3, tokenAddress, caller); await tokenContract.methods.repartition(2).send(); - - const events = await recordEvents(contract, async () => + + const events = await recordEvents(contract, async () => await tokenContract.methods.transfer(receiver, 1).send()); - + expect(events).to.deep.equal([ { address: collectionIdAddress, --- a/tests/src/eth/reFungibleAbi.json +++ b/tests/src/eth/reFungibleAbi.json @@ -482,6 +482,15 @@ }, { "inputs": [ + { "internalType": "uint256", "name": "token", "type": "uint256" } + ], + "name": "tokenContractAddress", + "outputs": [{ "internalType": "address", "name": "", "type": "address" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ { "internalType": "address", "name": "owner", "type": "address" }, { "internalType": "uint256", "name": "index", "type": "uint256" } ], @@ -526,5 +535,21 @@ "outputs": [], "stateMutability": "nonpayable", "type": "function" + }, + { + "inputs": [], + "name": "uniqueCollectionType", + "outputs": [{ "internalType": "string", "name": "", "type": "string" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "user", "type": "address" } + ], + "name": "verifyOwnerOrAdmin", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "view", + "type": "function" } ] --- a/tests/src/eth/reFungibleToken.test.ts +++ b/tests/src/eth/reFungibleToken.test.ts @@ -15,8 +15,7 @@ // along with Unique Network. If not, see . import {approve, createCollection, createRefungibleToken, transfer, transferFrom, UNIQUE, requirePallets, Pallets} from '../util/helpers'; -import {collectionIdToAddress, createEthAccount, createEthAccountWithBalance, evmCollection, evmCollectionHelpers, GAS_ARGS, getCollectionAddressFromResult, itWeb3, normalizeEvents, recordEthFee, recordEvents, subToEth, tokenIdToAddress, transferBalanceToEth} from './util/helpers'; -import reFungibleTokenAbi from './reFungibleTokenAbi.json'; +import {collectionIdFromAddress, collectionIdToAddress, createEthAccount, createEthAccountWithBalance, createNonfungibleCollection, createRefungibleCollection, evmCollection, evmCollectionHelpers, getCollectionAddressFromResult, itWeb3, normalizeEvents, recordEthFee, recordEvents, subToEth, tokenIdToAddress, transferBalanceToEth, uniqueNFT, uniqueRefungible, uniqueRefungibleToken} from './util/helpers'; import chai from 'chai'; import chaiAsPromised from 'chai-as-promised'; @@ -38,7 +37,7 @@ const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: caller})).itemId; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: caller, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, caller); const totalSupply = await contract.methods.totalSupply().call(); expect(totalSupply).to.equal('200'); @@ -54,7 +53,7 @@ const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: caller})).itemId; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: caller, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, caller); const balance = await contract.methods.balanceOf(caller).call(); expect(balance).to.equal('200'); @@ -70,7 +69,7 @@ const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: caller})).itemId; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: caller, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, caller); const decimals = await contract.methods.decimals().call(); expect(decimals).to.equal('0'); @@ -90,7 +89,7 @@ const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result); const receiver = createEthAccount(web3); const contract = evmCollection(web3, owner, collectionIdAddress, {type: 'ReFungible'}); - + const nextTokenId = await contract.methods.nextTokenId().call(); expect(nextTokenId).to.be.equal('1'); result = await contract.methods.mint( @@ -123,17 +122,17 @@ const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result); const receiver = createEthAccount(web3); const contract = evmCollection(web3, owner, collectionIdAddress, {type: 'ReFungible'}); - + const nextTokenId = await contract.methods.nextTokenId().call(); expect(nextTokenId).to.be.equal('1'); result = await contract.methods.mint( receiver, nextTokenId, ).send(); - + // Set URL await contract.methods.setProperty(nextTokenId, 'url', Buffer.from('Token URI')).send(); - + const events = normalizeEvents(result.events); const address = collectionIdToAddress(collectionId); @@ -159,14 +158,14 @@ const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result); const receiver = createEthAccount(web3); const contract = evmCollection(web3, owner, collectionIdAddress, {type: 'ReFungible'}); - + const nextTokenId = await contract.methods.nextTokenId().call(); expect(nextTokenId).to.be.equal('1'); result = await contract.methods.mint( receiver, nextTokenId, ).send(); - + const events = normalizeEvents(result.events); const address = collectionIdToAddress(collectionId); @@ -192,14 +191,14 @@ const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result); const receiver = createEthAccount(web3); const contract = evmCollection(web3, owner, collectionIdAddress, {type: 'ReFungible'}); - + const nextTokenId = await contract.methods.nextTokenId().call(); expect(nextTokenId).to.be.equal('1'); result = await contract.methods.mint( receiver, nextTokenId, ).send(); - + // Set suffix const suffix = '/some/suffix'; await contract.methods.setProperty(nextTokenId, 'suffix', Buffer.from(suffix)).send(); @@ -241,7 +240,7 @@ const spender = createEthAccount(web3); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: owner, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, owner); { const result = await contract.methods.approve(spender, 100).send({from: owner}); @@ -282,7 +281,7 @@ const receiver = createEthAccount(web3); const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: owner, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, owner); await contract.methods.approve(spender, 100).send(); @@ -336,7 +335,7 @@ await transferBalanceToEth(api, alice, receiver); const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: owner, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, owner); { const result = await contract.methods.transfer(receiver, 50).send({from: owner}); @@ -379,14 +378,14 @@ const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n, {Ethereum: owner})).itemId; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: owner, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, owner); await contract.methods.repartition(200).send({from: owner}); expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(200); await contract.methods.transfer(receiver, 110).send({from: owner}); expect(+await contract.methods.balanceOf(owner).call()).to.be.equal(90); expect(+await contract.methods.balanceOf(receiver).call()).to.be.equal(110); - + await expect(contract.methods.repartition(80).send({from: owner})).to.eventually.be.rejected; await contract.methods.transfer(receiver, 90).send({from: owner}); @@ -409,7 +408,7 @@ const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n, {Ethereum: owner})).itemId; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: owner, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, owner); const result = await contract.methods.repartition(200).send(); const events = normalizeEvents(result.events); @@ -438,7 +437,7 @@ const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n, {Ethereum: owner})).itemId; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: owner, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, owner); const result = await contract.methods.repartition(50).send(); const events = normalizeEvents(result.events); @@ -468,11 +467,11 @@ const address = tokenIdToAddress(collectionId, tokenId); - const tokenContract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: caller, ...GAS_ARGS}); + const tokenContract = uniqueRefungibleToken(web3, address, caller); await tokenContract.methods.repartition(2).send(); await tokenContract.methods.transfer(receiver, 1).send(); - const events = await recordEvents(contract, async () => + const events = await recordEvents(contract, async () => await tokenContract.methods.burnFrom(caller, 1).send()); expect(events).to.deep.equal([ { @@ -504,7 +503,7 @@ const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: owner})).itemId; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: owner, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, owner); const cost = await recordEthFee(api, owner, () => contract.methods.approve(spender, 100).send({from: owner})); expect(cost < BigInt(0.2 * Number(UNIQUE))); @@ -521,7 +520,7 @@ const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: owner})).itemId; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: owner, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, owner); await contract.methods.approve(spender, 100).send({from: owner}); @@ -540,7 +539,7 @@ const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n, {Ethereum: owner})).itemId; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address, {from: owner, ...GAS_ARGS}); + const contract = uniqueRefungibleToken(web3, address, owner); const cost = await recordEthFee(api, owner, () => contract.methods.transfer(receiver, 100).send({from: owner})); expect(cost < BigInt(0.2 * Number(UNIQUE))); @@ -562,7 +561,7 @@ const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n)).itemId; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address); + const contract = uniqueRefungibleToken(web3, address); const events = await recordEvents(contract, async () => { expect(await approve(api, collectionId, tokenId, alice, {Ethereum: receiver}, 100n)).to.be.true; @@ -593,7 +592,7 @@ expect(await approve(api, collectionId, tokenId, alice, bob.address, 100n)).to.be.true; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address); + const contract = uniqueRefungibleToken(web3, address); const events = await recordEvents(contract, async () => { expect(await transferFrom(api, collectionId, tokenId, bob, alice, {Ethereum: receiver}, 51n)).to.be.true; @@ -631,7 +630,7 @@ const tokenId = (await createRefungibleToken(api, alice, collectionId, 200n)).itemId; const address = tokenIdToAddress(collectionId, tokenId); - const contract = new web3.eth.Contract(reFungibleTokenAbi as any, address); + const contract = uniqueRefungibleToken(web3, address); const events = await recordEvents(contract, async () => { expect(await transfer(api, collectionId, tokenId, alice, {Ethereum: receiver}, 51n)).to.be.true; @@ -650,3 +649,47 @@ ]); }); }); + +describe('ERC 1633 implementation', () => { + itWeb3('Parent NFT token address and id', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const {collectionIdAddress: nftCollectionAddress} = await createNonfungibleCollection(api, web3, owner); + const nftContract = uniqueNFT(web3, nftCollectionAddress, owner); + const nftTokenId = await nftContract.methods.nextTokenId().call(); + await nftContract.methods.mint(owner, nftTokenId).send(); + const nftCollectionId = collectionIdFromAddress(nftCollectionAddress); + + const {collectionIdAddress, collectionId} = await createRefungibleCollection(api, web3, owner); + const refungibleContract = uniqueRefungible(web3, collectionIdAddress, owner); + const refungibleTokenId = await refungibleContract.methods.nextTokenId().call(); + await refungibleContract.methods.mint(owner, refungibleTokenId).send(); + + const rftTokenAddress = tokenIdToAddress(collectionId, refungibleTokenId); + const refungibleTokenContract = uniqueRefungibleToken(web3, rftTokenAddress, owner); + await refungibleTokenContract.methods.setParentNFT(nftCollectionAddress, nftTokenId).send(); + + const tokenAddress = await refungibleTokenContract.methods.parentToken().call(); + const tokenId = await refungibleTokenContract.methods.parentTokenId().call(); + const nftTokenAddress = tokenIdToAddress(nftCollectionId, nftTokenId); + expect(tokenAddress).to.be.equal(nftTokenAddress); + expect(tokenId).to.be.equal(nftTokenId); + }); + + itWeb3('Default parent token address and id', async ({api, web3, privateKeyWrapper}) => { + const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper); + + const {collectionIdAddress, collectionId} = await createRefungibleCollection(api, web3, owner); + const refungibleContract = uniqueRefungible(web3, collectionIdAddress, owner); + const refungibleTokenId = await refungibleContract.methods.nextTokenId().call(); + await refungibleContract.methods.mint(owner, refungibleTokenId).send(); + + const rftTokenAddress = tokenIdToAddress(collectionId, refungibleTokenId); + const refungibleTokenContract = uniqueRefungibleToken(web3, rftTokenAddress, owner); + + const tokenAddress = await refungibleTokenContract.methods.parentToken().call(); + const tokenId = await refungibleTokenContract.methods.parentTokenId().call(); + expect(tokenAddress).to.be.equal(rftTokenAddress); + expect(tokenId).to.be.equal(refungibleTokenId); + }); +}); --- a/tests/src/eth/reFungibleTokenAbi.json +++ b/tests/src/eth/reFungibleTokenAbi.json @@ -103,6 +103,20 @@ "type": "function" }, { + "inputs": [], + "name": "parentToken", + "outputs": [{ "internalType": "address", "name": "", "type": "address" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "parentTokenId", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { "inputs": [ { "internalType": "uint256", "name": "amount", "type": "uint256" } ], @@ -113,6 +127,16 @@ }, { "inputs": [ + { "internalType": "address", "name": "collection", "type": "address" }, + { "internalType": "uint256", "name": "nftId", "type": "uint256" } + ], + "name": "setParentNFT", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ { "internalType": "bytes4", "name": "interfaceID", "type": "bytes4" } ], "name": "supportsInterface", --- a/tests/src/eth/util/helpers.ts +++ b/tests/src/eth/util/helpers.ts @@ -32,6 +32,7 @@ import fungibleAbi from '../fungibleAbi.json'; import nonFungibleAbi from '../nonFungibleAbi.json'; import refungibleAbi from '../reFungibleAbi.json'; +import refungibleTokenAbi from '../reFungibleTokenAbi.json'; import contractHelpersAbi from './contractHelpersAbi.json'; export const GAS_ARGS = {gas: 2500000}; @@ -101,6 +102,18 @@ ]); return Web3.utils.toChecksumAddress('0x' + buf.toString('hex')); } + +export function tokenIdFromAddress(address: string) { + if (!address.startsWith('0x')) + throw 'address not starts with "0x"'; + if (address.length > 42) + throw 'address length is more than 20 bytes'; + return { + collectionId: Number('0x' + address.substring(address.length - 16, address.length - 8)), + tokenId: Number('0x' + address.substring(address.length - 8)), + }; +} + export function tokenIdToCross(collection: number, token: number): CrossAccountId { return { Ethereum: tokenIdToAddress(collection, token), @@ -128,6 +141,44 @@ expect(result.success).to.be.true; } +export async function createRefungibleCollection(api: ApiPromise, web3: Web3, owner: string) { + const collectionHelper = evmCollectionHelpers(web3, owner); + const result = await collectionHelper.methods + .createRefungibleCollection('A', 'B', 'C') + .send(); + return await getCollectionAddressFromResult(api, result); +} + + +export async function createNonfungibleCollection(api: ApiPromise, web3: Web3, owner: string) { + const collectionHelper = evmCollectionHelpers(web3, owner); + const result = await collectionHelper.methods + .createNonfungibleCollection('A', 'B', 'C') + .send(); + return await getCollectionAddressFromResult(api, result); +} + +export function uniqueNFT(web3: Web3, address: string, owner: string) { + return new web3.eth.Contract(nonFungibleAbi as any, address, { + from: owner, + ...GAS_ARGS, + }); +} + +export function uniqueRefungible(web3: Web3, collectionAddress: string, owner: string) { + return new web3.eth.Contract(refungibleAbi as any, collectionAddress, { + from: owner, + ...GAS_ARGS, + }); +} + +export function uniqueRefungibleToken(web3: Web3, tokenAddress: string, owner: string | undefined = undefined) { + return new web3.eth.Contract(refungibleTokenAbi as any, tokenAddress, { + from: owner, + ...GAS_ARGS, + }); +} + export async function itWeb3(name: string, cb: (apis: { web3: Web3, api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair }) => any, opts: { only?: boolean, skip?: boolean } = {}) { let i: any = it; if (opts.only) i = i.only; @@ -199,7 +250,12 @@ return Web3.utils.toChecksumAddress(subToEthLowercase(eth)); } -export function compileContract(name: string, src: string) { +export interface CompiledContract { + abi: any, + object: string, +} + +export function compileContract(name: string, src: string) : CompiledContract { const out = JSON.parse(solc.compile(JSON.stringify({ language: 'Solidity', sources: { --- a/tests/src/interfaces/augment-api-query.ts +++ b/tests/src/interfaces/augment-api-query.ts @@ -266,7 +266,7 @@ * * Currently used to store RMRK data. **/ - tokenAuxProperties: AugmentedQuery Observable>, [u32, u32, UpDataStructsPropertyScope, Bytes]> & QueryableStorageEntry; + tokenAuxProperties: AugmentedQuery Observable>, [u32, u32, UpDataStructsPropertyScope, Bytes]> & QueryableStorageEntry; /** * Used to enumerate token's children. **/ --- a/tests/src/interfaces/default/types.ts +++ b/tests/src/interfaces/default/types.ts @@ -2521,7 +2521,8 @@ export interface UpDataStructsPropertyScope extends Enum { readonly isNone: boolean; readonly isRmrk: boolean; - readonly type: 'None' | 'Rmrk'; + readonly isEth: boolean; + readonly type: 'None' | 'Rmrk' | 'Eth'; } /** @name UpDataStructsRpcCollection */ --- a/tests/src/interfaces/lookup.ts +++ b/tests/src/interfaces/lookup.ts @@ -2978,7 +2978,7 @@ * Lookup397: up_data_structs::PropertyScope **/ UpDataStructsPropertyScope: { - _enum: ['None', 'Rmrk'] + _enum: ['None', 'Rmrk', 'Eth'] }, /** * Lookup399: pallet_nonfungible::pallet::Error --- a/tests/src/interfaces/types-lookup.ts +++ b/tests/src/interfaces/types-lookup.ts @@ -3126,7 +3126,8 @@ export interface UpDataStructsPropertyScope extends Enum { readonly isNone: boolean; readonly isRmrk: boolean; - readonly type: 'None' | 'Rmrk'; + readonly isEth: boolean; + readonly type: 'None' | 'Rmrk' | 'Eth'; } /** @name PalletNonfungibleError (399) */ --- a/tests/yarn.lock +++ b/tests/yarn.lock @@ -963,6 +963,20 @@ dependencies: "@types/chai" "*" +"@types/chai-like@^1.1.1": + version "1.1.1" + resolved "https://registry.yarnpkg.com/@types/chai-like/-/chai-like-1.1.1.tgz#c454039b0a2f92664fb5b7b7a2a66c3358783ae7" + integrity sha512-s46EZsupBuVhLn66DbRee5B0SELLmL4nFXVrBiV29BxLGm9Sh7Bful623j3AfiQRu2zAP4cnlZ3ETWB3eWc4bA== + dependencies: + "@types/chai" "*" + +"@types/chai-things@^0.0.35": + version "0.0.35" + resolved "https://registry.yarnpkg.com/@types/chai-things/-/chai-things-0.0.35.tgz#4b5d9ec032067faa62b3bf7bb40dc0bec941945f" + integrity sha512-BC8FwMf9FHj87XT4dgTwbdb8dNRilGqYWGmwLPdJ54YNk6K2PlcFTt68NGHjgPDnms8zIYcOtmPePd0mPNTo/Q== + dependencies: + "@types/chai" "*" + "@types/chai@*", "@types/chai@^4.3.1": version "4.3.1" resolved "https://registry.yarnpkg.com/@types/chai/-/chai-4.3.1.tgz#e2c6e73e0bdeb2521d00756d099218e9f5d90a04" @@ -1545,6 +1559,16 @@ dependencies: check-error "^1.0.2" +chai-like@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/chai-like/-/chai-like-1.1.1.tgz#8c558a414c34514e814d497c772547ceb7958f64" + integrity sha512-VKa9z/SnhXhkT1zIjtPACFWSoWsqVoaz1Vg+ecrKo5DCKVlgL30F/pEyEvXPBOVwCgLZcWUleCM/C1okaKdTTA== + +chai-things@^0.2.0: + version "0.2.0" + resolved "https://registry.yarnpkg.com/chai-things/-/chai-things-0.2.0.tgz#c55128378f9bb399e994f00052151984ed6ebe70" + integrity sha512-6ns0SU21xdRCoEXVKH3HGbwnsgfVMXQ+sU5V8PI9rfxaITos8lss1vUxbF1FAcJKjfqmmmLVlr/z3sLes00w+A== + chai@^4.3.6: version "4.3.6" resolved "https://registry.yarnpkg.com/chai/-/chai-4.3.6.tgz#ffe4ba2d9fa9d6680cc0b370adae709ec9011e9c" -- gitstuff