git.delta.rocks / unique-network / refs/commits / c9f3344fa8b9

difftreelog

test Initial eth playgrounds

Andrey2022-09-04parent: #21a2ff1.patch.diff
in: master

4 files changed

modifiedtests/package.jsondiffbeforeafterboth
--- a/tests/package.json
+++ b/tests/package.json
@@ -79,7 +79,8 @@
     "testBlockProduction": "mocha --timeout 9999999 -r ts-node/register ./**/block-production.test.ts",
     "testEnableDisableTransfers": "mocha --timeout 9999999 -r ts-node/register ./**/enableDisableTransfer.test.ts",
     "testLimits": "mocha --timeout 9999999 -r ts-node/register ./**/limits.test.ts",
-    "testEthCreateCollection": "mocha --timeout 9999999 -r ts-node/register ./**/eth/createCollection.test.ts",
+    "testEthCreateNFTCollection": "mocha --timeout 9999999 -r ts-node/register ./**/eth/createNFTCollection.test.ts",
+    "testEthCreateRFTCollection": "mocha --timeout 9999999 -r ts-node/register ./**/eth/createRFTCollection.test.ts",
     "testRFT": "mocha --timeout 9999999 -r ts-node/register ./**/refungible.test.ts",
     "testFT": "mocha --timeout 9999999 -r ts-node/register ./**/fungible.test.ts",
     "testRPC": "mocha --timeout 9999999 -r ts-node/register ./**/rpc.test.ts",
