git.delta.rocks / unique-network / refs/commits / 12fbdbdcf4df

--- a/tests/src/change-collection-owner.test.ts
+++ b/tests/src/change-collection-owner.test.ts
@@ -31,11 +31,11 @@
   itSub('Changing owner changes owner address', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     const beforeChanging = await helper.collection.getData(collection.collectionId);
-    expect(beforeChanging?.normalizedOwner).to.be.equal(helper.util.normalizeSubstrateAddress(alice.address));
+    expect(beforeChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(alice.address));
 
     await collection.changeOwner(alice, bob.address);
     const afterChanging = await helper.collection.getData(collection.collectionId);
-    expect(afterChanging?.normalizedOwner).to.be.equal(helper.util.normalizeSubstrateAddress(bob.address));
+    expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
   });
 });
 
@@ -60,7 +60,7 @@
     await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
 
     const afterChanging = await helper.collection.getData(collection.collectionId);
-    expect(afterChanging?.normalizedOwner).to.be.equal(helper.util.normalizeSubstrateAddress(bob.address));
+    expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
   });
 
   itSub('New collectionOwner has access to sponsorship management operations in the collection', async ({helper}) => {
@@ -68,7 +68,7 @@
     await collection.changeOwner(alice, bob.address);
 
     const afterChanging = await helper.collection.getData(collection.collectionId);
-    expect(afterChanging?.normalizedOwner).to.be.equal(helper.util.normalizeSubstrateAddress(bob.address));
+    expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
 
     await collection.setSponsor(bob, charlie.address);
     await collection.confirmSponsorship(charlie);
@@ -97,7 +97,7 @@
     await collection.changeOwner(alice, bob.address);
     await collection.changeOwner(bob, charlie.address);
     const collectionData = await collection.getData();
-    expect(collectionData?.normalizedOwner).to.be.equal(helper.util.normalizeSubstrateAddress(charlie.address));
+    expect(collectionData?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(charlie.address));
   });
 });
 
@@ -140,7 +140,7 @@
     await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
 
     const afterChanging = await helper.collection.getData(collection.collectionId);
-    expect(afterChanging?.normalizedOwner).to.be.equal(helper.util.normalizeSubstrateAddress(bob.address));
+    expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
 
     const setSponsorTx = async () => collection.setSponsor(alice, charlie.address);
     const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);

--- a/tests/src/createCollection.test.ts
+++ b/tests/src/createCollection.test.ts
@@ -14,12 +14,12 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
+import {IKeyringPair} from '@polkadot/types/types';
 import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
-import {IKeyringPair} from '@polkadot/types/types';
 import {ICollectionCreationOptions, IProperty} from './util/playgrounds/types';
-import {DevUniqueHelper} from './util/playgrounds/unique.dev';
+import {UniqueHelper} from './util/playgrounds/unique';
 
-async function mintCollectionHelper(helper: DevUniqueHelper, signer: IKeyringPair, options: ICollectionCreationOptions, type?: 'nft' | 'fungible' | 'refungible') {
+async function mintCollectionHelper(helper: UniqueHelper, signer: IKeyringPair, options: ICollectionCreationOptions, type?: 'nft' | 'fungible' | 'refungible') {
   let collection;
   if (type === 'nft') {
     collection = await helper.nft.mintCollection(signer, options);
@@ -29,7 +29,7 @@
     collection = await helper.rft.mintCollection(signer, options);
   }
   const data = await collection.getData();
-  expect(data?.normalizedOwner).to.be.equal(helper.util.normalizeSubstrateAddress(signer.address));
+  expect(data?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(signer.address));
   expect(data?.name).to.be.equal(options.name);
   expect(data?.description).to.be.equal(options.description);
   expect(data?.raw.tokenPrefix).to.be.equal(options.tokenPrefix);
@@ -54,32 +54,27 @@
     });
   });
   itSub('Create new NFT collection', async ({helper}) => {
-
     await mintCollectionHelper(helper, alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 'nft');
   });
   itSub('Create new NFT collection whith collection_name of maximum length (64 bytes)', async ({helper}) => {
-
     await mintCollectionHelper(helper, alice, {name: 'A'.repeat(64), description: 'descr', tokenPrefix: 'COL'}, 'nft');
   });
   itSub('Create new NFT collection whith collection_description of maximum length (256 bytes)', async ({helper}) => {
-
     await mintCollectionHelper(helper, alice, {name: 'name', description: 'A'.repeat(256), tokenPrefix: 'COL'}, 'nft');
   });
   itSub('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async ({helper}) => {
-
     await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(16)}, 'nft');
   });
