`72c7cbd1ea21`

source

tests/src/util/helpers.ts39.3 KiBsource history
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 type { AccountId, EventRecord } from '@polkadot/types/interfaces';8import { IKeyringPair } from '@polkadot/types/types';9import { evmToAddress } from '@polkadot/util-crypto';10import { BigNumber } from 'bignumber.js';11import BN from 'bn.js';12import chai from 'chai';13import chaiAsPromised from 'chai-as-promised';14import { alicesPublicKey } from '../accounts';15import privateKey from '../substrate/privateKey';16import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';17import { ICollectionInterface } from '../types';18import { hexToStr, strToUTF16, utf16ToStr } from './util';1920chai.use(chaiAsPromised);21const expect = chai.expect;2223export type CrossAccountId = {24  substrate: string,25} | {26  ethereum: string,27};28export function normalizeAccountId(input: string | AccountId | CrossAccountId | IKeyringPair): CrossAccountId {29  if (typeof input === 'string')30    return { substrate: input };31  if ('address' in input) {32    return { substrate: input.address };33  }34  if ('ethereum' in input) {35    input.ethereum = input.ethereum.toLowerCase();36    return input;37  }38  if ('substrate' in input) {39    return input;40  }4142  // AccountId43  return {substrate: input.toString()};44}45export function toSubstrateAddress(input: string | CrossAccountId | IKeyringPair): string {46  input = normalizeAccountId(input);47  if ('substrate' in input) {48    return input.substrate;49  } else {50    return evmToAddress(input.ethereum);51  }52}5354export const U128_MAX = (1n << 128n) - 1n;5556type GenericResult = {57  success: boolean,58};5960interface CreateCollectionResult {61  success: boolean;62  collectionId: number;63}6465interface CreateItemResult {66  success: boolean;67  collectionId: number;68  itemId: number;69  recipient?: CrossAccountId;70}7172interface TransferResult {73  success: boolean;74  collectionId: number;75  itemId: number;76  sender?: CrossAccountId;77  recipient?: CrossAccountId;78  value: bigint;79}8081interface IReFungibleOwner {82  Fraction: BN;83  Owner: number[];84}8586interface ITokenDataType {87  Owner: IKeyringPair;88  ConstData: number[];89  VariableData: number[];90}9192interface IGetMessage {93  checkMsgNftMethod: string;94  checkMsgTrsMethod: string;95  checkMsgSysMethod: string;96}9798export interface IReFungibleTokenDataType {99  Owner: IReFungibleOwner[];100  ConstData: number[];101  VariableData: number[];102}103104export function nftEventMessage(events: EventRecord[]): IGetMessage {105  let checkMsgNftMethod = '';106  let checkMsgTrsMethod = '';107  let checkMsgSysMethod = '';108  events.forEach(({ event: { method, section } }) => {109    if (section === 'nft') {110      checkMsgNftMethod = method;111    } else if (section === 'treasury') {112      checkMsgTrsMethod = method;113    } else if (section === 'system') {114      checkMsgSysMethod = method;115    } else { return null; }116  });117  const result: IGetMessage = {118    checkMsgNftMethod,119    checkMsgTrsMethod,120    checkMsgSysMethod,121  };122  return result;123}124125export function getGenericResult(events: EventRecord[]): GenericResult {126  const result: GenericResult = {127    success: false,128  };129  events.forEach(({ event: { method } }) => {130    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);131    if (method === 'ExtrinsicSuccess') {132      result.success = true;133    }134  });135  return result;136}137138139140export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {141  let success = false;142  let collectionId = 0;143  events.forEach(({ event: { data, method, section } }) => {144    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);145    if (method == 'ExtrinsicSuccess') {146      success = true;147    } else if ((section == 'nft') && (method == 'CollectionCreated')) {148      collectionId = parseInt(data[0].toString());149    }150  });151  const result: CreateCollectionResult = {152    success,153    collectionId,154  };155  return result;156}157158export function getCreateItemResult(events: EventRecord[]): CreateItemResult {159  let success = false;160  let collectionId = 0;161  let itemId = 0;162  let recipient;163  events.forEach(({ event: { data, method, section } }) => {164    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);165    if (method == 'ExtrinsicSuccess') {166      success = true;167    } else if ((section == 'nft') && (method == 'ItemCreated')) {168      collectionId = parseInt(data[0].toString());169      itemId = parseInt(data[1].toString());170      recipient = data[2].toJSON();171    }172  });173  const result: CreateItemResult = {174    success,175    collectionId,176    itemId,177    recipient,178  };179  return result;180}181182export function getTransferResult(events: EventRecord[]): TransferResult {183  const result: TransferResult = {184    success: false,185    collectionId: 0,186    itemId: 0,187    value: 0n,188  };189190  events.forEach(({ event: { data, method, section } }) => {191    if (method === 'ExtrinsicSuccess') {192      result.success = true;193    } else if (section === 'nft' && method === 'Transfer') {194      result.collectionId = +data[0].toString();195      result.itemId = +data[1].toString();196      result.sender = data[2].toJSON() as CrossAccountId;197      result.recipient = data[3].toJSON() as CrossAccountId;198      result.value = BigInt(data[4].toString());199    }200  });201202  return result;203}204205interface Invalid {206  type: 'Invalid';207}208209interface Nft {210  type: 'NFT';211}212213interface Fungible {214  type: 'Fungible';215  decimalPoints: number;216}217218interface ReFungible {219  type: 'ReFungible';220}221222type CollectionMode = Nft | Fungible | ReFungible | Invalid;223224export type CreateCollectionParams = {225  mode: CollectionMode,226  name: string,227  description: string,228  tokenPrefix: string,229};230231const defaultCreateCollectionParams: CreateCollectionParams = {232  description: 'description',233  mode: { type: 'NFT' },234  name: 'name',235  tokenPrefix: 'prefix',236};237238export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {239  const { name, description, mode, tokenPrefix } = { ...defaultCreateCollectionParams, ...params };240241  let collectionId = 0;242  await usingApi(async (api) => {243    // Get number of collections before the transaction244    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);245246    // Run the CreateCollection transaction247    const alicePrivateKey = privateKey('//Alice');248249    let modeprm = {};250    if (mode.type === 'NFT') {251      modeprm = { nft: null };252    } else if (mode.type === 'Fungible') {253      modeprm = { fungible: mode.decimalPoints };254    } else if (mode.type === 'ReFungible') {255      modeprm = { refungible: null };256    } else if (mode.type === 'Invalid') {257      modeprm = { invalid: null };258    }259260    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);261    const events = await submitTransactionAsync(alicePrivateKey, tx);262    const result = getCreateCollectionResult(events);263264    // Get number of collections after the transaction265    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);266267    // Get the collection268    const collection: any = (await api.query.nft.collectionById(result.collectionId) as any).toJSON();269270    // What to expect271    // tslint:disable-next-line:no-unused-expression272    expect(result.success).to.be.true;273    expect(result.collectionId).to.be.equal(BcollectionCount);274    // tslint:disable-next-line:no-unused-expression275    expect(collection).to.be.not.null;276    expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');277    expect(collection.Owner).to.be.equal(toSubstrateAddress(alicesPublicKey));278    expect(utf16ToStr(collection.Name)).to.be.equal(name);279    expect(utf16ToStr(collection.Description)).to.be.equal(description);280    expect(hexToStr(collection.TokenPrefix)).to.be.equal(tokenPrefix);281282    collectionId = result.collectionId;283  });284285  return collectionId;286}287288export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {289  const { name, description, mode, tokenPrefix } = { ...defaultCreateCollectionParams, ...params };290291  let modeprm = {};292  if (mode.type === 'NFT') {293    modeprm = { nft: null };294  } else if (mode.type === 'Fungible') {295    modeprm = { fungible: mode.decimalPoints };296  } else if (mode.type === 'ReFungible') {297    modeprm = { refungible: null };298  } else if (mode.type === 'Invalid') {299    modeprm = { invalid: null };300  }301302  await usingApi(async (api) => {303    // Get number of collections before the transaction304    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());305306    // Run the CreateCollection transaction307    const alicePrivateKey = privateKey('//Alice');308    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);309    const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;310    const result = getCreateCollectionResult(events);311312    // Get number of collections after the transaction313    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());314315    // What to expect316    // tslint:disable-next-line:no-unused-expression317    expect(result.success).to.be.false;318    expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');319  });320}321322export async function findUnusedAddress(api: ApiPromise, seedAddition = ''): Promise<IKeyringPair> {323  let bal = new BigNumber(0);324  let unused;325  do {326    const randomSeed = 'seed' + Math.floor(Math.random() * Math.floor(10000)) + seedAddition;327    const keyring = new Keyring({ type: 'sr25519' });328    unused = keyring.addFromUri(`//${randomSeed}`);329    bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());330  } while (bal.toFixed() != '0');331  return unused;332}333334export async function getAllowance(collectionId: number, tokenId: number, owner: string, approved: string) {335  return await usingApi(async (api) => {336    const bn = await api.query.nft.allowances(collectionId, [tokenId, owner, approved]) as unknown as BN;337    return BigInt(bn.toString());338  });339}340341export function findUnusedAddresses(api: ApiPromise, amount: number): Promise<IKeyringPair[]> {342  return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, '_' + Date.now())));343}344345export async function findNotExistingCollection(api: ApiPromise): Promise<number> {346  const totalNumber = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10) as unknown as number;347  const newCollection: number = totalNumber + 1;348  return newCollection;349}350351function getDestroyResult(events: EventRecord[]): boolean {352  let success = false;353  events.forEach(({ event: { method } }) => {354    if (method == 'ExtrinsicSuccess') {355      success = true;356    }357  });358  return success;359}360361export async function destroyCollectionExpectFailure(collectionId: number, senderSeed = '//Alice') {362  await usingApi(async (api) => {363    // Run the DestroyCollection transaction364    const alicePrivateKey = privateKey(senderSeed);365    const tx = api.tx.nft.destroyCollection(collectionId);366    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;367  });368}369370export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed = '//Alice') {371  await usingApi(async (api) => {372    // Run the DestroyCollection transaction373    const alicePrivateKey = privateKey(senderSeed);374    const tx = api.tx.nft.destroyCollection(collectionId);375    const events = await submitTransactionAsync(alicePrivateKey, tx);376    const result = getDestroyResult(events);377378    // Get the collection379    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();380381    // What to expect382    expect(result).to.be.true;383    expect(collection).to.be.null;384  });385}386387export async function queryCollectionLimits(collectionId: number) {388  return await usingApi(async (api) => {389    return ((await api.query.nft.collectionById(collectionId)).toJSON() as any).Limits;390  });391}392393export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {394  await usingApi(async (api) => {395    const oldLimits = await queryCollectionLimits(collectionId);396    const newLimits = { ...oldLimits as any, ...limits };397    const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);398    const events = await submitTransactionAsync(sender, tx);399    const result = getGenericResult(events);400401    expect(result.success).to.be.true;402  });403}404405export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {406  await usingApi(async (api) => {407    const oldLimits = await queryCollectionLimits(collectionId);408    const newLimits = { ...oldLimits as any, ...limits };409    const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);410    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;411    const result = getGenericResult(events);412413    expect(result.success).to.be.false;414  });415}416417export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string) {418  await usingApi(async (api) => {419420    // Run the transaction421    const alicePrivateKey = privateKey('//Alice');422    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);423    const events = await submitTransactionAsync(alicePrivateKey, tx);424    const result = getGenericResult(events);425426    // Get the collection427    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();428429    // What to expect430    expect(result.success).to.be.true;431    expect(collection.Sponsorship).to.deep.equal({432      unconfirmed: sponsor,433    });434  });435}436437export async function removeCollectionSponsorExpectSuccess(collectionId: number) {438  await usingApi(async (api) => {439440    // Run the transaction441    const alicePrivateKey = privateKey('//Alice');442    const tx = api.tx.nft.removeCollectionSponsor(collectionId);443    const events = await submitTransactionAsync(alicePrivateKey, tx);444    const result = getGenericResult(events);445446    // Get the collection447    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();448449    // What to expect450    expect(result.success).to.be.true;451    expect(collection.Sponsorship).to.be.deep.equal({ disabled: null });452  });453}454455export async function removeCollectionSponsorExpectFailure(collectionId: number) {456  await usingApi(async (api) => {457458    // Run the transaction459    const alicePrivateKey = privateKey('//Alice');460    const tx = api.tx.nft.removeCollectionSponsor(collectionId);461    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;462  });463}464465export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed = '//Alice') {466  await usingApi(async (api) => {467468    // Run the transaction469    const alicePrivateKey = privateKey(senderSeed);470    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);471    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;472  });473}474475export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed = '//Alice') {476  await usingApi(async (api) => {477478    // Run the transaction479    const sender = privateKey(senderSeed);480    const tx = api.tx.nft.confirmSponsorship(collectionId);481    const events = await submitTransactionAsync(sender, tx);482    const result = getGenericResult(events);483484    // Get the collection485    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();486487    // What to expect488    expect(result.success).to.be.true;489    expect(collection.Sponsorship).to.be.deep.equal({490      confirmed: sender.address,491    });492  });493}494495496export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed = '//Alice') {497  await usingApi(async (api) => {498499    // Run the transaction500    const sender = privateKey(senderSeed);501    const tx = api.tx.nft.confirmSponsorship(collectionId);502    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;503  });504}505506export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {507  await usingApi(async (api) => {508    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);509    const events = await submitTransactionAsync(sender, tx);510    const result = getGenericResult(events);511512    expect(result.success).to.be.true;513  });514}515516export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {517  await usingApi(async (api) => {518    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);519    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;520    const result = getGenericResult(events);521522    expect(result.success).to.be.false;523  });524}525526export async function setTransferFlagExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {527528  await usingApi(async (api) => {529530    const tx = api.tx.nft.setTransfersEnabledFlag (collectionId, enabled);531    const events = await submitTransactionAsync(sender, tx);532    const result = getGenericResult(events);533534    expect(result.success).to.be.true;535  }); 536}537538export async function setTransferFlagExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {539540  await usingApi(async (api) => {541542    const tx = api.tx.nft.setTransfersEnabledFlag (collectionId, enabled);543    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;544    const result = getGenericResult(events);545546    expect(result.success).to.be.false;547  }); 548}549550export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {551  await usingApi(async (api) => {552    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);553    const events = await submitTransactionAsync(sender, tx);554    const result = getGenericResult(events);555556    expect(result.success).to.be.true;557  });558}559560export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {561  await usingApi(async (api) => {562    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);563    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;564    const result = getGenericResult(events);565566    expect(result.success).to.be.false;567  });568}569570export async function toggleContractWhitelistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, value = true) {571  await usingApi(async (api) => {572    const tx = api.tx.nft.toggleContractWhiteList(contractAddress, value);573    const events = await submitTransactionAsync(sender, tx);574    const result = getGenericResult(events);575576    expect(result.success).to.be.true;577  });578}579580export async function isWhitelistedInContract(contractAddress: AccountId | string, user: string) {581  let whitelisted = false;582  await usingApi(async (api) => {583    whitelisted = (await api.query.nft.contractWhiteList(contractAddress, user)).toJSON() as boolean;584  });585  return whitelisted;586}587588export async function addToContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {589  await usingApi(async (api) => {590    const tx = api.tx.nft.addToContractWhiteList(contractAddress.toString(), user.toString());591    const events = await submitTransactionAsync(sender, tx);592    const result = getGenericResult(events);593594    expect(result.success).to.be.true;595  });596}597598export async function removeFromContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {599  await usingApi(async (api) => {600    const tx = api.tx.nft.removeFromContractWhiteList(contractAddress.toString(), user.toString());601    const events = await submitTransactionAsync(sender, tx);602    const result = getGenericResult(events);603604    expect(result.success).to.be.true;605  });606}607608export async function removeFromContractWhiteListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {609  await usingApi(async (api) => {610    const tx = api.tx.nft.removeFromContractWhiteList(contractAddress.toString(), user.toString());611    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;612    const result = getGenericResult(events);613614    expect(result.success).to.be.false;615  });616}617618export async function setVariableMetaDataExpectSuccess(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {619  await usingApi(async (api) => {620    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));621    const events = await submitTransactionAsync(sender, tx);622    const result = getGenericResult(events);623624    expect(result.success).to.be.true;625  });626}627628export async function setVariableMetaDataExpectFailure(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {629  await usingApi(async (api) => {630    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));631    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;632  });633}634635export async function setOffchainSchemaExpectSuccess(sender: IKeyringPair, collectionId: number, data: number[]) {636  await usingApi(async (api) => {637    const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));638    const events = await submitTransactionAsync(sender, tx);639    const result = getGenericResult(events);640641    expect(result.success).to.be.true;642  });643}644645export async function setOffchainSchemaExpectFailure(sender: IKeyringPair, collectionId: number, data: number[]) {646  await usingApi(async (api) => {647    const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));648    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;649  });650}651652export interface CreateFungibleData {653  readonly Value: bigint;654}655656export interface CreateReFungibleData { }657export interface CreateNftData { }658659export type CreateItemData = {660  NFT: CreateNftData;661} | {662  Fungible: CreateFungibleData;663} | {664  ReFungible: CreateReFungibleData;665};666667export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {668  await usingApi(async (api) => {669    const tx = api.tx.nft.burnItem(collectionId, tokenId, value);670    const events = await submitTransactionAsync(owner, tx);671    const result = getGenericResult(events);672    // Get the item673    const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();674    // What to expect675    // tslint:disable-next-line:no-unused-expression676    expect(result.success).to.be.true;677    // tslint:disable-next-line:no-unused-expression678    expect(item).to.be.null;679  });680}681682export async function683approveExpectSuccess(684  collectionId: number,685  tokenId: number, owner: IKeyringPair, approved: IKeyringPair | CrossAccountId | string, amount: number | bigint = 1,686) {687  await usingApi(async (api: ApiPromise) => {688    approved = normalizeAccountId(approved);689    const allowanceBefore =690      await api.query.nft.allowances(collectionId, [tokenId, owner.address, toSubstrateAddress(approved)]) as unknown as BN;691    const approveNftTx = api.tx.nft.approve(approved, collectionId, tokenId, amount);692    const events = await submitTransactionAsync(owner, approveNftTx);693    const result = getCreateItemResult(events);694    // tslint:disable-next-line:no-unused-expression695    expect(result.success).to.be.true;696    const allowanceAfter =697      await api.query.nft.allowances(collectionId, [tokenId, owner.address, toSubstrateAddress(approved)]) as unknown as BN;698    expect(allowanceAfter.sub(allowanceBefore).toString()).to.be.equal(amount.toString());699  });700}701702export async function703transferFromExpectSuccess(704  collectionId: number,705  tokenId: number,706  accountApproved: IKeyringPair,707  accountFrom: IKeyringPair | CrossAccountId,708  accountTo: IKeyringPair | CrossAccountId,709  value: number | bigint = 1,710  type = 'NFT',711) {712  await usingApi(async (api: ApiPromise) => {713    const to = normalizeAccountId(accountTo);714    let balanceBefore = new BN(0);715    if (type === 'Fungible') {716      balanceBefore = await api.query.nft.balance(collectionId, toSubstrateAddress(to)) as unknown as BN;717    }718    const transferFromTx = api.tx.nft.transferFrom(normalizeAccountId(accountFrom), to, collectionId, tokenId, value);719    const events = await submitTransactionAsync(accountApproved, transferFromTx);720    const result = getCreateItemResult(events);721    // tslint:disable-next-line:no-unused-expression722    expect(result.success).to.be.true;723    if (type === 'NFT') {724      const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId) as any).toJSON() as ITokenDataType;725      expect(nftItemData.Owner).to.be.deep.equal(to);726    }727    if (type === 'Fungible') {728      const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to)) as any).Value as unknown as BN;729      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());730    }731    if (type === 'ReFungible') {732      const nftItemData =733        (await api.query.nft.reFungibleItemList(collectionId, tokenId) as any).toJSON() as IReFungibleTokenDataType;734      expect(nftItemData.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(to));735      expect(nftItemData.Owner[0].Fraction).to.be.equal(value);736    }737  });738}739740export async function741transferFromExpectFail(742  collectionId: number,743  tokenId: number,744  accountApproved: IKeyringPair,745  accountFrom: IKeyringPair,746  accountTo: IKeyringPair,747  value: number | bigint = 1,748) {749  await usingApi(async (api: ApiPromise) => {750    const transferFromTx = api.tx.nft.transferFrom(normalizeAccountId(accountFrom.address), normalizeAccountId(accountTo.address), collectionId, tokenId, value);751    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;752    const result = getCreateCollectionResult(events);753    // tslint:disable-next-line:no-unused-expression754    expect(result.success).to.be.false;755  });756}757758/* eslint no-async-promise-executor: "off" */759async function getBlockNumber(api: ApiPromise): Promise<number> {760  return new Promise<number>(async (resolve) => {761    const unsubscribe = await api.rpc.chain.subscribeNewHeads((head) => {762      unsubscribe();763      resolve(head.number.toNumber());764    });765  });766}767768export async function769scheduleTransferExpectSuccess(770  collectionId: number,771  tokenId: number,772  sender: IKeyringPair,773  recipient: IKeyringPair,774  value: number | bigint = 1,775  blockTimeMs: number,776  blockSchedule: number,777) {778  await usingApi(async (api: ApiPromise) => {779    const blockNumber: number | undefined = await getBlockNumber(api);780    const expectedBlockNumber = blockNumber + blockSchedule;781782    expect(blockNumber).to.be.greaterThan(0);783    const transferTx = await api.tx.nft.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value); 784    const scheduleTx = await api.tx.scheduler.schedule(expectedBlockNumber, null, 0, transferTx);785786    await submitTransactionAsync(sender, scheduleTx);787788    const recipientBalanceBefore = new BigNumber((await api.query.system.account(recipient.address)).data.free.toString());789790    const nftItemDataBefore = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as any as ITokenDataType;791    expect(toSubstrateAddress(nftItemDataBefore.Owner)).to.be.equal(sender.address);792793    // sleep for 4 blocks794    await new Promise(resolve => setTimeout(resolve, blockTimeMs * (blockSchedule + 1)));795796    const recipientBalanceAfter = new BigNumber((await api.query.system.account(recipient.address)).data.free.toString());797798    const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;799    expect(toSubstrateAddress(nftItemData.Owner)).to.be.equal(recipient.address);800    expect(recipientBalanceAfter.toNumber()).to.be.equal(recipientBalanceBefore.toNumber());801  });802}803804805export async function806transferExpectSuccess(807  collectionId: number,808  tokenId: number,809  sender: IKeyringPair,810  recipient: IKeyringPair | CrossAccountId,811  value: number | bigint = 1,812  type = 'NFT',813) {814  await usingApi(async (api: ApiPromise) => {815    const to = normalizeAccountId(recipient);816817    let balanceBefore = new BN(0);818    if (type === 'Fungible') {819      balanceBefore = await api.query.nft.balance(collectionId, toSubstrateAddress(to)) as unknown as BN;820    }821    const transferTx = api.tx.nft.transfer(to, collectionId, tokenId, value);822    const events = await submitTransactionAsync(sender, transferTx);823    const result = getTransferResult(events);824    // tslint:disable-next-line:no-unused-expression825    expect(result.success).to.be.true;826    expect(result.collectionId).to.be.equal(collectionId);827    expect(result.itemId).to.be.equal(tokenId);828    expect(result.sender).to.be.deep.equal(normalizeAccountId(sender.address));829    expect(result.recipient).to.be.deep.equal(to);830    expect(result.value.toString()).to.be.equal(value.toString());831    if (type === 'NFT') {832      const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;833      expect(nftItemData.Owner).to.be.deep.equal(to);834    }835    if (type === 'Fungible') {836      const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to)) as any).Value as unknown as BN;837      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());838    }839    if (type === 'ReFungible') {840      const nftItemData =841        (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON() as unknown as IReFungibleTokenDataType;842      expect(nftItemData.Owner[0].Owner).to.be.deep.equal(to);843      expect(nftItemData.Owner[0].Fraction.toString()).to.be.equal(value.toString());844    }845  });846}847848export async function849transferExpectFailure(850  collectionId: number,851  tokenId: number,852  sender: IKeyringPair,853  recipient: IKeyringPair,854  value: number | bigint = 1,855) {856  await usingApi(async (api: ApiPromise) => {857    const transferTx = api.tx.nft.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value);858    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;859    if (events && Array.isArray(events)) {860      const result = getCreateCollectionResult(events);861      // tslint:disable-next-line:no-unused-expression862      expect(result.success).to.be.false;863    }864  });865}866867export async function868approveExpectFail(869  collectionId: number,870  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1,871) {872  await usingApi(async (api: ApiPromise) => {873    const approveNftTx = api.tx.nft.approve(normalizeAccountId(approved.address), collectionId, tokenId, amount);874    const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;875    const result = getCreateCollectionResult(events);876    // tslint:disable-next-line:no-unused-expression877    expect(result.success).to.be.false;878  });879}880881export async function getFungibleBalance(882  collectionId: number,883  owner: string,884) {885  return await usingApi(async (api) => {886    const response = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON() as unknown as { Value: string };887    return BigInt(response.Value);888  });889}890891export async function createFungibleItemExpectSuccess(892  sender: IKeyringPair,893  collectionId: number,894  data: CreateFungibleData,895  owner: CrossAccountId | string = sender.address,896) {897  return await usingApi(async (api) => {898    const tx = api.tx.nft.createItem(collectionId, normalizeAccountId(owner), { Fungible: data });899900    const events = await submitTransactionAsync(sender, tx);901    const result = getCreateItemResult(events);902903    expect(result.success).to.be.true;904    return result.itemId;905  });906}907908export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {909  let newItemId = 0;910  await usingApi(async (api) => {911    const to = normalizeAccountId(owner);912    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);913    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to))).toJSON();914    const AItemBalance = new BigNumber(Aitem.Value);915916    let tx;917    if (createMode === 'Fungible') {918      const createData = { fungible: { value: 10 } };919      tx = api.tx.nft.createItem(collectionId, to, createData);920    } else if (createMode === 'ReFungible') {921      const createData = { refungible: { const_data: [], variable_data: [], pieces: 100 } };922      tx = api.tx.nft.createItem(collectionId, to, createData);923    } else {924      const createData = { nft: { const_data: [], variable_data: [] } };925      tx = api.tx.nft.createItem(collectionId, to, createData);926    }927928    const events = await submitTransactionAsync(sender, tx);929    const result = getCreateItemResult(events);930931    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);932    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to))).toJSON();933    const BItemBalance = new BigNumber(Bitem.Value);934935    // What to expect936    // tslint:disable-next-line:no-unused-expression937    expect(result.success).to.be.true;938    if (createMode === 'Fungible') {939      expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);940    } else {941      expect(BItemCount).to.be.equal(AItemCount + 1);942    }943    expect(collectionId).to.be.equal(result.collectionId);944    expect(BItemCount.toString()).to.be.equal(result.itemId.toString());945    expect(to).to.be.deep.equal(result.recipient);946    newItemId = result.itemId;947  });948  return newItemId;949}950951export async function createItemExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, owner: string = sender.address) {952  await usingApi(async (api) => {953    const tx = api.tx.nft.createItem(collectionId, normalizeAccountId(owner), createMode);954    955    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;956    const result = getCreateItemResult(events);957958    expect(result.success).to.be.false;959  });960}961962export async function setPublicAccessModeExpectSuccess(963  sender: IKeyringPair, collectionId: number,964  accessMode: 'Normal' | 'WhiteList',965) {966  await usingApi(async (api) => {967968    // Run the transaction969    const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);970    const events = await submitTransactionAsync(sender, tx);971    const result = getGenericResult(events);972973    // Get the collection974    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();975976    // What to expect977    // tslint:disable-next-line:no-unused-expression978    expect(result.success).to.be.true;979    expect(collection.Access).to.be.equal(accessMode);980  });981}982983export async function enableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {984  await setPublicAccessModeExpectSuccess(sender, collectionId, 'WhiteList');985}986987export async function disableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {988  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');989}990991export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {992  await usingApi(async (api) => {993994    // Run the transaction995    const tx = api.tx.nft.setMintPermission(collectionId, enabled);996    const events = await submitTransactionAsync(sender, tx);997    const result = getGenericResult(events);998999    // Get the collection1000    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();10011002    // What to expect1003    // tslint:disable-next-line:no-unused-expression1004    expect(result.success).to.be.true;1005    expect(collection.MintMode).to.be.equal(enabled);1006  });1007}10081009export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {1010  await setMintPermissionExpectSuccess(sender, collectionId, true);1011}10121013export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {1014  await usingApi(async (api) => {1015    // Run the transaction1016    const tx = api.tx.nft.setMintPermission(collectionId, enabled);1017    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1018    const result = getCreateCollectionResult(events);1019    // tslint:disable-next-line:no-unused-expression1020    expect(result.success).to.be.false;1021  });1022}10231024export async function isWhitelisted(collectionId: number, address: string) {1025  let whitelisted = false;1026  await usingApi(async (api) => {1027    whitelisted = (await api.query.nft.whiteList(collectionId, address)).toJSON() as unknown as boolean;1028  });1029  return whitelisted;1030}10311032export async function addToWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1033  await usingApi(async (api) => {10341035    const whiteListedBefore = (await api.query.nft.whiteList(collectionId, address)).toJSON();10361037    // Run the transaction1038    const tx = api.tx.nft.addToWhiteList(collectionId, normalizeAccountId(address));1039    const events = await submitTransactionAsync(sender, tx);1040    const result = getGenericResult(events);10411042    const whiteListedAfter = (await api.query.nft.whiteList(collectionId, address)).toJSON();10431044    // What to expect1045    // tslint:disable-next-line:no-unused-expression1046    expect(result.success).to.be.true;1047    // tslint:disable-next-line: no-unused-expression1048    expect(whiteListedBefore).to.be.false;1049    // tslint:disable-next-line: no-unused-expression1050    expect(whiteListedAfter).to.be.true;1051  });1052}10531054export async function removeFromWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1055  await usingApi(async (api) => {1056    // Run the transaction1057    const tx = api.tx.nft.removeFromWhiteList(collectionId, normalizeAccountId(address));1058    const events = await submitTransactionAsync(sender, tx);1059    const result = getGenericResult(events);10601061    // What to expect1062    // tslint:disable-next-line:no-unused-expression1063    expect(result.success).to.be.true;1064  });1065}10661067export async function removeFromWhiteListExpectFailure(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1068  await usingApi(async (api) => {1069    // Run the transaction1070    const tx = api.tx.nft.removeFromWhiteList(collectionId, normalizeAccountId(address));1071    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1072    const result = getGenericResult(events);10731074    // What to expect1075    // tslint:disable-next-line:no-unused-expression1076    expect(result.success).to.be.false;1077  });1078}10791080export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)1081  : Promise<ICollectionInterface | null> => {1082  return (await api.query.nft.collectionById(collectionId)).toJSON() as unknown as ICollectionInterface;1083};10841085export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {1086  // set global object - collectionsCount1087  return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();1088};10891090export async function queryCollectionExpectSuccess(collectionId: number): Promise<ICollectionInterface> {1091  return await usingApi(async (api) => {1092    return (await api.query.nft.collectionById(collectionId)).toJSON() as unknown as ICollectionInterface;1093  });1094}