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

87    "testLimits": "mocha --timeout 9999999 -r ts-node/register ./**/limits.test.ts",87    "testLimits": "mocha --timeout 9999999 -r ts-node/register ./**/limits.test.ts",
88    "testEthCreateNFTCollection": "mocha --timeout 9999999 -r ts-node/register ./**/eth/createNFTCollection.test.ts",88    "testEthCreateNFTCollection": "mocha --timeout 9999999 -r ts-node/register ./**/eth/createNFTCollection.test.ts",
89    "testEthCreateRFTCollection": "mocha --timeout 9999999 -r ts-node/register ./**/eth/createRFTCollection.test.ts",89    "testEthCreateRFTCollection": "mocha --timeout 9999999 -r ts-node/register ./**/eth/createRFTCollection.test.ts",
90    "testEthNFT": "mocha --timeout 9999999 -r ts-node/register ./**/eth/nonFungible.test.ts",
90    "testRFT": "mocha --timeout 9999999 -r ts-node/register ./**/refungible.test.ts",91    "testRFT": "mocha --timeout 9999999 -r ts-node/register ./**/refungible.test.ts",
92    "testEthRFT": "mocha --timeout 9999999 -r ts-node/register ./**/eth/reFungible.test.ts ./**/eth/reFungibleToken.test.ts",
91    "testFT": "mocha --timeout 9999999 -r ts-node/register ./**/fungible.test.ts",93    "testFT": "mocha --timeout 9999999 -r ts-node/register ./**/fungible.test.ts",
94    "testEthFT": "mocha --timeout 9999999 -r ts-node/register ./**/eth/fungible.test.ts",
92    "testRPC": "mocha --timeout 9999999 -r ts-node/register ./**/rpc.test.ts",95    "testRPC": "mocha --timeout 9999999 -r ts-node/register ./**/rpc.test.ts",
93    "testPromotion": "mocha --timeout 9999999 -r ts-node/register ./**/app-promotion.test.ts",96    "testPromotion": "mocha --timeout 9999999 -r ts-node/register ./**/app-promotion.test.ts",
94    "polkadot-types-fetch-metadata": "curl -H 'Content-Type: application/json' -d '{\"id\":\"1\", \"jsonrpc\":\"2.0\", \"method\": \"state_getMetadata\", \"params\":[]}' http://localhost:9933 > src/interfaces/metadata.json",97    "polkadot-types-fetch-metadata": "curl -H 'Content-Type: application/json' -d '{\"id\":\"1\", \"jsonrpc\":\"2.0\", \"method\": \"state_getMetadata\", \"params\":[]}' http://localhost:9933 > src/interfaces/metadata.json",

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import {approveExpectSuccess, createCollection, createCollectionExpectSuccess, createFungibleItemExpectSuccess, transferExpectSuccess, transferFromExpectSuccess, UNIQUE} from '../util/helpers';17import {expect, itEth, usingEthPlaygrounds} from './util/playgrounds';
18import {collectionIdToAddress, createEthAccount, createEthAccountWithBalance, evmCollection, GAS_ARGS, itWeb3, normalizeEvents, recordEthFee, recordEvents, subToEth, transferBalanceToEth} from './util/helpers';18import {IKeyringPair} from '@polkadot/types/types';
19import fungibleAbi from './fungibleAbi.json';
20import {expect} from 'chai';
21import {submitTransactionAsync} from '../substrate/substrate-api';
2219
23describe('Fungible: Information getting', () => {20describe('Fungible: Information getting', () => {
24  itWeb3('totalSupply', async ({api, web3, privateKeyWrapper}) => {21  let donor: IKeyringPair;
22  let alice: IKeyringPair;
23
25    const collection = await createCollectionExpectSuccess({24  before(async function() {
25    await usingEthPlaygrounds(async (helper, privateKey) => {
26      name: 'token name',26      donor = privateKey('//Alice');
27      mode: {type: 'Fungible', decimalPoints: 0},27      [alice] = await helper.arrange.createAccounts([20n], donor);
28    });28    });
29    const alice = privateKeyWrapper('//Alice');29  });
3030
31    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);31  itEth('totalSupply', async ({helper}) => {
32    const caller = await helper.eth.createAccountWithBalance(donor);
33    const collection = await helper.ft.mintCollection(alice);
34    await collection.mint(alice, 200n);
3235
33    await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Substrate: alice.address});36    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'ft', caller);
34
35    const address = collectionIdToAddress(collection);
36    const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: caller, ...GAS_ARGS});
37    const totalSupply = await contract.methods.totalSupply().call();37    const totalSupply = await contract.methods.totalSupply().call();
38
39    expect(totalSupply).to.equal('200');38    expect(totalSupply).to.equal('200');
40  });39  });
4140
42  itWeb3('balanceOf', async ({api, web3, privateKeyWrapper}) => {41  itEth('balanceOf', async ({helper}) => {
43    const collection = await createCollectionExpectSuccess({42    const caller = await helper.eth.createAccountWithBalance(donor);
44      name: 'token name',43    const collection = await helper.ft.mintCollection(alice);
45      mode: {type: 'Fungible', decimalPoints: 0},44    await collection.mint(alice, 200n, {Ethereum: caller});
46    });
47    const alice = privateKeyWrapper('//Alice');
4845
49    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);46    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'ft', caller);
50
51    await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: caller});
52
53    const address = collectionIdToAddress(collection);
54    const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: caller, ...GAS_ARGS});
55    const balance = await contract.methods.balanceOf(caller).call();47    const balance = await contract.methods.balanceOf(caller).call();
56
57    expect(balance).to.equal('200');48    expect(balance).to.equal('200');
58  });49  });
59});50});
6051
61describe('Fungible: Plain calls', () => {52describe('Fungible: Plain calls', () => {
62  itWeb3('Can perform mint()', async ({web3, api, privateKeyWrapper}) => {53  let donor: IKeyringPair;
54  let alice: IKeyringPair;
55
56  before(async function() {
57    await usingEthPlaygrounds(async (helper, privateKey) => {
63    const alice = privateKeyWrapper('//Alice');58      donor = privateKey('//Alice');
64    const collection = await createCollection(api, alice, {59      [alice] = await helper.arrange.createAccounts([20n], donor);
65      name: 'token name',
66      mode: {type: 'Fungible', decimalPoints: 0},
67    });60    });
61  });
6862
69    const receiver = createEthAccount(web3);63  itEth('Can perform mint()', async ({helper}) => {
64    const owner = await helper.eth.createAccountWithBalance(donor);
65    const receiver = helper.eth.createAccount();
66    const collection = await helper.ft.mintCollection(alice);
67    await collection.addAdmin(alice, {Ethereum: owner});
7068
71    const collectionIdAddress = collectionIdToAddress(collection.collectionId);69    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
72    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);70    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
73    const changeAdminTx = api.tx.unique.addCollectionAdmin(collection.collectionId, {Ethereum: owner});
74    await submitTransactionAsync(alice, changeAdminTx);
7571
76    const collectionContract = evmCollection(web3, owner, collectionIdAddress, {type: 'Fungible', decimalPoints: 0});72    const result = await contract.methods.mint(receiver, 100).send();
77    const result = await collectionContract.methods.mint(receiver, 100).send();
78    const events = normalizeEvents(result.events);
79    73    
80    expect(events).to.be.deep.equal([74    const event = result.events.Transfer;
81      {
82        address: collectionIdAddress,75    expect(event.address).to.equal(collectionAddress);
83        event: 'Transfer',76    expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');
84        args: {
85          from: '0x0000000000000000000000000000000000000000',
86          to: receiver,77    expect(event.returnValues.to).to.equal(receiver);
87          value: '100',78    expect(event.returnValues.value).to.equal('100');
88        },
89      },
90    ]);
91  });79  });
9280
93  itWeb3('Can perform mintBulk()', async ({web3, api, privateKeyWrapper}) => {81  itEth('Can perform mintBulk()', async ({helper}) => {
94    const alice = privateKeyWrapper('//Alice');82    const owner = await helper.eth.createAccountWithBalance(donor);
95    const collection = await createCollection(api, alice, {83    const bulkSize = 3;
96      name: 'token name',84    const receivers = [...new Array(bulkSize)].map(() => helper.eth.createAccount());
97      mode: {type: 'Fungible', decimalPoints: 0},85    const collection = await helper.ft.mintCollection(alice);
98    });86    await collection.addAdmin(alice, {Ethereum: owner});
9987
100    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);88    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
101    const receiver1 = createEthAccount(web3);89    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
102    const receiver2 = createEthAccount(web3);
103    const receiver3 = createEthAccount(web3);
10490
105    const collectionIdAddress = collectionIdToAddress(collection.collectionId);91    const result = await contract.methods.mintBulk(Array.from({length: bulkSize}, (_, i) => (
106    const changeAdminTx = api.tx.unique.addCollectionAdmin(collection.collectionId, {Ethereum: owner});
107    await submitTransactionAsync(alice, changeAdminTx);
108
109    const collectionContract = evmCollection(web3, owner, collectionIdAddress, {type: 'Fungible', decimalPoints: 0});
110    const result = await collectionContract.methods.mintBulk([
111      [receiver1, 10],92      [receivers[i], (i + 1) * 10]
112      [receiver2, 20],
113      [receiver3, 30],
114    ]).send();93    ))).send();
115    const events = normalizeEvents(result.events);94    const events = result.events.Transfer.sort((a: any, b: any) => +a.returnValues.value - b.returnValues.value);
116
117    expect(events).to.be.deep.contain({
118      address:collectionIdAddress,
119      event: 'Transfer',
120      args: {
121        from: '0x0000000000000000000000000000000000000000',
122        to: receiver1,95    for (let i = 0; i < bulkSize; i++) {
123        value: '10',
124      },96      const event = events[i];
125    });
126    97      expect(event.address).to.equal(collectionAddress);
127    expect(events).to.be.deep.contain({
128      address:collectionIdAddress,98      expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');
129      event: 'Transfer',
130      args: {
131        from: '0x0000000000000000000000000000000000000000',
132        to: receiver2,
133        value: '20',
134      },
135    });
136    99      expect(event.returnValues.to).to.equal(receivers[i]);
137    expect(events).to.be.deep.contain({
138      address:collectionIdAddress,100      expect(event.returnValues.value).to.equal(String(10 * (i + 1)));
139      event: 'Transfer',
140      args: {
141        from: '0x0000000000000000000000000000000000000000',
142        to: receiver3,
143        value: '30',
144      },101    }
145    });
146  });102  });
147103
148  itWeb3('Can perform burn()', async ({web3, api, privateKeyWrapper}) => {104  itEth('Can perform burn()', async ({helper}) => {
149    const alice = privateKeyWrapper('//Alice');105    const owner = await helper.eth.createAccountWithBalance(donor);
150    const collection = await createCollection(api, alice, {106    const receiver = await helper.eth.createAccountWithBalance(donor);
151      name: 'token name',107    const collection = await helper.ft.mintCollection(alice);
152      mode: {type: 'Fungible', decimalPoints: 0},108    await collection.addAdmin(alice, {Ethereum: owner});
153    });
154109
155    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);110    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
156    const changeAdminTx = api.tx.unique.addCollectionAdmin(collection.collectionId, {Ethereum: owner});111    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
157    await submitTransactionAsync(alice, changeAdminTx);112    await contract.methods.mint(receiver, 100).send();
158    const receiver = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
159113
160    const collectionIdAddress = collectionIdToAddress(collection.collectionId);114    const result = await contract.methods.burnFrom(receiver, 49).send({from: receiver});
161    const collectionContract = evmCollection(web3, owner, collectionIdAddress, {type: 'Fungible', decimalPoints: 0});
162    await collectionContract.methods.mint(receiver, 100).send();
163
164    const result = await collectionContract.methods.burnFrom(receiver, 49).send({from: receiver});
165    115    
166    const events = normalizeEvents(result.events);116    const event = result.events.Transfer;
117    expect(event.address).to.equal(collectionAddress);
118    expect(event.returnValues.from).to.equal(receiver);
119    expect(event.returnValues.to).to.equal('0x0000000000000000000000000000000000000000');
120    expect(event.returnValues.value).to.equal('49');
167121
168    expect(events).to.be.deep.equal([122    const balance = await contract.methods.balanceOf(receiver).call();
169      {
170        address: collectionIdAddress,
171        event: 'Transfer',
172        args: {
173          from: receiver,
174          to: '0x0000000000000000000000000000000000000000',
175          value: '49',
176        },
177      },
178    ]);
179
180    const balance = await collectionContract.methods.balanceOf(receiver).call();
181    expect(balance).to.equal('51');123    expect(balance).to.equal('51');
182  });124  });
183125
184  itWeb3('Can perform approve()', async ({web3, api, privateKeyWrapper}) => {126  itEth('Can perform approve()', async ({helper}) => {
185    const collection = await createCollectionExpectSuccess({127    const owner = await helper.eth.createAccountWithBalance(donor);
186      name: 'token name',128    const spender = helper.eth.createAccount();
187      mode: {type: 'Fungible', decimalPoints: 0},129    const collection = await helper.ft.mintCollection(alice);
188    });
189    const alice = privateKeyWrapper('//Alice');130    await collection.mint(alice, 200n, {Ethereum: owner});
190131
191    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);132    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
133    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
192134
193    await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});
194
195    const spender = createEthAccount(web3);
196
197    const address = collectionIdToAddress(collection);
198    const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});
199
200    {135    {
201      const result = await contract.methods.approve(spender, 100).send({from: owner});136      const result = await contract.methods.approve(spender, 100).send({from: owner});
202      const events = normalizeEvents(result.events);
203137
204      expect(events).to.be.deep.equal([138      const event = result.events.Approval;
205        {
206          address,139      expect(event.address).to.be.equal(collectionAddress);
207          event: 'Approval',140      expect(event.returnValues.owner).to.be.equal(owner);
208          args: {
209            owner,
210            spender,141      expect(event.returnValues.spender).to.be.equal(spender);
211            value: '100',142      expect(event.returnValues.value).to.be.equal('100');
212          },
213        },
214      ]);
215    }143    }
216144
217    {145    {
220    }148    }
221  });149  });
222150
223  itWeb3('Can perform transferFrom()', async ({web3, api, privateKeyWrapper}) => {151  itEth('Can perform transferFrom()', async ({helper}) => {
224    const collection = await createCollectionExpectSuccess({152    const owner = await helper.eth.createAccountWithBalance(donor);
225      name: 'token name',153    const spender = await helper.eth.createAccountWithBalance(donor);
226      mode: {type: 'Fungible', decimalPoints: 0},154    const receiver = helper.eth.createAccount();
227    });155    const collection = await helper.ft.mintCollection(alice);
228    const alice = privateKeyWrapper('//Alice');156    await collection.mint(alice, 200n, {Ethereum: owner});
229157
230    const owner = createEthAccount(web3);158    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
231    await transferBalanceToEth(api, alice, owner);159    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
232160
233    await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});
234
235    const spender = createEthAccount(web3);
236    await transferBalanceToEth(api, alice, spender);
237
238    const receiver = createEthAccount(web3);
239
240    const address = collectionIdToAddress(collection);
241    const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});
242
243    await contract.methods.approve(spender, 100).send();161    await contract.methods.approve(spender, 100).send();
244162
245    {163    {
246      const result = await contract.methods.transferFrom(owner, receiver, 49).send({from: spender});164      const result = await contract.methods.transferFrom(owner, receiver, 49).send({from: spender});
247      const events = normalizeEvents(result.events);165      
166      let event = result.events.Transfer;
248      expect(events).to.be.deep.equal([167      expect(event.address).to.be.equal(collectionAddress);
249        {168      expect(event.returnValues.from).to.be.equal(owner);
250          address,
251          event: 'Transfer',
252          args: {
253            from: owner,
254            to: receiver,169      expect(event.returnValues.to).to.be.equal(receiver);
255            value: '49',170      expect(event.returnValues.value).to.be.equal('49');
256          },171
257        },172      event = result.events.Approval;
258        {173      expect(event.address).to.be.equal(collectionAddress);
259          address,
260          event: 'Approval',174      expect(event.returnValues.owner).to.be.equal(owner);
261          args: {
262            owner,
263            spender,175      expect(event.returnValues.spender).to.be.equal(spender);
264            value: '51',176      expect(event.returnValues.value).to.be.equal('51');
265          },
266        },
267      ]);
268    }177    }
269178
270    {179    {
278    }187    }
279  });188  });
280189
281  itWeb3('Can perform transfer()', async ({web3, api, privateKeyWrapper}) => {190  itEth('Can perform transfer()', async ({helper}) => {
282    const collection = await createCollectionExpectSuccess({191    const owner = await helper.eth.createAccountWithBalance(donor);
283      name: 'token name',192    const receiver = await helper.eth.createAccountWithBalance(donor);
284      mode: {type: 'Fungible', decimalPoints: 0},193    const collection = await helper.ft.mintCollection(alice);
285    });
286    const alice = privateKeyWrapper('//Alice');194    await collection.mint(alice, 200n, {Ethereum: owner});
287195
288    const owner = createEthAccount(web3);196    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
289    await transferBalanceToEth(api, alice, owner);197    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
290198
291    await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});
292
293    const receiver = createEthAccount(web3);
294    await transferBalanceToEth(api, alice, receiver);
295
296    const address = collectionIdToAddress(collection);
297    const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});
298
299    {199    {
300      const result = await contract.methods.transfer(receiver, 50).send({from: owner});200      const result = await contract.methods.transfer(receiver, 50).send({from: owner});
301      const events = normalizeEvents(result.events);201      
202      const event = result.events.Transfer;
302      expect(events).to.be.deep.equal([203      expect(event.address).to.be.equal(collectionAddress);
303        {204      expect(event.returnValues.from).to.be.equal(owner);
304          address,
305          event: 'Transfer',
306          args: {
307            from: owner,
308            to: receiver,205      expect(event.returnValues.to).to.be.equal(receiver);
309            value: '50',206      expect(event.returnValues.value).to.be.equal('50');
310          },
311        },
312      ]);
313    }207    }
314208
315    {209    {
325});219});
326220
327describe('Fungible: Fees', () => {221describe('Fungible: Fees', () => {
328  itWeb3('approve() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {222  let donor: IKeyringPair;
223  let alice: IKeyringPair;
224
225  before(async function() {
226    await usingEthPlaygrounds(async (helper, privateKey) => {
329    const collection = await createCollectionExpectSuccess({227      donor = privateKey('//Alice');
330      mode: {type: 'Fungible', decimalPoints: 0},228      [alice] = await helper.arrange.createAccounts([20n], donor);
331    });229    });
332    const alice = privateKeyWrapper('//Alice');230  });
231  
232  itEth('approve() call fee is less than 0.2UNQ', async ({helper}) => {
233    const owner = await helper.eth.createAccountWithBalance(donor);
234    const spender = helper.eth.createAccount();
235    const collection = await helper.ft.mintCollection(alice);
236    await collection.mint(alice, 200n, {Ethereum: owner});
333237
334    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);238    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
335    const spender = createEthAccount(web3);239    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
336240
337    await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});241    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.approve(spender, 100).send({from: owner}));
338
339    const address = collectionIdToAddress(collection);
340    const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});
341
342    const cost = await recordEthFee(api, owner, () => contract.methods.approve(spender, 100).send({from: owner}));
343    expect(cost < BigInt(0.2 * Number(UNIQUE)));242    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));
344  });243  });
345244
346  itWeb3('transferFrom() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {245  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {
347    const collection = await createCollectionExpectSuccess({246    const owner = await helper.eth.createAccountWithBalance(donor);
348      mode: {type: 'Fungible', decimalPoints: 0},247    const spender = await helper.eth.createAccountWithBalance(donor);
349    });248    const collection = await helper.ft.mintCollection(alice);
350    const alice = privateKeyWrapper('//Alice');249    await collection.mint(alice, 200n, {Ethereum: owner});
351250
352    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);251    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
353    const spender = await createEthAccountWithBalance(api, web3, privateKeyWrapper);252    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
354253
355    await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});
356
357    const address = collectionIdToAddress(collection);
358    const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});
359
360    await contract.methods.approve(spender, 100).send({from: owner});254    await contract.methods.approve(spender, 100).send({from: owner});
361255
362    const cost = await recordEthFee(api, spender, () => contract.methods.transferFrom(owner, spender, 100).send({from: spender}));256    const cost = await helper.eth.recordCallFee(spender, () => contract.methods.transferFrom(owner, spender, 100).send({from: spender}));
363    expect(cost < BigInt(0.2 * Number(UNIQUE)));257    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));
364  });258  });
365259
366  itWeb3('transfer() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {260  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {
367    const collection = await createCollectionExpectSuccess({261    const owner = await helper.eth.createAccountWithBalance(donor);
368      mode: {type: 'Fungible', decimalPoints: 0},262    const receiver = helper.eth.createAccount();
369    });263    const collection = await helper.ft.mintCollection(alice);
370    const alice = privateKeyWrapper('//Alice');264    await collection.mint(alice, 200n, {Ethereum: owner});
371265
372    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);266    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
373    const receiver = createEthAccount(web3);267    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
374268
375    await createFungibleItemExpectSuccess(alice, collection, {Value: 200n}, {Ethereum: owner});269    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.transfer(receiver, 100).send({from: owner}));
376
377    const address = collectionIdToAddress(collection);
378    const contract = new web3.eth.Contract(fungibleAbi as any, address, {from: owner, ...GAS_ARGS});
379
380    const cost = await recordEthFee(api, owner, () => contract.methods.transfer(receiver, 100).send({from: owner}));
381    expect(cost < BigInt(0.2 * Number(UNIQUE)));270    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));
382  });271  });
383});272});
384273
385describe('Fungible: Substrate calls', () => {274describe('Fungible: Substrate calls', () => {
386  itWeb3('Events emitted for approve()', async ({web3, privateKeyWrapper}) => {275  let donor: IKeyringPair;
276  let alice: IKeyringPair;
277
278  before(async function() {
279    await usingEthPlaygrounds(async (helper, privateKey) => {
387    const collection = await createCollectionExpectSuccess({280      donor = privateKey('//Alice');
388      mode: {type: 'Fungible', decimalPoints: 0},281      [alice] = await helper.arrange.createAccounts([20n], donor);
389    });282    });
390    const alice = privateKeyWrapper('//Alice');283  });
391284
392    const receiver = createEthAccount(web3);285  itEth('Events emitted for approve()', async ({helper}) => {
286    const receiver = helper.eth.createAccount();
287    const collection = await helper.ft.mintCollection(alice);
288    await collection.mint(alice, 200n);
393289
394    await createFungibleItemExpectSuccess(alice, collection, {Value: 200n});290    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
291    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft');
395292
396    const address = collectionIdToAddress(collection);293    const events: any = [];
397    const contract = new web3.eth.Contract(fungibleAbi as any, address);294    contract.events.allEvents((_: any, event: any) => {
398
399    const events = await recordEvents(contract, async () => {
400      await approveExpectSuccess(collection, 0, alice, {Ethereum: receiver}, 100);295      events.push(event);
401    });296    });
297    await collection.approveTokens(alice, {Ethereum: receiver}, 100n);
402298
403    expect(events).to.be.deep.equal([299    const event = events[0];
404      {
405        address,
406        event: 'Approval',300    expect(event.event).to.be.equal('Approval');
407        args: {301    expect(event.address).to.be.equal(collectionAddress);
408          owner: subToEth(alice.address),302    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));
409          spender: receiver,303    expect(event.returnValues.spender).to.be.equal(receiver);
410          value: '100',304    expect(event.returnValues.value).to.be.equal('100');
411        },
412      },
413    ]);
414  });305  });
415306
416  itWeb3('Events emitted for transferFrom()', async ({web3, privateKeyWrapper}) => {307  itEth('Events emitted for transferFrom()', async ({helper}) => {
417    const collection = await createCollectionExpectSuccess({308    const [bob] = await helper.arrange.createAccounts([10n], donor);
418      mode: {type: 'Fungible', decimalPoints: 0},309    const receiver = helper.eth.createAccount();
419    });310    const collection = await helper.ft.mintCollection(alice);
420    const alice = privateKeyWrapper('//Alice');311    await collection.mint(alice, 200n);
421    const bob = privateKeyWrapper('//Bob');312    await collection.approveTokens(alice, {Substrate: bob.address}, 100n);
422313
423    const receiver = createEthAccount(web3);314    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
315    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft');
424316
425    await createFungibleItemExpectSuccess(alice, collection, {Value: 200n});317    const events: any = [];
426    await approveExpectSuccess(collection, 0, alice, bob.address, 100);
427
428    const address = collectionIdToAddress(collection);
429    const contract = new web3.eth.Contract(fungibleAbi as any, address);318    contract.events.allEvents((_: any, event: any) => {
430
431    const events = await recordEvents(contract, async () => {
432      await transferFromExpectSuccess(collection, 0, bob, alice, {Ethereum: receiver}, 51, 'Fungible');319      events.push(event);
433    });320    });
321    await collection.transferFrom(bob, {Substrate: alice.address}, {Ethereum: receiver}, 51n);
434322
435    expect(events).to.be.deep.equal([323    let event = events[0];
436      {
437        address,
438        event: 'Transfer',324    expect(event.event).to.be.equal('Transfer');
439        args: {325    expect(event.address).to.be.equal(collectionAddress);
440          from: subToEth(alice.address),
441          to: receiver,
442          value: '51',326    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));
443        },
444      },
445      {
446        address,
447        event: 'Approval',
448        args: {
449          owner: subToEth(alice.address),
450          spender: subToEth(bob.address),327    expect(event.returnValues.to).to.be.equal(receiver);
451          value: '49',328    expect(event.returnValues.value).to.be.equal('51');
452        },
453      },
454    ]);
455  });
456329
457  itWeb3('Events emitted for transfer()', async ({web3, privateKeyWrapper}) => {330    event = events[1];
458    const collection = await createCollectionExpectSuccess({331    expect(event.event).to.be.equal('Approval');
332    expect(event.address).to.be.equal(collectionAddress);
459      mode: {type: 'Fungible', decimalPoints: 0},333    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));
460    });334    expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(bob.address));
461    const alice = privateKeyWrapper('//Alice');335    expect(event.returnValues.value).to.be.equal('49');
462
463    const receiver = createEthAccount(web3);336  });
464337
465    await createFungibleItemExpectSuccess(alice, collection, {Value: 200n});338  itEth('Events emitted for transfer()', async ({helper}) => {
339    const receiver = helper.eth.createAccount();
340    const collection = await helper.ft.mintCollection(alice);
341    await collection.mint(alice, 200n);
466342
467    const address = collectionIdToAddress(collection);343    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
468    const contract = new web3.eth.Contract(fungibleAbi as any, address);344    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft');
469345
470    const events = await recordEvents(contract, async () => {346    const events: any = [];
347    contract.events.allEvents((_: any, event: any) => {
471      await transferExpectSuccess(collection, 0, alice, {Ethereum:receiver}, 51, 'Fungible');348      events.push(event);
472    });349    });
350    await collection.transfer(alice, {Ethereum:receiver}, 51n);
473351
474    expect(events).to.be.deep.equal([352    const event = events[0];
475      {
476        address,
477        event: 'Transfer',353    expect(event.event).to.be.equal('Transfer');
478        args: {354    expect(event.address).to.be.equal(collectionAddress);
479          from: subToEth(alice.address),355    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));
480          to: receiver,356    expect(event.returnValues.to).to.be.equal(receiver);
481          value: '51',357    expect(event.returnValues.value).to.be.equal('51');
482        },
483      },
484    ]);
485  });358  });
486});359});
487360

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import {approveExpectSuccess, burnItemExpectSuccess, createCollectionExpectSuccess, createItemExpectSuccess, transferExpectSuccess, transferFromExpectSuccess, UNIQUE} from '../util/helpers';17import {itEth, usingEthPlaygrounds, expect, EthUniqueHelper} from './util/playgrounds';
18import {collectionIdToAddress, createEthAccount, createEthAccountWithBalance, evmCollection, evmCollectionHelpers, GAS_ARGS, getCollectionAddressFromResult, itWeb3, normalizeEvents, recordEthFee, recordEvents, subToEth, transferBalanceToEth} from './util/helpers';18import {IKeyringPair} from '@polkadot/types/types';
19import nonFungibleAbi from './nonFungibleAbi.json';19import {Contract} from 'web3-eth-contract';
20import {expect} from 'chai';
21import {submitTransactionAsync} from '../substrate/substrate-api';
2220
23describe('NFT: Information getting', () => {21describe('NFT: Information getting', () => {
24  itWeb3('totalSupply', async ({api, web3, privateKeyWrapper}) => {22  let donor: IKeyringPair;
23  let alice: IKeyringPair;
24
25  before(async function() {
26    await usingEthPlaygrounds(async (helper, privateKey) => {
25    const collection = await createCollectionExpectSuccess({27      donor = privateKey('//Alice');
26      mode: {type: 'NFT'},28      [alice] = await helper.arrange.createAccounts([10n], donor);
27    });29    });
28    const alice = privateKeyWrapper('//Alice');30  });
31  
32  itEth('totalSupply', async ({helper}) => {
29    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);33    const collection = await helper.nft.mintCollection(alice, {});
34    await collection.mintToken(alice);
3035
31    await createItemExpectSuccess(alice, collection, 'NFT', {Substrate: alice.address});36    const caller = await helper.eth.createAccountWithBalance(donor);
3237
33    const address = collectionIdToAddress(collection);38    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);
34    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: caller, ...GAS_ARGS});
35    const totalSupply = await contract.methods.totalSupply().call();39    const totalSupply = await contract.methods.totalSupply().call();
3640
37    expect(totalSupply).to.equal('1');41    expect(totalSupply).to.equal('1');
38  });42  });
3943
40  itWeb3('balanceOf', async ({api, web3, privateKeyWrapper}) => {44  itEth('balanceOf', async ({helper}) => {
41    const collection = await createCollectionExpectSuccess({45    const collection = await helper.nft.mintCollection(alice, {});
42      mode: {type: 'NFT'},
43    });
44    const alice = privateKeyWrapper('//Alice');46    const caller = await helper.eth.createAccountWithBalance(donor);
4547
46    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);48    await collection.mintToken(alice, {Ethereum: caller});
47    await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum:caller});
48    await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: caller});49    await collection.mintToken(alice, {Ethereum: caller});
49    await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: caller});50    await collection.mintToken(alice, {Ethereum: caller});
5051
51    const address = collectionIdToAddress(collection);52    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);
52    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: caller, ...GAS_ARGS});
53    const balance = await contract.methods.balanceOf(caller).call();53    const balance = await contract.methods.balanceOf(caller).call();
5454
55    expect(balance).to.equal('3');55    expect(balance).to.equal('3');
56  });56  });
5757
58  itWeb3('ownerOf', async ({api, web3, privateKeyWrapper}) => {58  itEth('ownerOf', async ({helper}) => {
59    const collection = await createCollectionExpectSuccess({59    const collection = await helper.nft.mintCollection(alice, {});
60      mode: {type: 'NFT'},
61    });
62    const alice = privateKeyWrapper('//Alice');60    const caller = await helper.eth.createAccountWithBalance(donor);
6361
64    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);62    const token = await collection.mintToken(alice, {Ethereum: caller});
65    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: caller});
6663
67    const address = collectionIdToAddress(collection);64    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);
68    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: caller, ...GAS_ARGS});
69    const owner = await contract.methods.ownerOf(tokenId).call();
7065
66    const owner = await contract.methods.ownerOf(token.tokenId).call();
67
71    expect(owner).to.equal(caller);68    expect(owner).to.equal(caller);
72  });69  });
73});70});
7471
75describe('Check ERC721 token URI for NFT', () => {72describe('Check ERC721 token URI for NFT', () => {
76  itWeb3('Empty tokenURI', async ({web3, api, privateKeyWrapper}) => {73  let donor: IKeyringPair;
74
75  before(async function() {
76    await usingEthPlaygrounds(async (_helper, privateKey) => {
77      donor = privateKey('//Alice');
78    });
79  });
80
81  async function setup(helper: EthUniqueHelper, tokenPrefix: string, propertyKey?: string, propertyValue?: string): Promise<{contract: Contract, nextTokenId: string}> {
77    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);82    const owner = await helper.eth.createAccountWithBalance(donor);
83    const receiver = helper.eth.createAccount();
84
78    const helper = evmCollectionHelpers(web3, owner);85    const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
79    let result = await helper.methods.createERC721MetadataCompatibleCollection('Mint collection', '1', '1', '').send();86    let result = await collectionHelper.methods.createERC721MetadataCompatibleCollection('Mint collection', 'a', 'b', tokenPrefix).send();
80    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);87    const collectionAddress = helper.ethAddress.normalizeAddress(result.events.CollectionCreated.returnValues.collectionId);
81    const receiver = createEthAccount(web3);88    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
82    const contract = evmCollection(web3, owner, collectionIdAddress);
83    89    
84    const nextTokenId = await contract.methods.nextTokenId().call();90    const nextTokenId = await contract.methods.nextTokenId().call();
85    expect(nextTokenId).to.be.equal('1');91    expect(nextTokenId).to.be.equal('1');
88      nextTokenId,94      nextTokenId,
89    ).send();95    ).send();
9096
91    const events = normalizeEvents(result.events);97    if (propertyKey && propertyValue) {
92    const address = collectionIdToAddress(collectionId);98      // Set URL or suffix
99      await contract.methods.setProperty(nextTokenId, propertyKey, Buffer.from(propertyValue)).send();
100    }
93101
94    expect(events).to.be.deep.equal([102    const event = result.events.Transfer;
103    expect(event.address).to.be.equal(collectionAddress);
95      {104    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
96        address,
97        event: 'Transfer',
98        args: {
99          from: '0x0000000000000000000000000000000000000000',
100          to: receiver,105    expect(event.returnValues.to).to.be.equal(receiver);
101          tokenId: nextTokenId,106    expect(event.returnValues.tokenId).to.be.equal(nextTokenId);
102        },
103      },
104    ]);
105107
108    return {contract, nextTokenId};
109  }
110
111  itEth('Empty tokenURI', async ({helper}) => {
112    const {contract, nextTokenId} = await setup(helper, '');
106    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('');113    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('');
107  });114  });
108115
109  itWeb3('TokenURI from url', async ({web3, api, privateKeyWrapper}) => {116  itEth('TokenURI from url', async ({helper}) => {
110    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);117    const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'url', 'Token URI');
111    const helper = evmCollectionHelpers(web3, owner);
112    let result = await helper.methods.createERC721MetadataCompatibleCollection('Mint collection', '1', '1', 'BaseURI_').send();
113    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);
114    const receiver = createEthAccount(web3);
115    const contract = evmCollection(web3, owner, collectionIdAddress);
116    
117    const nextTokenId = await contract.methods.nextTokenId().call();
118    expect(nextTokenId).to.be.equal('1');
119    result = await contract.methods.mint(
120      receiver,
121      nextTokenId,
122    ).send();
123    
124    // Set URL
125    await contract.methods.setProperty(nextTokenId, 'url', Buffer.from('Token URI')).send();
126      
127    const events = normalizeEvents(result.events);
128    const address = collectionIdToAddress(collectionId);
129
130    expect(events).to.be.deep.equal([
131      {
132        address,
133        event: 'Transfer',
134        args: {
135          from: '0x0000000000000000000000000000000000000000',
136          to: receiver,
137          tokenId: nextTokenId,
138        },
139      },
140    ]);
141
142    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Token URI');118    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Token URI');
143  });119  });
144120
145  itWeb3('TokenURI from baseURI + tokenId', async ({web3, api, privateKeyWrapper}) => {121  itEth('TokenURI from baseURI + tokenId', async ({helper}) => {
146    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);122    const {contract, nextTokenId} = await setup(helper, 'BaseURI_');
147    const helper = evmCollectionHelpers(web3, owner);
148    let result = await helper.methods.createERC721MetadataCompatibleCollection('Mint collection', '1', '1', 'BaseURI_').send();
149    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);
150    const receiver = createEthAccount(web3);
151    const contract = evmCollection(web3, owner, collectionIdAddress);
152    
153    const nextTokenId = await contract.methods.nextTokenId().call();
154    expect(nextTokenId).to.be.equal('1');
155    result = await contract.methods.mint(
156      receiver,
157      nextTokenId,
158    ).send();
159          
160    const events = normalizeEvents(result.events);
161    const address = collectionIdToAddress(collectionId);
162
163    expect(events).to.be.deep.equal([
164      {
165        address,
166        event: 'Transfer',
167        args: {
168          from: '0x0000000000000000000000000000000000000000',
169          to: receiver,
170          tokenId: nextTokenId,
171        },
172      },
173    ]);
174
175    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + nextTokenId);123    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + nextTokenId);
176  });124  });
177125
178  itWeb3('TokenURI from baseURI + suffix', async ({web3, api, privateKeyWrapper}) => {126  itEth('TokenURI from baseURI + suffix', async ({helper}) => {
179    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
180    const helper = evmCollectionHelpers(web3, owner);
181    let result = await helper.methods.createERC721MetadataCompatibleCollection('Mint collection', '1', '1', 'BaseURI_').send();
182    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);
183    const receiver = createEthAccount(web3);
184    const contract = evmCollection(web3, owner, collectionIdAddress);
185    
186    const nextTokenId = await contract.methods.nextTokenId().call();
187    expect(nextTokenId).to.be.equal('1');
188    result = await contract.methods.mint(
189      receiver,
190      nextTokenId,
191    ).send();
192          
193    // Set suffix
194    const suffix = '/some/suffix';127    const suffix = '/some/suffix';
195    await contract.methods.setProperty(nextTokenId, 'suffix', Buffer.from(suffix)).send();128    const {contract, nextTokenId} = await setup(helper, 'BaseURI_', 'suffix', suffix);
196
197    const events = normalizeEvents(result.events);
198    const address = collectionIdToAddress(collectionId);
199
200    expect(events).to.be.deep.equal([
201      {
202        address,
203        event: 'Transfer',
204        args: {
205          from: '0x0000000000000000000000000000000000000000',
206          to: receiver,
207          tokenId: nextTokenId,
208        },
209      },
210    ]);
211
212    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + suffix);129    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('BaseURI_' + suffix);
213  });130  });
214});131});
215132
216describe('NFT: Plain calls', () => {133describe('NFT: Plain calls', () => {
217  itWeb3('Can perform mint()', async ({web3, api, privateKeyWrapper}) => {134  let donor: IKeyringPair;
135  let alice: IKeyringPair;
136
137  before(async function() {
138    await usingEthPlaygrounds(async (helper, privateKey) => {
218    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);139      donor = privateKey('//Alice');
219    const helper = evmCollectionHelpers(web3, owner);140      [alice] = await helper.arrange.createAccounts([10n], donor);
220    let result = await helper.methods.createNonfungibleCollection('Mint collection', '6', '6').send();141    });
142  });
143
144  itEth('Can perform mint()', async ({helper}) => {
221    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);145    const owner = await helper.eth.createAccountWithBalance(donor);
222    const receiver = createEthAccount(web3);146    const receiver = helper.eth.createAccount();
147
223    const contract = evmCollection(web3, owner, collectionIdAddress);148    const {collectionAddress} = await helper.eth.createNonfungibleCollection(owner, 'Minty', '6', '6');
149    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
224    const nextTokenId = await contract.methods.nextTokenId().call();150    const nextTokenId = await contract.methods.nextTokenId().call();
225151
226    expect(nextTokenId).to.be.equal('1');152    expect(nextTokenId).to.be.equal('1');
227    result = await contract.methods.mintWithTokenURI(153    const result = await contract.methods.mintWithTokenURI(
228      receiver,154      receiver,
229      nextTokenId,155      nextTokenId,
230      'Test URI',156      'Test URI',
231    ).send();157    ).send();
232158
233    const events = normalizeEvents(result.events);159    const event = result.events.Transfer;
160    expect(event.address).to.be.equal(collectionAddress);
234    const address = collectionIdToAddress(collectionId);161    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
162    expect(event.returnValues.to).to.be.equal(receiver);
163    expect(event.returnValues.tokenId).to.be.equal(nextTokenId);
235164
236    expect(events).to.be.deep.equal([
237      {
238        address,
239        event: 'Transfer',
240        args: {
241          from: '0x0000000000000000000000000000000000000000',
242          to: receiver,
243          tokenId: nextTokenId,
244        },
245      },
246    ]);
247
248    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');165    expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
249166
250    // TODO: this wont work right now, need release 919000 first167    // TODO: this wont work right now, need release 919000 first
254  });171  });
255172
256  //TODO: CORE-302 add eth methods173  //TODO: CORE-302 add eth methods
257  itWeb3.skip('Can perform mintBulk()', async ({web3, api, privateKeyWrapper}) => {174  /* todo:playgrounds skipped test!
175  itWeb3.skip('Can perform mintBulk()', async ({helper}) => {
258    const collection = await createCollectionExpectSuccess({176    const collection = await createCollectionExpectSuccess({
259      mode: {type: 'NFT'},177      mode: {type: 'NFT'},
260    });178    });
316      expect(await contract.methods.tokenURI(+nextTokenId + 2).call()).to.be.equal('Test URI 2');234      expect(await contract.methods.tokenURI(+nextTokenId + 2).call()).to.be.equal('Test URI 2');
317    }235    }
318  });236  });
237  */
319238
320  itWeb3('Can perform burn()', async ({web3, api, privateKeyWrapper}) => {239  itEth('Can perform burn()', async ({helper}) => {
321    const collection = await createCollectionExpectSuccess({240    const caller = await helper.eth.createAccountWithBalance(donor);
322      mode: {type: 'NFT'},
323    });
324    const alice = privateKeyWrapper('//Alice');
325241
326    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);242    const collection = await helper.nft.mintCollection(alice, {});
243    const {tokenId} = await collection.mintToken(alice, {Ethereum: caller});
327244
328    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: owner});245    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
246    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', caller);
329247
330    const address = collectionIdToAddress(collection);
331    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: owner, ...GAS_ARGS});
332
333    {248    {
334      const result = await contract.methods.burn(tokenId).send({from: owner});249      const result = await contract.methods.burn(tokenId).send({from: caller});
335      const events = normalizeEvents(result.events);250      
336251      const event = result.events.Transfer;
337      expect(events).to.be.deep.equal([252      expect(event.address).to.be.equal(collectionAddress);
338        {253      expect(event.returnValues.from).to.be.equal(caller);
339          address,
340          event: 'Transfer',
341          args: {
342            from: owner,
343            to: '0x0000000000000000000000000000000000000000',254      expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');
344            tokenId: tokenId.toString(),255      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);
345          },
346        },
347      ]);
348    }256    }
349  });257  });
350258
351  itWeb3('Can perform approve()', async ({web3, api, privateKeyWrapper}) => {259  itEth('Can perform approve()', async ({helper}) => {
352    const collection = await createCollectionExpectSuccess({260    const owner = await helper.eth.createAccountWithBalance(donor);
353      mode: {type: 'NFT'},
354    });
355    const alice = privateKeyWrapper('//Alice');261    const spender = helper.eth.createAccount();
356262
357    const owner = createEthAccount(web3);263    const collection = await helper.nft.mintCollection(alice, {});
358    await transferBalanceToEth(api, alice, owner);264    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});
359265
360    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: owner});266    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
267    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
361268
362    const spender = createEthAccount(web3);
363
364    const address = collectionIdToAddress(collection);
365    const contract = new web3.eth.Contract(nonFungibleAbi as any, address);
366
367    {269    {
368      const result = await contract.methods.approve(spender, tokenId).send({from: owner, ...GAS_ARGS});270      const result = await contract.methods.approve(spender, tokenId).send({from: owner});
369      const events = normalizeEvents(result.events);
370271
371      expect(events).to.be.deep.equal([272      const event = result.events.Approval;
372        {
373          address,273      expect(event.address).to.be.equal(collectionAddress);
374          event: 'Approval',274      expect(event.returnValues.owner).to.be.equal(owner);
375          args: {
376            owner,
377            approved: spender,275      expect(event.returnValues.approved).to.be.equal(spender);
378            tokenId: tokenId.toString(),276      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);
379          },
380        },
381      ]);
382    }277    }
383  });278  });
384279
385  itWeb3('Can perform transferFrom()', async ({web3, api, privateKeyWrapper}) => {280  itEth('Can perform transferFrom()', async ({helper}) => {
386    const collection = await createCollectionExpectSuccess({281    const owner = await helper.eth.createAccountWithBalance(donor);
387      mode: {type: 'NFT'},282    const spender = await helper.eth.createAccountWithBalance(donor);
388    });
389    const alice = privateKeyWrapper('//Alice');283    const receiver = helper.eth.createAccount();
390284
391    const owner = createEthAccount(web3);285    const collection = await helper.nft.mintCollection(alice, {});
392    await transferBalanceToEth(api, alice, owner);286    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});
393287
394    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: owner});288    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
289    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
395290
396    const spender = createEthAccount(web3);
397    await transferBalanceToEth(api, alice, spender);
398
399    const receiver = createEthAccount(web3);
400
401    const address = collectionIdToAddress(collection);
402    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: owner, ...GAS_ARGS});
403
404    await contract.methods.approve(spender, tokenId).send({from: owner});291    await contract.methods.approve(spender, tokenId).send({from: owner});
405292
406    {293    {
407      const result = await contract.methods.transferFrom(owner, receiver, tokenId).send({from: spender});294      const result = await contract.methods.transferFrom(owner, receiver, tokenId).send({from: spender});
295
408      const events = normalizeEvents(result.events);296      const event = result.events.Transfer;
409      expect(events).to.be.deep.equal([297      expect(event.address).to.be.equal(collectionAddress);
410        {298      expect(event.returnValues.from).to.be.equal(owner);
411          address,
412          event: 'Transfer',
413          args: {
414            from: owner,
415            to: receiver,299      expect(event.returnValues.to).to.be.equal(receiver);
416            tokenId: tokenId.toString(),300      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);
417          },
418        },
419      ]);
420    }301    }
421302
422    {303    {
430    }311    }
431  });312  });
432313
433  itWeb3('Can perform transfer()', async ({web3, api, privateKeyWrapper}) => {314  itEth('Can perform transfer()', async ({helper}) => {
434    const collection = await createCollectionExpectSuccess({315    const collection = await helper.nft.mintCollection(alice, {});
435      mode: {type: 'NFT'},316    const owner = await helper.eth.createAccountWithBalance(donor);
436    });
437    const alice = privateKeyWrapper('//Alice');317    const receiver = helper.eth.createAccount();
438318
439    const owner = createEthAccount(web3);319    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});
440    await transferBalanceToEth(api, alice, owner);
441320
442    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: owner});321    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
322    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
443323
444    const receiver = createEthAccount(web3);
445    await transferBalanceToEth(api, alice, receiver);
446
447    const address = collectionIdToAddress(collection);
448    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: owner, ...GAS_ARGS});
449
450    {324    {
451      const result = await contract.methods.transfer(receiver, tokenId).send({from: owner});325      const result = await contract.methods.transfer(receiver, tokenId).send({from: owner});
326
452      const events = normalizeEvents(result.events);327      const event = result.events.Transfer;
453      expect(events).to.be.deep.equal([328      expect(event.address).to.be.equal(collectionAddress);
454        {329      expect(event.returnValues.from).to.be.equal(owner);
455          address,
456          event: 'Transfer',
457          args: {
458            from: owner,
459            to: receiver,330      expect(event.returnValues.to).to.be.equal(receiver);
460            tokenId: tokenId.toString(),331      expect(event.returnValues.tokenId).to.be.equal(`${tokenId}`);
461          },
462        },
463      ]);
464    }332    }
465333
466    {334    {
476});344});
477345
478describe('NFT: Fees', () => {346describe('NFT: Fees', () => {
479  itWeb3('approve() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {347  let donor: IKeyringPair;
348  let alice: IKeyringPair;
349
350  before(async function() {
351    await usingEthPlaygrounds(async (helper, privateKey) => {
480    const collection = await createCollectionExpectSuccess({352      donor = privateKey('//Alice');
481      mode: {type: 'NFT'},353      [alice] = await helper.arrange.createAccounts([10n], donor);
482    });354    });
483    const alice = privateKeyWrapper('//Alice');355  });
356  
357  itEth('approve() call fee is less than 0.2UNQ', async ({helper}) => {
358    const owner = await helper.eth.createAccountWithBalance(donor);
359    const spender = helper.eth.createAccount();
484360
485    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);361    const collection = await helper.nft.mintCollection(alice, {});
486    const spender = createEthAccount(web3);362    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});
487363
488    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: owner});364    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);
489365
490    const address = collectionIdToAddress(collection);366    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.approve(spender, tokenId).send({from: owner}));
491    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: owner, ...GAS_ARGS});
492
493    const cost = await recordEthFee(api, owner, () => contract.methods.approve(spender, tokenId).send({from: owner}));
494    expect(cost < BigInt(0.2 * Number(UNIQUE)));367    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));
495  });368  });
496369
497  itWeb3('transferFrom() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {370  itEth('transferFrom() call fee is less than 0.2UNQ', async ({helper}) => {
498    const collection = await createCollectionExpectSuccess({371    const owner = await helper.eth.createAccountWithBalance(donor);
499      mode: {type: 'NFT'},
500    });
501    const alice = privateKeyWrapper('//Alice');372    const spender = await helper.eth.createAccountWithBalance(donor);
502373
503    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);374    const collection = await helper.nft.mintCollection(alice, {});
504    const spender = await createEthAccountWithBalance(api, web3, privateKeyWrapper);375    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});
505376
506    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: owner});377    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);
507378
508    const address = collectionIdToAddress(collection);
509    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: owner, ...GAS_ARGS});
510
511    await contract.methods.approve(spender, tokenId).send({from: owner});379    await contract.methods.approve(spender, tokenId).send({from: owner});
512380
513    const cost = await recordEthFee(api, spender, () => contract.methods.transferFrom(owner, spender, tokenId).send({from: spender}));381    const cost = await helper.eth.recordCallFee(spender, () => contract.methods.transferFrom(owner, spender, tokenId).send({from: spender}));
514    expect(cost < BigInt(0.2 * Number(UNIQUE)));382    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));
515  });383  });
516384
517  itWeb3('transfer() call fee is less than 0.2UNQ', async ({web3, api, privateKeyWrapper}) => {385  itEth('transfer() call fee is less than 0.2UNQ', async ({helper}) => {
518    const collection = await createCollectionExpectSuccess({386    const owner = await helper.eth.createAccountWithBalance(donor);
519      mode: {type: 'NFT'},
520    });
521    const alice = privateKeyWrapper('//Alice');387    const receiver = helper.eth.createAccount();
522388
523    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);389    const collection = await helper.nft.mintCollection(alice, {});
524    const receiver = createEthAccount(web3);390    const {tokenId} = await collection.mintToken(alice, {Ethereum: owner});
525391
526    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: owner});392    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', owner);
527393
528    const address = collectionIdToAddress(collection);394    const cost = await helper.eth.recordCallFee(owner, () => contract.methods.transfer(receiver, tokenId).send({from: owner}));
529    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: owner, ...GAS_ARGS});
530
531    const cost = await recordEthFee(api, owner, () => contract.methods.transfer(receiver, tokenId).send({from: owner}));
532    expect(cost < BigInt(0.2 * Number(UNIQUE)));395    expect(cost < BigInt(0.2 * Number(helper.balance.getOneTokenNominal())));
533  });396  });
534});397});
535398
536describe('NFT: Substrate calls', () => {399describe('NFT: Substrate calls', () => {
537  itWeb3('Events emitted for mint()', async ({web3, privateKeyWrapper}) => {400  let donor: IKeyringPair;
538    const collection = await createCollectionExpectSuccess({
539      mode: {type: 'NFT'},
540    });
541    const alice = privateKeyWrapper('//Alice');401  let alice: IKeyringPair;
542402
543    const address = collectionIdToAddress(collection);403  before(async function() {
544    const contract = new web3.eth.Contract(nonFungibleAbi as any, address);404    await usingEthPlaygrounds(async (helper, privateKey) => {
545
546    let tokenId: number;
547    const events = await recordEvents(contract, async () => {405      donor = privateKey('//Alice');
548      tokenId = await createItemExpectSuccess(alice, collection, 'NFT');406      [alice] = await helper.arrange.createAccounts([20n], donor);
549    });407    });
550
551    expect(events).to.be.deep.equal([
552      {
553        address,
554        event: 'Transfer',
555        args: {
556          from: '0x0000000000000000000000000000000000000000',
557          to: subToEth(alice.address),
558          tokenId: tokenId!.toString(),
559        },
560      },
561    ]);
562  });408  });
563409
564  itWeb3('Events emitted for burn()', async ({web3, privateKeyWrapper}) => {410  itEth('Events emitted for mint()', async ({helper}) => {
565    const collection = await createCollectionExpectSuccess({411    const collection = await helper.nft.mintCollection(alice, {});
566      mode: {type: 'NFT'},412    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
567    });
568    const alice = privateKeyWrapper('//Alice');413    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft');
569414
570    const address = collectionIdToAddress(collection);415    const events: any = [];
571    const contract = new web3.eth.Contract(nonFungibleAbi as any, address);416    contract.events.allEvents((_: any, event: any) => {
572
573    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT');
574    const events = await recordEvents(contract, async () => {
575      await burnItemExpectSuccess(alice, collection, tokenId);417      events.push(event);
576    });418    });
419    const {tokenId} = await collection.mintToken(alice);
577420
578    expect(events).to.be.deep.equal([421    const event = events[0];
579      {
580        address,
581        event: 'Transfer',422    expect(event.event).to.be.equal('Transfer');
582        args: {423    expect(event.address).to.be.equal(collectionAddress);
583          from: subToEth(alice.address),
584          to: '0x0000000000000000000000000000000000000000',424    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
585          tokenId: tokenId.toString(),425    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(alice.address));
586        },
587      },
588    ]);426    expect(event.returnValues.tokenId).to.be.equal(tokenId.toString());
589  });427  });
590428
591  itWeb3('Events emitted for approve()', async ({web3, privateKeyWrapper}) => {429  itEth('Events emitted for burn()', async ({helper}) => {
592    const collection = await createCollectionExpectSuccess({430    const collection = await helper.nft.mintCollection(alice, {});
593      mode: {type: 'NFT'},431    const token = await collection.mintToken(alice);
432
433    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
434    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft');
435    
436    const events: any = [];
437    contract.events.allEvents((_: any, event: any) => {
438      events.push(event);
594    });439    });
595    const alice = privateKeyWrapper('//Alice');
596440
597    const receiver = createEthAccount(web3);441    await token.burn(alice);
598442
599    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT');443    const event = events[0];
444    expect(event.event).to.be.equal('Transfer');
445    expect(event.address).to.be.equal(collectionAddress);
446    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));
447    expect(event.returnValues.to).to.be.equal('0x0000000000000000000000000000000000000000');
448    expect(event.returnValues.tokenId).to.be.equal(token.tokenId.toString());
449  });
600450
601    const address = collectionIdToAddress(collection);451  itEth('Events emitted for approve()', async ({helper}) => {
602    const contract = new web3.eth.Contract(nonFungibleAbi as any, address);452    const receiver = helper.eth.createAccount();
603453
604    const events = await recordEvents(contract, async () => {454    const collection = await helper.nft.mintCollection(alice, {});
605      await approveExpectSuccess(collection, tokenId, alice, {Ethereum: receiver}, 1);455    const token = await collection.mintToken(alice);
606    });
607456
608    expect(events).to.be.deep.equal([457    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
609      {458    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft');
610        address,
611        event: 'Approval',
612        args: {
613          owner: subToEth(alice.address),
614          approved: receiver,459    
615          tokenId: tokenId.toString(),460    const events: any = [];
616        },
617      },
618    ]);
619  });461    contract.events.allEvents((_: any, event: any) => {
620
621  itWeb3('Events emitted for transferFrom()', async ({web3, privateKeyWrapper}) => {
622    const collection = await createCollectionExpectSuccess({462      events.push(event);
623      mode: {type: 'NFT'},
624    });463    });
625    const alice = privateKeyWrapper('//Alice');
626    const bob = privateKeyWrapper('//Bob');
627464
628    const receiver = createEthAccount(web3);465    await token.approve(alice, {Ethereum: receiver});
629466
630    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT');467    const event = events[0];
468    expect(event.event).to.be.equal('Approval');
631    await approveExpectSuccess(collection, tokenId, alice, bob.address, 1);469    expect(event.address).to.be.equal(collectionAddress);
470    expect(event.returnValues.owner).to.be.equal(helper.address.substrateToEth(alice.address));
471    expect(event.returnValues.approved).to.be.equal(receiver);
472    expect(event.returnValues.tokenId).to.be.equal(token.tokenId.toString());
473  });
632474
633    const address = collectionIdToAddress(collection);475  itEth('Events emitted for transferFrom()', async ({helper}) => {
476    const [bob] = await helper.arrange.createAccounts([10n], donor);
634    const contract = new web3.eth.Contract(nonFungibleAbi as any, address);477    const receiver = helper.eth.createAccount();
635478
636    const events = await recordEvents(contract, async () => {479    const collection = await helper.nft.mintCollection(alice, {});
480    const token = await collection.mintToken(alice);
481    await token.approve(alice, {Substrate: bob.address});
482
637      await transferFromExpectSuccess(collection, tokenId, bob, alice, {Ethereum: receiver}, 1, 'NFT');483    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
484    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft');
485    
486    const events: any = [];
487    contract.events.allEvents((_: any, event: any) => {
488      events.push(event);
638    });489    });
639490
640    expect(events).to.be.deep.equal([491    await token.transferFrom(bob, {Substrate: alice.address}, {Ethereum: receiver});
641      {
642        address,
643        event: 'Transfer',492    
644        args: {493    const event = events[0];
645          from: subToEth(alice.address),494    expect(event.address).to.be.equal(collectionAddress);
495    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));
646          to: receiver,496    expect(event.returnValues.to).to.be.equal(receiver);
647          tokenId: tokenId.toString(),497    expect(event.returnValues.tokenId).to.be.equal(`${token.tokenId}`);
648        },
649      },
650    ]);
651  });498  });
652499
653  itWeb3('Events emitted for transfer()', async ({web3, privateKeyWrapper}) => {500  itEth('Events emitted for transfer()', async ({helper}) => {
654    const collection = await createCollectionExpectSuccess({501    const receiver = helper.eth.createAccount();
655      mode: {type: 'NFT'},
656    });
657    const alice = privateKeyWrapper('//Alice');
658502
659    const receiver = createEthAccount(web3);503    const collection = await helper.nft.mintCollection(alice, {});
504    const token = await collection.mintToken(alice);
660505
661    const tokenId = await createItemExpectSuccess(alice, collection, 'NFT');506    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
662
663    const address = collectionIdToAddress(collection);507    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft');
664    const contract = new web3.eth.Contract(nonFungibleAbi as any, address);508    
665509    const events: any = [];
666    const events = await recordEvents(contract, async () => {510    contract.events.allEvents((_: any, event: any) => {
667      await transferExpectSuccess(collection, tokenId, alice, {Ethereum: receiver}, 1, 'NFT');511      events.push(event);
668    });512    });
669513
670    expect(events).to.be.deep.equal([514    await token.transfer(alice, {Ethereum: receiver});
671      {515    
672        address,516    const event = events[0];
673        event: 'Transfer',517    expect(event.address).to.be.equal(collectionAddress);
674        args: {518    expect(event.returnValues.from).to.be.equal(helper.address.substrateToEth(alice.address));
675          from: subToEth(alice.address),
676          to: receiver,519    expect(event.returnValues.to).to.be.equal(receiver);
677          tokenId: tokenId.toString(),520    expect(event.returnValues.tokenId).to.be.equal(`${token.tokenId}`);
678        },
679      },
680    ]);
681  });521  });
682});522});
683523
684describe('Common metadata', () => {524describe('Common metadata', () => {
685  itWeb3('Returns collection name', async ({api, web3, privateKeyWrapper}) => {525  let donor: IKeyringPair;
526  let alice: IKeyringPair;
527
528  before(async function() {
686    const collection = await createCollectionExpectSuccess({529    await usingEthPlaygrounds(async (helper, privateKey) => {
687      name: 'token name',530      donor = privateKey('//Alice');
688      mode: {type: 'NFT'},531      [alice] = await helper.arrange.createAccounts([20n], donor);
689    });532    });
690    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);533  });
691534
692    const address = collectionIdToAddress(collection);535  itEth('Returns collection name', async ({helper}) => {
693    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: caller, ...GAS_ARGS});536    const caller = await helper.eth.createAccountWithBalance(donor);
694    const name = await contract.methods.name().call();537    const collection = await helper.nft.mintCollection(alice, {name: 'oh River', tokenPrefix: 'CHANGE'});
695538
696    expect(name).to.equal('token name');539    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);
540    const name = await contract.methods.name().call();
541    expect(name).to.equal('oh River');
697  });542  });
698543
699  itWeb3('Returns symbol name', async ({api, web3, privateKeyWrapper}) => {544  itEth('Returns symbol name', async ({helper}) => {
700    const collection = await createCollectionExpectSuccess({545    const caller = await helper.eth.createAccountWithBalance(donor);
701      tokenPrefix: 'TOK',
702      mode: {type: 'NFT'},
703    });
704    const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);546    const collection = await helper.nft.mintCollection(alice, {name: 'oh River', tokenPrefix: 'CHANGE'});
705547
706    const address = collectionIdToAddress(collection);548    const contract = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller);
707    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: caller, ...GAS_ARGS});
708    const symbol = await contract.methods.symbol().call();549    const symbol = await contract.methods.symbol().call();
709
710    expect(symbol).to.equal('TOK');550    expect(symbol).to.equal('CHANGE');
711  });551  });
712});552});