+
   itSub('Create new Fungible collection', async ({helper}) => {
-
     await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 'fungible');
   });
+
   itSub.ifWithPallets('Create new ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
-
     await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 'refungible');
   });
 
   itSub('create new collection with properties', async ({helper}) => {
-
     await mintCollectionHelper(helper, alice, {
       name: 'name', description: 'descr', tokenPrefix: 'COL',
       properties: [{key: 'key1', value: 'val1'}],
@@ -88,7 +83,6 @@
   });
 
   itSub('Create new collection with extra fields', async ({helper}) => {
-
     const collection = await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 'fungible');
     await collection.setPermissions(alice, {access: 'AllowList'});
     await collection.setLimits(alice, {accountTokenOwnershipLimit: 3});
@@ -96,7 +90,7 @@
     const limits = await collection.getEffectiveLimits();
     const raw = data?.raw;
 
-    expect(data?.normalizedOwner).to.be.equal(helper.util.normalizeSubstrateAddress(alice.address));
+    expect(data?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(alice.address));
     expect(data?.name).to.be.equal('name');
     expect(data?.description).to.be.equal('descr');
     expect(raw.permissions.access).to.be.equal('AllowList');
@@ -105,7 +99,6 @@
   });
 
   itSub('New collection is not external', async ({helper}) => {
-
     const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
     const data = await collection.getData();
     expect(data?.raw.readOnly).to.be.false;
@@ -131,12 +124,11 @@
     await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
   itSub('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async ({helper}) => {
-
     const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(17)});
     await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
+  
   itSub('(!negative test!) fails when bad limits are set', async ({helper}) => {
-
     const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', limits: {tokenLimit: 0}});
     await expect(mintCollectionTx()).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
   });

--- a/tests/src/createItem.test.ts
+++ b/tests/src/createItem.test.ts
@@ -15,24 +15,14 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-
-import {
-  createCollection,
-  itApi,
-  normalizeAccountId,
-  getCreateItemResult,
-  CrossAccountId,
-} from './util/helpers';
-
 import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
-import {IProperty} from './util/playgrounds/types';
-import {executeTransaction} from './substrate/substrate-api';
-import {DevUniqueHelper} from './util/playgrounds/unique.dev';
+import {IProperty, ICrossAccountId} from './util/playgrounds/types';
+import {UniqueHelper} from './util/playgrounds/unique';
 
-async function mintTokenHelper(helper: DevUniqueHelper, collection: any, signer: IKeyringPair, owner: CrossAccountId, type: 'nft' | 'fungible' | 'refungible'='nft', properties?: IProperty[]) {
+async function mintTokenHelper(helper: UniqueHelper, collection: any, signer: IKeyringPair, owner: ICrossAccountId, type: 'nft' | 'fungible' | 'refungible'='nft', properties?: IProperty[]) {
   let token;
   const itemCountBefore = await helper.collection.getLastTokenId(collection.collectionId);
-  const itemBalanceBefore = (await helper.api!.rpc.unique.balance(collection.collectionId, owner, 0)).toBigInt();
+  const itemBalanceBefore = (await helper.callRpc('api.rpc.unique.balance', [collection.collectionId, owner, 0])).toBigInt();
   if (type === 'nft') {
     token = await collection.mintToken(signer, owner, properties);
   } else if (type === 'fungible') {
@@ -42,7 +32,7 @@
   }
 
   const itemCountAfter = await helper.collection.getLastTokenId(collection.collectionId);
-  const itemBalanceAfter = (await helper.api!.rpc.unique.balance(collection.collectionId, owner, 0)).toBigInt();
+  const itemBalanceAfter = (await helper.callRpc('api.rpc.unique.balance', [collection.collectionId, owner, 0])).toBigInt();
 
   if (type === 'fungible') {
     expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);
@@ -75,27 +65,22 @@
   });
   itSub('Check events on create new item in Fungible collection', async ({helper}) => {
     const {collectionId} = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'}, 0);
-    const api = helper.api!;
-
-
-    const to = normalizeAccountId(alice);
+    const to = {Substrate: alice.address};
     {
       const createData = {fungible: {value: 100}};
-      const tx = api.tx.unique.createItem(collectionId, to, createData as any);
-      const events = await executeTransaction(api, alice, tx);
-      const result = getCreateItemResult(events);
-      expect(result.amount).to.be.equal(100);
-      expect(result.collectionId).to.be.equal(collectionId);
-      expect(result.recipient).to.be.deep.equal(to);
+      const events = await helper.executeExtrinsic(alice, 'api.tx.unique.createItem', [collectionId, to, createData as any]);
+      const result = helper.util.extractTokensFromCreationResult(events);
+      expect(result.tokens[0].amount).to.be.equal(100n);
+      expect(result.tokens[0].collectionId).to.be.equal(collectionId);
+      expect(result.tokens[0].owner).to.be.deep.equal(to);
     }
     {
       const createData = {fungible: {value: 50}};
-      const tx = api.tx.unique.createItem(collectionId, to, createData as any);
-      const events = await executeTransaction(api, alice, tx);
-      const result = getCreateItemResult(events);
-      expect(result.amount).to.be.equal(50);
-      expect(result.collectionId).to.be.equal(collectionId);
-      expect(result.recipient).to.be.deep.equal(to);
+      const events = await helper.executeExtrinsic(alice, 'api.tx.unique.createItem', [collectionId, to, createData as any]);
+      const result = helper.util.extractTokensFromCreationResult(events);
+      expect(result.tokens[0].amount).to.be.equal(50n);
+      expect(result.tokens[0].collectionId).to.be.equal(collectionId);
+      expect(result.tokens[0].owner).to.be.deep.equal(to);
     }
   });
   itSub.ifWithPallets('Create new item in ReFungible collection', [Pallets.ReFungible], async ({helper}) =>  {
@@ -162,12 +147,12 @@
     const amount = 1n;
     const token = await mintTokenHelper(helper, collection, alice, {Substrate: bob.address});
     {
-      const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
+      const totalPieces = await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, token.tokenId]);
       expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
     }
     await token.transfer(bob, {Substrate: alice.address});
     {
-      const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
+      const totalPieces = await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, token.tokenId]);
       expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
     }
   });
