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/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;
   });

--- a/tests/src/util/playgrounds/unique.ts
+++ b/tests/src/util/playgrounds/unique.ts
@@ -120,7 +120,7 @@
     return keyring.addFromUri(seed);
   }
 
-  static extractCollectionIdFromCreationResult(creationResult: ITransactionResult) {
+  static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {
     if (creationResult.status !== this.transactionStatus.SUCCESS) {
       throw Error('Unable to create collection!');
     }
@@ -139,12 +139,15 @@
     return collectionId;
   }
 
-  static extractTokensFromCreationResult(creationResult: ITransactionResult) {
+  static extractTokensFromCreationResult(creationResult: ITransactionResult): {
+    success: boolean, 
+    tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],
+  } {
     if (creationResult.status !== this.transactionStatus.SUCCESS) {
       throw Error('Unable to create tokens!');
     }
     let success = false;
-    const tokens = [] as any;
+    const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];
     creationResult.result.events.forEach(({event: {data, method, section}}) => {
       if (method === 'ExtrinsicSuccess') {
         success = true;
@@ -152,19 +155,23 @@
         tokens.push({
           collectionId: parseInt(data[0].toString(), 10),
           tokenId: parseInt(data[1].toString(), 10),
-          owner: data[2].toJSON(),
+          owner: data[2].toHuman(),
+          amount: data[3].toBigInt(),
         });
       }
     });
     return {success, tokens};
   }
 
-  static extractTokensFromBurnResult(burnResult: ITransactionResult) {
+  static extractTokensFromBurnResult(burnResult: ITransactionResult): {
+    success: boolean, 
+    tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],
+  } {
     if (burnResult.status !== this.transactionStatus.SUCCESS) {
       throw Error('Unable to burn tokens!');
     }
     let success = false;
-    const tokens = [] as any;
+    const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];
     burnResult.result.events.forEach(({event: {data, method, section}}) => {
       if (method === 'ExtrinsicSuccess') {
         success = true;
@@ -172,14 +179,15 @@
         tokens.push({
           collectionId: parseInt(data[0].toString(), 10),
           tokenId: parseInt(data[1].toString(), 10),
-          owner: data[2].toJSON(),
+          owner: data[2].toHuman(),
+          amount: data[3].toBigInt(),
         });
       }
     });
     return {success, tokens};
   }
 
-  static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string) {
+  static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {
     let eventId = null;
     events.forEach(({event: {data, method, section}}) => {
       if ((section === expectedSection) && (method === expectedMethod)) {
@@ -1001,12 +1009,9 @@
    * @param tokenId ID of token
    * @param amount amount of tokens to be burned. For NFT must be set to 1n
    * @example burnToken(aliceKeyring, 10, 5);
-   * @returns ```true``` and burnt token number is extrinsic success. Otherwise ```false``` and ```null```
+   * @returns ```true``` if the extrinsic is successful, otherwise ```false```
    */
-  async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<{
-    success: boolean,
-    token: number | null
-  }> {
+  async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {
     const burnResult = await this.helper.executeExtrinsic(
       signer,
       'api.tx.unique.burnItem', [collectionId, tokenId, amount],
@@ -1014,7 +1019,7 @@
     );
     const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);
     if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');
-    return {success: burnedTokens.success, token: burnedTokens.tokens.length > 0 ? burnedTokens.tokens[0] : null};
+    return burnedTokens.success;
   }
 
   /**
@@ -1140,7 +1145,9 @@
     if (tokenData === null || tokenData.owner === null) return null;
     const owner = {} as any;
     for (const key of Object.keys(tokenData.owner)) {
-      owner[key.toLocaleLowerCase()] = new CrossAccountId(tokenData.owner[key]).withNormalizedSubstrate();
+      owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate' 
+        ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key]) 
+        : tokenData.owner[key];
     }
     tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);
     return tokenData;
@@ -1690,9 +1697,9 @@
    * @param tokenId ID of token
    * @param amount number of pieces to be burnt
    * @example burnToken(aliceKeyring, 10, 5);
-   * @returns ```true``` and burnt token number, if extrinsic is successful. Otherwise ```false``` and ```null```
+   * @returns ```true``` if the extrinsic is successful, otherwise ```false```
    */
-  async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<{ success: boolean; token: number | null; }> {
+  async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {
     return await super.burnToken(signer, collectionId, tokenId, amount);
   }
 
@@ -1898,7 +1905,7 @@
    * @returns ```true``` if extrinsic success, otherwise ```false```
    */
   async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {
-    return (await super.burnToken(signer, collectionId, 0, amount)).success;
+    return await super.burnToken(signer, collectionId, 0, amount);
   }
 
   /**