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

difftreelog

transferSuccess

kpozdnikin2021-01-19parent: #8154d7d.patch.diff
in: master

3 files changed

modifiedtests/src/burnItem.test.tsdiffbeforeafterboth
--- a/tests/src/burnItem.test.ts
+++ b/tests/src/burnItem.test.ts
@@ -35,16 +35,16 @@
       const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
       const events = await submitTransactionAsync(alice, tx);
       const result = getGenericResult(events);
-  
-      // Get the item 
+      // Get the item
       const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();
- 
       // What to expect
+      // tslint:disable-next-line:no-unused-expression
       expect(result.success).to.be.true;
+      // tslint:disable-next-line:no-unused-expression
       expect(item).to.be.not.null;
       expect(item.Owner).to.be.equal(nullPublicKey);
     });
-  
+
   });
   it('Burn item in Fungible collection', async () => {
     const createMode = 'Fungible';
modifiedtests/src/transfer.test.tsdiffbeforeafterboth
--- a/tests/src/transfer.test.ts
+++ b/tests/src/transfer.test.ts
@@ -8,17 +8,18 @@
 import { alicesPublicKey, bobsPublicKey } from './accounts';
 import getBalance from './substrate/get-balance';
 import privateKey from './substrate/privateKey';
-import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
+import { default as usingApi, submitTransactionAsync } from './substrate/substrate-api';
 import {
-  approveExpectSuccess,
-  createCollectionExpectSuccess, createItemExpectSuccess,
+  burnItemExpectSuccess, createCollectionExpectSuccess, createItemExpectSuccess,
+  destroyCollectionExpectSuccess,
   findUnusedAddress,
   getCreateCollectionResult,
   getCreateItemResult,
+  transferExpectFail,
   transferExpectSuccess,
 } from './util/helpers';
 
-describe('Integration Test Transfer(recipient, collection_id, item_id, value)', () => {
+/*describe('Integration Test Transfer(recipient, collection_id, item_id, value)', () => {
   it('Balance transfers and check balance', async () => {
     await usingApi(async (api: ApiPromise) => {
       const [alicesBalanceBefore, bobsBalanceBefore] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);
@@ -58,44 +59,125 @@
   });
 
   it('Create collection, balance transfers and check balance', async () => {
-    const Alice = privateKey('//Alice');
-    const Bob = privateKey('//Bob');
-    const Charlie = privateKey('//CHARLIE');
-    // nft
-    const nftCollectionId = await createCollectionExpectSuccess();
-    const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
-
-    await transferExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1, 'NFT');
-
-    // fungible
-    const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-    const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
-    await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
-    await transferExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1, 'Fungible');
-    // reFungible
-    const reFungibleCollectionId = await
-      createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
-    const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
-    await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
-    await transferExpectSuccess(reFungibleCollectionId,
-      newReFungibleTokenId, Alice, Bob, 1, 'ReFungible');
+    await usingApi(async (api) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await transferExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1, 'NFT');
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await transferExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1, 'Fungible');
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await transferExpectSuccess(reFungibleCollectionId,
+        newReFungibleTokenId, Alice, Bob, 1, 'ReFungible');
+    });
   });
-});
+});*/
 
 describe('Negative Integration Test Transfer(recipient, collection_id, item_id, value)', () => {
-  it('Transfer with not existed collection_id', async () => {
-
+  /*it('Transfer with not existed collection_id', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await transferExpectFail(nftCollectionCount + 1, 1, Alice, Bob, 1);
+      // fungible
+      const fungibleCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await transferExpectFail(fungibleCollectionCount + 1, 1, Alice, Bob, 1);
+      // reFungible
+      const reFungibleCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await transferExpectFail(reFungibleCollectionCount + 1, 1, Alice, Bob, 1);
+    });
   });
   it('Transfer with deleted collection_id', async () => {
-
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await transferExpectFail(nftCollectionId, newNftTokenId, Alice, Bob, 1, 'NFT');
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await transferExpectFail(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1, 'Fungible');
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
+      await transferExpectFail(reFungibleCollectionId,
+        newReFungibleTokenId, Alice, Bob, 1, 'ReFungible');
+    });
   });
   it('Transfer with not existed item_id', async () => {
-
+   await usingApi(async (api: ApiPromise) => {
+     const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      await transferExpectFail(nftCollectionId, 2, Alice, Bob, 1, 'NFT');
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      await transferExpectFail(fungibleCollectionId, 2, Alice, Bob, 1, 'Fungible');
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      await transferExpectFail(reFungibleCollectionId,
+        2, Alice, Bob, 1, 'ReFungible');
+   });
   });
   it('Transfer with deleted item_id', async () => {
-
-  });
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await burnItemExpectSuccess(Alice, nftCollectionId, newNftTokenId, 1);
+      await transferExpectFail(nftCollectionId, newNftTokenId, Alice, Bob, 1, 'NFT');
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await burnItemExpectSuccess(Alice, fungibleCollectionId, newFungibleTokenId, 1);
+      await transferExpectFail(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1, 'Fungible');
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await burnItemExpectSuccess(Alice, reFungibleCollectionId, newReFungibleTokenId, 1);
+      await transferExpectFail(reFungibleCollectionId,
+        newReFungibleTokenId, Alice, Bob, 1, 'ReFungible');
+    });
+  });*/
   it('Transfer with recipient that is not owner', async () => {
-
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const Charlie = privateKey('//CHARLIE');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await transferExpectFail(nftCollectionId, newNftTokenId, Charlie, Bob, 1, 'NFT');
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await transferExpectFail(fungibleCollectionId, newFungibleTokenId, Charlie, Bob, 1, 'Fungible');
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await transferExpectFail(reFungibleCollectionId,
+        newReFungibleTokenId, Charlie, Bob, 1, 'ReFungible');
+    });
   });
 });
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
before · tests/src/util/helpers.ts
1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56import { ApiPromise, Keyring } from '@polkadot/api';7import { Enum, Struct } from '@polkadot/types/codec';8import type { AccountId, EventRecord } from '@polkadot/types/interfaces';9import { u128 } from '@polkadot/types/primitive';10import { IKeyringPair } from '@polkadot/types/types';11import { BigNumber } from 'bignumber.js';12import BN from 'bn.js';13import chai from 'chai';14import chaiAsPromised from 'chai-as-promised';15import { alicesPublicKey, nullPublicKey } from '../accounts';16import privateKey from '../substrate/privateKey';17import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';18import { ICollectionInterface } from '../types';19import { hexToStr, strToUTF16, utf16ToStr } from './util';2021chai.use(chaiAsPromised);22const expect = chai.expect;2324type GenericResult = {25  success: boolean,26};2728interface CreateCollectionResult {29  success: boolean;30  collectionId: number;31}3233interface CreateItemResult {34  success: boolean;35  collectionId: number;36  itemId: number;37}3839interface IReFungibleOwner {40  Fraction: BN;41  Owner: number[];42}4344interface ITokenDataType {45  Owner: number[];46  ConstData: number[];47  VariableData: number[];48}4950interface IFungibleTokenDataType {51  Value: BN;52}5354interface IReFungibleTokenDataType {55  Owner: IReFungibleOwner[];56  ConstData: number[];57  VariableData: number[];58}5960export function getGenericResult(events: EventRecord[]): GenericResult {61  const result: GenericResult = {62    success: false,63  };64  events.forEach(({ phase, event: { data, method, section } }) => {65    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);66    if (method === 'ExtrinsicSuccess') {67      result.success = true;68    }69  });70  return result;71}7273export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {74  let success = false;75  let collectionId: number = 0;76  events.forEach(({ phase, event: { data, method, section } }) => {77    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);78    if (method == 'ExtrinsicSuccess') {79      success = true;80    } else if ((section == 'nft') && (method == 'Created')) {81      collectionId = parseInt(data[0].toString());82    }83  });84  const result: CreateCollectionResult = {85    success,86    collectionId,87  };88  return result;89}9091export function getCreateItemResult(events: EventRecord[]): CreateItemResult {92  let success = false;93  let collectionId: number = 0;94  let itemId: number = 0;95  events.forEach(({ phase, event: { data, method, section } }) => {96    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);97    if (method == 'ExtrinsicSuccess') {98      success = true;99    } else if ((section == 'nft') && (method == 'ItemCreated')) {100      collectionId = parseInt(data[0].toString());101      itemId = parseInt(data[1].toString());102    }103  });104  const result: CreateItemResult = {105    success,106    collectionId,107    itemId,108  };109  return result;110}111112interface Invalid {113  type: 'Invalid';114}115116interface Nft {117  type: 'NFT';118}119120interface Fungible {121  type: 'Fungible';122  decimalPoints: number;123}124125interface ReFungible {126  type: 'ReFungible';127  decimalPoints: number;128}129130interface Nft {131  type: 'NFT'132}133134interface Fungible {135  type: 'Fungible',136  decimalPoints: number137}138139interface ReFungible {140  type: 'ReFungible',141  decimalPoints: number142}143144type CollectionMode = Nft | Fungible | ReFungible | Invalid;145146export type CreateCollectionParams = {147  mode: CollectionMode,148  name: string,149  description: string,150  tokenPrefix: string,151};152153const defaultCreateCollectionParams: CreateCollectionParams = {154  description: 'description',155  mode: { type: 'NFT' },156  name: 'name',157  tokenPrefix: 'prefix',158}159160export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {161  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};162163  let collectionId: number = 0;164  await usingApi(async (api) => {165    // Get number of collections before the transaction166    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);167168    // Run the CreateCollection transaction169    const alicePrivateKey = privateKey('//Alice');170171    let modeprm = {};172    if (mode.type === 'NFT') {173      modeprm = {nft: null};174    } else if (mode.type === 'Fungible') {175      modeprm = {fungible: mode.decimalPoints};176    } else if (mode.type === 'ReFungible') {177      modeprm = {refungible: mode.decimalPoints};178    } else if (mode.type === 'Invalid') {179      modeprm = {invalid: null};180    }181182    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);183    const events = await submitTransactionAsync(alicePrivateKey, tx);184    const result = getCreateCollectionResult(events);185186    // Get number of collections after the transaction187    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);188189    // Get the collection190    const collection: any = (await api.query.nft.collection(result.collectionId)).toJSON();191192    // What to expect193    // tslint:disable-next-line:no-unused-expression194    expect(result.success).to.be.true;195    expect(result.collectionId).to.be.equal(BcollectionCount);196    // tslint:disable-next-line:no-unused-expression197    expect(collection).to.be.not.null;198    expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');199    expect(collection.Owner).to.be.equal(alicesPublicKey);200    expect(utf16ToStr(collection.Name)).to.be.equal(name);201    expect(utf16ToStr(collection.Description)).to.be.equal(description);202    expect(hexToStr(collection.TokenPrefix)).to.be.equal(tokenPrefix);203204    collectionId = result.collectionId;205  });206207  return collectionId;208}209210export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {211  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};212213  let modeprm = {};214  if (mode.type === 'NFT') {215    modeprm = {nft: null};216  } else if (mode.type === 'Fungible') {217    modeprm = {fungible: mode.decimalPoints};218  } else if (mode.type === 'ReFungible') {219    modeprm = {refungible: mode.decimalPoints};220  } else if (mode.type === 'Invalid') {221    modeprm = {invalid: null};222  }223224  await usingApi(async (api) => {225    // Get number of collections before the transaction226    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());227228    // Run the CreateCollection transaction229    const alicePrivateKey = privateKey('//Alice');230    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);231    const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;232    const result = getCreateCollectionResult(events);233234    // Get number of collections after the transaction235    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());236237    // What to expect238    // tslint:disable-next-line:no-unused-expression239    expect(result.success).to.be.false;240    expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');241  });242}243244export async function findUnusedAddress(api: ApiPromise): Promise<IKeyringPair> {245  let bal = new BigNumber(0);246  let unused;247  do {248    const randomSeed = 'seed' +  Math.floor(Math.random() * Math.floor(10000));249    const keyring = new Keyring({ type: 'sr25519' });250    unused = keyring.addFromUri(`//${randomSeed}`);251    bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());252  } while (bal.toFixed() != '0');253  return unused;254}255256function getDestroyResult(events: EventRecord[]): boolean {257  let success: boolean = false;258  events.forEach(({ phase, event: { data, method, section } }) => {259    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);260    if (method == 'ExtrinsicSuccess') {261      success = true;262    }263  });264  return success;265}266267export async function destroyCollectionExpectFailure(collectionId: number, senderSeed: string = '//Alice') {268  await usingApi(async (api) => {269    // Run the DestroyCollection transaction270    const alicePrivateKey = privateKey(senderSeed);271    const tx = api.tx.nft.destroyCollection(collectionId);272    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;273  });274}275276export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {277  await usingApi(async (api) => {278    // Run the DestroyCollection transaction279    const alicePrivateKey = privateKey(senderSeed);280    const tx = api.tx.nft.destroyCollection(collectionId);281    const events = await submitTransactionAsync(alicePrivateKey, tx);282    const result = getDestroyResult(events);283284    // Get the collection285    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();286287    // What to expect288    expect(result).to.be.true;289    expect(collection).to.be.not.null;290    expect(collection.Owner).to.be.equal(nullPublicKey);291  });292}293294export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string) {295  await usingApi(async (api) => {296297    // Run the transaction298    const alicePrivateKey = privateKey('//Alice');299    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);300    const events = await submitTransactionAsync(alicePrivateKey, tx);301    const result = getGenericResult(events);302303    // Get the collection304    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();305306    // What to expect307    expect(result.success).to.be.true;308    expect(collection.Sponsor.toString()).to.be.equal(sponsor.toString());309    expect(collection.SponsorConfirmed).to.be.false;310  });311}312313export async function removeCollectionSponsorExpectSuccess(collectionId: number) {314  await usingApi(async (api) => {315316    // Run the transaction317    const alicePrivateKey = privateKey('//Alice');318    const tx = api.tx.nft.removeCollectionSponsor(collectionId);319    const events = await submitTransactionAsync(alicePrivateKey, tx);320    const result = getGenericResult(events);321322    // Get the collection323    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();324325    // What to expect326    expect(result.success).to.be.true;327    expect(collection.Sponsor).to.be.equal(nullPublicKey);328    expect(collection.SponsorConfirmed).to.be.false;329  });330}331332export async function removeCollectionSponsorExpectFailure(collectionId: number) {333  await usingApi(async (api) => {334335    // Run the transaction336    const alicePrivateKey = privateKey('//Alice');337    const tx = api.tx.nft.removeCollectionSponsor(collectionId);338    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;339  });340}341342export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed: string = '//Alice') {343  await usingApi(async (api) => {344345    // Run the transaction346    const alicePrivateKey = privateKey(senderSeed);347    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);348    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;349  });350}351352export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {353  await usingApi(async (api) => {354355    // Run the transaction356    const sender = privateKey(senderSeed);357    const tx = api.tx.nft.confirmSponsorship(collectionId);358    const events = await submitTransactionAsync(sender, tx);359    const result = getGenericResult(events);360361    // Get the collection362    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();363364    // What to expect365    expect(result.success).to.be.true;366    expect(collection.Sponsor).to.be.equal(sender.address);367    expect(collection.SponsorConfirmed).to.be.true;368  });369}370371export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed: string = '//Alice') {372  await usingApi(async (api) => {373374    // Run the transaction375    const sender = privateKey(senderSeed);376    const tx = api.tx.nft.confirmSponsorship(collectionId);377    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;378  });379}380381export interface CreateFungibleData extends Struct {382  readonly value: u128;383}384385export interface CreateReFungibleData extends Struct {}386export interface CreateNftData extends Struct {}387388export interface CreateItemData extends Enum {389  NFT: CreateNftData;390  Fungible: CreateFungibleData;391  ReFungible: CreateReFungibleData;392}393394export async function395approveExpectSuccess(collectionId: number,396                     tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {397  await usingApi(async (api: ApiPromise) => {398    const allowanceBefore =399      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;400    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);401    const events = await submitTransactionAsync(owner, approveNftTx);402    const result = getCreateItemResult(events);403    // tslint:disable-next-line:no-unused-expression404    expect(result.success).to.be.true;405    const allowanceAfter =406      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;407    expect(allowanceAfter.toNumber() - allowanceBefore.toNumber()).to.be.equal(amount);408  });409}410411export async function412transferFromExpectSuccess(collectionId: number,413                          tokenId: number,414                          accountApproved: IKeyringPair,415                          accountFrom: IKeyringPair,416                          accountTo: IKeyringPair,417                          value: number = 1,418                          type: string = 'NFT') {419  await usingApi(async (api: ApiPromise) => {420    let balanceBefore = new BN(0);421    if (type === 'Fungible') {422      balanceBefore = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;423    }424    const transferFromTx = await api.tx.nft.transferFrom(425      accountFrom.address, accountTo.address, collectionId, tokenId, value);426    const events = await submitTransactionAsync(accountFrom, transferFromTx);427    const result = getCreateItemResult(events);428    // tslint:disable-next-line:no-unused-expression429    expect(result.success).to.be.true;430    if (type === 'NFT') {431      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;432      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);433    }434    if (type === 'Fungible') {435      const balanceAfter = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;436      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);437    }438    if (type === 'ReFungible') {439      const nftItemData =440        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;441      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);442      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);443    }444  });445}446447export async function448transferFromExpectFail(collectionId: number,449                       tokenId: number,450                       accountApproved: IKeyringPair,451                       accountFrom: IKeyringPair,452                       accountTo: IKeyringPair,453                       value: number = 1) {454  await usingApi(async (api: ApiPromise) => {455    const transferFromTx = await api.tx.nft.transferFrom(456      accountFrom.address, accountTo.address, collectionId, tokenId, value);457    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;458    const result = getCreateCollectionResult(events);459    // tslint:disable-next-line:no-unused-expression460    expect(result.success).to.be.false;461  });462}463464export async function465transferExpectSuccess(collectionId: number,466                      tokenId: number,467                      sender: IKeyringPair,468                      recipient: IKeyringPair,469                      value: number = 1,470                      type: string = 'NFT') {471  await usingApi(async (api: ApiPromise) => {472    let balanceBefore = new BN(0);473    if (type === 'Fungible') {474      balanceBefore = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;475    }476    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);477    const events = await submitTransactionAsync(sender, transferTx);478    const result = getCreateItemResult(events);479    // tslint:disable-next-line:no-unused-expression480    expect(result.success).to.be.true;481    if (type === 'NFT') {482      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;483      expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);484    }485    if (type === 'Fungible') {486      const balanceAfter = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;487      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);488    }489    if (type === 'ReFungible') {490      const nftItemData =491        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;492      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);493      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);494    }495  });496}497498export async function499approveExpectFail(collectionId: number,500                  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {501  await usingApi(async (api: ApiPromise) => {502    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);503    const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;504    const result = getCreateCollectionResult(events);505    // tslint:disable-next-line:no-unused-expression506    expect(result.success).to.be.false;507  });508}509510export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: string = '') {511  let newItemId: number = 0;512  await usingApi(async (api) => {513    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);514    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();515    const AItemBalance = new BigNumber(Aitem.Value);516517    if (owner === '') {518      owner = sender.address;519    }520521    let tx;522    if (createMode === 'Fungible') {523      const createData = {fungible: {value: 10}};524      tx = api.tx.nft.createItem(collectionId, owner, createData);525    } else {526      tx = api.tx.nft.createItem(collectionId, owner, createMode);527    }528    const events = await submitTransactionAsync(sender, tx);529    const result = getCreateItemResult(events);530531    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);532    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();533    const BItemBalance = new BigNumber(Bitem.Value);534535    // What to expect536    // tslint:disable-next-line:no-unused-expression537    expect(result.success).to.be.true;538    if (createMode === 'Fungible') {539      expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);540    } else {541      expect(BItemCount).to.be.equal(AItemCount + 1);542    }543    expect(collectionId).to.be.equal(result.collectionId);544    expect(BItemCount).to.be.equal(result.itemId);545    newItemId = result.itemId;546  });547  return newItemId;548}549550export async function enableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {551  await usingApi(async (api) => {552553    // Run the transaction554    const tx = api.tx.nft.setPublicAccessMode(collectionId, 'WhiteList');555    const events = await submitTransactionAsync(sender, tx);556    const result = getGenericResult(events);557558    // Get the collection559    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();560561    // What to expect562    expect(result.success).to.be.true;563    expect(collection.Access).to.be.equal('WhiteList');564  });565}566567export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {568  await usingApi(async (api) => {569570    // Run the transaction571    const tx = api.tx.nft.setMintPermission(collectionId, true);572    const events = await submitTransactionAsync(sender, tx);573    const result = getGenericResult(events);574575    // Get the collection576    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();577578    // What to expect579    expect(result.success).to.be.true;580    expect(collection.MintMode).to.be.equal(true);581  });582}583584export async function addToWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {585  await usingApi(async (api) => {586587    // Run the transaction588    const tx = api.tx.nft.addToWhiteList(collectionId, address);589    const events = await submitTransactionAsync(sender, tx);590    const result = getGenericResult(events);591592    // Get the collection593    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();594595    // What to expect596    expect(result.success).to.be.true;597    expect(collection.MintMode).to.be.equal(true);598  });599}600601export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)602  : Promise<ICollectionInterface | null> => {603  return await api.query.nft.collection(collectionId) as unknown as ICollectionInterface;604};605606export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {607  // set global object - collectionsCount608  return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();609};