git.delta.rocks / unique-network / refs/commits / 1fff4fcd4a6c

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  recipient: string;40}4142interface TransferResult {43  success: boolean;44  collectionId: number;45  itemId: number;46  sender: string;47  recipient: string;48  value: bigint;49}5051interface IReFungibleOwner {52  Fraction: BN;53  Owner: number[];54}5556interface ITokenDataType {57  Owner: number[];58  ConstData: number[];59  VariableData: number[];60}6162interface IFungibleTokenDataType {63  Value: BN;64}6566export interface IReFungibleTokenDataType {67  Owner: IReFungibleOwner[];68  ConstData: number[];69  VariableData: number[];70}7172export function getGenericResult(events: EventRecord[]): GenericResult {73  const result: GenericResult = {74    success: false,75  };76  events.forEach(({ phase, event: { data, method, section } }) => {77    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);78    if (method === 'ExtrinsicSuccess') {79      result.success = true;80    }81  });82  return result;83}8485export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {86  let success = false;87  let collectionId: number = 0;88  events.forEach(({ phase, event: { data, method, section } }) => {89    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);90    if (method == 'ExtrinsicSuccess') {91      success = true;92    } else if ((section == 'nft') && (method == 'Created')) {93      collectionId = parseInt(data[0].toString());94    }95  });96  const result: CreateCollectionResult = {97    success,98    collectionId,99  };100  return result;101}102103export function getCreateItemResult(events: EventRecord[]): CreateItemResult {104  let success = false;105  let collectionId: number = 0;106  let itemId: number = 0;107  let recipient: string = '';108  events.forEach(({ phase, event: { data, method, section } }) => {109    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);110    if (method == 'ExtrinsicSuccess') {111      success = true;112    } else if ((section == 'nft') && (method == 'ItemCreated')) {113      collectionId = parseInt(data[0].toString());114      itemId = parseInt(data[1].toString());115      recipient = data[2].toString();116    }117  });118  const result: CreateItemResult = {119    success,120    collectionId,121    itemId,122    recipient,123  };124  return result;125}126127export function getTransferResult(events: EventRecord[]): TransferResult {128  const result: TransferResult = {129    success: false,130    collectionId: 0,131    itemId: 0,132    sender: '',133    recipient: '',134    value: 0n,135  };136137  events.forEach(({event: {data, method, section}}) => {138    if (method === 'ExtrinsicSuccess') {139      result.success = true;140    } else if (section === 'nft' && method === 'Transfer') {141      result.collectionId = +data[0].toString();142      result.itemId = +data[1].toString();143      result.sender = data[2].toString();144      result.recipient = data[3].toString();145      result.value = BigInt(data[4].toString());146    }147  });148149  return result;150}151152interface Invalid {153  type: 'Invalid';154}155156interface Nft {157  type: 'NFT';158}159160interface Fungible {161  type: 'Fungible';162  decimalPoints: number;163}164165interface ReFungible {166  type: 'ReFungible';167}168169type CollectionMode = Nft | Fungible | ReFungible | Invalid;170171export type CreateCollectionParams = {172  mode: CollectionMode,173  name: string,174  description: string,175  tokenPrefix: string,176};177178const defaultCreateCollectionParams: CreateCollectionParams = {179  description: 'description',180  mode: { type: 'NFT' },181  name: 'name',182  tokenPrefix: 'prefix',183}184185export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {186  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};187188  let collectionId: number = 0;189  await usingApi(async (api) => {190    // Get number of collections before the transaction191    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);192193    // Run the CreateCollection transaction194    const alicePrivateKey = privateKey('//Alice');195196    let modeprm = {};197    if (mode.type === 'NFT') {198      modeprm = {nft: null};199    } else if (mode.type === 'Fungible') {200      modeprm = {fungible: mode.decimalPoints};201    } else if (mode.type === 'ReFungible') {202      modeprm = {refungible: null};203    } else if (mode.type === 'Invalid') {204      modeprm = {invalid: null};205    }206207    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);208    const events = await submitTransactionAsync(alicePrivateKey, tx);209    const result = getCreateCollectionResult(events);210211    // Get number of collections after the transaction212    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);213214    // Get the collection215    const collection: any = (await api.query.nft.collection(result.collectionId)).toJSON();216217    // What to expect218    // tslint:disable-next-line:no-unused-expression219    expect(result.success).to.be.true;220    expect(result.collectionId).to.be.equal(BcollectionCount);221    // tslint:disable-next-line:no-unused-expression222    expect(collection).to.be.not.null;223    expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');224    expect(collection.Owner).to.be.equal(alicesPublicKey);225    expect(utf16ToStr(collection.Name)).to.be.equal(name);226    expect(utf16ToStr(collection.Description)).to.be.equal(description);227    expect(hexToStr(collection.TokenPrefix)).to.be.equal(tokenPrefix);228229    collectionId = result.collectionId;230  });231232  return collectionId;233}234235export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {236  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};237238  let modeprm = {};239  if (mode.type === 'NFT') {240    modeprm = {nft: null};241  } else if (mode.type === 'Fungible') {242    modeprm = {fungible: mode.decimalPoints};243  } else if (mode.type === 'ReFungible') {244    modeprm = {refungible: null};245  } else if (mode.type === 'Invalid') {246    modeprm = {invalid: null};247  }248249  await usingApi(async (api) => {250    // Get number of collections before the transaction251    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());252253    // Run the CreateCollection transaction254    const alicePrivateKey = privateKey('//Alice');255    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);256    const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;257    const result = getCreateCollectionResult(events);258259    // Get number of collections after the transaction260    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());261262    // What to expect263    // tslint:disable-next-line:no-unused-expression264    expect(result.success).to.be.false;265    expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');266  });267}268269export async function findUnusedAddress(api: ApiPromise, seedAddition = ''): Promise<IKeyringPair> {270  let bal = new BigNumber(0);271  let unused;272  do {273    const randomSeed = 'seed' +  Math.floor(Math.random() * Math.floor(10000)) + seedAddition;274    const keyring = new Keyring({ type: 'sr25519' });275    unused = keyring.addFromUri(`//${randomSeed}`);276    bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());277  } while (bal.toFixed() != '0');278  return unused;279}280281export async function getAllowance(collectionId: number, tokenId: number, owner: string, approved: string) {282  return await usingApi(async (api) => {283    const bn = await api.query.nft.allowances(collectionId, [tokenId, owner, approved]) as unknown as BN;284    return BigInt(bn.toString());285  });286}287288export function findUnusedAddresses(api: ApiPromise, amount: number): Promise<IKeyringPair[]> {289  return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, '_' + Date.now())));290}291292export async function findNotExistingCollection(api: ApiPromise): Promise<number> {293  const totalNumber = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10) as unknown as number;294  const newCollection: number = totalNumber + 1;295  return newCollection;296}297298function getDestroyResult(events: EventRecord[]): boolean {299  let success: boolean = false;300  events.forEach(({ phase, event: { data, method, section } }) => {301    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);302    if (method == 'ExtrinsicSuccess') {303      success = true;304    }305  });306  return success;307}308309export async function destroyCollectionExpectFailure(collectionId: number, senderSeed: string = '//Alice') {310  await usingApi(async (api) => {311    // Run the DestroyCollection transaction312    const alicePrivateKey = privateKey(senderSeed);313    const tx = api.tx.nft.destroyCollection(collectionId);314    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;315  });316}317318export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {319  await usingApi(async (api) => {320    // Run the DestroyCollection transaction321    const alicePrivateKey = privateKey(senderSeed);322    const tx = api.tx.nft.destroyCollection(collectionId);323    const events = await submitTransactionAsync(alicePrivateKey, tx);324    const result = getDestroyResult(events);325326    // Get the collection327    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();328329    // What to expect330    expect(result).to.be.true;331    expect(collection).to.be.not.null;332    expect(collection.Owner).to.be.equal(nullPublicKey);333  });334}335336export async function queryCollectionLimits(collectionId: number) {337  return await usingApi(async (api) => {338    return ((await api.query.nft.collection(collectionId)).toJSON() as any).Limits;339  });340}341342export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {343  await usingApi(async (api) => {344    const oldLimits = await queryCollectionLimits(collectionId);345    const newLimits = { ...oldLimits as any, ...limits };346    const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);347    const events = await submitTransactionAsync(sender, tx);348    const result = getGenericResult(events);349350    expect(result.success).to.be.true;351  });352}353354export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {355  await usingApi(async (api) => {356    const oldLimits = await queryCollectionLimits(collectionId);357    const newLimits = { ...oldLimits as any, ...limits };358    const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);359    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;360    const result = getGenericResult(events);361362    expect(result.success).to.be.false;363  });364}365366export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string) {367  await usingApi(async (api) => {368369    // Run the transaction370    const alicePrivateKey = privateKey('//Alice');371    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);372    const events = await submitTransactionAsync(alicePrivateKey, tx);373    const result = getGenericResult(events);374375    // Get the collection376    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();377378    // What to expect379    expect(result.success).to.be.true;380    expect(collection.Sponsorship).to.deep.equal({381      Unconfirmed: sponsor.toString(),382    });383  });384}385386export async function removeCollectionSponsorExpectSuccess(collectionId: number) {387  await usingApi(async (api) => {388389    // Run the transaction390    const alicePrivateKey = privateKey('//Alice');391    const tx = api.tx.nft.removeCollectionSponsor(collectionId);392    const events = await submitTransactionAsync(alicePrivateKey, tx);393    const result = getGenericResult(events);394395    // Get the collection396    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();397398    // What to expect399    expect(result.success).to.be.true;400    expect(collection.Sponsorship).to.be.deep.equal({ Disabled: null });401  });402}403404export async function removeCollectionSponsorExpectFailure(collectionId: number) {405  await usingApi(async (api) => {406407    // Run the transaction408    const alicePrivateKey = privateKey('//Alice');409    const tx = api.tx.nft.removeCollectionSponsor(collectionId);410    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;411  });412}413414export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed: string = '//Alice') {415  await usingApi(async (api) => {416417    // Run the transaction418    const alicePrivateKey = privateKey(senderSeed);419    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);420    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;421  });422}423424export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {425  await usingApi(async (api) => {426427    // Run the transaction428    const sender = privateKey(senderSeed);429    const tx = api.tx.nft.confirmSponsorship(collectionId);430    const events = await submitTransactionAsync(sender, tx);431    const result = getGenericResult(events);432433    // Get the collection434    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();435436    // What to expect437    expect(result.success).to.be.true;438    expect(collection.Sponsorship).to.be.deep.equal({439      Confirmed: sender.address,440    });441  });442}443444445export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed: string = '//Alice') {446  await usingApi(async (api) => {447448    // Run the transaction449    const sender = privateKey(senderSeed);450    const tx = api.tx.nft.confirmSponsorship(collectionId);451    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;452  });453}454455export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {456  await usingApi(async (api) => {457    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);458    const events = await submitTransactionAsync(sender, tx);459    const result = getGenericResult(events);460461    expect(result.success).to.be.true;462  });463}464465export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {466  await usingApi(async (api) => {467    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);468    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;469    const result = getGenericResult(events);470471    expect(result.success).to.be.false;472  });473}474475export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {476  await usingApi(async (api) => {477    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);478    const events = await submitTransactionAsync(sender, tx);479    const result = getGenericResult(events);480481    expect(result.success).to.be.true;482  });483}484485export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {486  await usingApi(async (api) => {487    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);488    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;489    const result = getGenericResult(events);490491    expect(result.success).to.be.false;492  });493}494495export async function toggleContractWhitelistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enabled: boolean) {496  await usingApi(async (api) => {497    const tx = api.tx.nft.toggleContractWhiteList(contractAddress, true);498    const events = await submitTransactionAsync(sender, tx);499    const result = getGenericResult(events);500501    expect(result.success).to.be.true;502  });503}504505export async function isWhitelistedInContract(contractAddress: AccountId | string, user: string) {506  let whitelisted: boolean = false;507  await usingApi(async (api) => {508    whitelisted = (await api.query.nft.contractWhiteList(contractAddress, user)).toJSON() as boolean;509  });510  return whitelisted;511}512513export async function addToContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {514  await usingApi(async (api) => {515    const tx = api.tx.nft.addToContractWhiteList(contractAddress, user);516    const events = await submitTransactionAsync(sender, tx);517    const result = getGenericResult(events);518519    expect(result.success).to.be.true;520  });521}522523export async function removeFromContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {524  await usingApi(async (api) => {525    const tx = api.tx.nft.removeFromContractWhiteList(contractAddress, user);526    const events = await submitTransactionAsync(sender, tx);527    const result = getGenericResult(events);528529    expect(result.success).to.be.true;530  });531}532533export async function removeFromContractWhiteListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {534  await usingApi(async (api) => {535    const tx = api.tx.nft.removeFromContractWhiteList(contractAddress, user);536    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;537    const result = getGenericResult(events);538539    expect(result.success).to.be.false;540  });541}542543export async function setVariableMetaDataExpectSuccess(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {544  await usingApi(async (api) => {545    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));546    const events = await submitTransactionAsync(sender, tx);547    const result = getGenericResult(events);548549    expect(result.success).to.be.true;550  });551}552553export async function setVariableMetaDataExpectFailure(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {554  await usingApi(async (api) => {555    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));556    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;557  });558}559560export async function setOffchainSchemaExpectSuccess(sender: IKeyringPair, collectionId: number, data: number[]) {561  await usingApi(async (api) => {562    const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));563    const events = await submitTransactionAsync(sender, tx);564    const result = getGenericResult(events);565566    expect(result.success).to.be.true;567  });568}569570export async function setOffchainSchemaExpectFailure(sender: IKeyringPair, collectionId: number, data: number[]) {571  await usingApi(async (api) => {572    const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));573    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;574  });575}576577export interface CreateFungibleData {578  readonly Value: bigint;579}580581export interface CreateReFungibleData { }582export interface CreateNftData { }583584export type CreateItemData = {585  NFT: CreateNftData;586} | {587  Fungible: CreateFungibleData;588} | {589  ReFungible: CreateReFungibleData;590};591592export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {593  await usingApi(async (api) => {594    const tx = api.tx.nft.burnItem(collectionId, tokenId, value);595    const events = await submitTransactionAsync(owner, tx);596    const result = getGenericResult(events);597    // Get the item598    const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();599    // What to expect600    // tslint:disable-next-line:no-unused-expression601    expect(result.success).to.be.true;602    // tslint:disable-next-line:no-unused-expression603    expect(item).to.be.not.null;604    expect(item.Owner).to.be.equal(nullPublicKey);605  });606}607608export async function609approveExpectSuccess(collectionId: number,610                     tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1) {611  await usingApi(async (api: ApiPromise) => {612    const allowanceBefore =613      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;614    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);615    const events = await submitTransactionAsync(owner, approveNftTx);616    const result = getCreateItemResult(events);617    // tslint:disable-next-line:no-unused-expression618    expect(result.success).to.be.true;619    const allowanceAfter =620      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;621    expect(allowanceAfter.sub(allowanceBefore).toString()).to.be.equal(amount.toString());622  });623}624625export async function626transferFromExpectSuccess(collectionId: number,627                          tokenId: number,628                          accountApproved: IKeyringPair,629                          accountFrom: IKeyringPair,630                          accountTo: IKeyringPair,631                          value: number | bigint = 1,632                          type: string = 'NFT') {633  await usingApi(async (api: ApiPromise) => {634    let balanceBefore = new BN(0);635    if (type === 'Fungible') {636      balanceBefore = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;637    }638    const transferFromTx = await api.tx.nft.transferFrom(639      accountFrom.address, accountTo.address, collectionId, tokenId, value);640    const events = await submitTransactionAsync(accountApproved, transferFromTx);641    const result = getCreateItemResult(events);642    // tslint:disable-next-line:no-unused-expression643    expect(result.success).to.be.true;644    if (type === 'NFT') {645      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;646      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);647    }648    if (type === 'Fungible') {649      const balanceAfter = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;650      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());651    }652    if (type === 'ReFungible') {653      const nftItemData =654        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;655      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);656      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);657    }658  });659}660661export async function662transferFromExpectFail(collectionId: number,663                       tokenId: number,664                       accountApproved: IKeyringPair,665                       accountFrom: IKeyringPair,666                       accountTo: IKeyringPair,667                       value: number | bigint = 1) {668  await usingApi(async (api: ApiPromise) => {669    const transferFromTx = await api.tx.nft.transferFrom(670      accountFrom.address, accountTo.address, collectionId, tokenId, value);671    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;672    const result = getCreateCollectionResult(events);673    // tslint:disable-next-line:no-unused-expression674    expect(result.success).to.be.false;675  });676}677678export async function679transferExpectSuccess(collectionId: number,680                      tokenId: number,681                      sender: IKeyringPair,682                      recipient: IKeyringPair,683                      value: number | bigint = 1,684                      type: string = 'NFT') {685  await usingApi(async (api: ApiPromise) => {686    let balanceBefore = new BN(0);687    if (type === 'Fungible') {688      balanceBefore = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;689    }690    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);691    const events = await submitTransactionAsync(sender, transferTx);692    const result = getTransferResult(events);693    // tslint:disable-next-line:no-unused-expression694    expect(result.success).to.be.true;695    expect(result.collectionId).to.be.equal(collectionId);696    expect(result.itemId).to.be.equal(tokenId);697    expect(result.sender).to.be.equal(sender.address);698    expect(result.recipient).to.be.equal(recipient.address);699    expect(result.value.toString()).to.be.equal(value.toString());700    if (type === 'NFT') {701      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;702      expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);703    }704    if (type === 'Fungible') {705      const balanceAfter = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;706      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());707    }708    if (type === 'ReFungible') {709      const nftItemData =710        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;711      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);712      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);713    }714  });715}716717export async function718transferExpectFail(collectionId: number,719                   tokenId: number,720                   sender: IKeyringPair,721                   recipient: IKeyringPair,722                   value: number | bigint = 1,723                   type: string = 'NFT') {724  await usingApi(async (api: ApiPromise) => {725    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);726    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;727    if (events && Array.isArray(events)) {728      const result = getCreateCollectionResult(events);729      // tslint:disable-next-line:no-unused-expression730      expect(result.success).to.be.false;731    }732  });733}734735export async function736approveExpectFail(collectionId: number,737                  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1) {738  await usingApi(async (api: ApiPromise) => {739    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);740    const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;741    const result = getCreateCollectionResult(events);742    // tslint:disable-next-line:no-unused-expression743    expect(result.success).to.be.false;744  });745}746747export async function getFungibleBalance(748  collectionId: number,749  owner: string,750) {751  return await usingApi(async (api) => {752    const response = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON() as unknown as {Value: string};753    return BigInt(response.Value);754  });755}756757export async function createFungibleItemExpectSuccess(758  sender: IKeyringPair,759  collectionId: number,760  data: CreateFungibleData,761  owner: string = sender.address,762) {763  return await usingApi(async (api) => {764    const tx = api.tx.nft.createItem(collectionId, owner, { Fungible: data });765766    const events = await submitTransactionAsync(sender, tx);767    const result = getCreateItemResult(events);768769    expect(result.success).to.be.true;770    return result.itemId;771  });772}773774export async function createItemExpectSuccess(775  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = '') {776  let newItemId: number = 0;777  await usingApi(async (api) => {778    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);779    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();780    const AItemBalance = new BigNumber(Aitem.Value);781782    if (owner === '') {783      owner = sender.address;784    }785786    let tx;787    if (createMode === 'Fungible') {788      const createData = {fungible: {value: 10}};789      tx = api.tx.nft.createItem(collectionId, owner, createData);790    } else if (createMode === 'ReFungible') {791      const createData = {refungible: {const_data: [], variable_data: [], pieces: 100}};792      tx = api.tx.nft.createItem(collectionId, owner, createData);793    } else {794      tx = api.tx.nft.createItem(collectionId, owner, createMode);795    }796    const events = await submitTransactionAsync(sender, tx);797    const result = getCreateItemResult(events);798799    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);800    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();801    const BItemBalance = new BigNumber(Bitem.Value);802803    // What to expect804    // tslint:disable-next-line:no-unused-expression805    expect(result.success).to.be.true;806    if (createMode === 'Fungible') {807      expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);808    } else {809      expect(BItemCount).to.be.equal(AItemCount + 1);810    }811    expect(collectionId).to.be.equal(result.collectionId);812    expect(BItemCount).to.be.equal(result.itemId);813    expect(owner).to.be.equal(result.recipient);814    newItemId = result.itemId;815  });816  return newItemId;817}818819export async function createItemExpectFailure(820  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = sender.address) {821  await usingApi(async (api) => {822    const tx = api.tx.nft.createItem(collectionId, owner, createMode);823    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;824    const result = getCreateItemResult(events);825826    expect(result.success).to.be.false;827  });828}829830export async function setPublicAccessModeExpectSuccess(831  sender: IKeyringPair, collectionId: number,832  accessMode: 'Normal' | 'WhiteList',833) {834  await usingApi(async (api) => {835836    // Run the transaction837    const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);838    const events = await submitTransactionAsync(sender, tx);839    const result = getGenericResult(events);840841    // Get the collection842    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();843844    // What to expect845    // tslint:disable-next-line:no-unused-expression846    expect(result.success).to.be.true;847    expect(collection.Access).to.be.equal(accessMode);848  });849}850851export async function enableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {852  await setPublicAccessModeExpectSuccess(sender, collectionId, 'WhiteList');853}854855export async function disableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {856  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');857}858859export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {860  await usingApi(async (api) => {861862    // Run the transaction863    const tx = api.tx.nft.setMintPermission(collectionId, enabled);864    const events = await submitTransactionAsync(sender, tx);865    const result = getGenericResult(events);866867    // Get the collection868    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();869870    // What to expect871    // tslint:disable-next-line:no-unused-expression872    expect(result.success).to.be.true;873    expect(collection.MintMode).to.be.equal(enabled);874  });875}876877export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {878  await setMintPermissionExpectSuccess(sender, collectionId, true);879}880881export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {882  await usingApi(async (api) => {883    // Run the transaction884    const tx = api.tx.nft.setMintPermission(collectionId, enabled);885    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;886    const result = getCreateCollectionResult(events);887    // tslint:disable-next-line:no-unused-expression888    expect(result.success).to.be.false;889  });890}891892export async function isWhitelisted(collectionId: number, address: string) {893  let whitelisted: boolean = false;894  await usingApi(async (api) => {895    whitelisted = (await api.query.nft.whiteList(collectionId, address)).toJSON() as unknown as boolean;896  });897  return whitelisted;898}899900export async function addToWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {901  await usingApi(async (api) => {902903    const whiteListedBefore = (await api.query.nft.whiteList(collectionId, address)).toJSON();904905    // Run the transaction906    const tx = api.tx.nft.addToWhiteList(collectionId, address);907    const events = await submitTransactionAsync(sender, tx);908    const result = getGenericResult(events);909910    const whiteListedAfter = (await api.query.nft.whiteList(collectionId, address)).toJSON();911912    // What to expect913    // tslint:disable-next-line:no-unused-expression914    expect(result.success).to.be.true;915    // tslint:disable-next-line: no-unused-expression916    expect(whiteListedBefore).to.be.false;917    // tslint:disable-next-line: no-unused-expression918    expect(whiteListedAfter).to.be.true;919  });920}921922export async function removeFromWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {923  await usingApi(async (api) => {924    // Run the transaction925    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);926    const events = await submitTransactionAsync(sender, tx);927    const result = getGenericResult(events);928929    // What to expect930    // tslint:disable-next-line:no-unused-expression931    expect(result.success).to.be.true;932  });933}934935export async function removeFromWhiteListExpectFailure(sender: IKeyringPair, collectionId: number, address: string) {936  await usingApi(async (api) => {937    // Run the transaction938    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);939    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;940    const result = getGenericResult(events);941942    // What to expect943    // tslint:disable-next-line:no-unused-expression944    expect(result.success).to.be.false;945  });946}947948export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)949  : Promise<ICollectionInterface | null> => {950  return await api.query.nft.collection(collectionId) as unknown as ICollectionInterface;951};952953export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {954  // set global object - collectionsCount955  return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();956};957958export async function queryCollectionExpectSuccess(collectionId: number): Promise<ICollectionInterface> {959  return await usingApi(async (api) => {960    return (await api.query.nft.collection(collectionId)) as unknown as ICollectionInterface;961  });962}