@@ -267,21 +252,21 @@
   itSub('Check total pieces for invalid Fungible token', async ({helper}) => {
     const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
     const invalidTokenId = 1_000_000;
-    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
-    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
+    expect((await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, invalidTokenId]))?.isNone).to.be.true;
+    expect((await helper.callRpc('api.rpc.unique.tokenData', [collection.collectionId, invalidTokenId]))?.pieces.toBigInt()).to.be.equal(0n);
   });
 
   itSub('Check total pieces for invalid NFT token', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     const invalidTokenId = 1_000_000;
-    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
-    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
+    expect((await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, invalidTokenId]))?.isNone).to.be.true;
+    expect((await helper.callRpc('api.rpc.unique.tokenData', [collection.collectionId, invalidTokenId]))?.pieces.toBigInt()).to.be.equal(0n);
   });
 
   itSub.ifWithPallets('Check total pieces for invalid Refungible token', [Pallets.ReFungible], async ({helper}) => {
     const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     const invalidTokenId = 1_000_000;
-    expect((await helper.api?.rpc.unique.totalPieces(collection.collectionId, invalidTokenId))?.isNone).to.be.true;
-    expect((await helper.api?.rpc.unique.tokenData(collection.collectionId, invalidTokenId))?.pieces.toBigInt()).to.be.equal(0n);
+    expect((await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, invalidTokenId]))?.isNone).to.be.true;
+    expect((await helper.callRpc('api.rpc.unique.tokenData', [collection.collectionId, invalidTokenId]))?.pieces.toBigInt()).to.be.equal(0n);
   });
 });

