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

110    const [alice, ...accounts] = await helper.arrange.createAccounts([10n, 0n, 0n, 0n, 0n, 0n, 0n, 0n], donor);110    const [alice, ...accounts] = await helper.arrange.createAccounts([10n, 0n, 0n, 0n, 0n, 0n, 0n, 0n], donor);
111    const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});111    const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
112112
113    const chainAdminLimit = (helper.api!.consts.common.collectionAdminsLimit as any).toNumber();113    const chainAdminLimit = (helper.getApi().consts.common.collectionAdminsLimit as any).toNumber();
114    expect(chainAdminLimit).to.be.equal(5);114    expect(chainAdminLimit).to.be.equal(5);
115115
116    for (let i = 0; i < chainAdminLimit; i++) {116    for (let i = 0; i < chainAdminLimit; i++) {

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 {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import {18import {itSub, usingPlaygrounds, Pallets, requirePalletsOrSkip} from './util/playgrounds';
19  normalizeAccountId,
20  getModuleNames,
21  Pallets,
22} from './util/helpers';
23import {itSub, usingPlaygrounds} from './util/playgrounds';
24import {encodeAddress} from '@polkadot/util-crypto';19import {encodeAddress} from '@polkadot/util-crypto';
25import {stringToU8a} from '@polkadot/util';20import {stringToU8a} from '@polkadot/util';
26import {SponsoringMode} from './eth/util/helpers';
27import {DevUniqueHelper} from './util/playgrounds/unique.dev';21import {DevUniqueHelper} from './util/playgrounds/unique.dev';
28import {itEth, expect} from './eth/util/playgrounds';22import {itEth, expect, SponsoringMode} from './eth/util/playgrounds';
2923
30let alice: IKeyringPair;24let alice: IKeyringPair;
31let palletAdmin: IKeyringPair;25let palletAdmin: IKeyringPair;
42describe('App promotion', () => {36describe('App promotion', () => {
43  before(async function () {37  before(async function () {
44    await usingPlaygrounds(async (helper, privateKey) => {38    await usingPlaygrounds(async (helper, privateKey) => {
45      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();39      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);
46      alice = await privateKey({filename: __filename});40      alice = await privateKey({filename: __filename});
47      [palletAdmin] = await helper.arrange.createAccounts([100n], alice);41      [palletAdmin] = await helper.arrange.createAccounts([100n], alice);
48      await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));42      const api = helper.getApi();
43      await helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));
49      nominal = helper.balance.getOneTokenNominal();44      nominal = helper.balance.getOneTokenNominal();
50      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);45      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);
51      await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);46      await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);
231  226  
232  describe('admin adress', () => {227  describe('admin adress', () => {
233    itSub('can be set by sudo only', async ({helper}) => {228    itSub('can be set by sudo only', async ({helper}) => {
229      const api = helper.getApi();
234      const nonAdmin = accounts.pop()!;230      const nonAdmin = accounts.pop()!;
235      // nonAdmin can not set admin not from himself nor as a sudo231      // nonAdmin can not set admin not from himself nor as a sudo
236      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.rejected;232      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.rejected;
237      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.rejected;233      await expect(helper.signTransaction(nonAdmin, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.rejected;
238  234  
239      // Alice can235      // Alice can
240      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;236      await expect(helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;
241    });237    });
242    238    
243    itSub('can be any valid CrossAccountId', async ({helper}) => {239    itSub('can be any valid CrossAccountId', async ({helper}) => {
244      // We are not going to set an eth address as a sponsor,240      // We are not going to set an eth address as a sponsor,
245      // but we do want to check, it doesn't break anything;241      // but we do want to check, it doesn't break anything;
242      const api = helper.getApi();
246      const account = accounts.pop()!;243      const account = accounts.pop()!;
247      const ethAccount = helper.address.substrateToEth(account.address); 244      const ethAccount = helper.address.substrateToEth(account.address); 
248      // Alice sets Ethereum address as a sudo. Then Substrate address back...245      // Alice sets Ethereum address as a sudo. Then Substrate address back...
249      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.fulfilled;246      await expect(helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.fulfilled;
250      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;247      await expect(helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;
251        248        
252      // ...It doesn't break anything;249      // ...It doesn't break anything;
253      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});250      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
254      await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;251      await expect(helper.signTransaction(account, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;
255    });252    });
256  253  
257    itSub('can be reassigned', async ({helper}) => {254    itSub('can be reassigned', async ({helper}) => {
255      const api = helper.getApi();
258      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];256      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];
259      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});257      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
260        258        
261      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.fulfilled;259      await expect(helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: oldAdmin.address})))).to.be.fulfilled;
262      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.fulfilled;260      await expect(helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: newAdmin.address})))).to.be.fulfilled;
263      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;261      await expect(helper.signTransaction(oldAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;
264        262        
265      await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;263      await expect(helper.signTransaction(newAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;
266    });264    });
267  });265  });
268  266  
269  describe('collection sponsoring', () => {267  describe('collection sponsoring', () => {
270    before(async function () {268    before(async function () {
271      await usingPlaygrounds(async (helper) => {269      await usingPlaygrounds(async (helper) => {
272        const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));270        const api = helper.getApi();
271        const tx = api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));
273        await helper.signTransaction(alice, tx);272        await helper.signTransaction(alice, tx);
274      });273      });
275    });274    });
276  275  
277    itSub('should actually sponsor transactions', async ({helper}) => {276    itSub('should actually sponsor transactions', async ({helper}) => {
277      const api = helper.getApi();
278      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];278      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];
279      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});279      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});
280      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});280      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});
281      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));281      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));
282      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);282      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);
283  283  
284      await token.transfer(tokenSender, {Substrate: receiver.address});284      await token.transfer(tokenSender, {Substrate: receiver.address});
291    });291    });
292  292  
293    itSub('can not be set by non admin', async ({helper}) => {293    itSub('can not be set by non admin', async ({helper}) => {
294      const api = helper.getApi();
294      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];295      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];
295  296  
296      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});297      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
297        298        
298      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;299      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;
299      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');300      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');
300    });301    });
301  302  
302    itSub('should set pallet address as confirmed admin', async ({helper}) => {303    itSub('should set pallet address as confirmed admin', async ({helper}) => {
304      const api = helper.getApi();
303      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];305      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];
304        306        
305      // Can set sponsoring for collection without sponsor307      // Can set sponsoring for collection without sponsor
306      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});308      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});
307      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;309      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;
308      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});310      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
309  311  
310      // Can set sponsoring for collection with unconfirmed sponsor312      // Can set sponsoring for collection with unconfirmed sponsor
311      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});313      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});
312      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});314      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});
313      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;315      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;
314      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});316      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
315  317  
316      // Can set sponsoring for collection with confirmed sponsor318      // Can set sponsoring for collection with confirmed sponsor
317      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});319      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});
318      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);320      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);
319      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;321      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;
320      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});322      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
321    });323    });
322  324  
323    itSub('can be overwritten by collection owner', async ({helper}) => {    325    itSub('can be overwritten by collection owner', async ({helper}) => {    
326      const api = helper.getApi();
324      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];327      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];
325      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});328      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
326      const collectionId = collection.collectionId;329      const collectionId = collection.collectionId;
327        330        
328      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;331      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;
329        332        
330      // Collection limits still can be changed by the owner333      // Collection limits still can be changed by the owner
331      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;334      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;
338    });341    });
339    342    
340    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {343    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {
344      const api = helper.getApi();
341      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};345      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};
342      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});346      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});
343  347  
344      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;348      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;
345      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);349      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);
346    });350    });
347    351    
348    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {352    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {
353      const api = helper.getApi();
349      const collectionOwner = accounts.pop()!;354      const collectionOwner = accounts.pop()!;
350        355        
351      // collection has never existed356      // collection has never existed
352      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;357      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;
353      // collection has been burned358      // collection has been burned
354      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});359      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
355      await collection.burn(collectionOwner);360      await collection.burn(collectionOwner);
356  361  
357      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;362      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;
358    });363    });
359  });364  });
360  365  
361  describe('stopSponsoringCollection', () => {366  describe('stopSponsoringCollection', () => {
362    itSub('can not be called by non-admin', async ({helper}) => {    367    itSub('can not be called by non-admin', async ({helper}) => {
368      const api = helper.getApi();
363      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];369      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];
364      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});370      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
365        371        
366      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;372      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;
367        373        
368      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;374      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;
369      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});375      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
370    });376    });
371  377  
372    itSub('should set sponsoring as disabled', async ({helper}) => {378    itSub('should set sponsoring as disabled', async ({helper}) => {
379      const api = helper.getApi();
373      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];380      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];
374      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});381      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});
375      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});382      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});
376        383        
377      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));384      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));
378      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));385      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));
379        386        
380      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');387      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');
381  388  
387    });394    });
388  395  
389    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {396    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {
397      const api = helper.getApi();
390      const collectionOwner = accounts.pop()!;398      const collectionOwner = accounts.pop()!;
391      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});399      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});
392      await collection.confirmSponsorship(collectionOwner);400      await collection.confirmSponsorship(collectionOwner);
393        401        
394      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;402      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;
395        403        
396      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});404      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});
397    });405    });
415      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);423      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);
416      424      
417      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  425      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
418      expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  426      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  
419      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({427      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({
420        confirmed: {428        confirmed: {
421          substrate: palletAddress,429          substrate: palletAddress,
422        },430        },
431      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;439      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;
432  440  
433      // Contract is self sponsored441      // Contract is self sponsored
434      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({442      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({
435        confirmed: {443        confirmed: {
436          ethereum: flipper.options.address.toLowerCase(),444          ethereum: flipper.options.address.toLowerCase(),
437        },445        },
462      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;470      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
463  471  
464      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  472      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
465      expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  473      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  
466      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({474      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({
467        confirmed: {475        confirmed: {
468          ethereum: flipper.options.address.toLowerCase(),476          ethereum: flipper.options.address.toLowerCase(),
469        },477        },
482      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');490      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');
483  491  
484      // contract still self-sponsored 492      // contract still self-sponsored 
485      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({493      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({
486        confirmed: {494        confirmed: {
487          ethereum: flipper.options.address.toLowerCase(),495          ethereum: flipper.options.address.toLowerCase(),
488        },496        },
505      await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);513      await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);
506  514  
507      // Set promotion to the Flipper515      // Set promotion to the Flipper
508      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorContract(flipper.options.address));516      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);
509  517  
510      // Caller calls Flipper518      // Caller calls Flipper
511      await flipper.methods.flip().send({from: caller});519      await flipper.methods.flip().send({from: caller});
536      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);544      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);
537  545  
538      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  546      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  
539      expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  547      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  
540      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({548      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({
541        disabled: null,549        disabled: null,
542      });550      });
543  551  
717// Wait while promotion period less than specified block, to avoid boundary cases725// Wait while promotion period less than specified block, to avoid boundary cases
718// 0 if this should be the beginning of the period.726// 0 if this should be the beginning of the period.
719async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {727async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {
720  const relayBlockNumber = (await helper.api!.query.parachainSystem.validationData()).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();728  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();
721  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;729  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;
722730
723  if (currentPeriodBlock > waitBlockLessThan) {731  if (currentPeriodBlock > waitBlockLessThan) {

60    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});60    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
61    await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});61    await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});
62    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true;62    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true;
63    await helper.signTransaction(alice, helper.api?.tx.unique.approve({Substrate: bob.address}, collectionId, tokenId, 0));63    await helper.signTransaction(alice, helper.constructApiCall('api.tx.unique.approve', [{Substrate: bob.address}, collectionId, tokenId, 0]));
64    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false;64    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false;
65  });65  });
6666
275    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});275    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
276    await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});276    await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});
277    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true;277    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true;
278    await helper.signTransaction(alice, helper.api?.tx.unique.approve({Substrate: bob.address}, collectionId, tokenId, 0));278    await helper.signTransaction(alice, helper.constructApiCall('api.tx.unique.approve', [{Substrate: bob.address}, collectionId, tokenId, 0]));
279    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false;279    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false;
280    const transferTokenFromTx = async () => helper.nft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: bob.address});280    const transferTokenFromTx = async () => helper.nft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: bob.address});
281    await expect(transferTokenFromTx()).to.be.rejected;281    await expect(transferTokenFromTx()).to.be.rejected;
328  itSub('1 for NFT', async ({helper}) => {328  itSub('1 for NFT', async ({helper}) => {
329    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});329    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
330    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});330    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
331    const approveTx = async () => helper.signTransaction(bob, helper.api?.tx.unique.approve({Substrate: charlie.address}, collectionId, tokenId, 2));331    const approveTx = async () => helper.signTransaction(bob, helper.constructApiCall('api.tx.unique.approve', [{Substrate: charlie.address}, collectionId, tokenId, 2]));
332    await expect(approveTx()).to.be.rejected;332    await expect(approveTx()).to.be.rejected;
333    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: charlie.address})).to.be.false;333    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: charlie.address})).to.be.false;
334  });334  });