modifiedtests/src/eth/nesting/nest.test.tsdiffbeforeafterboth
1import {ApiPromise} from '@polkadot/api';1import {IKeyringPair} from '@polkadot/types/types';
2import {Contract} from 'web3-eth-contract';2import {Contract} from 'web3-eth-contract';
3import {expect} from 'chai';3
4import Web3 from 'web3';
5import {createEthAccountWithBalance, evmCollectionHelpers, GAS_ARGS, getCollectionAddressFromResult, itWeb3, tokenIdToAddress} from '../../eth/util/helpers';4import {itEth, EthUniqueHelper, usingEthPlaygrounds, expect} from '../util/playgrounds'
6import nonFungibleAbi from '../nonFungibleAbi.json';
75
8const createNestingCollection = async (6const createNestingCollection = async (
9  api: ApiPromise,7  helper: EthUniqueHelper,
10  web3: Web3,
11  owner: string,8  owner: string,
12): Promise<{ collectionId: number, collectionAddress: string, contract: Contract }> => {9): Promise<{ collectionId: number, collectionAddress: string, contract: Contract }> => {
13  const collectionHelper = evmCollectionHelpers(web3, owner);
14        
15  const result = await collectionHelper.methods10  const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
16    .createNonfungibleCollection('A', 'B', 'C')
17    .send();
18  const {collectionIdAddress: collectionAddress, collectionId} = await getCollectionAddressFromResult(api, result);
1911
20  const contract = new web3.eth.Contract(nonFungibleAbi as any, collectionAddress, {from: owner, ...GAS_ARGS});12  const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
21  await contract.methods.setCollectionNesting(true).send({from: owner});13  await contract.methods.setCollectionNesting(true).send({from: owner});
2214
23  return {collectionId, collectionAddress, contract};15  return {collectionId, collectionAddress, contract};
24};16};
2517
26describe('Integration Test: EVM Nesting', () => {
27  itWeb3('NFT: allows an Owner to nest/unnest their token', async ({api, web3, privateKeyWrapper}) => {
28    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
29    const {collectionId, contract} = await createNestingCollection(api, web3, owner);
30
31    // Create a token to be nested
32    const targetNFTTokenId = await contract.methods.nextTokenId().call();
33    await contract.methods.mint(
34      owner,
35      targetNFTTokenId,
36    ).send({from: owner});
37
38    const targetNftTokenAddress = tokenIdToAddress(collectionId, targetNFTTokenId);
39
40    // Create a nested token
41    const firstTokenId = await contract.methods.nextTokenId().call();
42    await contract.methods.mint(
43      targetNftTokenAddress,
44      firstTokenId,
45    ).send({from: owner});
46
47    expect(await contract.methods.ownerOf(firstTokenId).call()).to.be.equal(targetNftTokenAddress);
48
49    // Create a token to be nested and nest
50    const secondTokenId = await contract.methods.nextTokenId().call();
51    await contract.methods.mint(
52      owner,
53      secondTokenId,
54    ).send({from: owner});
55
56    await contract.methods.transfer(targetNftTokenAddress, secondTokenId).send({from: owner});
57
58    expect(await contract.methods.ownerOf(secondTokenId).call()).to.be.equal(targetNftTokenAddress);
59
60    // Unnest token back
61    await contract.methods.transferFrom(targetNftTokenAddress, owner, secondTokenId).send({from: owner});
62    expect(await contract.methods.ownerOf(secondTokenId).call()).to.be.equal(owner);
63  });
64
65  itWeb3('NFT: allows an Owner to nest/unnest their token (Restricted nesting)', async ({api, web3, privateKeyWrapper}) => {
66    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
67
68    const {collectionId: collectionIdA, collectionAddress: collectionAddressA, contract: contractA} = await createNestingCollection(api, web3, owner);
69    const {collectionAddress: collectionAddressB, contract: contractB} = await createNestingCollection(api, web3, owner);
70    await contractA.methods.setCollectionNesting(true, [collectionAddressA, collectionAddressB]).send({from: owner});
71
72    // Create a token to nest into
73    const targetNftTokenId = await contractA.methods.nextTokenId().call();
74    await contractA.methods.mint(
75      owner,
76      targetNftTokenId,
77    ).send({from: owner});
78    const nftTokenAddressA1 = tokenIdToAddress(collectionIdA, targetNftTokenId);
79
80    // Create a token for nesting in the same collection as the target
81    const nftTokenIdA = await contractA.methods.nextTokenId().call();
82    await contractA.methods.mint(
83      owner,
84      nftTokenIdA,
85    ).send({from: owner});
86
87    // Create a token for nesting in a different collection
88    const nftTokenIdB = await contractB.methods.nextTokenId().call();
89    await contractB.methods.mint(
90      owner,
91      nftTokenIdB,
92    ).send({from: owner});
93
94    // Nest
95    await contractA.methods.transfer(nftTokenAddressA1, nftTokenIdA).send({from: owner});
96    expect(await contractA.methods.ownerOf(nftTokenIdA).call()).to.be.equal(nftTokenAddressA1);
97
98    await contractB.methods.transfer(nftTokenAddressA1, nftTokenIdB).send({from: owner});
99    expect(await contractB.methods.ownerOf(nftTokenIdB).call()).to.be.equal(nftTokenAddressA1);
100  });
101});
10218
103describe('Negative Test: EVM Nesting', async() => {19describe('EVM nesting tests group', () => {
20  let donor: IKeyringPair;
21
22  before(async function() {
23    await usingEthPlaygrounds(async (helper, privateKey) => {
24      donor = privateKey('//Alice');
25    });
26  });
27
28  describe('Integration Test: EVM Nesting', () => {
29    itEth('NFT: allows an Owner to nest/unnest their token', async ({helper}) => {
30      const owner = await helper.eth.createAccountWithBalance(donor);
31      const {collectionId, contract} = await createNestingCollection(helper, owner);
32  
33      // Create a token to be nested
34      const targetNFTTokenId = await contract.methods.nextTokenId().call();
35      await contract.methods.mint(
36        owner,
37        targetNFTTokenId,
38      ).send({from: owner});
39  
40      const targetNftTokenAddress = helper.ethAddress.fromTokenId(collectionId, targetNFTTokenId);
41  
42      // Create a nested token
43      const firstTokenId = await contract.methods.nextTokenId().call();
44      await contract.methods.mint(
45        targetNftTokenAddress,
46        firstTokenId,
47      ).send({from: owner});
48  
49      expect(await contract.methods.ownerOf(firstTokenId).call()).to.be.equal(targetNftTokenAddress);
50  
51      // Create a token to be nested and nest
52      const secondTokenId = await contract.methods.nextTokenId().call();
53      await contract.methods.mint(
54        owner,
55        secondTokenId,
56      ).send({from: owner});
57  
58      await contract.methods.transfer(targetNftTokenAddress, secondTokenId).send({from: owner});
59  
60      expect(await contract.methods.ownerOf(secondTokenId).call()).to.be.equal(targetNftTokenAddress);
61  
62      // Unnest token back
63      await contract.methods.transferFrom(targetNftTokenAddress, owner, secondTokenId).send({from: owner});
64      expect(await contract.methods.ownerOf(secondTokenId).call()).to.be.equal(owner);
65    });
66  
67    itEth('NFT: allows an Owner to nest/unnest their token (Restricted nesting)', async ({helper}) => {
68      const owner = await helper.eth.createAccountWithBalance(donor);
69  
70      const {collectionId: collectionIdA, collectionAddress: collectionAddressA, contract: contractA} = await createNestingCollection(helper, owner);
71      const {collectionAddress: collectionAddressB, contract: contractB} = await createNestingCollection(helper, owner);
72      await contractA.methods.setCollectionNesting(true, [collectionAddressA, collectionAddressB]).send({from: owner});
73  
74      // Create a token to nest into
75      const targetNftTokenId = await contractA.methods.nextTokenId().call();
76      await contractA.methods.mint(
77        owner,
78        targetNftTokenId,
79      ).send({from: owner});
80      const nftTokenAddressA1 = helper.ethAddress.fromTokenId(collectionIdA, targetNftTokenId);
81  
82      // Create a token for nesting in the same collection as the target
83      const nftTokenIdA = await contractA.methods.nextTokenId().call();
84      await contractA.methods.mint(
85        owner,
86        nftTokenIdA,
87      ).send({from: owner});
88  
89      // Create a token for nesting in a different collection
90      const nftTokenIdB = await contractB.methods.nextTokenId().call();
91      await contractB.methods.mint(
92        owner,
93        nftTokenIdB,
94      ).send({from: owner});
95  
96      // Nest
97      await contractA.methods.transfer(nftTokenAddressA1, nftTokenIdA).send({from: owner});
98      expect(await contractA.methods.ownerOf(nftTokenIdA).call()).to.be.equal(nftTokenAddressA1);
99  
100      await contractB.methods.transfer(nftTokenAddressA1, nftTokenIdB).send({from: owner});
101      expect(await contractB.methods.ownerOf(nftTokenIdB).call()).to.be.equal(nftTokenAddressA1);
102    });
103  });
104
105  describe('Negative Test: EVM Nesting', async() => {
104  itWeb3('NFT: disallows to nest token if nesting is disabled', async ({api, web3, privateKeyWrapper}) => {106    itEth('NFT: disallows to nest token if nesting is disabled', async ({helper}) => {
105    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);107      const owner = await helper.eth.createAccountWithBalance(donor);
106108  
107    const {collectionId, contract} = await createNestingCollection(api, web3, owner);109      const {collectionId, contract} = await createNestingCollection(helper, owner);
108    await contract.methods.setCollectionNesting(false).send({from: owner});110      await contract.methods.setCollectionNesting(false).send({from: owner});
109111  
110    // Create a token to nest into112      // Create a token to nest into
114      targetNftTokenId,116        targetNftTokenId,
115    ).send({from: owner});117      ).send({from: owner});
116118  
117    const targetNftTokenAddress = tokenIdToAddress(collectionId, targetNftTokenId);119      const targetNftTokenAddress = helper.ethAddress.fromTokenId(collectionId, targetNftTokenId);
118120  
119    // Create a token to nest121      // Create a token to nest
120    const nftTokenId = await contract.methods.nextTokenId().call();122      const nftTokenId = await contract.methods.nextTokenId().call();
129      .call({from: owner})).to.be.rejectedWith('UserIsNotAllowedToNest');131        .call({from: owner})).to.be.rejectedWith('UserIsNotAllowedToNest');
130  });132    });
131133  
132  itWeb3('NFT: disallows a non-Owner to nest someone else\'s token', async ({api, web3, privateKeyWrapper}) => {134    itEth('NFT: disallows a non-Owner to nest someone else\'s token', async ({helper}) => {
133    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);135      const owner = await helper.eth.createAccountWithBalance(donor);
134    const malignant = await createEthAccountWithBalance(api, web3, privateKeyWrapper);136      const malignant = await helper.eth.createAccountWithBalance(donor);
135137  
136    const {collectionId, contract} = await createNestingCollection(api, web3, owner);138      const {collectionId, contract} = await createNestingCollection(helper, owner);
137139  
138    // Mint a token140      // Mint a token
139    const targetTokenId = await contract.methods.nextTokenId().call();141      const targetTokenId = await contract.methods.nextTokenId().call();
140    await contract.methods.mint(142      await contract.methods.mint(
141      owner,143        owner,
142      targetTokenId,144        targetTokenId,
143    ).send({from: owner});145      ).send({from: owner});
144    const targetTokenAddress = tokenIdToAddress(collectionId, targetTokenId);146      const targetTokenAddress = helper.ethAddress.fromTokenId(collectionId, targetTokenId);
145147  
146    // Mint a token belonging to a different account148      // Mint a token belonging to a different account
147    const tokenId = await contract.methods.nextTokenId().call();149      const tokenId = await contract.methods.nextTokenId().call();
156      .call({from: malignant})).to.be.rejectedWith('UserIsNotAllowedToNest');158        .call({from: malignant})).to.be.rejectedWith('UserIsNotAllowedToNest');
157  });159    });
158160  
159  itWeb3('NFT: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async ({api, web3, privateKeyWrapper}) => {161    itEth('NFT: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async ({helper}) => {
160    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);162      const owner = await helper.eth.createAccountWithBalance(donor);
161    const malignant = await createEthAccountWithBalance(api, web3, privateKeyWrapper);163      const malignant = await helper.eth.createAccountWithBalance(donor);
162164  
163    const {collectionId: collectionIdA, collectionAddress: collectionAddressA, contract: contractA} = await createNestingCollection(api, web3, owner);165      const {collectionId: collectionIdA, collectionAddress: collectionAddressA, contract: contractA} = await createNestingCollection(helper, owner);
164    const {collectionAddress: collectionAddressB, contract: contractB} = await createNestingCollection(api, web3, owner);166      const {collectionAddress: collectionAddressB, contract: contractB} = await createNestingCollection(helper, owner);
165167  
166    await contractA.methods.setCollectionNesting(true, [collectionAddressA, collectionAddressB]).send({from: owner});168      await contractA.methods.setCollectionNesting(true, [collectionAddressA, collectionAddressB]).send({from: owner});
167169  
171      owner,173        owner,
172      nftTokenIdA,174        nftTokenIdA,
173    ).send({from: owner});175      ).send({from: owner});
174    const nftTokenAddressA = tokenIdToAddress(collectionIdA, nftTokenIdA);176      const nftTokenAddressA = helper.ethAddress.fromTokenId(collectionIdA, nftTokenIdA);
175177  
176    // Create a token in another collection belonging to someone else178      // Create a token in another collection belonging to someone else
177    const nftTokenIdB = await contractB.methods.nextTokenId().call();179      const nftTokenIdB = await contractB.methods.nextTokenId().call();
186      .call({from: malignant})).to.be.rejectedWith('UserIsNotAllowedToNest');188        .call({from: malignant})).to.be.rejectedWith('UserIsNotAllowedToNest');
187  });189    });
188190  
189  itWeb3('NFT: disallows to nest token in an unlisted collection', async ({api, web3, privateKeyWrapper}) => {191    itEth('NFT: disallows to nest token in an unlisted collection', async ({helper}) => {
190    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);192      const owner = await helper.eth.createAccountWithBalance(donor);
191193  
192    const {collectionId: collectionIdA, collectionAddress: collectionAddressA, contract: contractA} = await createNestingCollection(api, web3, owner);194      const {collectionId: collectionIdA, collectionAddress: collectionAddressA, contract: contractA} = await createNestingCollection(helper, owner);
193    const {contract: contractB} = await createNestingCollection(api, web3, owner);195      const {contract: contractB} = await createNestingCollection(helper, owner);
194196  
195    await contractA.methods.setCollectionNesting(true, [collectionAddressA]).send({from: owner});197      await contractA.methods.setCollectionNesting(true, [collectionAddressA]).send({from: owner});
196198  
200      owner,202        owner,
201      nftTokenIdA,203        nftTokenIdA,
202    ).send({from: owner});204      ).send({from: owner});
203    const nftTokenAddressA = tokenIdToAddress(collectionIdA, nftTokenIdA);205      const nftTokenAddressA = helper.ethAddress.fromTokenId(collectionIdA, nftTokenIdA);
204206  
205    // Create a token in another collection207      // Create a token in another collection
206    const nftTokenIdB = await contractB.methods.nextTokenId().call();208      const nftTokenIdB = await contractB.methods.nextTokenId().call();
214      .transfer(nftTokenAddressA, nftTokenIdB)216        .transfer(nftTokenAddressA, nftTokenIdB)
215      .call()).to.be.rejectedWith('SourceCollectionIsNotAllowedToNest');217        .call()).to.be.rejectedWith('SourceCollectionIsNotAllowedToNest');
216  });218    });
217});219  });
220});
218221
addedtests/src/eth/util/playgrounds/index.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/eth/util/playgrounds/index.ts
@@ -0,0 +1,67 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+import {IKeyringPair} from '@polkadot/types/types';
+
+import config from '../../../config';
+
+import {EthUniqueHelper} from './unique.dev';
+import {SilentLogger} from '../../../util/playgrounds/unique.dev';
+
+export {EthUniqueHelper} from './unique.dev';
+
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+chai.use(chaiAsPromised);
+export const expect = chai.expect;
+
+export const usingEthPlaygrounds = async (code: (helper: EthUniqueHelper, privateKey: (seed: string) => IKeyringPair) => Promise<void>) => {
+  // TODO: Remove, this is temporary: Filter unneeded API output
+  // (Jaco promised it will be removed in the next version)
+  const consoleErr = console.error;
+  const consoleLog = console.log;
+  const consoleWarn = console.warn;
+
+  const outFn = (printer: any) => (...args: any[]) => {
+    for (const arg of args) {
+      if (typeof arg !== 'string')
+        continue;
+      if (arg.includes('1000:: Normal connection closure') || arg.includes('Not decorating unknown runtime apis: UniqueApi/2, RmrkApi/1') || arg.includes('RPC methods not decorated:') || arg === 'Normal connection closure')
+        return;
+    }
+    printer(...args);
+  };
+
+  console.error = outFn(consoleErr.bind(console));
+  console.log = outFn(consoleLog.bind(console));
+  console.warn = outFn(consoleWarn.bind(console));
+  const helper = new EthUniqueHelper(new SilentLogger());
+
+  try {
+    await helper.connect(config.substrateUrl);
+    await helper.connectWeb3(config.substrateUrl);
+    const ss58Format = helper.chain.getChainProperties().ss58Format;
+    const privateKey = (seed: string) => helper.util.fromSeed(seed, ss58Format);
+    await code(helper, privateKey);
+  }
+  finally {
+    await helper.disconnect();
+    await helper.disconnectWeb3();
+    console.error = consoleErr;
+    console.log = consoleLog;
+    console.warn = consoleWarn;
+  }
+}
+  
+export async function itEth(name: string, cb: (apis: { helper: EthUniqueHelper, privateKey: (seed: string) => IKeyringPair }) => any, opts: { only?: boolean, skip?: boolean } = {}) {
+  let i: any = it;
+  if (opts.only) i = i.only;
+  else if (opts.skip) i = i.skip;
+  i(name, async () => {
+    await usingEthPlaygrounds(async (helper, privateKey) => {
+      await cb({helper, privateKey});
+    });
+  });
+}
+itEth.only = (name: string, cb: (apis: { helper: EthUniqueHelper, privateKey: (seed: string) => IKeyringPair }) => any) => itEth(name, cb, {only: true});
+itEth.skip = (name: string, cb: (apis: { helper: EthUniqueHelper, privateKey: (seed: string) => IKeyringPair }) => any) => itEth(name, cb, {skip: true});
\ No newline at end of file
addedtests/src/eth/util/playgrounds/unique.dev.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/eth/util/playgrounds/unique.dev.ts
@@ -0,0 +1,162 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable function-call-argument-newline */
+
+import Web3 from 'web3';
+import {WebsocketProvider} from 'web3-core';
+import {Contract} from 'web3-eth-contract';
+
+import {evmToAddress} from '@polkadot/util-crypto';
+import {IKeyringPair} from '@polkadot/types/types';
+
+import {DevUniqueHelper} from '../../../util/playgrounds/unique.dev';
+
+// Native contracts ABI
+import collectionHelpersAbi from '../../collectionHelpersAbi.json';
+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';
+
+class EthGroupBase {
+  helper: EthUniqueHelper;
+
+  constructor(helper: EthUniqueHelper) {
+    this.helper = helper;
+  }
+}
+  
+  
+class NativeContractGroup extends EthGroupBase {
+  DEFAULT_GAS = 2_500_000;
+
+  contractHelpers(caller: string): Contract {
+    const web3 = this.helper.getWeb3();
+    return new web3.eth.Contract(contractHelpersAbi as any, '0x842899ECF380553E8a4de75bF534cdf6fBF64049', {from: caller, gas: this.DEFAULT_GAS});
+  }
+
+  collectionHelpers(caller: string) {
+    const web3 = this.helper.getWeb3();
+    return new web3.eth.Contract(collectionHelpersAbi as any, '0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f', {from: caller, gas: this.DEFAULT_GAS});
+  }
+
+  collection(address: string, mode: 'nft' | 'rft' | 'ft', caller?: string): Contract {
+    const abi = {
+      'nft': nonFungibleAbi,
+      'rft': refungibleAbi,
+      'ft': fungibleAbi
+    }[mode];
+    const web3 = this.helper.getWeb3();
+    return new web3.eth.Contract(abi as any, address, {gas: this.DEFAULT_GAS, ...(caller ? {from: caller} : {})});
+  }
+
+  rftTokenByAddress(address: string, caller?: string): Contract {
+    const web3 = this.helper.getWeb3();
+    return new web3.eth.Contract(refungibleTokenAbi as any, address, {gas: this.DEFAULT_GAS, ...(caller ? {from: caller} : {})});
+  }
+
+  rftToken(collectionId: number, tokenId: number, caller?: string): Contract {
+    return this.rftTokenByAddress(this.helper.ethAddress.fromTokenId(collectionId, tokenId), caller);
+  }
+}
+
+  
+class EthGroup extends EthGroupBase {
+  createAccount() {
+    const web3 = this.helper.getWeb3();
+    const account = web3.eth.accounts.create();
+    web3.eth.accounts.wallet.add(account.privateKey);
+    return account.address;
+  }
+
+  async createAccountWithBalance(donor: IKeyringPair, amount=1000n) {
+    const account = this.createAccount();
+    await this.transferBalanceFromSubstrate(donor, account, amount);
+  
+    return account;
+  }
+
+  async transferBalanceFromSubstrate(donor: IKeyringPair, recepient: string, amount=1000n) {
+    return await this.helper.balance.transferToSubstrate(donor, evmToAddress(recepient), amount * this.helper.balance.getOneTokenNominal());
+  }
+
+  async createNonfungibleCollection(signer: string, name: string, description: string, tokenPrefix: string): Promise<{collectionId: number, collectionAddress: string}> {
+    const collectionHelper = this.helper.ethNativeContract.collectionHelpers(signer);
+        
+    const result = await collectionHelper.methods.createNonfungibleCollection(name, description, tokenPrefix).send();
+
+    const collectionAddress = this.helper.ethAddress.normalizeAddress(result.events.CollectionCreated.returnValues.collectionId);
+    const collectionId = this.helper.ethAddress.extractCollectionId(collectionAddress);
+
+    return {collectionId, collectionAddress};
+  }
+}
+  
+  
+class EthAddressGroup extends EthGroupBase {
+  extractCollectionId(address: string): number {
+    if (!(address.length === 42 || address.length === 40)) throw new Error('address wrong format');
+    return parseInt(address.substr(address.length - 8), 16);
+  }
+
+  fromCollectionId(collectionId: number): string {
+    if (collectionId >= 0xffffffff || collectionId < 0) throw new Error('collectionId overflow');
+    return Web3.utils.toChecksumAddress(`0x17c4e6453cc49aaaaeaca894e6d9683e${collectionId.toString(16).padStart(8, '0')}`);
+  }
+
+  extractTokenId(address: string): {collectionId: number, tokenId: number} {
+    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)),
+    };
+  }
+
+  fromTokenId(collectionId: number, tokenId: number): string  {
+    return this.helper.util.getNestingTokenAddress(collectionId, tokenId);
+  }
+
+  normalizeAddress(address: string): string {
+    return '0x' + address.substring(address.length - 40);
+  }
+}  
+ 
+
+export class EthUniqueHelper extends DevUniqueHelper {
+  web3: Web3 | null = null;
+  web3Provider: WebsocketProvider | null = null;
+
+  eth: EthGroup;
+  ethAddress: EthAddressGroup;
+  ethNativeContract: NativeContractGroup;
+
+  constructor(logger: { log: (msg: any, level: any) => void, level: any }) {
+    super(logger);
+    this.eth = new EthGroup(this);
+    this.ethAddress = new EthAddressGroup(this);
+    this.ethNativeContract = new NativeContractGroup(this);
+  }
+
+  getWeb3(): Web3 {
+    if(this.web3 === null) throw Error('Web3 not connected');
+    return this.web3;
+  }
+
+  async connectWeb3(wsEndpoint: string) {
+    if(this.web3 !== null) return;
+    this.web3Provider = new Web3.providers.WebsocketProvider(wsEndpoint);
+    this.web3 = new Web3(this.web3Provider);
+  }
+
+  async disconnectWeb3() {
+    if(this.web3 === null) return;
+    this.web3Provider?.connection.close();
+    this.web3 = null;
+  }
+}
+  
\ No newline at end of file