--- a/tests/src/createMultipleItems.test.ts
+++ b/tests/src/createMultipleItems.test.ts
@@ -15,12 +15,8 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import {
-  normalizeAccountId,
-} from './util/helpers';
 import {usingPlaygrounds, expect, Pallets, itSub} from './util/playgrounds';
 
-
 describe('Integration Test createMultipleItems(collection_id, owner, items_data):', () => {
   let alice: IKeyringPair;
 
@@ -48,7 +44,7 @@
     const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
     for (const [i, token] of tokens.entries()) {
       const tokenData = await token.getData();
-      expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: helper.util.normalizeSubstrateAddress(alice.address)});
+      expect(tokenData?.normalizedOwner.Substrate).to.be.deep.equal(helper.address.normalizeSubstrate(alice.address));
       expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
     }
   });
@@ -116,7 +112,7 @@
     const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
     for (const [i, token] of tokens.entries()) {
       const tokenData = await token.getData();
-      expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: helper.util.normalizeSubstrateAddress(alice.address)});
+      expect(tokenData?.normalizedOwner.Substrate).to.be.deep.equal(helper.address.normalizeSubstrate(alice.address));
       expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
     }
   });
@@ -138,7 +134,7 @@
     const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
     for (const [i, token] of tokens.entries()) {
       const tokenData = await token.getData();
-      expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: helper.util.normalizeSubstrateAddress(alice.address)});
+      expect(tokenData?.normalizedOwner.Substrate).to.be.deep.equal(helper.address.normalizeSubstrate(alice.address));
       expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
     }
   });
@@ -160,7 +156,7 @@
     const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
     for (const [i, token] of tokens.entries()) {
       const tokenData = await token.getData();
-      expect(tokenData?.normalizedOwner).to.be.deep.equal({Substrate: helper.util.normalizeSubstrateAddress(alice.address)});
+      expect(tokenData?.normalizedOwner.Substrate).to.be.equal(helper.address.normalizeSubstrate(alice.address));
       expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
     }
   });
@@ -275,8 +271,11 @@
     });
 
     const types = ['NFT', 'Fungible', 'ReFungible'];