3737
38describe('Block Production smoke test', () => {38describe('Block Production smoke test', () => {
39  itSub('Node produces new blocks', async ({helper}) => {39  itSub('Node produces new blocks', async ({helper}) => {
40    const blocks: number[] | undefined = await getBlocks(helper.api!);40    const blocks: number[] | undefined = await getBlocks(helper.getApi());
41    expect(blocks[0]).to.be.lessThan(blocks[1]);41    expect(blocks[0]).to.be.lessThan(blocks[1]);
42  });42  });
43});43});

1import {ApiPromise} from '@polkadot/api';
2import {IKeyringPair} from '@polkadot/types/types';1import {IKeyringPair} from '@polkadot/types/types';
3import Web3 from 'web3';2
4import {collectionIdToAddress, createEthAccount, createEthAccountWithBalance, GAS_ARGS, recordEthFee, usingWeb3} from './eth/util/helpers';3import {usingEthPlaygrounds, EthUniqueHelper} from './eth/util/playgrounds';
5import usingApi, {executeTransaction} from './substrate/substrate-api';4
6import {createCollectionExpectSuccess, createItemExpectSuccess, transferExpectSuccess, UNIQUE, waitNewBlocks} from './util/helpers';
7import nonFungibleAbi from './eth/nonFungibleAbi.json';
85
9function linearRegression(points: { x: bigint, y: bigint }[]) {6function linearRegression(points: { x: bigint, y: bigint }[]) {
10  let sumxy = 0n;7  let sumxy = 0n;
59  }).reduce((a, b) => a + b, 0n) / BigInt(points.length));56  }).reduce((a, b) => a + b, 0n) / BigInt(points.length));
60}57}
6158
62async function calibrateWeightToFee(api: ApiPromise, privateKey: (account: string) => IKeyringPair) {59async function calibrateWeightToFee(helper: EthUniqueHelper, privateKey: (account: string) => IKeyringPair) {
63  const alice = privateKey('//Alice');60  const alice = privateKey('//Alice');
64  const bob = privateKey('//Bob');61  const bob = privateKey('//Bob');
65  const dataPoints = [];62  const dataPoints = [];
6663
67  {64  {
68    const collectionId = await createCollectionExpectSuccess();65    const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New collection', tokenPrefix: 'NEW'});
69    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');66    const token = await collection.mintToken(alice, {Substrate: alice.address});
70    const aliceBalanceBefore = (await api.query.system.account(alice.address)).data.free.toBigInt();67    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
71    await transferExpectSuccess(collectionId, tokenId, alice, bob, 1, 'NFT');68    await token.transfer(alice, {Substrate: bob.address});
72    const aliceBalanceAfter = (await api.query.system.account(alice.address)).data.free.toBigInt();69    const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
7370
74    console.log(`Original price: ${Number(aliceBalanceBefore - aliceBalanceAfter) / Number(UNIQUE)} UNQ`);71    console.log(`Original price: ${Number(aliceBalanceBefore - aliceBalanceAfter) / Number(helper.balance.getOneTokenNominal())} UNQ`);
75  }72  }
7673
74  const api = helper.getApi();
77  const defaultCoeff = (api.consts.configuration.defaultWeightToFeeCoefficient as any).toBigInt();75  const defaultCoeff = (api.consts.configuration.defaultWeightToFeeCoefficient as any).toBigInt();
78  for (let i = -5; i < 5; i++) {76  for (let i = -5; i < 5; i++) {
79    await executeTransaction(api, alice, api.tx.sudo.sudo(api.tx.configuration.setWeightToFeeCoefficientOverride(defaultCoeff + defaultCoeff / 1000n * BigInt(i))));77    await helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.configuration.setWeightToFeeCoefficientOverride(defaultCoeff + defaultCoeff / 1000n * BigInt(i))));
8078
81    const coefficient = (await api.query.configuration.weightToFeeCoefficientOverride() as any).toBigInt();79    const coefficient = (await api.query.configuration.weightToFeeCoefficientOverride() as any).toBigInt();
82    const collectionId = await createCollectionExpectSuccess();80    const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New collection', tokenPrefix: 'NEW'});
83    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');81    const token = await collection.mintToken(alice, {Substrate: alice.address});
8482
85    const aliceBalanceBefore = (await api.query.system.account(alice.address)).data.free.toBigInt();83    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
86    await transferExpectSuccess(collectionId, tokenId, alice, bob, 1, 'NFT');84    await token.transfer(alice, {Substrate: bob.address});
87    const aliceBalanceAfter = (await api.query.system.account(alice.address)).data.free.toBigInt();85    const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
8886
89    const transferPrice = aliceBalanceBefore - aliceBalanceAfter;87    const transferPrice = aliceBalanceBefore - aliceBalanceAfter;
9088
9492
95  // console.log(`Error: ${error(dataPoints, x => a*x+b)}`);93  // console.log(`Error: ${error(dataPoints, x => a*x+b)}`);
9694
97  const perfectValue = a * UNIQUE / 10n + b;95  const perfectValue = a * helper.balance.getOneTokenNominal() / 10n + b;
98  await executeTransaction(api, alice, api.tx.sudo.sudo(api.tx.configuration.setWeightToFeeCoefficientOverride(perfectValue.toString())));96  await helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.configuration.setWeightToFeeCoefficientOverride(perfectValue.toString())));
9997
100  {98  {
101    const collectionId = await createCollectionExpectSuccess();99    const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New collection', tokenPrefix: 'NEW'});
102    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');100    const token = await collection.mintToken(alice, {Substrate: alice.address});
103    const aliceBalanceBefore = (await api.query.system.account(alice.address)).data.free.toBigInt();101    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
104    await transferExpectSuccess(collectionId, tokenId, alice, bob, 1, 'NFT');102    await token.transfer(alice, {Substrate: bob.address});
105    const aliceBalanceAfter = (await api.query.system.account(alice.address)).data.free.toBigInt();103    const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
106104
107    console.log(`Calibrated price: ${Number(aliceBalanceBefore - aliceBalanceAfter) / Number(UNIQUE)} UNQ`);105    console.log(`Calibrated price: ${Number(aliceBalanceBefore - aliceBalanceAfter) / Number(helper.balance.getOneTokenNominal())} UNQ`);
108  }106  }
109}107}
110108
111async function calibrateMinGasPrice(api: ApiPromise, web3: Web3, privateKey: (account: string) => IKeyringPair) {109async function calibrateMinGasPrice(helper: EthUniqueHelper, privateKey: (account: string) => IKeyringPair) {
112  const alice = privateKey('//Alice');110  const alice = privateKey('//Alice');
113  const caller = await createEthAccountWithBalance(api, web3, privateKey);111  const caller = await helper.eth.createAccountWithBalance(alice);
114  const receiver = createEthAccount(web3);112  const receiver = helper.eth.createAccount();
115  const dataPoints = [];113  const dataPoints = [];
116114
117  {115  {
118    const collectionId = await createCollectionExpectSuccess();116    const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New collection', tokenPrefix: 'NEW'});
119    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', {Ethereum: caller});117    const token = await collection.mintToken(alice, {Ethereum: caller});
120118
121    const address = collectionIdToAddress(collectionId);119    const address = helper.ethAddress.fromCollectionId(collection.collectionId);
122    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: caller, ...GAS_ARGS});120    const contract = helper.ethNativeContract.collection(address, 'nft', caller);
123121
124    const cost = await recordEthFee(api, caller, () => contract.methods.transfer(receiver, tokenId).send(caller));122    const cost = await helper.eth.calculateFee({Ethereum: caller}, () => contract.methods.transfer(receiver, token.tokenId).send({from: caller, gas: helper.eth.DEFAULT_GAS}));
125123
126    console.log(`Original price: ${Number(cost) / Number(UNIQUE)} UNQ`);124    console.log(`Original price: ${Number(cost) / Number(helper.balance.getOneTokenNominal())} UNQ`);
127  }125  }
128126
127  const api = helper.getApi();
129  const defaultCoeff = (api.consts.configuration.defaultMinGasPrice as any).toBigInt();128  const defaultCoeff = (api.consts.configuration.defaultMinGasPrice as any).toBigInt();
130  for (let i = -8; i < 8; i++) {129  for (let i = -8; i < 8; i++) {
131    const gasPrice = defaultCoeff + defaultCoeff / 100000n * BigInt(i);130    const gasPrice = defaultCoeff + defaultCoeff / 100000n * BigInt(i);
132    const gasPriceStr = '0x' + gasPrice.toString(16);131    const gasPriceStr = '0x' + gasPrice.toString(16);
133    await executeTransaction(api, alice, api.tx.sudo.sudo(api.tx.configuration.setMinGasPriceOverride(gasPrice)));132    await helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.configuration.setMinGasPriceOverride(gasPrice)));
134133
135    const coefficient = (await api.query.configuration.minGasPriceOverride() as any).toBigInt();134    const coefficient = (await api.query.configuration.minGasPriceOverride() as any).toBigInt();
136    const collectionId = await createCollectionExpectSuccess();135    const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New collection', tokenPrefix: 'NEW'});
137    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', {Ethereum: caller});136    const token = await collection.mintToken(alice, {Ethereum: caller});
138137
139    const address = collectionIdToAddress(collectionId);138    const address = helper.ethAddress.fromCollectionId(collection.collectionId);
140    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: caller, gasPrice: gasPriceStr, ...GAS_ARGS});139    const contract = helper.ethNativeContract.collection(address, 'nft', caller);
141140
142    const transferPrice = await recordEthFee(api, caller, () => contract.methods.transfer(receiver, tokenId).send(caller));141    const transferPrice = await helper.eth.calculateFee({Ethereum: caller}, () => contract.methods.transfer(receiver, token.tokenId).send({from: caller, gasPrice: gasPriceStr, gas: helper.eth.DEFAULT_GAS}));
143142
144    dataPoints.push({x: transferPrice, y: coefficient});143    dataPoints.push({x: transferPrice, y: coefficient});
145  }144  }
149  // console.log(`Error: ${error(dataPoints, x => a*x+b)}`);148  // console.log(`Error: ${error(dataPoints, x => a*x+b)}`);
150149
151  // * 0.15 = * 10000 / 66666150  // * 0.15 = * 10000 / 66666
152  const perfectValue = a * UNIQUE * 1000000n / 6666666n + b;151  const perfectValue = a * helper.balance.getOneTokenNominal() * 1000000n / 6666666n + b;
153  await executeTransaction(api, alice, api.tx.sudo.sudo(api.tx.configuration.setMinGasPriceOverride(perfectValue.toString())));152  await helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.configuration.setMinGasPriceOverride(perfectValue.toString())));
154153
155  {154  {
156    const collectionId = await createCollectionExpectSuccess();155    const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New collection', tokenPrefix: 'NEW'});
157    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', {Ethereum: caller});156    const token = await collection.mintToken(alice, {Ethereum: caller});
158157
159    const address = collectionIdToAddress(collectionId);158    const address = helper.ethAddress.fromCollectionId(collection.collectionId);
160    const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: caller, ...GAS_ARGS});159    const contract = helper.ethNativeContract.collection(address, 'nft', caller);
161160
162    const cost = await recordEthFee(api, caller, () => contract.methods.transfer(receiver, tokenId).send(caller));161    const cost = await helper.eth.calculateFee({Ethereum: caller}, () => contract.methods.transfer(receiver, token.tokenId).send({from: caller, gas: helper.eth.DEFAULT_GAS}));
163162
164    console.log(`Calibrated price: ${Number(cost) / Number(UNIQUE)} UNQ`);163    console.log(`Calibrated price: ${Number(cost) / Number(helper.balance.getOneTokenNominal())} UNQ`);
165  }164  }
166}165}
167166
168(async () => {167(async () => {
169  await usingApi(async (api, privateKey) => {168  await usingEthPlaygrounds(async (helper: EthUniqueHelper, privateKey) => {
170    // Second run slightly reduces error sometimes, as price line is not actually straight, this is a curve169    // Second run slightly reduces error sometimes, as price line is not actually straight, this is a curve
171170
172    await calibrateWeightToFee(api, privateKey);171    await calibrateWeightToFee(helper, privateKey);
173    await calibrateWeightToFee(api, privateKey);172    await calibrateWeightToFee(helper, privateKey);
174173
175    await usingWeb3(async web3 => {174    await calibrateMinGasPrice(helper, privateKey);
176      await calibrateMinGasPrice(api, web3, privateKey);
177      await calibrateMinGasPrice(api, web3, privateKey);
178    });
179
180    await api.disconnect();175    await calibrateMinGasPrice(helper, privateKey);
181  });176  });
182})();177})();
183178

