git.delta.rocks / unique-network / refs/commits / 2a441390261c

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}6566interface IGetMessage {67  checkMsgNftMethod: string;68  checkMsgTrsMethod: string;69  checkMsgSysMethod: string;70}7172export interface IReFungibleTokenDataType {73  Owner: IReFungibleOwner[];74  ConstData: number[];75  VariableData: number[];76}7778export function nftEventMessage(events: EventRecord[]): IGetMessage {79  let checkMsgNftMethod: string = '';80  let checkMsgTrsMethod: string = '';81  let checkMsgSysMethod: string = '';82  events.forEach(({ event: { method, section } }) => {83    if (section === 'nft') {84      checkMsgNftMethod = method;85    } else if (section === 'treasury') {86      checkMsgTrsMethod = method;87    } else if (section === 'system') {88      checkMsgSysMethod = method;89    } else { return null; }90  });91  const result: IGetMessage = {92    checkMsgNftMethod,93    checkMsgTrsMethod,94    checkMsgSysMethod,95  };96  return result;97}9899export function getGenericResult(events: EventRecord[]): GenericResult {100  const result: GenericResult = {101    success: false,102  };103  events.forEach(({ phase, event: { data, method, section } }) => {104    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);105    if (method === 'ExtrinsicSuccess') {106      result.success = true;107    }108  });109  return result;110}111112113114export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {115  let success = false;116  let collectionId: number = 0;117  events.forEach(({ phase, event: { data, method, section } }) => {118    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);119    if (method == 'ExtrinsicSuccess') {120      success = true;121    } else if ((section == 'nft')  && (method == 'CollectionCreated')) {122      collectionId = parseInt(data[0].toString());123    }124  });125  const result: CreateCollectionResult = {126    success,127    collectionId,128  };129  return result;130}131132export function getCreateItemResult(events: EventRecord[]): CreateItemResult {133  let success = false;134  let collectionId: number = 0;135  let itemId: number = 0;136  let recipient: string = '';137  events.forEach(({ phase, event: { data, method, section } }) => {138    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);139    if (method == 'ExtrinsicSuccess') {140      success = true;141    } else if ((section == 'nft') && (method == 'ItemCreated')) {142      collectionId = parseInt(data[0].toString());143      itemId = parseInt(data[1].toString());144      recipient = data[2].toString();145    }146  });147  const result: CreateItemResult = {148    success,149    collectionId,150    itemId,151    recipient,152  };153  return result;154}155156export function getTransferResult(events: EventRecord[]): TransferResult {157  const result: TransferResult = {158    success: false,159    collectionId: 0,160    itemId: 0,161    sender: '',162    recipient: '',163    value: 0n,164  };165166  events.forEach(({event: {data, method, section}}) => {167    if (method === 'ExtrinsicSuccess') {168      result.success = true;169    } else if (section === 'nft' && method === 'Transfer') {170      result.collectionId = +data[0].toString();171      result.itemId = +data[1].toString();172      result.sender = data[2].toString();173      result.recipient = data[3].toString();174      result.value = BigInt(data[4].toString());175    }176  });177178  return result;179}180181interface Invalid {182  type: 'Invalid';183}184185interface Nft {186  type: 'NFT';187}188189interface Fungible {190  type: 'Fungible';191  decimalPoints: number;192}193194interface ReFungible {195  type: 'ReFungible';196}197198type CollectionMode = Nft | Fungible | ReFungible | Invalid;199200export type CreateCollectionParams = {201  mode: CollectionMode,202  name: string,203  description: string,204  tokenPrefix: string,205};206207const defaultCreateCollectionParams: CreateCollectionParams = {208  description: 'description',209  mode: { type: 'NFT' },210  name: 'name',211  tokenPrefix: 'prefix',212}213214export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {215  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};216217  let collectionId: number = 0;218  await usingApi(async (api) => {219    // Get number of collections before the transaction220    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);221222    // Run the CreateCollection transaction223    const alicePrivateKey = privateKey('//Alice');224225    let modeprm = {};226    if (mode.type === 'NFT') {227      modeprm = {nft: null};228    } else if (mode.type === 'Fungible') {229      modeprm = {fungible: mode.decimalPoints};230    } else if (mode.type === 'ReFungible') {231      modeprm = {refungible: null};232    } else if (mode.type === 'Invalid') {233      modeprm = {invalid: null};234    }235236    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);237    const events = await submitTransactionAsync(alicePrivateKey, tx);238    const result = getCreateCollectionResult(events);239240    // Get number of collections after the transaction241    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);242243    // Get the collection244    const collection: any = (await api.query.nft.collectionById(result.collectionId)).toJSON();245246    // What to expect247    // tslint:disable-next-line:no-unused-expression248    expect(result.success).to.be.true;249    expect(result.collectionId).to.be.equal(BcollectionCount);250    // tslint:disable-next-line:no-unused-expression251    expect(collection).to.be.not.null;252    expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');253    expect(collection.Owner).to.be.equal(alicesPublicKey);254    expect(utf16ToStr(collection.Name)).to.be.equal(name);255    expect(utf16ToStr(collection.Description)).to.be.equal(description);256    expect(hexToStr(collection.TokenPrefix)).to.be.equal(tokenPrefix);257258    collectionId = result.collectionId;259  });260261  return collectionId;262}263264export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {265  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};266267  let modeprm = {};268  if (mode.type === 'NFT') {269    modeprm = {nft: null};270  } else if (mode.type === 'Fungible') {271    modeprm = {fungible: mode.decimalPoints};272  } else if (mode.type === 'ReFungible') {273    modeprm = {refungible: null};274  } else if (mode.type === 'Invalid') {275    modeprm = {invalid: null};276  }277278  await usingApi(async (api) => {279    // Get number of collections before the transaction280    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());281282    // Run the CreateCollection transaction283    const alicePrivateKey = privateKey('//Alice');284    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);285    const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;286    const result = getCreateCollectionResult(events);287288    // Get number of collections after the transaction289    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());290291    // What to expect292    // tslint:disable-next-line:no-unused-expression293    expect(result.success).to.be.false;294    expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');295  });296}297298export async function findUnusedAddress(api: ApiPromise, seedAddition = ''): Promise<IKeyringPair> {299  let bal = new BigNumber(0);300  let unused;301  do {302    const randomSeed = 'seed' +  Math.floor(Math.random() * Math.floor(10000)) + seedAddition;303    const keyring = new Keyring({ type: 'sr25519' });304    unused = keyring.addFromUri(`//${randomSeed}`);305    bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());306  } while (bal.toFixed() != '0');307  return unused;308}309310export async function getAllowance(collectionId: number, tokenId: number, owner: string, approved: string) {311  return await usingApi(async (api) => {312    const bn = await api.query.nft.allowances(collectionId, [tokenId, owner, approved]) as unknown as BN;313    return BigInt(bn.toString());314  });315}316317export function findUnusedAddresses(api: ApiPromise, amount: number): Promise<IKeyringPair[]> {318  return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, '_' + Date.now())));319}320321export async function findNotExistingCollection(api: ApiPromise): Promise<number> {322  const totalNumber = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10) as unknown as number;323  const newCollection: number = totalNumber + 1;324  return newCollection;325}326327function getDestroyResult(events: EventRecord[]): boolean {328  let success: boolean = false;329  events.forEach(({ phase, event: { data, method, section } }) => {330    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);331    if (method == 'ExtrinsicSuccess') {332      success = true;333    }334  });335  return success;336}337338export async function destroyCollectionExpectFailure(collectionId: number, senderSeed: string = '//Alice') {339  await usingApi(async (api) => {340    // Run the DestroyCollection transaction341    const alicePrivateKey = privateKey(senderSeed);342    const tx = api.tx.nft.destroyCollection(collectionId);343    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;344  });345}346347export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {348  await usingApi(async (api) => {349    // Run the DestroyCollection transaction350    const alicePrivateKey = privateKey(senderSeed);351    const tx = api.tx.nft.destroyCollection(collectionId);352    const events = await submitTransactionAsync(alicePrivateKey, tx);353    const result = getDestroyResult(events);354355    // Get the collection356    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();357358    // What to expect359    expect(result).to.be.true;360    expect(collection).to.be.null;361  });362}363364export async function queryCollectionLimits(collectionId: number) {365  return await usingApi(async (api) => {366    return ((await api.query.nft.collectionById(collectionId)).toJSON() as any).Limits;367  });368}369370export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {371  await usingApi(async (api) => {372    const oldLimits = await queryCollectionLimits(collectionId);373    const newLimits = { ...oldLimits as any, ...limits };374    const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);375    const events = await submitTransactionAsync(sender, tx);376    const result = getGenericResult(events);377378    expect(result.success).to.be.true;379  });380}381382export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {383  await usingApi(async (api) => {384    const oldLimits = await queryCollectionLimits(collectionId);385    const newLimits = { ...oldLimits as any, ...limits };386    const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);387    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;388    const result = getGenericResult(events);389390    expect(result.success).to.be.false;391  });392}393394export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string) {395  await usingApi(async (api) => {396397    // Run the transaction398    const alicePrivateKey = privateKey('//Alice');399    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);400    const events = await submitTransactionAsync(alicePrivateKey, tx);401    const result = getGenericResult(events);402403    // Get the collection404    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();405406    // What to expect407    expect(result.success).to.be.true;408    expect(collection.Sponsorship).to.deep.equal({409      Unconfirmed: sponsor.toString(),410    });411  });412}413414export async function removeCollectionSponsorExpectSuccess(collectionId: number) {415  await usingApi(async (api) => {416417    // Run the transaction418    const alicePrivateKey = privateKey('//Alice');419    const tx = api.tx.nft.removeCollectionSponsor(collectionId);420    const events = await submitTransactionAsync(alicePrivateKey, tx);421    const result = getGenericResult(events);422423    // Get the collection424    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();425426    // What to expect427    expect(result.success).to.be.true;428    expect(collection.Sponsorship).to.be.deep.equal({ Disabled: null });429  });430}431432export async function removeCollectionSponsorExpectFailure(collectionId: number) {433  await usingApi(async (api) => {434435    // Run the transaction436    const alicePrivateKey = privateKey('//Alice');437    const tx = api.tx.nft.removeCollectionSponsor(collectionId);438    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;439  });440}441442export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed: string = '//Alice') {443  await usingApi(async (api) => {444445    // Run the transaction446    const alicePrivateKey = privateKey(senderSeed);447    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);448    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;449  });450}451452export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {453  await usingApi(async (api) => {454455    // Run the transaction456    const sender = privateKey(senderSeed);457    const tx = api.tx.nft.confirmSponsorship(collectionId);458    const events = await submitTransactionAsync(sender, tx);459    const result = getGenericResult(events);460461    // Get the collection462    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();463464    // What to expect465    expect(result.success).to.be.true;466    expect(collection.Sponsorship).to.be.deep.equal({467      Confirmed: sender.address,468    });469  });470}471472473export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed: string = '//Alice') {474  await usingApi(async (api) => {475476    // Run the transaction477    const sender = privateKey(senderSeed);478    const tx = api.tx.nft.confirmSponsorship(collectionId);479    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;480  });481}482483export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {484  await usingApi(async (api) => {485    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);486    const events = await submitTransactionAsync(sender, tx);487    const result = getGenericResult(events);488489    expect(result.success).to.be.true;490  });491}492493export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {494  await usingApi(async (api) => {495    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);496    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;497    const result = getGenericResult(events);498499    expect(result.success).to.be.false;500  });501}502503export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {504  await usingApi(async (api) => {505    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);506    const events = await submitTransactionAsync(sender, tx);507    const result = getGenericResult(events);508509    expect(result.success).to.be.true;510  });511}512513export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {514  await usingApi(async (api) => {515    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);516    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;517    const result = getGenericResult(events);518519    expect(result.success).to.be.false;520  });521}522523export async function toggleContractWhitelistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enabled: boolean) {524  await usingApi(async (api) => {525    const tx = api.tx.nft.toggleContractWhiteList(contractAddress, true);526    const events = await submitTransactionAsync(sender, tx);527    const result = getGenericResult(events);528529    expect(result.success).to.be.true;530  });531}532533export async function isWhitelistedInContract(contractAddress: AccountId | string, user: string) {534  let whitelisted: boolean = false;535  await usingApi(async (api) => {536    whitelisted = (await api.query.nft.contractWhiteList(contractAddress, user)).toJSON() as boolean;537  });538  return whitelisted;539}540541export async function addToContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {542  await usingApi(async (api) => {543    const tx = api.tx.nft.addToContractWhiteList(contractAddress, user);544    const events = await submitTransactionAsync(sender, tx);545    const result = getGenericResult(events);546547    expect(result.success).to.be.true;548  });549}550551export async function removeFromContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {552  await usingApi(async (api) => {553    const tx = api.tx.nft.removeFromContractWhiteList(contractAddress, user);554    const events = await submitTransactionAsync(sender, tx);555    const result = getGenericResult(events);556557    expect(result.success).to.be.true;558  });559}560561export async function removeFromContractWhiteListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {562  await usingApi(async (api) => {563    const tx = api.tx.nft.removeFromContractWhiteList(contractAddress, user);564    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;565    const result = getGenericResult(events);566567    expect(result.success).to.be.false;568  });569}570571export async function setVariableMetaDataExpectSuccess(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {572  await usingApi(async (api) => {573    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));574    const events = await submitTransactionAsync(sender, tx);575    const result = getGenericResult(events);576577    expect(result.success).to.be.true;578  });579}580581export async function setVariableMetaDataExpectFailure(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {582  await usingApi(async (api) => {583    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));584    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;585  });586}587588export async function setOffchainSchemaExpectSuccess(sender: IKeyringPair, collectionId: number, data: number[]) {589  await usingApi(async (api) => {590    const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));591    const events = await submitTransactionAsync(sender, tx);592    const result = getGenericResult(events);593594    expect(result.success).to.be.true;595  });596}597598export async function setOffchainSchemaExpectFailure(sender: IKeyringPair, collectionId: number, data: number[]) {599  await usingApi(async (api) => {600    const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));601    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;602  });603}604605export interface CreateFungibleData {606  readonly Value: bigint;607}608609export interface CreateReFungibleData { }610export interface CreateNftData { }611612export type CreateItemData = {613  NFT: CreateNftData;614} | {615  Fungible: CreateFungibleData;616} | {617  ReFungible: CreateReFungibleData;618};619620export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {621  await usingApi(async (api) => {622    const tx = api.tx.nft.burnItem(collectionId, tokenId, value);623    const events = await submitTransactionAsync(owner, tx);624    const result = getGenericResult(events);625    // Get the item626    const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();627    // What to expect628    // tslint:disable-next-line:no-unused-expression629    expect(result.success).to.be.true;630    // tslint:disable-next-line:no-unused-expression631    expect(item).to.be.null;632  });633}634635export async function636approveExpectSuccess(collectionId: number,637                     tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1) {638  await usingApi(async (api: ApiPromise) => {639    const allowanceBefore =640      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;641    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);642    const events = await submitTransactionAsync(owner, approveNftTx);643    const result = getCreateItemResult(events);644    // tslint:disable-next-line:no-unused-expression645    expect(result.success).to.be.true;646    const allowanceAfter =647      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;648    expect(allowanceAfter.sub(allowanceBefore).toString()).to.be.equal(amount.toString());649  });650}651652export async function653transferFromExpectSuccess(collectionId: number,654                          tokenId: number,655                          accountApproved: IKeyringPair,656                          accountFrom: IKeyringPair,657                          accountTo: IKeyringPair,658                          value: number | bigint = 1,659                          type: string = 'NFT') {660  await usingApi(async (api: ApiPromise) => {661    let balanceBefore = new BN(0);662    if (type === 'Fungible') {663      balanceBefore = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;664    }665    const transferFromTx = await api.tx.nft.transferFrom(666      accountFrom.address, accountTo.address, collectionId, tokenId, value);667    const events = await submitTransactionAsync(accountApproved, transferFromTx);668    const result = getCreateItemResult(events);669    // tslint:disable-next-line:no-unused-expression670    expect(result.success).to.be.true;671    if (type === 'NFT') {672      const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap() as ITokenDataType;673      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);674    }675    if (type === 'Fungible') {676      const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, accountTo.address) as any).Value as unknown as BN;677      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());678    }679    if (type === 'ReFungible') {680      const nftItemData =681        (await api.query.nft.reFungibleItemList(collectionId, tokenId) as any).unwrap() as IReFungibleTokenDataType;682      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);683      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);684    }685  });686}687688export async function689transferFromExpectFail(collectionId: number,690                       tokenId: number,691                       accountApproved: IKeyringPair,692                       accountFrom: IKeyringPair,693                       accountTo: IKeyringPair,694                       value: number | bigint = 1) {695  await usingApi(async (api: ApiPromise) => {696    const transferFromTx = await api.tx.nft.transferFrom(697      accountFrom.address, accountTo.address, collectionId, tokenId, value);698    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;699    const result = getCreateCollectionResult(events);700    // tslint:disable-next-line:no-unused-expression701    expect(result.success).to.be.false;702  });703}704705export async function706transferExpectSuccess(collectionId: number,707                      tokenId: number,708                      sender: IKeyringPair,709                      recipient: IKeyringPair,710                      value: number | bigint = 1,711                      type: string = 'NFT') {712  await usingApi(async (api: ApiPromise) => {713    let balanceBefore = new BN(0);714    if (type === 'Fungible') {715      balanceBefore = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;716    }717    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);718    const events = await submitTransactionAsync(sender, transferTx);719    const result = getTransferResult(events);720    // tslint:disable-next-line:no-unused-expression721    expect(result.success).to.be.true;722    expect(result.collectionId).to.be.equal(collectionId);723    expect(result.itemId).to.be.equal(tokenId);724    expect(result.sender).to.be.equal(sender.address);725    expect(result.recipient).to.be.equal(recipient.address);726    expect(result.value.toString()).to.be.equal(value.toString());727    if (type === 'NFT') {728      const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;729      expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);730    }731    if (type === 'Fungible') {732      const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, recipient.address) as any).Value as unknown as BN;733      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());734    }735    if (type === 'ReFungible') {736      const nftItemData =737        (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON() as unknown as IReFungibleTokenDataType;738      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);739      expect(nftItemData.Owner[0].Fraction.toString()).to.be.equal(value.toString());740    }741  });742}743744export async function745transferExpectFail(collectionId: number,746                   tokenId: number,747                   sender: IKeyringPair,748                   recipient: IKeyringPair,749                   value: number | bigint = 1,750                   type: string = 'NFT') {751  await usingApi(async (api: ApiPromise) => {752    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);753    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;754    if (events && Array.isArray(events)) {755      const result = getCreateCollectionResult(events);756      // tslint:disable-next-line:no-unused-expression757      expect(result.success).to.be.false;758    }759  });760}761762export async function763approveExpectFail(collectionId: number,764                  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1) {765  await usingApi(async (api: ApiPromise) => {766    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);767    const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;768    const result = getCreateCollectionResult(events);769    // tslint:disable-next-line:no-unused-expression770    expect(result.success).to.be.false;771  });772}773774export async function getFungibleBalance(775  collectionId: number,776  owner: string,777) {778  return await usingApi(async (api) => {779    const response = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON() as unknown as {Value: string};780    return BigInt(response.Value);781  });782}783784export async function createFungibleItemExpectSuccess(785  sender: IKeyringPair,786  collectionId: number,787  data: CreateFungibleData,788  owner: string = sender.address,789) {790  return await usingApi(async (api) => {791    const tx = api.tx.nft.createItem(collectionId, owner, { Fungible: data });792793    const events = await submitTransactionAsync(sender, tx);794    const result = getCreateItemResult(events);795796    expect(result.success).to.be.true;797    return result.itemId;798  });799}800801export async function createItemExpectSuccess(802  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = '') {803  let newItemId: number = 0;804  await usingApi(async (api) => {805    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);806    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();807    const AItemBalance = new BigNumber(Aitem.Value);808809    if (owner === '') {810      owner = sender.address;811    }812813    let tx;814    if (createMode === 'Fungible') {815      const createData = {fungible: {value: 10}};816      tx = api.tx.nft.createItem(collectionId, owner, createData);817    } else if (createMode === 'ReFungible') {818      const createData = {refungible: {const_data: [], variable_data: [], pieces: 100}};819      tx = api.tx.nft.createItem(collectionId, owner, createData);820    } else {821      tx = api.tx.nft.createItem(collectionId, owner, createMode);822    }823    const events = await submitTransactionAsync(sender, tx);824    const result = getCreateItemResult(events);825826    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);827    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();828    const BItemBalance = new BigNumber(Bitem.Value);829830    // What to expect831    // tslint:disable-next-line:no-unused-expression832    expect(result.success).to.be.true;833    if (createMode === 'Fungible') {834      expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);835    } else {836      expect(BItemCount).to.be.equal(AItemCount + 1);837    }838    expect(collectionId).to.be.equal(result.collectionId);839    expect(BItemCount).to.be.equal(result.itemId);840    expect(owner).to.be.equal(result.recipient);841    newItemId = result.itemId;842  });843  return newItemId;844}845846export async function createItemExpectFailure(847  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = sender.address) {848  await usingApi(async (api) => {849    const tx = api.tx.nft.createItem(collectionId, owner, createMode);850    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;851    const result = getCreateItemResult(events);852853    expect(result.success).to.be.false;854  });855}856857export async function setPublicAccessModeExpectSuccess(858  sender: IKeyringPair, collectionId: number,859  accessMode: 'Normal' | 'WhiteList',860) {861  await usingApi(async (api) => {862863    // Run the transaction864    const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);865    const events = await submitTransactionAsync(sender, tx);866    const result = getGenericResult(events);867868    // Get the collection869    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();870871    // What to expect872    // tslint:disable-next-line:no-unused-expression873    expect(result.success).to.be.true;874    expect(collection.Access).to.be.equal(accessMode);875  });876}877878export async function enableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {879  await setPublicAccessModeExpectSuccess(sender, collectionId, 'WhiteList');880}881882export async function disableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {883  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');884}885886export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {887  await usingApi(async (api) => {888889    // Run the transaction890    const tx = api.tx.nft.setMintPermission(collectionId, enabled);891    const events = await submitTransactionAsync(sender, tx);892    const result = getGenericResult(events);893894    // Get the collection895    const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();896897    // What to expect898    // tslint:disable-next-line:no-unused-expression899    expect(result.success).to.be.true;900    expect(collection.MintMode).to.be.equal(enabled);901  });902}903904export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {905  await setMintPermissionExpectSuccess(sender, collectionId, true);906}907908export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {909  await usingApi(async (api) => {910    // Run the transaction911    const tx = api.tx.nft.setMintPermission(collectionId, enabled);912    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;913    const result = getCreateCollectionResult(events);914    // tslint:disable-next-line:no-unused-expression915    expect(result.success).to.be.false;916  });917}918919export async function isWhitelisted(collectionId: number, address: string) {920  let whitelisted: boolean = false;921  await usingApi(async (api) => {922    whitelisted = (await api.query.nft.whiteList(collectionId, address)).toJSON() as unknown as boolean;923  });924  return whitelisted;925}926927export async function addToWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {928  await usingApi(async (api) => {929930    const whiteListedBefore = (await api.query.nft.whiteList(collectionId, address)).toJSON();931932    // Run the transaction933    const tx = api.tx.nft.addToWhiteList(collectionId, address);934    const events = await submitTransactionAsync(sender, tx);935    const result = getGenericResult(events);936937    const whiteListedAfter = (await api.query.nft.whiteList(collectionId, address)).toJSON();938939    // What to expect940    // tslint:disable-next-line:no-unused-expression941    expect(result.success).to.be.true;942    // tslint:disable-next-line: no-unused-expression943    expect(whiteListedBefore).to.be.false;944    // tslint:disable-next-line: no-unused-expression945    expect(whiteListedAfter).to.be.true;946  });947}948949export async function removeFromWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {950  await usingApi(async (api) => {951    // Run the transaction952    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);953    const events = await submitTransactionAsync(sender, tx);954    const result = getGenericResult(events);955956    // What to expect957    // tslint:disable-next-line:no-unused-expression958    expect(result.success).to.be.true;959  });960}961962export async function removeFromWhiteListExpectFailure(sender: IKeyringPair, collectionId: number, address: string) {963  await usingApi(async (api) => {964    // Run the transaction965    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);966    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;967    const result = getGenericResult(events);968969    // What to expect970    // tslint:disable-next-line:no-unused-expression971    expect(result.success).to.be.false;972  });973}974975export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)976  : Promise<ICollectionInterface | null> => {977  return (await api.query.nft.collectionById(collectionId)).toJSON() as unknown as ICollectionInterface;978};979980export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {981  // set global object - collectionsCount982  return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();983};984985export async function queryCollectionExpectSuccess(collectionId: number): Promise<ICollectionInterface> {986  return await usingApi(async (api) => {987    return (await api.query.nft.collectionById(collectionId)).toJSON() as unknown as ICollectionInterface;988  });989}