`9cb826388a25`

1 file changed

modifiedtests/src/eth/collectionAdmin.test.tsdiff before after both
14// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.14// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1515
16import {IKeyringPair} from '@polkadot/types/types';16import {IKeyringPair} from '@polkadot/types/types';
17import privateKey from '../substrate/privateKey';
18import {UNIQUE} from '../util/helpers';17import {UNIQUE} from '../util/helpers';
19import {18import {
20  createEthAccount,
21  createEthAccountWithBalance,
22  evmCollection,
23  evmCollectionHelpers,
24  getCollectionAddressFromResult,
25  itWeb3,
26  recordEthFee,19  recordEthFee,
27} from './util/helpers';20} from './util/helpers';
28import {usingEthPlaygrounds, itEth, expect} from './util/playgrounds';21import {usingEthPlaygrounds, itEth, expect} from './util/playgrounds';
62      .to.be.eq(newAdmin.address.toLocaleLowerCase());55      .to.be.eq(newAdmin.address.toLocaleLowerCase());
63  });56  });
6457
58  //FIXME:
65  itWeb3('Verify owner or admin', async ({api, web3, privateKeyWrapper}) => {59  itEth('Verify owner or admin', async ({helper}) => {
66    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);60    const owner = await helper.eth.createAccountWithBalance(donor);
67    const collectionHelper = evmCollectionHelpers(web3, owner);
68
69    const result = await collectionHelper.methods61    const {collectionAddress} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
70      .createNonfungibleCollection('A', 'B', 'C')
71      .send();
72    const {collectionIdAddress} = await getCollectionAddressFromResult(api, result);
7362
74    const newAdmin = createEthAccount(web3);63    const newAdmin = helper.eth.createAccount();
75    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);64    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
76    expect(await collectionEvm.methods.isOwnerOrAdmin(newAdmin).call()).to.be.false;65    expect(await collectionEvm.methods.isOwnerOrAdmin(newAdmin).call()).to.be.false;
77    await collectionEvm.methods.addCollectionAdmin(newAdmin).send();66    await collectionEvm.methods.addCollectionAdmin(newAdmin).send();
78    expect(await collectionEvm.methods.isOwnerOrAdmin(newAdmin).call()).to.be.true;67    expect(await collectionEvm.methods.isOwnerOrAdmin(newAdmin).call()).to.be.true;
79  });68  });
8069
81  itWeb3('(!negative tests!) Add admin by ADMIN is not allowed', async ({api, web3, privateKeyWrapper}) => {70  itEth('(!negative tests!) Add admin by ADMIN is not allowed', async ({helper}) => {
82    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
83    const collectionHelper = evmCollectionHelpers(web3, owner);
84
85    const result = await collectionHelper.methods71    const owner = await helper.eth.createAccountWithBalance(donor);
86      .createNonfungibleCollection('A', 'B', 'C')
87      .send();
88    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);72    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
8973
90    const admin = await createEthAccountWithBalance(api, web3, privateKeyWrapper);74    const admin = await helper.eth.createAccountWithBalance(donor);
91    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);75    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
92    await collectionEvm.methods.addCollectionAdmin(admin).send();76    await collectionEvm.methods.addCollectionAdmin(admin).send();
9377
94    const user = createEthAccount(web3);78    const user = helper.eth.createAccount();
95    await expect(collectionEvm.methods.addCollectionAdmin(user).call({from: admin}))79    await expect(collectionEvm.methods.addCollectionAdmin(user).call({from: admin}))
96      .to.be.rejectedWith('NoPermission');80      .to.be.rejectedWith('NoPermission');
9781
98    const adminList = await api.rpc.unique.adminlist(collectionId);82    const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
99    expect(adminList.length).to.be.eq(1);83    expect(adminList.length).to.be.eq(1);
100    expect(adminList[0].asEthereum.toString().toLocaleLowerCase())84    expect(adminList[0].asEthereum.toString().toLocaleLowerCase())
101      .to.be.eq(admin.toLocaleLowerCase());85      .to.be.eq(admin.toLocaleLowerCase());
102  });86  });
10387
104  itWeb3('(!negative tests!) Add admin by USER is not allowed', async ({api, web3, privateKeyWrapper}) => {88  itEth('(!negative tests!) Add admin by USER is not allowed', async ({helper}) => {
105    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
106    const collectionHelper = evmCollectionHelpers(web3, owner);
107
108    const result = await collectionHelper.methods89    const owner = await helper.eth.createAccountWithBalance(donor);
109      .createNonfungibleCollection('A', 'B', 'C')
110      .send();
111    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);90    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
11291
113    const notAdmin = await createEthAccountWithBalance(api, web3, privateKeyWrapper);92    const notAdmin = await helper.eth.createAccountWithBalance(donor);
114    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);93    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
11594
116    const user = createEthAccount(web3);95    const user = helper.eth.createAccount();
117    await expect(collectionEvm.methods.addCollectionAdmin(user).call({from: notAdmin}))96    await expect(collectionEvm.methods.addCollectionAdmin(user).call({from: notAdmin}))
118      .to.be.rejectedWith('NoPermission');97      .to.be.rejectedWith('NoPermission');
11998
120    const adminList = await api.rpc.unique.adminlist(collectionId);99    const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
121    expect(adminList.length).to.be.eq(0);100    expect(adminList.length).to.be.eq(0);
122  });101  });
123102
124  itWeb3('(!negative tests!) Add substrate admin by ADMIN is not allowed', async ({api, web3, privateKeyWrapper}) => {103  itEth('(!negative tests!) Add substrate admin by ADMIN is not allowed', async ({helper}) => {
125    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
126    const collectionHelper = evmCollectionHelpers(web3, owner);
127
128    const result = await collectionHelper.methods104    const owner = await helper.eth.createAccountWithBalance(donor);
129      .createNonfungibleCollection('A', 'B', 'C')
130      .send();
131    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);105    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
132106
133    const admin = await createEthAccountWithBalance(api, web3, privateKeyWrapper);107    const admin = await helper.eth.createAccountWithBalance(donor);
134    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);108    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
135    await collectionEvm.methods.addCollectionAdmin(admin).send();109    await collectionEvm.methods.addCollectionAdmin(admin).send();
136110
137    const notAdmin = privateKey('//Alice');111    const [notAdmin] = await helper.arrange.createAccounts([10n], donor);
138    await expect(collectionEvm.methods.addCollectionAdminSubstrate(notAdmin.addressRaw).call({from: admin}))112    await expect(collectionEvm.methods.addCollectionAdminSubstrate(notAdmin.addressRaw).call({from: admin}))
139      .to.be.rejectedWith('NoPermission');113      .to.be.rejectedWith('NoPermission');
140114
141    const adminList = await api.rpc.unique.adminlist(collectionId);115    const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
142    expect(adminList.length).to.be.eq(1);116    expect(adminList.length).to.be.eq(1);
143    expect(adminList[0].asEthereum.toString().toLocaleLowerCase())117    expect(adminList[0].asEthereum.toString().toLocaleLowerCase())
144      .to.be.eq(admin.toLocaleLowerCase());118      .to.be.eq(admin.toLocaleLowerCase());
145  });119  });
146120
147  itWeb3('(!negative tests!) Add substrate admin by USER is not allowed', async ({api, web3, privateKeyWrapper}) => {121  itEth('(!negative tests!) Add substrate admin by USER is not allowed', async ({helper}) => {
148    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
149    const collectionHelper = evmCollectionHelpers(web3, owner);
150
151    const result = await collectionHelper.methods122    const owner = await helper.eth.createAccountWithBalance(donor);
152      .createNonfungibleCollection('A', 'B', 'C')
153      .send();
154    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);123    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
155124
156    const notAdmin0 = await createEthAccountWithBalance(api, web3, privateKeyWrapper);125    const notAdmin0 = await helper.eth.createAccountWithBalance(donor);
157    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);126    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
158    const notAdmin1 = privateKey('//Alice');127    const [notAdmin1] = await helper.arrange.createAccounts([10n], donor);
159    await expect(collectionEvm.methods.addCollectionAdminSubstrate(notAdmin1.addressRaw).call({from: notAdmin0}))128    await expect(collectionEvm.methods.addCollectionAdminSubstrate(notAdmin1.addressRaw).call({from: notAdmin0}))
160      .to.be.rejectedWith('NoPermission');129      .to.be.rejectedWith('NoPermission');
161130
162    const adminList = await api.rpc.unique.adminlist(collectionId);131    const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
163    expect(adminList.length).to.be.eq(0);132    expect(adminList.length).to.be.eq(0);
164  });133  });
165});134});
166135
167describe('Remove collection admins', () => {136describe('Remove collection admins', () => {
137  let donor: IKeyringPair;
138
139  before(async function() {
140    await usingEthPlaygrounds(async (_helper, privateKey) => {
141      donor = privateKey('//Alice');
142    });
143  });
144
168  itWeb3('Remove admin by owner', async ({api, web3, privateKeyWrapper}) => {145  itEth('Remove admin by owner', async ({helper}) => {
169    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
170    const collectionHelper = evmCollectionHelpers(web3, owner);
171
172    const result = await collectionHelper.methods146    const owner = await helper.eth.createAccountWithBalance(donor);
173      .createNonfungibleCollection('A', 'B', 'C')
174      .send();
175    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);147    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
176148
177    const newAdmin = createEthAccount(web3);149    const newAdmin = helper.eth.createAccount();
178    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);150    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
179    await collectionEvm.methods.addCollectionAdmin(newAdmin).send();151    await collectionEvm.methods.addCollectionAdmin(newAdmin).send();
152
180    {153    {
181      const adminList = await api.rpc.unique.adminlist(collectionId);154      const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
182      expect(adminList.length).to.be.eq(1);155      expect(adminList.length).to.be.eq(1);
183      expect(adminList[0].asEthereum.toString().toLocaleLowerCase())156      expect(adminList[0].asEthereum.toString().toLocaleLowerCase())
184        .to.be.eq(newAdmin.toLocaleLowerCase());157        .to.be.eq(newAdmin.toLocaleLowerCase());
185    }158    }
186159
187    await collectionEvm.methods.removeCollectionAdmin(newAdmin).send();160    await collectionEvm.methods.removeCollectionAdmin(newAdmin).send();
188    const adminList = await api.rpc.unique.adminlist(collectionId);161    const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
189    expect(adminList.length).to.be.eq(0);162    expect(adminList.length).to.be.eq(0);
190  });163  });
191164
192  itWeb3('Remove substrate admin by owner', async ({api, web3, privateKeyWrapper}) => {165  itEth('Remove substrate admin by owner', async ({helper}) => {
193    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);166    const owner = await helper.eth.createAccountWithBalance(donor);
194    const collectionHelper = evmCollectionHelpers(web3, owner);
195
196    const result = await collectionHelper.methods167    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
197      .createNonfungibleCollection('A', 'B', 'C')168
198      .send();
199    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);169    const [newAdmin] = await helper.arrange.createAccounts([10n], donor);
200
201    const newAdmin = privateKeyWrapper('//Alice');
202    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);170    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
203    await collectionEvm.methods.addCollectionAdminSubstrate(newAdmin.addressRaw).send();171    await collectionEvm.methods.addCollectionAdminSubstrate(newAdmin.addressRaw).send();
204    {172    {
205      const adminList = await api.rpc.unique.adminlist(collectionId);173      const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
206      expect(adminList[0].asSubstrate.toString().toLocaleLowerCase())174      expect(adminList[0].asSubstrate.toString().toLocaleLowerCase())
207        .to.be.eq(newAdmin.address.toLocaleLowerCase());175        .to.be.eq(newAdmin.address.toLocaleLowerCase());
208    }176    }
209177
210    await collectionEvm.methods.removeCollectionAdminSubstrate(newAdmin.addressRaw).send();178    await collectionEvm.methods.removeCollectionAdminSubstrate(newAdmin.addressRaw).send();
211    const adminList = await api.rpc.unique.adminlist(collectionId);179    const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
212    expect(adminList.length).to.be.eq(0);180    expect(adminList.length).to.be.eq(0);
213  });181  });
214182
215  itWeb3('(!negative tests!) Remove admin by ADMIN is not allowed', async ({api, web3, privateKeyWrapper}) => {183  itEth('(!negative tests!) Remove admin by ADMIN is not allowed', async ({helper}) => {
216    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
217    const collectionHelper = evmCollectionHelpers(web3, owner);
218
219    const result = await collectionHelper.methods184    const owner = await helper.eth.createAccountWithBalance(donor);
220      .createNonfungibleCollection('A', 'B', 'C')
221      .send();
222    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);185    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
223186
224    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);187    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
225188
226    const admin0 = await createEthAccountWithBalance(api, web3, privateKeyWrapper);189    const admin0 = await helper.eth.createAccountWithBalance(donor);
227    await collectionEvm.methods.addCollectionAdmin(admin0).send();190    await collectionEvm.methods.addCollectionAdmin(admin0).send();
228    const admin1 = createEthAccount(web3);191    const admin1 = await helper.eth.createAccountWithBalance(donor);
229    await collectionEvm.methods.addCollectionAdmin(admin1).send();192    await collectionEvm.methods.addCollectionAdmin(admin1).send();
230193
231    await expect(collectionEvm.methods.removeCollectionAdmin(admin1).call({from: admin0}))194    await expect(collectionEvm.methods.removeCollectionAdmin(admin1).call({from: admin0}))
232      .to.be.rejectedWith('NoPermission');195      .to.be.rejectedWith('NoPermission');
233    {196    {
234      const adminList = await api.rpc.unique.adminlist(collectionId);197      const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
235      expect(adminList.length).to.be.eq(2);198      expect(adminList.length).to.be.eq(2);
236      expect(adminList.toString().toLocaleLowerCase())199      expect(adminList.toString().toLocaleLowerCase())
237        .to.be.deep.contains(admin0.toLocaleLowerCase())200        .to.be.deep.contains(admin0.toLocaleLowerCase())
238        .to.be.deep.contains(admin1.toLocaleLowerCase());201        .to.be.deep.contains(admin1.toLocaleLowerCase());
239    }202    }
240  });203  });
241204
242  itWeb3('(!negative tests!) Remove admin by USER is not allowed', async ({api, web3, privateKeyWrapper}) => {205  itEth('(!negative tests!) Remove admin by USER is not allowed', async ({helper}) => {
243    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
244    const collectionHelper = evmCollectionHelpers(web3, owner);
245
246    const result = await collectionHelper.methods206    const owner = await helper.eth.createAccountWithBalance(donor);
247      .createNonfungibleCollection('A', 'B', 'C')
248      .send();
249    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);207    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
250208
251    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);209    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
252210
253    const admin = await createEthAccountWithBalance(api, web3, privateKeyWrapper);211    const admin = await helper.eth.createAccountWithBalance(donor);
254    await collectionEvm.methods.addCollectionAdmin(admin).send();212    await collectionEvm.methods.addCollectionAdmin(admin).send();
255    const notAdmin = createEthAccount(web3);213    const notAdmin = helper.eth.createAccount();
256214
257    await expect(collectionEvm.methods.removeCollectionAdmin(admin).call({from: notAdmin}))215    await expect(collectionEvm.methods.removeCollectionAdmin(admin).call({from: notAdmin}))
258      .to.be.rejectedWith('NoPermission');216      .to.be.rejectedWith('NoPermission');
259    {217    {
260      const adminList = await api.rpc.unique.adminlist(collectionId);218      const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
261      expect(adminList[0].asEthereum.toString().toLocaleLowerCase())219      expect(adminList[0].asEthereum.toString().toLocaleLowerCase())
262        .to.be.eq(admin.toLocaleLowerCase());220        .to.be.eq(admin.toLocaleLowerCase());
263      expect(adminList.length).to.be.eq(1);221      expect(adminList.length).to.be.eq(1);
264    }222    }
265  });223  });
266224
267  itWeb3('(!negative tests!) Remove substrate admin by ADMIN is not allowed', async ({api, web3, privateKeyWrapper}) => {225  itEth('(!negative tests!) Remove substrate admin by ADMIN is not allowed', async ({helper}) => {
268    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);226    const owner = await helper.eth.createAccountWithBalance(donor);
269    const collectionHelper = evmCollectionHelpers(web3, owner);
270
271    const result = await collectionHelper.methods227    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
272      .createNonfungibleCollection('A', 'B', 'C')228
273      .send();
274    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);229    const [adminSub] = await helper.arrange.createAccounts([10n], donor);
275
276    const adminSub = privateKeyWrapper('//Alice');
277    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);230    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
278    await collectionEvm.methods.addCollectionAdminSubstrate(adminSub.addressRaw).send();231    await collectionEvm.methods.addCollectionAdminSubstrate(adminSub.addressRaw).send();
279    const adminEth = await createEthAccountWithBalance(api, web3, privateKeyWrapper);232    const adminEth = await helper.eth.createAccountWithBalance(donor);
280    await collectionEvm.methods.addCollectionAdmin(adminEth).send();233    await collectionEvm.methods.addCollectionAdmin(adminEth).send();
281234
282    await expect(collectionEvm.methods.removeCollectionAdminSubstrate(adminSub.addressRaw).call({from: adminEth}))235    await expect(collectionEvm.methods.removeCollectionAdminSubstrate(adminSub.addressRaw).call({from: adminEth}))
283      .to.be.rejectedWith('NoPermission');236      .to.be.rejectedWith('NoPermission');
284237
285    const adminList = await api.rpc.unique.adminlist(collectionId);238    const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
286    expect(adminList.length).to.be.eq(2);239    expect(adminList.length).to.be.eq(2);
287    expect(adminList.toString().toLocaleLowerCase())240    expect(adminList.toString().toLocaleLowerCase())
288      .to.be.deep.contains(adminSub.address.toLocaleLowerCase())241      .to.be.deep.contains(adminSub.address.toLocaleLowerCase())
289      .to.be.deep.contains(adminEth.toLocaleLowerCase());242      .to.be.deep.contains(adminEth.toLocaleLowerCase());
290  });243  });
291244
292  itWeb3('(!negative tests!) Remove substrate admin by USER is not allowed', async ({api, web3, privateKeyWrapper}) => {245  itEth('(!negative tests!) Remove substrate admin by USER is not allowed', async ({helper}) => {
293    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);246    const owner = await helper.eth.createAccountWithBalance(donor);
294    const collectionHelper = evmCollectionHelpers(web3, owner);
295
296    const result = await collectionHelper.methods247    const {collectionAddress, collectionId} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
297      .createNonfungibleCollection('A', 'B', 'C')248
298      .send();
299    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);249    const [adminSub] = await helper.arrange.createAccounts([10n], donor);
300
301    const adminSub = privateKeyWrapper('//Alice');
302    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);250    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
303    await collectionEvm.methods.addCollectionAdminSubstrate(adminSub.addressRaw).send();251    await collectionEvm.methods.addCollectionAdminSubstrate(adminSub.addressRaw).send();
304    const notAdminEth = await createEthAccountWithBalance(api, web3, privateKeyWrapper);252    const notAdminEth = await helper.eth.createAccountWithBalance(donor);
305253
306    await expect(collectionEvm.methods.removeCollectionAdminSubstrate(adminSub.addressRaw).call({from: notAdminEth}))254    await expect(collectionEvm.methods.removeCollectionAdminSubstrate(adminSub.addressRaw).call({from: notAdminEth}))
307      .to.be.rejectedWith('NoPermission');255      .to.be.rejectedWith('NoPermission');
308256
309    const adminList = await api.rpc.unique.adminlist(collectionId);257    const adminList = await helper.api!.rpc.unique.adminlist(collectionId);
310    expect(adminList.length).to.be.eq(1);258    expect(adminList.length).to.be.eq(1);
311    expect(adminList[0].asSubstrate.toString().toLocaleLowerCase())259    expect(adminList[0].asSubstrate.toString().toLocaleLowerCase())
312      .to.be.eq(adminSub.address.toLocaleLowerCase());260      .to.be.eq(adminSub.address.toLocaleLowerCase());
313  });261  });
314});262});
315263
316describe('Change owner tests', () => {264describe('Change owner tests', () => {
265  let donor: IKeyringPair;
266
267  before(async function() {
268    await usingEthPlaygrounds(async (_helper, privateKey) => {
269      donor = privateKey('//Alice');
270    });
271  });
272
317  itWeb3('Change owner', async ({api, web3, privateKeyWrapper}) => {273  itEth('Change owner', async ({helper}) => {
318    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);274    const owner = await helper.eth.createAccountWithBalance(donor);
319    const newOwner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);275    const newOwner = await helper.eth.createAccountWithBalance(donor);
320    const collectionHelper = evmCollectionHelpers(web3, owner);
321    const result = await collectionHelper.methods276    const {collectionAddress} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
322      .createNonfungibleCollection('A', 'B', 'C')
323      .send();
324    const {collectionIdAddress} = await getCollectionAddressFromResult(api, result);
325    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);277    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
326278
327    await collectionEvm.methods.setOwner(newOwner).send();279    await collectionEvm.methods.setOwner(newOwner).send();
328280
329    expect(await collectionEvm.methods.isOwnerOrAdmin(owner).call()).to.be.false;281    expect(await collectionEvm.methods.isOwnerOrAdmin(owner).call()).to.be.false;
330    expect(await collectionEvm.methods.isOwnerOrAdmin(newOwner).call()).to.be.true;282    expect(await collectionEvm.methods.isOwnerOrAdmin(newOwner).call()).to.be.true;
331  });283  });
332284
333  itWeb3('change owner call fee', async ({web3, api, privateKeyWrapper}) => {285  itEth('change owner call fee', async ({helper}) => {
334    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);286    const owner = await helper.eth.createAccountWithBalance(donor);
335    const newOwner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);287    const newOwner = await helper.eth.createAccountWithBalance(donor);
336    const collectionHelper = evmCollectionHelpers(web3, owner);
337    const result = await collectionHelper.methods288    const {collectionAddress} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
338      .createNonfungibleCollection('A', 'B', 'C')
339      .send();
340    const {collectionIdAddress} = await getCollectionAddressFromResult(api, result);
341    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);289    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
342290
343    const cost = await recordEthFee(api, owner, () => collectionEvm.methods.setOwner(newOwner).send());291    const cost = await recordEthFee(helper.api!, owner, () => collectionEvm.methods.setOwner(newOwner).send());
344    expect(cost < BigInt(0.2 * Number(UNIQUE)));292    expect(cost < BigInt(0.2 * Number(UNIQUE)));
345    expect(cost > 0);293    expect(cost > 0);
346  });294  });
347295
296  //FIXME
348  itWeb3('(!negative tests!) call setOwner by non owner', async ({api, web3, privateKeyWrapper}) => {297  itEth('(!negative tests!) call setOwner by non owner', async ({helper}) => {
349    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);298    const owner = await helper.eth.createAccountWithBalance(donor);
350    const newOwner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);299    const newOwner = await helper.eth.createAccountWithBalance(donor);
351    const collectionHelper = evmCollectionHelpers(web3, owner);
352    const result = await collectionHelper.methods300    const {collectionAddress} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
353      .createNonfungibleCollection('A', 'B', 'C')
354      .send();
355    const {collectionIdAddress} = await getCollectionAddressFromResult(api, result);
356    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);301    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
357302
358    await expect(collectionEvm.methods.setOwner(newOwner).send({from: newOwner})).to.be.rejected;303    await expect(collectionEvm.methods.setOwner(newOwner).send({from: newOwner})).to.be.rejected;
359    expect(await collectionEvm.methods.isOwnerOrAdmin(newOwner).call()).to.be.false;304    expect(await collectionEvm.methods.isOwnerOrAdmin(newOwner).call()).to.be.false;
360  });305  });
361});306});
362307
363describe('Change substrate owner tests', () => {308describe('Change substrate owner tests', () => {
309  let donor: IKeyringPair;
310
311  before(async function() {
312    await usingEthPlaygrounds(async (_helper, privateKey) => {
313      donor = privateKey('//Alice');
314    });
315  });
316
317  //FIXME
364  itWeb3('Change owner', async ({api, web3, privateKeyWrapper}) => {318  itEth('Change owner', async ({helper}) => {
365    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);319    const owner = await helper.eth.createAccountWithBalance(donor);
366    const newOwner = privateKeyWrapper('//Alice');
367    const collectionHelper = evmCollectionHelpers(web3, owner);
368    const result = await collectionHelper.methods320    const [newOwner] = await helper.arrange.createAccounts([10n], donor);
369      .createNonfungibleCollection('A', 'B', 'C')
370      .send();
371    const {collectionIdAddress} = await getCollectionAddressFromResult(api, result);321    const {collectionAddress} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
372    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);322    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
373323
374    expect(await collectionEvm.methods.isOwnerOrAdmin(owner).call()).to.be.true;324    expect(await collectionEvm.methods.isOwnerOrAdmin(owner).call()).to.be.true;
375    expect(await collectionEvm.methods.isOwnerOrAdminSubstrate(newOwner.addressRaw).call()).to.be.false;325    expect(await collectionEvm.methods.isOwnerOrAdminSubstrate(newOwner.addressRaw).call()).to.be.false;
380    expect(await collectionEvm.methods.isOwnerOrAdminSubstrate(newOwner.addressRaw).call()).to.be.true;330    expect(await collectionEvm.methods.isOwnerOrAdminSubstrate(newOwner.addressRaw).call()).to.be.true;
381  });331  });
382332
383  itWeb3('change owner call fee', async ({web3, api, privateKeyWrapper}) => {333  itEth('change owner call fee', async ({helper}) => {
384    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);334    const owner = await helper.eth.createAccountWithBalance(donor);
385    const newOwner = privateKeyWrapper('//Alice');
386    const collectionHelper = evmCollectionHelpers(web3, owner);
387    const result = await collectionHelper.methods335    const [newOwner] = await helper.arrange.createAccounts([10n], donor);
388      .createNonfungibleCollection('A', 'B', 'C')
389      .send();
390    const {collectionIdAddress} = await getCollectionAddressFromResult(api, result);336    const {collectionAddress} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
391    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);337    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
392338
393    const cost = await recordEthFee(api, owner, () => collectionEvm.methods.setOwnerSubstrate(newOwner.addressRaw).send());339    const cost = await recordEthFee(helper.api!, owner, () => collectionEvm.methods.setOwnerSubstrate(newOwner.addressRaw).send());
394    expect(cost < BigInt(0.2 * Number(UNIQUE)));340    expect(cost < BigInt(0.2 * Number(UNIQUE)));
395    expect(cost > 0);341    expect(cost > 0);
396  });342  });
397343
344  //FIXME
398  itWeb3('(!negative tests!) call setOwner by non owner', async ({api, web3, privateKeyWrapper}) => {345  itEth('(!negative tests!) call setOwner by non owner', async ({helper}) => {
399    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);346    const owner = await helper.eth.createAccountWithBalance(donor);
400    const otherReceiver = await createEthAccountWithBalance(api, web3, privateKeyWrapper);347    const otherReceiver = await helper.eth.createAccountWithBalance(donor);
401    const newOwner = privateKeyWrapper('//Alice');
402    const collectionHelper = evmCollectionHelpers(web3, owner);
403    const result = await collectionHelper.methods348    const [newOwner] = await helper.arrange.createAccounts([10n], donor);
404      .createNonfungibleCollection('A', 'B', 'C')
405      .send();
406    const {collectionIdAddress} = await getCollectionAddressFromResult(api, result);349    const {collectionAddress} = await helper.eth.createNonfungibleCollection(owner, 'A', 'B', 'C');
407    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);350    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
408351
409    await expect(collectionEvm.methods.setOwnerSubstrate(newOwner.addressRaw).send({from: otherReceiver})).to.be.rejected;352    await expect(collectionEvm.methods.setOwnerSubstrate(newOwner.addressRaw).send({from: otherReceiver})).to.be.rejected;
410    expect(await collectionEvm.methods.isOwnerOrAdminSubstrate(newOwner.addressRaw).call()).to.be.false;353    expect(await collectionEvm.methods.isOwnerOrAdminSubstrate(newOwner.addressRaw).call()).to.be.false;