178      tokenPrefix: 'COL',178      tokenPrefix: 'COL',
179    }, 0);179    }, 0);
180180
181    const api = helper.api;
182    await helper.signTransaction(alice, api?.tx.unique.createMultipleItemsEx(collection.collectionId, {181    await helper.executeExtrinsic(alice, 'api.tx.unique.createMultipleItemsEx',[collection.collectionId, {
183      Fungible: new Map([182      Fungible: new Map([
184        [JSON.stringify({Substrate: alice.address}), 50],183        [JSON.stringify({Substrate: alice.address}), 50],
185        [JSON.stringify({Substrate: bob.address}), 100],184        [JSON.stringify({Substrate: bob.address}), 100],
186      ]),185      ]),
187    }));186    }], true);
188187
189    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(50n);188    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(50n);
190    expect(await collection.getBalance({Substrate: bob.address})).to.be.equal(100n);189    expect(await collection.getBalance({Substrate: bob.address})).to.be.equal(100n);
200      ],199      ],
201    });200    });
202201
203    const api = helper.api;
204    await helper.signTransaction(alice, api?.tx.unique.createMultipleItemsEx(collection.collectionId, {202    await helper.executeExtrinsic(alice, 'api.tx.unique.createMultipleItemsEx', [collection.collectionId, {
205      RefungibleMultipleOwners: {203      RefungibleMultipleOwners: {
206        users: new Map([204        users: new Map([
207          [JSON.stringify({Substrate: alice.address}), 1],205          [JSON.stringify({Substrate: alice.address}), 1],
211          {key: 'k', value: 'v'},209          {key: 'k', value: 'v'},
212        ],210        ],
213      },211      },
214    }));212    }], true);
215    const tokenId = await collection.getLastTokenId();213    const tokenId = await collection.getLastTokenId();
216    expect(tokenId).to.be.equal(1);214    expect(tokenId).to.be.equal(1);
217    expect(await collection.getTokenBalance(1, {Substrate: alice.address})).to.be.equal(1n);215    expect(await collection.getTokenBalance(1, {Substrate: alice.address})).to.be.equal(1n);
228      ],226      ],
229    });227    });
230
231    const api = helper.api;
232228
233    await helper.signTransaction(alice, api?.tx.unique.createMultipleItemsEx(collection.collectionId, {229    await helper.executeExtrinsic(alice, 'api.tx.unique.createMultipleItemsEx', [collection.collectionId, {
234      RefungibleMultipleItems: [230      RefungibleMultipleItems: [
235        {231        {
236          user: {Substrate: alice.address}, pieces: 1,232          user: {Substrate: alice.address}, pieces: 1,
245          ],241          ],
246        },242        },
247      ],243      ],
248    }));244    }], true);
249245
250    expect(await collection.getLastTokenId()).to.be.equal(2);246    expect(await collection.getLastTokenId()).to.be.equal(2);
251    expect(await collection.getTokenBalance(1, {Substrate: alice.address})).to.be.equal(1n);247    expect(await collection.getTokenBalance(1, {Substrate: alice.address})).to.be.equal(1n);