-    const mintTx = helper.api?.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), types);
-    await expect(helper.signTransaction(alice, mintTx)).to.be.rejected;
+    await expect(helper.executeExtrinsic(
+      alice, 
+      'api.tx.unique.createMultipleItems', 
+      [collectionId, {Substrate: alice.address}, types],
+    )).to.be.rejectedWith(/nonfungible\.NotNonfungibleDataUsedToMintFungibleCollectionToken/);
   });
 
   itSub('Create tokens with different data limits <> maximum data limit', async ({helper}) => {

--- a/tests/src/creditFeesToTreasury.test.ts
+++ b/tests/src/creditFeesToTreasury.test.ts
@@ -16,11 +16,6 @@
 
 import './interfaces/augment-api-consts';
 import {IKeyringPair} from '@polkadot/types/types';
-import {
-  UNIQUE,
-} from './util/helpers';
-
-import {default as waitNewBlocks} from './substrate/wait-new-blocks';
 import {ApiPromise} from '@polkadot/api';
 import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
 
@@ -63,7 +58,7 @@
   itSub('Total issuance does not change', async ({helper}) => {
     const api = helper.api!;
     await skipInflationBlock(api);
-    await waitNewBlocks(api, 1);
+    await helper.wait.newBlocks(1);
 
     const totalBefore = (await api.query.balances.totalIssuance()).toBigInt();
 
@@ -75,9 +70,8 @@
   });
 
   itSub('Sender balance decreased by fee+sent amount, Treasury balance increased by fee', async ({helper}) => {
-    const api = helper.api!;
-    await skipInflationBlock(api);
-    await waitNewBlocks(api, 1);
+    await skipInflationBlock(helper.api!);
+    await helper.wait.newBlocks(1);
 
     const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
     const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
@@ -96,7 +90,7 @@
 
   itSub('Treasury balance increased by failed tx fee', async ({helper}) => {
     const api = helper.api!;
-    await waitNewBlocks(api, 1);
+    await helper.wait.newBlocks(1);
 
     const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
     const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
@@ -113,9 +107,8 @@
   });
 
   itSub('NFT Transactions also send fees to Treasury', async ({helper}) => {
-    const api = helper.api!;
-    await skipInflationBlock(api);
-    await waitNewBlocks(api, 1);
+    await skipInflationBlock(helper.api!);
+    await helper.wait.newBlocks(1);
 
     const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
     const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
@@ -131,9 +124,9 @@
   });
 
   itSub('Fees are sane', async ({helper}) => {
-    const api = helper.api!;
-    await skipInflationBlock(api);
-    await waitNewBlocks(api, 1);
+    const unique = helper.balance.getOneTokenNominal();
+    await skipInflationBlock(helper.api!);
+    await helper.wait.newBlocks(1);
 
     const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
 
@@ -142,14 +135,13 @@
     const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
     const fee = aliceBalanceBefore - aliceBalanceAfter;
 
-    expect(fee / UNIQUE < BigInt(Math.ceil(saneMaximumFee + createCollectionDeposit))).to.be.true;
-    expect(fee / UNIQUE < BigInt(Math.ceil(saneMinimumFee  + createCollectionDeposit))).to.be.true;
+    expect(fee / unique < BigInt(Math.ceil(saneMaximumFee + createCollectionDeposit))).to.be.true;
+    expect(fee / unique < BigInt(Math.ceil(saneMinimumFee  + createCollectionDeposit))).to.be.true;
   });
 
   itSub('NFT Transfer fee is close to 0.1 Unique', async ({helper}) => {
-    const api = helper.api!;
-    await skipInflationBlock(api);
-    await waitNewBlocks(api, 1);
+    await skipInflationBlock(helper.api!);
+    await helper.wait.newBlocks(1);
 
     const collection = await helper.nft.mintCollection(alice, {
       name: 'test',
@@ -163,7 +155,7 @@
     await token.transfer(alice, {Substrate: bob.address});
     const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
 
-    const fee = Number(aliceBalanceBefore - aliceBalanceAfter) / Number(UNIQUE);
+    const fee = Number(aliceBalanceBefore - aliceBalanceAfter) / Number(helper.balance.getOneTokenNominal());
     const expectedTransferFee = 0.1;
     // fee drifts because of NextFeeMultiplier
     const tolerance = 0.001;

--- a/tests/src/destroyCollection.test.ts
+++ b/tests/src/destroyCollection.test.ts
@@ -15,10 +15,7 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import {
-  Pallets,
-} from './util/helpers';
-import {itSub, expect, usingPlaygrounds} from './util/playgrounds';
+import {itSub, expect, usingPlaygrounds, Pallets} from './util/playgrounds';
 
 describe('integration test: ext. destroyCollection():', () => {
   let alice: IKeyringPair;

--- a/tests/src/nesting/properties.test.ts
+++ b/tests/src/nesting/properties.test.ts
@@ -666,7 +666,6 @@
           `on adding property #${i} by signer #${j}`,
         ).to.be.fulfilled;
       }
-
     }
 
     const properties = await nestedToken.getProperties(propertyKeys);

--- a/tests/src/refungible.test.ts
+++ b/tests/src/refungible.test.ts
@@ -124,7 +124,7 @@
     const token = await collection.mintToken(alice, 100n);
     expect(await collection.isTokenExists(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
-    expect((await token.burn(alice, 99n)).success).to.be.true;
+    expect(await token.burn(alice, 99n)).to.be.true;
     expect(await collection.isTokenExists(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(1n);
   });
@@ -136,7 +136,7 @@
     expect(await collection.isTokenExists(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
 
-    expect((await token.burn(alice, 100n)).success).to.be.true;
+    expect(await token.burn(alice, 100n)).to.be.true;
     expect(await collection.isTokenExists(token.tokenId)).to.be.false;
   });
 
@@ -152,17 +152,17 @@
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(40n);
     expect(await token.getBalance({Substrate: bob.address})).to.be.equal(60n);
 
-    expect((await token.burn(alice, 40n)).success).to.be.true;
+    expect(await token.burn(alice, 40n)).to.be.true;
 
     expect(await collection.isTokenExists(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(0n);
 
-    expect((await token.burn(bob, 59n)).success).to.be.true;
+    expect(await token.burn(bob, 59n)).to.be.true;
 
     expect(await token.getBalance({Substrate: bob.address})).to.be.equal(1n);
     expect(await collection.isTokenExists(token.tokenId)).to.be.true;
 
-    expect((await token.burn(bob, 1n)).success).to.be.true;
+    expect(await token.burn(bob, 1n)).to.be.true;
 
     expect(await collection.isTokenExists(token.tokenId)).to.be.false;
   });

120    return keyring.addFromUri(seed);120    return keyring.addFromUri(seed);
121  }121  }
122122
123  static extractCollectionIdFromCreationResult(creationResult: ITransactionResult) {123  static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {
124    if (creationResult.status !== this.transactionStatus.SUCCESS) {124    if (creationResult.status !== this.transactionStatus.SUCCESS) {
125      throw Error('Unable to create collection!');125      throw Error('Unable to create collection!');
126    }126    }
139    return collectionId;139    return collectionId;
140  }140  }
141141
142  static extractTokensFromCreationResult(creationResult: ITransactionResult) {142  static extractTokensFromCreationResult(creationResult: ITransactionResult): {
143    success: boolean, 
144    tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],
145  } {
143    if (creationResult.status !== this.transactionStatus.SUCCESS) {146    if (creationResult.status !== this.transactionStatus.SUCCESS) {
144      throw Error('Unable to create tokens!');147      throw Error('Unable to create tokens!');
145    }148    }
146    let success = false;149    let success = false;
147    const tokens = [] as any;150    const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];
148    creationResult.result.events.forEach(({event: {data, method, section}}) => {151    creationResult.result.events.forEach(({event: {data, method, section}}) => {
149      if (method === 'ExtrinsicSuccess') {152      if (method === 'ExtrinsicSuccess') {
150        success = true;153        success = true;
151      } else if ((section === 'common') && (method === 'ItemCreated')) {154      } else if ((section === 'common') && (method === 'ItemCreated')) {
152        tokens.push({155        tokens.push({
153          collectionId: parseInt(data[0].toString(), 10),156          collectionId: parseInt(data[0].toString(), 10),
154          tokenId: parseInt(data[1].toString(), 10),157          tokenId: parseInt(data[1].toString(), 10),
155          owner: data[2].toJSON(),158          owner: data[2].toHuman(),
159          amount: data[3].toBigInt(),
156        });160        });
157      }161      }
158    });162    });
159    return {success, tokens};163    return {success, tokens};
160  }164  }
161165
162  static extractTokensFromBurnResult(burnResult: ITransactionResult) {166  static extractTokensFromBurnResult(burnResult: ITransactionResult): {
167    success: boolean, 
168    tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],
169  } {
163    if (burnResult.status !== this.transactionStatus.SUCCESS) {170    if (burnResult.status !== this.transactionStatus.SUCCESS) {
164      throw Error('Unable to burn tokens!');171      throw Error('Unable to burn tokens!');
165    }172    }
166    let success = false;173    let success = false;
167    const tokens = [] as any;174    const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];
168    burnResult.result.events.forEach(({event: {data, method, section}}) => {175    burnResult.result.events.forEach(({event: {data, method, section}}) => {
169      if (method === 'ExtrinsicSuccess') {176      if (method === 'ExtrinsicSuccess') {
170        success = true;177        success = true;
171      } else if ((section === 'common') && (method === 'ItemDestroyed')) {178      } else if ((section === 'common') && (method === 'ItemDestroyed')) {
172        tokens.push({179        tokens.push({
173          collectionId: parseInt(data[0].toString(), 10),180          collectionId: parseInt(data[0].toString(), 10),
174          tokenId: parseInt(data[1].toString(), 10),181          tokenId: parseInt(data[1].toString(), 10),
175          owner: data[2].toJSON(),182          owner: data[2].toHuman(),
183          amount: data[3].toBigInt(),
176        });184        });
177      }185      }
178    });186    });
179    return {success, tokens};187    return {success, tokens};
180  }188  }
181189
182  static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string) {190  static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {
183    let eventId = null;191    let eventId = null;
184    events.forEach(({event: {data, method, section}}) => {192    events.forEach(({event: {data, method, section}}) => {
185      if ((section === expectedSection) && (method === expectedMethod)) {193      if ((section === expectedSection) && (method === expectedMethod)) {
992    return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1000    return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);
993  }1001  }
9941002
995  /**1003  /**
996   *1004   *
997   * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1005   * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.
998   *1006   *
999   * @param signer keyring of signer1007   * @param signer keyring of signer
1000   * @param collectionId ID of collection1008   * @param collectionId ID of collection
1001   * @param tokenId ID of token1009   * @param tokenId ID of token
1002   * @param amount amount of tokens to be burned. For NFT must be set to 1n1010   * @param amount amount of tokens to be burned. For NFT must be set to 1n
1003   * @example burnToken(aliceKeyring, 10, 5);1011   * @example burnToken(aliceKeyring, 10, 5);
1004   * @returns ```true``` and burnt token number is extrinsic success. Otherwise ```false``` and ```null```1012   * @returns ```true``` if the extrinsic is successful, otherwise ```false```
1005   */1013   */
1006  async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<{1014  async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {
1007    success: boolean,
1008    token: number | null
1009  }> {
1010    const burnResult = await this.helper.executeExtrinsic(1015    const burnResult = await this.helper.executeExtrinsic(
1011      signer,1016      signer,
1012      'api.tx.unique.burnItem', [collectionId, tokenId, amount],1017      'api.tx.unique.burnItem', [collectionId, tokenId, amount],
1013      true, // `Unable to burn token for ${label}`,1018      true, // `Unable to burn token for ${label}`,
1014    );1019    );
1015    const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1020    const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);
1016    if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1021    if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');
1017    return {success: burnedTokens.success, token: burnedTokens.tokens.length > 0 ? burnedTokens.tokens[0] : null};1022    return burnedTokens.success;
1018  }1023  }
10191024
1020  /**1025  /**
1140    if (tokenData === null || tokenData.owner === null) return null;1145    if (tokenData === null || tokenData.owner === null) return null;
1141    const owner = {} as any;1146    const owner = {} as any;
1142    for (const key of Object.keys(tokenData.owner)) {1147    for (const key of Object.keys(tokenData.owner)) {
1143      owner[key.toLocaleLowerCase()] = new CrossAccountId(tokenData.owner[key]).withNormalizedSubstrate();1148      owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate' 
1149        ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key]) 
1150        : tokenData.owner[key];
1144    }1151    }
1145    tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1152    tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);
1146    return tokenData;1153    return tokenData;
1683    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1690    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));
1684  }1691  }
16851692
1686  /**1693  /**
1687   * Destroys a concrete instance of RFT.1694   * Destroys a concrete instance of RFT.
1688   * @param signer keyring of signer1695   * @param signer keyring of signer
1689   * @param collectionId ID of collection1696   * @param collectionId ID of collection
1690   * @param tokenId ID of token1697   * @param tokenId ID of token
1691   * @param amount number of pieces to be burnt1698   * @param amount number of pieces to be burnt
1692   * @example burnToken(aliceKeyring, 10, 5);1699   * @example burnToken(aliceKeyring, 10, 5);
1693   * @returns ```true``` and burnt token number, if extrinsic is successful. Otherwise ```false``` and ```null```1700   * @returns ```true``` if the extrinsic is successful, otherwise ```false```
1694   */1701   */
1695  async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<{ success: boolean; token: number | null; }> {1702  async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {
1696    return await super.burnToken(signer, collectionId, tokenId, amount);1703    return await super.burnToken(signer, collectionId, tokenId, amount);
1697  }1704  }
16981705
1898   * @returns ```true``` if extrinsic success, otherwise ```false```1905   * @returns ```true``` if extrinsic success, otherwise ```false```
1899   */1906   */
1900  async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {1907  async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {
1901    return (await super.burnToken(signer, collectionId, 0, amount)).success;1908    return await super.burnToken(signer, collectionId, 0, amount);
1902  }1909  }
19031910
1904  /**1911  /**