`8a4b6c870c52`

1 file changed

modifiedtests/src/util/helpers.tsdiff before after both

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}5354export interface 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}255256export async function findNotExistingCollection(api: ApiPromise): Promise<number> {257  const totalNumber = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10) as unknown as number;258  const newCollection: number = totalNumber + 1;259  return newCollection;260}261262function getDestroyResult(events: EventRecord[]): boolean {263  let success: boolean = false;264  events.forEach(({ phase, event: { data, method, section } }) => {265    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);266    if (method == 'ExtrinsicSuccess') {267      success = true;268    }269  });270  return success;271}272273export async function destroyCollectionExpectFailure(collectionId: number, senderSeed: string = '//Alice') {274  await usingApi(async (api) => {275    // Run the DestroyCollection transaction276    const alicePrivateKey = privateKey(senderSeed);277    const tx = api.tx.nft.destroyCollection(collectionId);278    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;279  });280}281282export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {283  await usingApi(async (api) => {284    // Run the DestroyCollection transaction285    const alicePrivateKey = privateKey(senderSeed);286    const tx = api.tx.nft.destroyCollection(collectionId);287    const events = await submitTransactionAsync(alicePrivateKey, tx);288    const result = getDestroyResult(events);289290    // Get the collection291    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();292293    // What to expect294    expect(result).to.be.true;295    expect(collection).to.be.not.null;296    expect(collection.Owner).to.be.equal(nullPublicKey);297  });298}299300export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string) {301  await usingApi(async (api) => {302303    // Run the transaction304    const alicePrivateKey = privateKey('//Alice');305    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);306    const events = await submitTransactionAsync(alicePrivateKey, tx);307    const result = getGenericResult(events);308309    // Get the collection310    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();311312    // What to expect313    expect(result.success).to.be.true;314    expect(collection.Sponsor.toString()).to.be.equal(sponsor.toString());315    expect(collection.SponsorConfirmed).to.be.false;316  });317}318319export async function removeCollectionSponsorExpectSuccess(collectionId: number) {320  await usingApi(async (api) => {321322    // Run the transaction323    const alicePrivateKey = privateKey('//Alice');324    const tx = api.tx.nft.removeCollectionSponsor(collectionId);325    const events = await submitTransactionAsync(alicePrivateKey, tx);326    const result = getGenericResult(events);327328    // Get the collection329    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();330331    // What to expect332    expect(result.success).to.be.true;333    expect(collection.Sponsor).to.be.equal(nullPublicKey);334    expect(collection.SponsorConfirmed).to.be.false;335  });336}337338export async function removeCollectionSponsorExpectFailure(collectionId: number) {339  await usingApi(async (api) => {340341    // Run the transaction342    const alicePrivateKey = privateKey('//Alice');343    const tx = api.tx.nft.removeCollectionSponsor(collectionId);344    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;345  });346}347348export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed: string = '//Alice') {349  await usingApi(async (api) => {350351    // Run the transaction352    const alicePrivateKey = privateKey(senderSeed);353    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);354    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;355  });356}357358export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {359  await usingApi(async (api) => {360361    // Run the transaction362    const sender = privateKey(senderSeed);363    const tx = api.tx.nft.confirmSponsorship(collectionId);364    const events = await submitTransactionAsync(sender, tx);365    const result = getGenericResult(events);366367    // Get the collection368    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();369370    // What to expect371    expect(result.success).to.be.true;372    expect(collection.Sponsor).to.be.equal(sender.address);373    expect(collection.SponsorConfirmed).to.be.true;374  });375}376377export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed: string = '//Alice') {378  await usingApi(async (api) => {379380    // Run the transaction381    const sender = privateKey(senderSeed);382    const tx = api.tx.nft.confirmSponsorship(collectionId);383    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;384  });385}386387export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {388  await usingApi(async (api) => {389    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);390    const events = await submitTransactionAsync(sender, tx);391    const result = getGenericResult(events);392393    expect(result.success).to.be.true;394  });395}396397export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {398  await usingApi(async (api) => {399    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);400    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;401    const result = getGenericResult(events);402403    expect(result.success).to.be.false;404  });405}406407export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {408  await usingApi(async (api) => {409    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);410    const events = await submitTransactionAsync(sender, tx);411    const result = getGenericResult(events);412413    expect(result.success).to.be.true;414  });415}416417export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {418  await usingApi(async (api) => {419    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);420    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;421    const result = getGenericResult(events);422423    expect(result.success).to.be.false;424  });425}426427export async function setVariableMetaDataExpectSuccess(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {428  await usingApi(async (api) => {429    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));430    const events = await submitTransactionAsync(sender, tx);431    const result = getGenericResult(events);432433    expect(result.success).to.be.true;434  });435}436437export async function setVariableMetaDataExpectFailure(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {438  await usingApi(async (api) => {439    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));440    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;441  });442}443444export interface CreateFungibleData extends Struct {445  readonly value: u128;446}447448export interface CreateReFungibleData extends Struct {}449export interface CreateNftData extends Struct {}450451export interface CreateItemData extends Enum {452  NFT: CreateNftData;453  Fungible: CreateFungibleData;454  ReFungible: CreateReFungibleData;455}456457export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {458  await usingApi(async (api) => {459    const tx = api.tx.nft.burnItem(collectionId, tokenId, value);460    const events = await submitTransactionAsync(owner, tx);461    const result = getGenericResult(events);462    // Get the item463    const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();464    // What to expect465    // tslint:disable-next-line:no-unused-expression466    expect(result.success).to.be.true;467    // tslint:disable-next-line:no-unused-expression468    expect(item).to.be.not.null;469    expect(item.Owner).to.be.equal(nullPublicKey);470  });471}472473export async function474approveExpectSuccess(collectionId: number,475                     tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {476  await usingApi(async (api: ApiPromise) => {477    const allowanceBefore =478      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;479    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);480    const events = await submitTransactionAsync(owner, approveNftTx);481    const result = getCreateItemResult(events);482    // tslint:disable-next-line:no-unused-expression483    expect(result.success).to.be.true;484    const allowanceAfter =485      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;486    expect(allowanceAfter.toNumber() - allowanceBefore.toNumber()).to.be.equal(amount);487  });488}489490export async function491transferFromExpectSuccess(collectionId: number,492                          tokenId: number,493                          accountApproved: IKeyringPair,494                          accountFrom: IKeyringPair,495                          accountTo: IKeyringPair,496                          value: number = 1,497                          type: string = 'NFT') {498  await usingApi(async (api: ApiPromise) => {499    let balanceBefore = new BN(0);500    if (type === 'Fungible') {501      balanceBefore = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;502    }503    const transferFromTx = await api.tx.nft.transferFrom(504      accountFrom.address, accountTo.address, collectionId, tokenId, value);505    const events = await submitTransactionAsync(accountApproved, transferFromTx);506    const result = getCreateItemResult(events);507    // tslint:disable-next-line:no-unused-expression508    expect(result.success).to.be.true;509    if (type === 'NFT') {510      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;511      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);512    }513    if (type === 'Fungible') {514      const balanceAfter = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;515      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);516    }517    if (type === 'ReFungible') {518      const nftItemData =519        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;520      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);521      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);522    }523  });524}525526export async function527transferFromExpectFail(collectionId: number,528                       tokenId: number,529                       accountApproved: IKeyringPair,530                       accountFrom: IKeyringPair,531                       accountTo: IKeyringPair,532                       value: number = 1) {533  await usingApi(async (api: ApiPromise) => {534    const transferFromTx = await api.tx.nft.transferFrom(535      accountFrom.address, accountTo.address, collectionId, tokenId, value);536    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;537    const result = getCreateCollectionResult(events);538    // tslint:disable-next-line:no-unused-expression539    expect(result.success).to.be.false;540  });541}542543export async function544transferExpectSuccess(collectionId: number,545                      tokenId: number,546                      sender: IKeyringPair,547                      recipient: IKeyringPair,548                      value: number = 1,549                      type: string = 'NFT') {550  await usingApi(async (api: ApiPromise) => {551    let balanceBefore = new BN(0);552    if (type === 'Fungible') {553      balanceBefore = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;554    }555    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);556    const events = await submitTransactionAsync(sender, transferTx);557    const result = getCreateItemResult(events);558    // tslint:disable-next-line:no-unused-expression559    expect(result.success).to.be.true;560    if (type === 'NFT') {561      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;562      expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);563    }564    if (type === 'Fungible') {565      const balanceAfter = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;566      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);567    }568    if (type === 'ReFungible') {569      const nftItemData =570        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;571      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);572      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);573    }574  });575}576577export async function578transferExpectFail(collectionId: number,579                   tokenId: number,580                   sender: IKeyringPair,581                   recipient: IKeyringPair,582                   value: number = 1,583                   type: string = 'NFT') {584  await usingApi(async (api: ApiPromise) => {585    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);586    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;587    if (events && Array.isArray(events)) {588      const result = getCreateCollectionResult(events);589      // tslint:disable-next-line:no-unused-expression590      expect(result.success).to.be.false;591    }592  });593}594595export async function596approveExpectFail(collectionId: number,597                  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {598  await usingApi(async (api: ApiPromise) => {599    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);600    const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;601    const result = getCreateCollectionResult(events);602    // tslint:disable-next-line:no-unused-expression603    expect(result.success).to.be.false;604  });605}606607export async function createItemExpectSuccess(608  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = '') {609  let newItemId: number = 0;610  await usingApi(async (api) => {611    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);612    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();613    const AItemBalance = new BigNumber(Aitem.Value);614615    if (owner === '') {616      owner = sender.address;617    }618619    let tx;620    if (createMode === 'Fungible') {621      const createData = {fungible: {value: 10}};622      tx = api.tx.nft.createItem(collectionId, owner, createData);623    } else {624      tx = api.tx.nft.createItem(collectionId, owner, createMode);625    }626    const events = await submitTransactionAsync(sender, tx);627    const result = getCreateItemResult(events);628629    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);630    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();631    const BItemBalance = new BigNumber(Bitem.Value);632633    // What to expect634    // tslint:disable-next-line:no-unused-expression635    expect(result.success).to.be.true;636    if (createMode === 'Fungible') {637      expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);638    } else {639      expect(BItemCount).to.be.equal(AItemCount + 1);640    }641    expect(collectionId).to.be.equal(result.collectionId);642    expect(BItemCount).to.be.equal(result.itemId);643    newItemId = result.itemId;644  });645  return newItemId;646}647648export async function createItemExpectFailure(649  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = sender.address) {650  await usingApi(async (api) => {651    const tx = api.tx.nft.createItem(collectionId, owner, createMode);652    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;653    const result = getCreateItemResult(events);654655    expect(result.success).to.be.false;656  });657}658659export async function setPublicAccessModeExpectSuccess(660  sender: IKeyringPair, collectionId: number,661  accessMode: 'Normal' | 'WhiteList',662) {663  await usingApi(async (api) => {664665    // Run the transaction666    const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);667    const events = await submitTransactionAsync(sender, tx);668    const result = getGenericResult(events);669670    // Get the collection671    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();672673    // What to expect674    // tslint:disable-next-line:no-unused-expression675    expect(result.success).to.be.true;676    expect(collection.Access).to.be.equal(accessMode);677  });678}679680export async function enableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {681  await setPublicAccessModeExpectSuccess(sender, collectionId, 'WhiteList');682}683684export async function disableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {685  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');686}687688export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {689  await usingApi(async (api) => {690691    // Run the transaction692    const tx = api.tx.nft.setMintPermission(collectionId, enabled);693    const events = await submitTransactionAsync(sender, tx);694    const result = getGenericResult(events);695696    // Get the collection697    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();698699    // What to expect700    // tslint:disable-next-line:no-unused-expression701    expect(result.success).to.be.true;702    expect(collection.MintMode).to.be.equal(enabled);703  });704}705706export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {707  await setMintPermissionExpectSuccess(sender, collectionId, true);708}709710export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {711  await usingApi(async (api) => {712    // Run the transaction713    const tx = api.tx.nft.setMintPermission(collectionId, enabled);714    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;715    const result = getCreateCollectionResult(events);716    // tslint:disable-next-line:no-unused-expression717    expect(result.success).to.be.false;718  });719}720721export async function isWhitelisted(collectionId: number, address: string) {722  let whitelisted: boolean = false;723  await usingApi(async (api) => {724    whitelisted = (await api.query.nft.whiteList(collectionId, address)).toJSON() as unknown as boolean;725  });726  return whitelisted;727}728729export async function addToWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {730  await usingApi(async (api) => {731732    const whiteListedBefore = (await api.query.nft.whiteList(collectionId, address)).toJSON();733734    // Run the transaction735    const tx = api.tx.nft.addToWhiteList(collectionId, address);736    const events = await submitTransactionAsync(sender, tx);737    const result = getGenericResult(events);738739    const whiteListedAfter = (await api.query.nft.whiteList(collectionId, address)).toJSON();740741    // What to expect742    // tslint:disable-next-line:no-unused-expression743    expect(result.success).to.be.true;744    // tslint:disable-next-line: no-unused-expression745    expect(whiteListedBefore).to.be.false;746    // tslint:disable-next-line: no-unused-expression747    expect(whiteListedAfter).to.be.true;748  });749}750751export async function removeFromWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {752  await usingApi(async (api) => {753    // Run the transaction754    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);755    const events = await submitTransactionAsync(sender, tx);756    const result = getGenericResult(events);757758    // What to expect759    // tslint:disable-next-line:no-unused-expression760    expect(result.success).to.be.true;761  });762}763764export async function removeFromWhiteListExpectFailure(sender: IKeyringPair, collectionId: number, address: string) {765  await usingApi(async (api) => {766    // Run the transaction767    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);768    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;769    const result = getGenericResult(events);770771    // What to expect772    // tslint:disable-next-line:no-unused-expression773    expect(result.success).to.be.false;774  });775}776777export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)778  : Promise<ICollectionInterface | null> => {779  return await api.query.nft.collection(collectionId) as unknown as ICollectionInterface;780};781782export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {783  // set global object - collectionsCount784  return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();785};

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;2324export const U128_MAX = (1n << 128n) - 1n;2526type GenericResult = {27  success: boolean,28};2930interface CreateCollectionResult {31  success: boolean;32  collectionId: number;33}3435interface CreateItemResult {36  success: boolean;37  collectionId: number;38  itemId: number;39}4041interface IReFungibleOwner {42  Fraction: BN;43  Owner: number[];44}4546interface ITokenDataType {47  Owner: number[];48  ConstData: number[];49  VariableData: number[];50}5152interface IFungibleTokenDataType {53  Value: BN;54}5556export interface IReFungibleTokenDataType {57  Owner: IReFungibleOwner[];58  ConstData: number[];59  VariableData: number[];60}6162export function getGenericResult(events: EventRecord[]): GenericResult {63  const result: GenericResult = {64    success: false,65  };66  events.forEach(({ phase, event: { data, method, section } }) => {67    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);68    if (method === 'ExtrinsicSuccess') {69      result.success = true;70    }71  });72  return result;73}7475export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {76  let success = false;77  let collectionId: number = 0;78  events.forEach(({ phase, event: { data, method, section } }) => {79    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);80    if (method == 'ExtrinsicSuccess') {81      success = true;82    } else if ((section == 'nft') && (method == 'Created')) {83      collectionId = parseInt(data[0].toString());84    }85  });86  const result: CreateCollectionResult = {87    success,88    collectionId,89  };90  return result;91}9293export function getCreateItemResult(events: EventRecord[]): CreateItemResult {94  let success = false;95  let collectionId: number = 0;96  let itemId: number = 0;97  events.forEach(({ phase, event: { data, method, section } }) => {98    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);99    if (method == 'ExtrinsicSuccess') {100      success = true;101    } else if ((section == 'nft') && (method == 'ItemCreated')) {102      collectionId = parseInt(data[0].toString());103      itemId = parseInt(data[1].toString());104    }105  });106  const result: CreateItemResult = {107    success,108    collectionId,109    itemId,110  };111  return result;112}113114interface Invalid {115  type: 'Invalid';116}117118interface Nft {119  type: 'NFT';120}121122interface Fungible {123  type: 'Fungible';124  decimalPoints: number;125}126127interface ReFungible {128  type: 'ReFungible';129  decimalPoints: number;130}131132interface Nft {133  type: 'NFT'134}135136interface Fungible {137  type: 'Fungible',138  decimalPoints: number139}140141interface ReFungible {142  type: 'ReFungible',143  decimalPoints: number144}145146type CollectionMode = Nft | Fungible | ReFungible | Invalid;147148export type CreateCollectionParams = {149  mode: CollectionMode,150  name: string,151  description: string,152  tokenPrefix: string,153};154155const defaultCreateCollectionParams: CreateCollectionParams = {156  description: 'description',157  mode: { type: 'NFT' },158  name: 'name',159  tokenPrefix: 'prefix',160}161162export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {163  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};164165  let collectionId: number = 0;166  await usingApi(async (api) => {167    // Get number of collections before the transaction168    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);169170    // Run the CreateCollection transaction171    const alicePrivateKey = privateKey('//Alice');172173    let modeprm = {};174    if (mode.type === 'NFT') {175      modeprm = {nft: null};176    } else if (mode.type === 'Fungible') {177      modeprm = {fungible: mode.decimalPoints};178    } else if (mode.type === 'ReFungible') {179      modeprm = {refungible: mode.decimalPoints};180    } else if (mode.type === 'Invalid') {181      modeprm = {invalid: null};182    }183184    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);185    const events = await submitTransactionAsync(alicePrivateKey, tx);186    const result = getCreateCollectionResult(events);187188    // Get number of collections after the transaction189    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);190191    // Get the collection192    const collection: any = (await api.query.nft.collection(result.collectionId)).toJSON();193194    // What to expect195    // tslint:disable-next-line:no-unused-expression196    expect(result.success).to.be.true;197    expect(result.collectionId).to.be.equal(BcollectionCount);198    // tslint:disable-next-line:no-unused-expression199    expect(collection).to.be.not.null;200    expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');201    expect(collection.Owner).to.be.equal(alicesPublicKey);202    expect(utf16ToStr(collection.Name)).to.be.equal(name);203    expect(utf16ToStr(collection.Description)).to.be.equal(description);204    expect(hexToStr(collection.TokenPrefix)).to.be.equal(tokenPrefix);205206    collectionId = result.collectionId;207  });208209  return collectionId;210}211212export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {213  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};214215  let modeprm = {};216  if (mode.type === 'NFT') {217    modeprm = {nft: null};218  } else if (mode.type === 'Fungible') {219    modeprm = {fungible: mode.decimalPoints};220  } else if (mode.type === 'ReFungible') {221    modeprm = {refungible: mode.decimalPoints};222  } else if (mode.type === 'Invalid') {223    modeprm = {invalid: null};224  }225226  await usingApi(async (api) => {227    // Get number of collections before the transaction228    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());229230    // Run the CreateCollection transaction231    const alicePrivateKey = privateKey('//Alice');232    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);233    const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;234    const result = getCreateCollectionResult(events);235236    // Get number of collections after the transaction237    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());238239    // What to expect240    // tslint:disable-next-line:no-unused-expression241    expect(result.success).to.be.false;242    expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');243  });244}245246export async function findUnusedAddress(api: ApiPromise): Promise<IKeyringPair> {247  let bal = new BigNumber(0);248  let unused;249  do {250    const randomSeed = 'seed' +  Math.floor(Math.random() * Math.floor(10000));251    const keyring = new Keyring({ type: 'sr25519' });252    unused = keyring.addFromUri(`//${randomSeed}`);253    bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());254  } while (bal.toFixed() != '0');255  return unused;256}257258export async function findNotExistingCollection(api: ApiPromise): Promise<number> {259  const totalNumber = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10) as unknown as number;260  const newCollection: number = totalNumber + 1;261  return newCollection;262}263264function getDestroyResult(events: EventRecord[]): boolean {265  let success: boolean = false;266  events.forEach(({ phase, event: { data, method, section } }) => {267    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);268    if (method == 'ExtrinsicSuccess') {269      success = true;270    }271  });272  return success;273}274275export async function destroyCollectionExpectFailure(collectionId: number, senderSeed: string = '//Alice') {276  await usingApi(async (api) => {277    // Run the DestroyCollection transaction278    const alicePrivateKey = privateKey(senderSeed);279    const tx = api.tx.nft.destroyCollection(collectionId);280    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;281  });282}283284export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {285  await usingApi(async (api) => {286    // Run the DestroyCollection transaction287    const alicePrivateKey = privateKey(senderSeed);288    const tx = api.tx.nft.destroyCollection(collectionId);289    const events = await submitTransactionAsync(alicePrivateKey, tx);290    const result = getDestroyResult(events);291292    // Get the collection293    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();294295    // What to expect296    expect(result).to.be.true;297    expect(collection).to.be.not.null;298    expect(collection.Owner).to.be.equal(nullPublicKey);299  });300}301302export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string) {303  await usingApi(async (api) => {304305    // Run the transaction306    const alicePrivateKey = privateKey('//Alice');307    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);308    const events = await submitTransactionAsync(alicePrivateKey, tx);309    const result = getGenericResult(events);310311    // Get the collection312    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();313314    // What to expect315    expect(result.success).to.be.true;316    expect(collection.Sponsor.toString()).to.be.equal(sponsor.toString());317    expect(collection.SponsorConfirmed).to.be.false;318  });319}320321export async function removeCollectionSponsorExpectSuccess(collectionId: number) {322  await usingApi(async (api) => {323324    // Run the transaction325    const alicePrivateKey = privateKey('//Alice');326    const tx = api.tx.nft.removeCollectionSponsor(collectionId);327    const events = await submitTransactionAsync(alicePrivateKey, tx);328    const result = getGenericResult(events);329330    // Get the collection331    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();332333    // What to expect334    expect(result.success).to.be.true;335    expect(collection.Sponsor).to.be.equal(nullPublicKey);336    expect(collection.SponsorConfirmed).to.be.false;337  });338}339340export async function removeCollectionSponsorExpectFailure(collectionId: number) {341  await usingApi(async (api) => {342343    // Run the transaction344    const alicePrivateKey = privateKey('//Alice');345    const tx = api.tx.nft.removeCollectionSponsor(collectionId);346    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;347  });348}349350export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed: string = '//Alice') {351  await usingApi(async (api) => {352353    // Run the transaction354    const alicePrivateKey = privateKey(senderSeed);355    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);356    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;357  });358}359360export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {361  await usingApi(async (api) => {362363    // Run the transaction364    const sender = privateKey(senderSeed);365    const tx = api.tx.nft.confirmSponsorship(collectionId);366    const events = await submitTransactionAsync(sender, tx);367    const result = getGenericResult(events);368369    // Get the collection370    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();371372    // What to expect373    expect(result.success).to.be.true;374    expect(collection.Sponsor).to.be.equal(sender.address);375    expect(collection.SponsorConfirmed).to.be.true;376  });377}378379export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed: string = '//Alice') {380  await usingApi(async (api) => {381382    // Run the transaction383    const sender = privateKey(senderSeed);384    const tx = api.tx.nft.confirmSponsorship(collectionId);385    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;386  });387}388389export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {390  await usingApi(async (api) => {391    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);392    const events = await submitTransactionAsync(sender, tx);393    const result = getGenericResult(events);394395    expect(result.success).to.be.true;396  });397}398399export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {400  await usingApi(async (api) => {401    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);402    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;403    const result = getGenericResult(events);404405    expect(result.success).to.be.false;406  });407}408409export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {410  await usingApi(async (api) => {411    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);412    const events = await submitTransactionAsync(sender, tx);413    const result = getGenericResult(events);414415    expect(result.success).to.be.true;416  });417}418419export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {420  await usingApi(async (api) => {421    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);422    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;423    const result = getGenericResult(events);424425    expect(result.success).to.be.false;426  });427}428429export async function setVariableMetaDataExpectSuccess(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {430  await usingApi(async (api) => {431    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));432    const events = await submitTransactionAsync(sender, tx);433    const result = getGenericResult(events);434435    expect(result.success).to.be.true;436  });437}438439export async function setVariableMetaDataExpectFailure(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {440  await usingApi(async (api) => {441    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));442    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;443  });444}445446export interface CreateFungibleData extends Struct {447  readonly value: u128;448}449450export interface CreateReFungibleData extends Struct {}451export interface CreateNftData extends Struct {}452453export interface CreateItemData extends Enum {454  NFT: CreateNftData;455  Fungible: CreateFungibleData;456  ReFungible: CreateReFungibleData;457}458459export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {460  await usingApi(async (api) => {461    const tx = api.tx.nft.burnItem(collectionId, tokenId, value);462    const events = await submitTransactionAsync(owner, tx);463    const result = getGenericResult(events);464    // Get the item465    const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();466    // What to expect467    // tslint:disable-next-line:no-unused-expression468    expect(result.success).to.be.true;469    // tslint:disable-next-line:no-unused-expression470    expect(item).to.be.not.null;471    expect(item.Owner).to.be.equal(nullPublicKey);472  });473}474475export async function476approveExpectSuccess(collectionId: number,477                     tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {478  await usingApi(async (api: ApiPromise) => {479    const allowanceBefore =480      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;481    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);482    const events = await submitTransactionAsync(owner, approveNftTx);483    const result = getCreateItemResult(events);484    // tslint:disable-next-line:no-unused-expression485    expect(result.success).to.be.true;486    const allowanceAfter =487      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;488    expect(allowanceAfter.toNumber() - allowanceBefore.toNumber()).to.be.equal(amount);489  });490}491492export async function493transferFromExpectSuccess(collectionId: number,494                          tokenId: number,495                          accountApproved: IKeyringPair,496                          accountFrom: IKeyringPair,497                          accountTo: IKeyringPair,498                          value: number = 1,499                          type: string = 'NFT') {500  await usingApi(async (api: ApiPromise) => {501    let balanceBefore = new BN(0);502    if (type === 'Fungible') {503      balanceBefore = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;504    }505    const transferFromTx = await api.tx.nft.transferFrom(506      accountFrom.address, accountTo.address, collectionId, tokenId, value);507    const events = await submitTransactionAsync(accountApproved, transferFromTx);508    const result = getCreateItemResult(events);509    // tslint:disable-next-line:no-unused-expression510    expect(result.success).to.be.true;511    if (type === 'NFT') {512      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;513      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);514    }515    if (type === 'Fungible') {516      const balanceAfter = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;517      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);518    }519    if (type === 'ReFungible') {520      const nftItemData =521        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;522      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);523      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);524    }525  });526}527528export async function529transferFromExpectFail(collectionId: number,530                       tokenId: number,531                       accountApproved: IKeyringPair,532                       accountFrom: IKeyringPair,533                       accountTo: IKeyringPair,534                       value: number = 1) {535  await usingApi(async (api: ApiPromise) => {536    const transferFromTx = await api.tx.nft.transferFrom(537      accountFrom.address, accountTo.address, collectionId, tokenId, value);538    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;539    const result = getCreateCollectionResult(events);540    // tslint:disable-next-line:no-unused-expression541    expect(result.success).to.be.false;542  });543}544545export async function546transferExpectSuccess(collectionId: number,547                      tokenId: number,548                      sender: IKeyringPair,549                      recipient: IKeyringPair,550                      value: number = 1,551                      type: string = 'NFT') {552  await usingApi(async (api: ApiPromise) => {553    let balanceBefore = new BN(0);554    if (type === 'Fungible') {555      balanceBefore = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;556    }557    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);558    const events = await submitTransactionAsync(sender, transferTx);559    const result = getCreateItemResult(events);560    // tslint:disable-next-line:no-unused-expression561    expect(result.success).to.be.true;562    if (type === 'NFT') {563      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;564      expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);565    }566    if (type === 'Fungible') {567      const balanceAfter = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;568      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);569    }570    if (type === 'ReFungible') {571      const nftItemData =572        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;573      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);574      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);575    }576  });577}578579export async function580transferExpectFail(collectionId: number,581                   tokenId: number,582                   sender: IKeyringPair,583                   recipient: IKeyringPair,584                   value: number = 1,585                   type: string = 'NFT') {586  await usingApi(async (api: ApiPromise) => {587    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);588    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;589    if (events && Array.isArray(events)) {590      const result = getCreateCollectionResult(events);591      // tslint:disable-next-line:no-unused-expression592      expect(result.success).to.be.false;593    }594  });595}596597export async function598approveExpectFail(collectionId: number,599                  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {600  await usingApi(async (api: ApiPromise) => {601    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);602    const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;603    const result = getCreateCollectionResult(events);604    // tslint:disable-next-line:no-unused-expression605    expect(result.success).to.be.false;606  });607}608609export async function createItemExpectSuccess(610  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = '') {611  let newItemId: number = 0;612  await usingApi(async (api) => {613    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);614    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();615    const AItemBalance = new BigNumber(Aitem.Value);616617    if (owner === '') {618      owner = sender.address;619    }620621    let tx;622    if (createMode === 'Fungible') {623      const createData = {fungible: {value: 10}};624      tx = api.tx.nft.createItem(collectionId, owner, createData);625    } else {626      tx = api.tx.nft.createItem(collectionId, owner, createMode);627    }628    const events = await submitTransactionAsync(sender, tx);629    const result = getCreateItemResult(events);630631    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);632    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();633    const BItemBalance = new BigNumber(Bitem.Value);634635    // What to expect636    // tslint:disable-next-line:no-unused-expression637    expect(result.success).to.be.true;638    if (createMode === 'Fungible') {639      expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);640    } else {641      expect(BItemCount).to.be.equal(AItemCount + 1);642    }643    expect(collectionId).to.be.equal(result.collectionId);644    expect(BItemCount).to.be.equal(result.itemId);645    newItemId = result.itemId;646  });647  return newItemId;648}649650export async function createItemExpectFailure(651  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = sender.address) {652  await usingApi(async (api) => {653    const tx = api.tx.nft.createItem(collectionId, owner, createMode);654    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;655    const result = getCreateItemResult(events);656657    expect(result.success).to.be.false;658  });659}660661export async function setPublicAccessModeExpectSuccess(662  sender: IKeyringPair, collectionId: number,663  accessMode: 'Normal' | 'WhiteList',664) {665  await usingApi(async (api) => {666667    // Run the transaction668    const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);669    const events = await submitTransactionAsync(sender, tx);670    const result = getGenericResult(events);671672    // Get the collection673    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();674675    // What to expect676    // tslint:disable-next-line:no-unused-expression677    expect(result.success).to.be.true;678    expect(collection.Access).to.be.equal(accessMode);679  });680}681682export async function enableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {683  await setPublicAccessModeExpectSuccess(sender, collectionId, 'WhiteList');684}685686export async function disableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {687  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');688}689690export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {691  await usingApi(async (api) => {692693    // Run the transaction694    const tx = api.tx.nft.setMintPermission(collectionId, enabled);695    const events = await submitTransactionAsync(sender, tx);696    const result = getGenericResult(events);697698    // Get the collection699    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();700701    // What to expect702    // tslint:disable-next-line:no-unused-expression703    expect(result.success).to.be.true;704    expect(collection.MintMode).to.be.equal(enabled);705  });706}707708export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {709  await setMintPermissionExpectSuccess(sender, collectionId, true);710}711712export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {713  await usingApi(async (api) => {714    // Run the transaction715    const tx = api.tx.nft.setMintPermission(collectionId, enabled);716    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;717    const result = getCreateCollectionResult(events);718    // tslint:disable-next-line:no-unused-expression719    expect(result.success).to.be.false;720  });721}722723export async function isWhitelisted(collectionId: number, address: string) {724  let whitelisted: boolean = false;725  await usingApi(async (api) => {726    whitelisted = (await api.query.nft.whiteList(collectionId, address)).toJSON() as unknown as boolean;727  });728  return whitelisted;729}730731export async function addToWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {732  await usingApi(async (api) => {733734    const whiteListedBefore = (await api.query.nft.whiteList(collectionId, address)).toJSON();735736    // Run the transaction737    const tx = api.tx.nft.addToWhiteList(collectionId, address);738    const events = await submitTransactionAsync(sender, tx);739    const result = getGenericResult(events);740741    const whiteListedAfter = (await api.query.nft.whiteList(collectionId, address)).toJSON();742743    // What to expect744    // tslint:disable-next-line:no-unused-expression745    expect(result.success).to.be.true;746    // tslint:disable-next-line: no-unused-expression747    expect(whiteListedBefore).to.be.false;748    // tslint:disable-next-line: no-unused-expression749    expect(whiteListedAfter).to.be.true;750  });751}752753export async function removeFromWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {754  await usingApi(async (api) => {755    // Run the transaction756    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);757    const events = await submitTransactionAsync(sender, tx);758    const result = getGenericResult(events);759760    // What to expect761    // tslint:disable-next-line:no-unused-expression762    expect(result.success).to.be.true;763  });764}765766export async function removeFromWhiteListExpectFailure(sender: IKeyringPair, collectionId: number, address: string) {767  await usingApi(async (api) => {768    // Run the transaction769    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);770    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;771    const result = getGenericResult(events);772773    // What to expect774    // tslint:disable-next-line:no-unused-expression775    expect(result.success).to.be.false;776  });777}778779export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)780  : Promise<ICollectionInterface | null> => {781  return await api.query.nft.collection(collectionId) as unknown as ICollectionInterface;782};783784export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {785  // set global object - collectionsCount786  return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();787};