29/*eslint no-async-promise-executor: "off"*/29/*eslint no-async-promise-executor: "off"*/
30function skipInflationBlock(api: ApiPromise): Promise<void> {30function skipInflationBlock(api: ApiPromise): Promise<void> {
31  const promise = new Promise<void>(async (resolve) => {31  const promise = new Promise<void>(async (resolve) => {
32    const blockInterval = (await api.consts.inflation.inflationBlockInterval).toNumber();32    const blockInterval = api.consts.inflation.inflationBlockInterval.toNumber();
33    const unsubscribe = await api.rpc.chain.subscribeNewHeads(head => {33    const unsubscribe = await api.rpc.chain.subscribeNewHeads(head => {
34      const currentBlock = head.number.toNumber();34      const currentBlock = head.number.toNumber();
35      if (currentBlock % blockInterval < blockInterval - 10) {35      if (currentBlock % blockInterval < blockInterval - 10) {
56  });56  });
5757
58  itSub('Total issuance does not change', async ({helper}) => {58  itSub('Total issuance does not change', async ({helper}) => {
59    const api = helper.api!;59    const api = helper.getApi();
60    await skipInflationBlock(api);60    await skipInflationBlock(api);
61    await helper.wait.newBlocks(1);61    await helper.wait.newBlocks(1);
6262
63    const totalBefore = (await api.query.balances.totalIssuance()).toBigInt();63    const totalBefore = (await helper.callRpc('api.query.balances.totalIssuance', [])).toBigInt();
6464
65    await helper.balance.transferToSubstrate(alice, bob.address, 1n);65    await helper.balance.transferToSubstrate(alice, bob.address, 1n);
6666
67    const totalAfter = (await api.query.balances.totalIssuance()).toBigInt();67    const totalAfter = (await helper.callRpc('api.query.balances.totalIssuance', [])).toBigInt();
6868
69    expect(totalAfter).to.be.equal(totalBefore);69    expect(totalAfter).to.be.equal(totalBefore);
70  });70  });
7171
72  itSub('Sender balance decreased by fee+sent amount, Treasury balance increased by fee', async ({helper}) => {72  itSub('Sender balance decreased by fee+sent amount, Treasury balance increased by fee', async ({helper}) => {
73    await skipInflationBlock(helper.api!);73    await skipInflationBlock(helper.getApi());
74    await helper.wait.newBlocks(1);74    await helper.wait.newBlocks(1);
7575
76    const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);76    const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
89  });89  });
9090
91  itSub('Treasury balance increased by failed tx fee', async ({helper}) => {91  itSub('Treasury balance increased by failed tx fee', async ({helper}) => {
92    const api = helper.api!;92    const api = helper.getApi();
93    await helper.wait.newBlocks(1);93    await helper.wait.newBlocks(1);
9494
95    const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);95    const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
107  });107  });
108108
109  itSub('NFT Transactions also send fees to Treasury', async ({helper}) => {109  itSub('NFT Transactions also send fees to Treasury', async ({helper}) => {
110    await skipInflationBlock(helper.api!);110    await skipInflationBlock(helper.getApi());
111    await helper.wait.newBlocks(1);111    await helper.wait.newBlocks(1);
112112
113    const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);113    const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
125125
126  itSub('Fees are sane', async ({helper}) => {126  itSub('Fees are sane', async ({helper}) => {
127    const unique = helper.balance.getOneTokenNominal();127    const unique = helper.balance.getOneTokenNominal();
128    await skipInflationBlock(helper.api!);128    await skipInflationBlock(helper.getApi());
129    await helper.wait.newBlocks(1);129    await helper.wait.newBlocks(1);
130130
131    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);131    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
140  });140  });
141141
142  itSub('NFT Transfer fee is close to 0.1 Unique', async ({helper}) => {142  itSub('NFT Transfer fee is close to 0.1 Unique', async ({helper}) => {
143    await skipInflationBlock(helper.api!);143    await skipInflationBlock(helper.getApi());
144    await helper.wait.newBlocks(1);144    await helper.wait.newBlocks(1);
145145
146    const collection = await helper.nft.mintCollection(alice, {146    const collection = await helper.nft.mintCollection(alice, {