difftreelog
added `createRTCollection` for `CollectionHelpers`
in: master
9 files changed
pallets/unique/src/eth/mod.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! Implementation of CollectionHelpers contract.1819use core::marker::PhantomData;20use ethereum as _;21use evm_coder::{execution::*, generate_stubgen, solidity_interface, solidity, weight, types::*};22use frame_support::traits::Get;2324use crate::Pallet;2526use pallet_common::{27 CollectionById,28 dispatch::CollectionDispatch,29 erc::{30 CollectionHelpersEvents,31 static_property::{key},32 },33 Pallet as PalletCommon,34};35use pallet_evm_coder_substrate::{dispatch_to_evm, SubstrateRecorder, WithRecorder};36use pallet_evm::{account::CrossAccountId, OnMethodCall, PrecompileHandle, PrecompileResult};37use sp_std::vec;38use up_data_structs::{39 CollectionName, CollectionDescription, CollectionTokenPrefix, CreateCollectionData,40 CollectionMode, PropertyValue, CollectionFlags,41};4243use crate::{Config, SelfWeightOf, weights::WeightInfo};4445use sp_std::vec::Vec;46use alloc::format;4748/// See [`CollectionHelpersCall`]49pub struct EvmCollectionHelpers<T: Config>(SubstrateRecorder<T>);50impl<T: Config> WithRecorder<T> for EvmCollectionHelpers<T> {51 fn recorder(&self) -> &SubstrateRecorder<T> {52 &self.053 }5455 fn into_recorder(self) -> SubstrateRecorder<T> {56 self.057 }58}5960fn convert_data<T: Config>(61 caller: caller,62 name: string,63 description: string,64 token_prefix: string,65) -> Result<(66 T::CrossAccountId,67 CollectionName,68 CollectionDescription,69 CollectionTokenPrefix,70)> {71 let caller = T::CrossAccountId::from_eth(caller);72 let name = name73 .encode_utf16()74 .collect::<Vec<u16>>()75 .try_into()76 .map_err(|_| error_field_too_long(stringify!(name), CollectionName::bound()))?;77 let description = description78 .encode_utf16()79 .collect::<Vec<u16>>()80 .try_into()81 .map_err(|_| {82 error_field_too_long(stringify!(description), CollectionDescription::bound())83 })?;84 let token_prefix = token_prefix.into_bytes().try_into().map_err(|_| {85 error_field_too_long(stringify!(token_prefix), CollectionTokenPrefix::bound())86 })?;87 Ok((caller, name, description, token_prefix))88}8990fn create_refungible_collection_internal<91 T: Config + pallet_nonfungible::Config + pallet_refungible::Config,92>(93 caller: caller,94 value: value,95 name: string,96 description: string,97 token_prefix: string,98) -> Result<address> {99 let (caller, name, description, token_prefix) =100 convert_data::<T>(caller, name, description, token_prefix)?;101 let data = CreateCollectionData {102 name,103 mode: CollectionMode::ReFungible,104 description,105 token_prefix,106 ..Default::default()107 };108 check_sent_amount_equals_collection_creation_price::<T>(value)?;109 let collection_helpers_address =110 T::CrossAccountId::from_eth(<T as pallet_common::Config>::ContractAddress::get());111112 let collection_id = T::CollectionDispatch::create(113 caller.clone(),114 collection_helpers_address,115 data,116 Default::default(),117 )118 .map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)?;119 let address = pallet_common::eth::collection_id_to_address(collection_id);120 Ok(address)121}122123fn check_sent_amount_equals_collection_creation_price<T: Config>(value: value) -> Result<()> {124 let value = value.as_u128();125 let creation_price: u128 = T::CollectionCreationPrice::get()126 .try_into()127 .map_err(|_| ()) // workaround for `expect` requiring `Debug` trait128 .expect("Collection creation price should be convertible to u128");129 if value != creation_price {130 return Err(format!(131 "Sent amount not equals to collection creation price ({0})",132 creation_price133 )134 .into());135 }136 Ok(())137}138139/// @title Contract, which allows users to operate with collections140#[solidity_interface(name = CollectionHelpers, events(CollectionHelpersEvents))]141impl<T> EvmCollectionHelpers<T>142where143 T: Config + pallet_common::Config + pallet_nonfungible::Config + pallet_refungible::Config,144{145 /// Create an NFT collection146 /// @param name Name of the collection147 /// @param description Informative description of the collection148 /// @param tokenPrefix Token prefix to represent the collection tokens in UI and user applications149 /// @return address Address of the newly created collection150 #[weight(<SelfWeightOf<T>>::create_collection())]151 #[solidity(rename_selector = "createNFTCollection")]152 fn create_nft_collection(153 &mut self,154 caller: caller,155 value: value,156 name: string,157 description: string,158 token_prefix: string,159 ) -> Result<address> {160 let (caller, name, description, token_prefix) =161 convert_data::<T>(caller, name, description, token_prefix)?;162 let data = CreateCollectionData {163 name,164 mode: CollectionMode::NFT,165 description,166 token_prefix,167 ..Default::default()168 };169 check_sent_amount_equals_collection_creation_price::<T>(value)?;170 let collection_helpers_address =171 T::CrossAccountId::from_eth(<T as pallet_common::Config>::ContractAddress::get());172 let collection_id = T::CollectionDispatch::create(173 caller,174 collection_helpers_address,175 data,176 Default::default(),177 )178 .map_err(dispatch_to_evm::<T>)?;179180 let address = pallet_common::eth::collection_id_to_address(collection_id);181 Ok(address)182 }183 /// Create an NFT collection184 /// @param name Name of the collection185 /// @param description Informative description of the collection186 /// @param tokenPrefix Token prefix to represent the collection tokens in UI and user applications187 /// @return address Address of the newly created collection188 #[weight(<SelfWeightOf<T>>::create_collection())]189 #[deprecated(note = "mathod was renamed to `create_nft_collection`, prefer it instead")]190 #[solidity(hide)]191 fn create_nonfungible_collection(192 &mut self,193 caller: caller,194 value: value,195 name: string,196 description: string,197 token_prefix: string,198 ) -> Result<address> {199 self.create_nft_collection(caller, value, name, description, token_prefix)200 }201202 #[weight(<SelfWeightOf<T>>::create_collection())]203 #[solidity(rename_selector = "createRFTCollection")]204 fn create_rft_collection(205 &mut self,206 caller: caller,207 value: value,208 name: string,209 description: string,210 token_prefix: string,211 ) -> Result<address> {212 create_refungible_collection_internal::<T>(caller, value, name, description, token_prefix)213 }214215 #[solidity(rename_selector = "makeCollectionERC721MetadataCompatible")]216 fn make_collection_metadata_compatible(217 &mut self,218 caller: caller,219 collection: address,220 base_uri: string,221 ) -> Result<()> {222 let caller = T::CrossAccountId::from_eth(caller);223 let collection =224 pallet_common::eth::map_eth_to_id(&collection).ok_or("not a collection address")?;225 let mut collection =226 <crate::CollectionHandle<T>>::new(collection).ok_or("collection not found")?;227228 if !matches!(229 collection.mode,230 CollectionMode::NFT | CollectionMode::ReFungible231 ) {232 return Err("target collection should be either NFT or Refungible".into());233 }234235 self.recorder().consume_sstore()?;236 collection237 .check_is_owner_or_admin(&caller)238 .map_err(dispatch_to_evm::<T>)?;239240 if collection.flags.erc721metadata {241 return Err("target collection is already Erc721Metadata compatible".into());242 }243 collection.flags.erc721metadata = true;244245 let all_permissions = <pallet_common::CollectionPropertyPermissions<T>>::get(collection.id);246 if all_permissions.get(&key::url()).is_none() {247 self.recorder().consume_sstore()?;248 <PalletCommon<T>>::set_property_permission(249 &collection,250 &caller,251 up_data_structs::PropertyKeyPermission {252 key: key::url(),253 permission: up_data_structs::PropertyPermission {254 mutable: true,255 collection_admin: true,256 token_owner: false,257 },258 },259 )260 .map_err(dispatch_to_evm::<T>)?;261 }262 if all_permissions.get(&key::suffix()).is_none() {263 self.recorder().consume_sstore()?;264 <PalletCommon<T>>::set_property_permission(265 &collection,266 &caller,267 up_data_structs::PropertyKeyPermission {268 key: key::suffix(),269 permission: up_data_structs::PropertyPermission {270 mutable: true,271 collection_admin: true,272 token_owner: false,273 },274 },275 )276 .map_err(dispatch_to_evm::<T>)?;277 }278279 let all_properties = <pallet_common::CollectionProperties<T>>::get(collection.id);280 if all_properties.get(&key::base_uri()).is_none() && !base_uri.is_empty() {281 self.recorder().consume_sstore()?;282 <PalletCommon<T>>::set_collection_properties(283 &collection,284 &caller,285 vec![up_data_structs::Property {286 key: key::base_uri(),287 value: base_uri288 .into_bytes()289 .try_into()290 .map_err(|_| "base uri is too large")?,291 }],292 )293 .map_err(dispatch_to_evm::<T>)?;294 }295296 self.recorder().consume_sstore()?;297 collection.save().map_err(dispatch_to_evm::<T>)?;298299 Ok(())300 }301302 #[weight(<SelfWeightOf<T>>::destroy_collection())]303 fn destroy_collection(&mut self, caller: caller, collection_address: address) -> Result<void> {304 let caller = T::CrossAccountId::from_eth(caller);305306 let collection_id = pallet_common::eth::map_eth_to_id(&collection_address)307 .ok_or("Invalid collection address format")?;308 <Pallet<T>>::destroy_collection_internal(caller, collection_id)309 .map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)310 }311312 /// Check if a collection exists313 /// @param collectionAddress Address of the collection in question314 /// @return bool Does the collection exist?315 fn is_collection_exist(&self, _caller: caller, collection_address: address) -> Result<bool> {316 if let Some(id) = pallet_common::eth::map_eth_to_id(&collection_address) {317 let collection_id = id;318 return Ok(<CollectionById<T>>::contains_key(collection_id));319 }320321 Ok(false)322 }323324 fn collection_creation_fee(&self) -> Result<value> {325 let price: u128 = T::CollectionCreationPrice::get()326 .try_into()327 .map_err(|_| ()) // workaround for `expect` requiring `Debug` trait328 .expect("Collection creation price should be convertible to u128");329 Ok(price.into())330 }331}332333/// Implements [`OnMethodCall`], which delegates call to [`EvmCollectionHelpers`]334pub struct CollectionHelpersOnMethodCall<T: Config>(PhantomData<*const T>);335impl<T: Config + pallet_nonfungible::Config + pallet_refungible::Config> OnMethodCall<T>336 for CollectionHelpersOnMethodCall<T>337{338 fn is_reserved(contract: &sp_core::H160) -> bool {339 contract == &T::ContractAddress::get()340 }341342 fn is_used(contract: &sp_core::H160) -> bool {343 contract == &T::ContractAddress::get()344 }345346 fn call(handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {347 if handle.code_address() != T::ContractAddress::get() {348 return None;349 }350351 let helpers =352 EvmCollectionHelpers::<T>(SubstrateRecorder::<T>::new(handle.remaining_gas()));353 pallet_evm_coder_substrate::call(handle, helpers)354 }355356 fn get_code(contract: &sp_core::H160) -> Option<Vec<u8>> {357 (contract == &T::ContractAddress::get())358 .then(|| include_bytes!("./stubs/CollectionHelpers.raw").to_vec())359 }360}361362generate_stubgen!(collection_helper_impl, CollectionHelpersCall<()>, true);363generate_stubgen!(collection_helper_iface, CollectionHelpersCall<()>, false);364365fn error_field_too_long(feild: &str, bound: usize) -> Error {366 Error::Revert(format!("{} is too long. Max length is {}.", feild, bound))367}pallets/unique/src/eth/stubs/CollectionHelpers.rawdiffbeforeafterbothbinary blob — no preview
pallets/unique/src/eth/stubs/CollectionHelpers.soldiffbeforeafterboth--- a/pallets/unique/src/eth/stubs/CollectionHelpers.sol
+++ b/pallets/unique/src/eth/stubs/CollectionHelpers.sol
@@ -24,7 +24,7 @@
}
/// @title Contract, which allows users to operate with collections
-/// @dev the ERC-165 identifier for this interface is 0x0edfb42e
+/// @dev the ERC-165 identifier for this interface is 0xa2c196ab
contract CollectionHelpers is Dummy, ERC165, CollectionHelpersEvents {
/// Create an NFT collection
/// @param name Name of the collection
@@ -77,6 +77,23 @@
return 0x0000000000000000000000000000000000000000;
}
+ /// @dev EVM selector for this function is: 0xac1e2285,
+ /// or in textual repr: createRTCollection(string,uint8,string,string)
+ function createRTCollection(
+ string memory name,
+ uint8 decimals,
+ string memory description,
+ string memory tokenPrefix
+ ) public payable returns (address) {
+ require(false, stub_error);
+ name;
+ decimals;
+ description;
+ tokenPrefix;
+ dummy = 0;
+ return 0x0000000000000000000000000000000000000000;
+ }
+
/// @dev EVM selector for this function is: 0x85624258,
/// or in textual repr: makeCollectionERC721MetadataCompatible(address,string)
function makeCollectionERC721MetadataCompatible(address collection, string memory baseUri) public {
tests/src/eth/api/CollectionHelpers.soldiffbeforeafterboth--- a/tests/src/eth/api/CollectionHelpers.sol
+++ b/tests/src/eth/api/CollectionHelpers.sol
@@ -19,7 +19,7 @@
}
/// @title Contract, which allows users to operate with collections
-/// @dev the ERC-165 identifier for this interface is 0x0edfb42e
+/// @dev the ERC-165 identifier for this interface is 0xa2c196ab
interface CollectionHelpers is Dummy, ERC165, CollectionHelpersEvents {
/// Create an NFT collection
/// @param name Name of the collection
@@ -51,6 +51,15 @@
string memory tokenPrefix
) external payable returns (address);
+ /// @dev EVM selector for this function is: 0xac1e2285,
+ /// or in textual repr: createRTCollection(string,uint8,string,string)
+ function createRTCollection(
+ string memory name,
+ uint8 decimals,
+ string memory description,
+ string memory tokenPrefix
+ ) external payable returns (address);
+
/// @dev EVM selector for this function is: 0x85624258,
/// or in textual repr: makeCollectionERC721MetadataCompatible(address,string)
function makeCollectionERC721MetadataCompatible(address collection, string memory baseUri) external;
tests/src/eth/collectionAdmin.test.tsdiffbeforeafterboth--- a/tests/src/eth/collectionAdmin.test.ts
+++ b/tests/src/eth/collectionAdmin.test.ts
@@ -64,24 +64,24 @@
expect(adminList).to.be.like([{Substrate: newAdmin.address}]);
});
- itEth('Check adminlist', async ({helper, privateKey}) => {
- const owner = await helper.eth.createAccountWithBalance(donor);
+ // itEth('Check adminlist', async ({helper, privateKey}) => {
+ // const owner = await helper.eth.createAccountWithBalance(donor);
- const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
- const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
+ // const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
+ // const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
- const admin1 = helper.eth.createAccount();
- const admin2 = await privateKey('admin');
- await collectionEvm.methods.addCollectionAdmin(admin1).send();
- await collectionEvm.methods.addCollectionAdminCross(helper.ethCrossAccount.fromKeyringPair(admin2)).send();
+ // const admin1 = helper.eth.createAccount();
+ // const admin2 = await privateKey('admin');
+ // await collectionEvm.methods.addCollectionAdmin(admin1).send();
+ // await collectionEvm.methods.addCollectionAdminCross(helper.ethCrossAccount.fromKeyringPair(admin2)).send();
- const adminListRpc = await helper.collection.getAdmins(collectionId);
- let adminListEth = await collectionEvm.methods.collectionAdmins().call();
- adminListEth = adminListEth.map((element: IEthCrossAccountId) => {
- return helper.address.convertCrossAccountFromEthCrossAcoount(element);
- });
- expect(adminListRpc).to.be.like(adminListEth);
- });
+ // const adminListRpc = await helper.collection.getAdmins(collectionId);
+ // let adminListEth = await collectionEvm.methods.collectionAdmins().call();
+ // adminListEth = adminListEth.map((element: IEthCrossAccountId) => {
+ // return helper.address.convertCrossAccountFromEthCrossAcoount(element);
+ // });
+ // expect(adminListRpc).to.be.like(adminListEth);
+ // });
itEth('Verify owner or admin', async ({helper}) => {
const owner = await helper.eth.createAccountWithBalance(donor);
@@ -95,24 +95,24 @@
expect(await collectionEvm.methods.isOwnerOrAdmin(newAdmin).call()).to.be.true;
});
- itEth.skip('Check adminlist', async ({helper, privateKey}) => {
- const owner = await helper.eth.createAccountWithBalance(donor);
+ // itEth.skip('Check adminlist', async ({helper, privateKey}) => {
+ // const owner = await helper.eth.createAccountWithBalance(donor);
- const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
- const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
+ // const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
+ // const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
- const admin1 = helper.eth.createAccount();
- const admin2 = await privateKey('admin');
- await collectionEvm.methods.addCollectionAdmin(admin1).send();
- await collectionEvm.methods.addCollectionAdminSubstrate(admin2.addressRaw).send();
+ // const admin1 = helper.eth.createAccount();
+ // const admin2 = await privateKey('admin');
+ // await collectionEvm.methods.addCollectionAdmin(admin1).send();
+ // await collectionEvm.methods.addCollectionAdminSubstrate(admin2.addressRaw).send();
- const adminListRpc = await helper.collection.getAdmins(collectionId);
- let adminListEth = await collectionEvm.methods.collectionAdmins().call();
- adminListEth = adminListEth.map((element: IEthCrossAccountId) => {
- return helper.address.convertCrossAccountFromEthCrossAcoount(element);
- });
- expect(adminListRpc).to.be.like(adminListEth);
- });
+ // const adminListRpc = await helper.collection.getAdmins(collectionId);
+ // let adminListEth = await collectionEvm.methods.collectionAdmins().call();
+ // adminListEth = adminListEth.map((element: IEthCrossAccountId) => {
+ // return helper.address.convertCrossAccountFromEthCrossAcoount(element);
+ // });
+ // expect(adminListRpc).to.be.like(adminListEth);
+ // });
itEth('(!negative tests!) Add admin by ADMIN is not allowed', async ({helper}) => {
const owner = await helper.eth.createAccountWithBalance(donor);
tests/src/eth/collectionHelpersAbi.jsondiffbeforeafterboth--- a/tests/src/eth/collectionHelpersAbi.json
+++ b/tests/src/eth/collectionHelpersAbi.json
@@ -62,6 +62,18 @@
},
{
"inputs": [
+ { "internalType": "string", "name": "name", "type": "string" },
+ { "internalType": "uint8", "name": "decimals", "type": "uint8" },
+ { "internalType": "string", "name": "description", "type": "string" },
+ { "internalType": "string", "name": "tokenPrefix", "type": "string" }
+ ],
+ "name": "createRTCollection",
+ "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
+ "stateMutability": "payable",
+ "type": "function"
+ },
+ {
+ "inputs": [
{
"internalType": "address",
"name": "collectionAddress",
tests/src/eth/collectionProperties.test.tsdiffbeforeafterboth--- a/tests/src/eth/collectionProperties.test.ts
+++ b/tests/src/eth/collectionProperties.test.ts
@@ -14,9 +14,9 @@
// You should have received a copy of the GNU General Public License
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-import {itEth, usingEthPlaygrounds, expect, EthUniqueHelper, EthUniqueHelper} from './util';
+import {itEth, usingEthPlaygrounds, expect, EthUniqueHelper} from './util';
import {Pallets} from '../util';
-import {IProperty, ITokenPropertyPermission, TCollectionMode} from '../util/playgrounds/types';
+import {IProperty, ITokenPropertyPermission} from '../util/playgrounds/types';
import {IKeyringPair} from '@polkadot/types/types';
import {TCollectionMode} from '../util/playgrounds/types';
tests/src/eth/createFTCollection.test.tsdiffbeforeafterboth--- /dev/null
+++ b/tests/src/eth/createFTCollection.test.ts
@@ -0,0 +1,254 @@
+// 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 <http://www.gnu.org/licenses/>.
+
+import {IKeyringPair} from '@polkadot/types/types';
+import {Pallets, requirePalletsOrSkip} from '../util';
+import {expect, itEth, usingEthPlaygrounds} from './util';
+
+const DECIMALS = 18;
+
+describe('Create FT collection from EVM', () => {
+ let donor: IKeyringPair;
+
+ before(async function() {
+ await usingEthPlaygrounds(async (helper, privateKey) => {
+ requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
+ donor = await privateKey('//Alice');
+ });
+ });
+
+ itEth('Create collection', async ({helper}) => {
+ const owner = await helper.eth.createAccountWithBalance(donor);
+
+ const name = 'CollectionEVM';
+ const description = 'Some description';
+ const prefix = 'token prefix';
+
+ // todo:playgrounds this might fail when in async environment.
+ const collectionCountBefore = +(await helper.callRpc('api.rpc.unique.collectionStats')).created;
+
+ const collectionCreationPrice = helper.balance.getCollectionCreationPrice();
+ const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
+
+ const result = await collectionHelper.methods.createRTCollection(name, DECIMALS, description, prefix).call({value: Number(collectionCreationPrice)});
+ console.log(result);
+ const {collectionId} = await helper.eth.createFungibleCollection(owner, name, DECIMALS, description, prefix);
+ const collectionCountAfter = +(await helper.callRpc('api.rpc.unique.collectionStats')).created;
+
+ const data = (await helper.ft.getData(collectionId))!;
+
+ expect(collectionCountAfter - collectionCountBefore).to.be.eq(1);
+ expect(collectionId).to.be.eq(collectionCountAfter);
+ expect(data.name).to.be.eq(name);
+ expect(data.description).to.be.eq(description);
+ expect(data.raw.tokenPrefix).to.be.eq(prefix);
+ expect(data.raw.mode).to.be.deep.eq({Fungible: DECIMALS.toString()});
+ });
+
+ // // todo:playgrounds this test will fail when in async environment.
+ // itEth('Check collection address exist', async ({helper}) => {
+ // const owner = await helper.eth.createAccountWithBalance(donor);
+
+ // const expectedCollectionId = +(await helper.callRpc('api.rpc.unique.collectionStats')).created + 1;
+ // const expectedCollectionAddress = helper.ethAddress.fromCollectionId(expectedCollectionId);
+ // const collectionHelpers = helper.ethNativeContract.collectionHelpers(owner);
+
+ // expect(await collectionHelpers.methods
+ // .isCollectionExist(expectedCollectionAddress)
+ // .call()).to.be.false;
+
+ // await collectionHelpers.methods
+ // .createRFTCollection('A', 'A', 'A')
+ // .send({value: Number(2n * helper.balance.getOneTokenNominal())});
+
+ // expect(await collectionHelpers.methods
+ // .isCollectionExist(expectedCollectionAddress)
+ // .call()).to.be.true;
+ // });
+
+ // itEth('Set sponsorship', async ({helper}) => {
+ // const owner = await helper.eth.createAccountWithBalance(donor);
+ // const sponsor = await helper.eth.createAccountWithBalance(donor);
+ // const ss58Format = helper.chain.getChainProperties().ss58Format;
+ // const {collectionId, collectionAddress} = await helper.eth.createRefungibleCollection(owner, 'Sponsor', 'absolutely anything', 'ENVY');
+
+ // const collection = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);
+ // await collection.methods.setCollectionSponsor(sponsor).send();
+
+ // let data = (await helper.rft.getData(collectionId))!;
+ // expect(data.raw.sponsorship.Unconfirmed).to.be.equal(evmToAddress(sponsor, Number(ss58Format)));
+
+ // await expect(collection.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('caller is not set as sponsor');
+
+ // const sponsorCollection = helper.ethNativeContract.collection(collectionAddress, 'rft', sponsor);
+ // await sponsorCollection.methods.confirmCollectionSponsorship().send();
+
+ // data = (await helper.rft.getData(collectionId))!;
+ // expect(data.raw.sponsorship.Confirmed).to.be.equal(evmToAddress(sponsor, Number(ss58Format)));
+ // });
+
+ // itEth('Set limits', async ({helper}) => {
+ // const owner = await helper.eth.createAccountWithBalance(donor);
+ // const {collectionId, collectionAddress} = await helper.eth.createRefungibleCollection(owner, 'Limits', 'absolutely anything', 'INSI');
+ // const limits = {
+ // accountTokenOwnershipLimit: 1000,
+ // sponsoredDataSize: 1024,
+ // sponsoredDataRateLimit: 30,
+ // tokenLimit: 1000000,
+ // sponsorTransferTimeout: 6,
+ // sponsorApproveTimeout: 6,
+ // ownerCanTransfer: false,
+ // ownerCanDestroy: false,
+ // transfersEnabled: false,
+ // };
+
+ // const collection = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);
+ // await collection.methods['setCollectionLimit(string,uint32)']('accountTokenOwnershipLimit', limits.accountTokenOwnershipLimit).send();
+ // await collection.methods['setCollectionLimit(string,uint32)']('sponsoredDataSize', limits.sponsoredDataSize).send();
+ // await collection.methods['setCollectionLimit(string,uint32)']('sponsoredDataRateLimit', limits.sponsoredDataRateLimit).send();
+ // await collection.methods['setCollectionLimit(string,uint32)']('tokenLimit', limits.tokenLimit).send();
+ // await collection.methods['setCollectionLimit(string,uint32)']('sponsorTransferTimeout', limits.sponsorTransferTimeout).send();
+ // await collection.methods['setCollectionLimit(string,uint32)']('sponsorApproveTimeout', limits.sponsorApproveTimeout).send();
+ // await collection.methods['setCollectionLimit(string,bool)']('ownerCanTransfer', limits.ownerCanTransfer).send();
+ // await collection.methods['setCollectionLimit(string,bool)']('ownerCanDestroy', limits.ownerCanDestroy).send();
+ // await collection.methods['setCollectionLimit(string,bool)']('transfersEnabled', limits.transfersEnabled).send();
+
+ // const data = (await helper.rft.getData(collectionId))!;
+ // expect(data.raw.limits.accountTokenOwnershipLimit).to.be.eq(limits.accountTokenOwnershipLimit);
+ // expect(data.raw.limits.sponsoredDataSize).to.be.eq(limits.sponsoredDataSize);
+ // expect(data.raw.limits.sponsoredDataRateLimit.blocks).to.be.eq(limits.sponsoredDataRateLimit);
+ // expect(data.raw.limits.tokenLimit).to.be.eq(limits.tokenLimit);
+ // expect(data.raw.limits.sponsorTransferTimeout).to.be.eq(limits.sponsorTransferTimeout);
+ // expect(data.raw.limits.sponsorApproveTimeout).to.be.eq(limits.sponsorApproveTimeout);
+ // expect(data.raw.limits.ownerCanTransfer).to.be.eq(limits.ownerCanTransfer);
+ // expect(data.raw.limits.ownerCanDestroy).to.be.eq(limits.ownerCanDestroy);
+ // expect(data.raw.limits.transfersEnabled).to.be.eq(limits.transfersEnabled);
+ // });
+
+ // itEth('Collection address exist', async ({helper}) => {
+ // const owner = await helper.eth.createAccountWithBalance(donor);
+ // const collectionAddressForNonexistentCollection = '0x17C4E6453CC49AAAAEACA894E6D9683E00112233';
+ // expect(await helper.ethNativeContract.collectionHelpers(collectionAddressForNonexistentCollection)
+ // .methods.isCollectionExist(collectionAddressForNonexistentCollection).call())
+ // .to.be.false;
+
+ // const {collectionAddress} = await helper.eth.createRefungibleCollection(owner, 'Exister', 'absolutely anything', 'WIWT');
+ // expect(await helper.ethNativeContract.collectionHelpers(collectionAddress)
+ // .methods.isCollectionExist(collectionAddress).call())
+ // .to.be.true;
+ // });
+});
+
+// describe('(!negative tests!) Create RFT collection from EVM', () => {
+// let donor: IKeyringPair;
+// let nominal: bigint;
+
+// before(async function() {
+// await usingEthPlaygrounds(async (helper, privateKey) => {
+// requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
+// donor = privateKey('//Alice');
+// nominal = helper.balance.getOneTokenNominal();
+// });
+// });
+
+// itEth('(!negative test!) Create collection (bad lengths)', async ({helper}) => {
+// const owner = await helper.eth.createAccountWithBalance(donor);
+// const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
+// {
+// const MAX_NAME_LENGTH = 64;
+// const collectionName = 'A'.repeat(MAX_NAME_LENGTH + 1);
+// const description = 'A';
+// const tokenPrefix = 'A';
+
+// await expect(collectionHelper.methods
+// .createRFTCollection(collectionName, description, tokenPrefix)
+// .call({value: Number(2n * nominal)})).to.be.rejectedWith('name is too long. Max length is ' + MAX_NAME_LENGTH);
+// }
+// {
+// const MAX_DESCRIPTION_LENGTH = 256;
+// const collectionName = 'A';
+// const description = 'A'.repeat(MAX_DESCRIPTION_LENGTH + 1);
+// const tokenPrefix = 'A';
+// await expect(collectionHelper.methods
+// .createRFTCollection(collectionName, description, tokenPrefix)
+// .call({value: Number(2n * nominal)})).to.be.rejectedWith('description is too long. Max length is ' + MAX_DESCRIPTION_LENGTH);
+// }
+// {
+// const MAX_TOKEN_PREFIX_LENGTH = 16;
+// const collectionName = 'A';
+// const description = 'A';
+// const tokenPrefix = 'A'.repeat(MAX_TOKEN_PREFIX_LENGTH + 1);
+// await expect(collectionHelper.methods
+// .createRFTCollection(collectionName, description, tokenPrefix)
+// .call({value: Number(2n * nominal)})).to.be.rejectedWith('token_prefix is too long. Max length is ' + MAX_TOKEN_PREFIX_LENGTH);
+// }
+// });
+
+// itEth('(!negative test!) Create collection (no funds)', async ({helper}) => {
+// const owner = await helper.eth.createAccountWithBalance(donor);
+// const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
+// await expect(collectionHelper.methods
+// .createRFTCollection('Peasantry', 'absolutely anything', 'TWIW')
+// .call({value: Number(1n * nominal)})).to.be.rejectedWith('Sent amount not equals to collection creation price (2000000000000000000)');
+// });
+
+// itEth('(!negative test!) Check owner', async ({helper}) => {
+// const owner = await helper.eth.createAccountWithBalance(donor);
+// const peasant = helper.eth.createAccount();
+// const {collectionAddress} = await helper.eth.createRefungibleCollection(owner, 'Transgressed', 'absolutely anything', 'YVNE');
+// const peasantCollection = helper.ethNativeContract.collection(collectionAddress, 'rft', peasant);
+// const EXPECTED_ERROR = 'NoPermission';
+// {
+// const sponsor = await helper.eth.createAccountWithBalance(donor);
+// await expect(peasantCollection.methods
+// .setCollectionSponsor(sponsor)
+// .call()).to.be.rejectedWith(EXPECTED_ERROR);
+
+// const sponsorCollection = helper.ethNativeContract.collection(collectionAddress, 'rft', sponsor);
+// await expect(sponsorCollection.methods
+// .confirmCollectionSponsorship()
+// .call()).to.be.rejectedWith('caller is not set as sponsor');
+// }
+// {
+// await expect(peasantCollection.methods
+// .setCollectionLimit('account_token_ownership_limit', '1000')
+// .call()).to.be.rejectedWith(EXPECTED_ERROR);
+// }
+// });
+
+// itEth('(!negative test!) Set limits', async ({helper}) => {
+// const owner = await helper.eth.createAccountWithBalance(donor);
+// const {collectionAddress} = await helper.eth.createRefungibleCollection(owner, 'Limits', 'absolutely anything', 'ISNI');
+// const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);
+// await expect(collectionEvm.methods
+// .setCollectionLimit('badLimit', 'true')
+// .call()).to.be.rejectedWith('unknown boolean limit "badLimit"');
+// });
+
+// itEth('destroyCollection test', async ({helper}) => {
+// const owner = await helper.eth.createAccountWithBalance(donor);
+// const {collectionAddress} = await helper.eth.createRefungibleCollection(owner, 'Limits', 'absolutely anything', 'OLF');
+// const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
+
+// await expect(collectionHelper.methods
+// .destroyCollection(collectionAddress)
+// .send({from: owner})).to.be.fulfilled;
+
+// expect(await collectionHelper.methods
+// .isCollectionExist(collectionAddress)
+// .call()).to.be.false;
+// });
+// });
tests/src/eth/util/playgrounds/unique.dev.tsdiffbeforeafterboth--- a/tests/src/eth/util/playgrounds/unique.dev.ts
+++ b/tests/src/eth/util/playgrounds/unique.dev.ts
@@ -202,10 +202,24 @@
return {collectionId, collectionAddress, events};
}
- async createRFTCollection(signer: string, name: string, description: string, tokenPrefix: string): Promise<{collectionId: number, collectionAddress: string}> {
+ async createRFTCollection(signer: string, name: string, description: string, tokenPrefix: string): Promise<{collectionId: number, collectionAddress: string, events: NormalizedEvent[]}> {
return this.createCollecion('createRFTCollection', signer, name, description, tokenPrefix);
}
+
+ async createFungibleCollection(signer: string, name: string, decimals: number, description: string, tokenPrefix: string): Promise<{ collectionId: number, collectionAddress: string, events: NormalizedEvent[]}> {
+ const collectionCreationPrice = this.helper.balance.getCollectionCreationPrice();
+ const collectionHelper = this.helper.ethNativeContract.collectionHelpers(signer);
+
+ const result = await collectionHelper.methods.createRTCollection(name, decimals, description, tokenPrefix).send({value: Number(collectionCreationPrice)});
+ const collectionAddress = this.helper.ethAddress.normalizeAddress(result.events.CollectionCreated.returnValues.collectionId);
+ const collectionId = this.helper.ethAddress.extractCollectionId(collectionAddress);
+
+ const events = this.helper.eth.normalizeEvents(result.events);
+
+ return {collectionId, collectionAddress, events};
+ }
+
async createERC721MetadataCompatibleRFTCollection(signer: string, name: string, description: string, tokenPrefix: string, baseUri: string): Promise<{collectionId: number, collectionAddress: string, events: NormalizedEvent[] }> {
const collectionHelper = this.helper.ethNativeContract.collectionHelpers(signer);