git.delta.rocks / unique-network / refs/commits / 48f959311e08

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import '../interfaces/augment-api-rpc';18import '../interfaces/augment-api-query';19import {ApiPromise, Keyring} from '@polkadot/api';20import type {AccountId, EventRecord, Event, BlockNumber} from '@polkadot/types/interfaces';21import type {GenericEventData} from '@polkadot/types';22import {AnyTuple, IEvent, IKeyringPair} from '@polkadot/types/types';23import {evmToAddress} from '@polkadot/util-crypto';24import {AnyNumber} from '@polkadot/types-codec/types';25import BN from 'bn.js';26import chai from 'chai';27import chaiAsPromised from 'chai-as-promised';28import {default as usingApi, executeTransaction, submitTransactionAsync, submitTransactionExpectFailAsync} from '../substrate/substrate-api';29import {hexToStr, strToUTF16, utf16ToStr} from './util';30import {UpDataStructsRpcCollection, UpDataStructsCreateItemData, UpDataStructsProperty} from '@polkadot/types/lookup';31import {UpDataStructsTokenChild} from '../interfaces';32import {Context} from 'mocha';3334chai.use(chaiAsPromised);35const expect = chai.expect;3637export type CrossAccountId = {38  Substrate: string,39} | {40  Ethereum: string,41};424344export enum Pallets {45  Inflation = 'inflation',46  RmrkCore = 'rmrkcore',47  RmrkEquip = 'rmrkequip',48  ReFungible = 'refungible',49  Fungible = 'fungible',50  NFT = 'nonfungible',51  Scheduler = 'scheduler',52  AppPromotion = 'apppromotion',53}5455export async function isUnique(): Promise<boolean> {56  return usingApi(async api => {57    const chain = await api.rpc.system.chain();5859    return chain.eq('UNIQUE');60  });61}6263export async function isQuartz(): Promise<boolean> {64  return usingApi(async api => {65    const chain = await api.rpc.system.chain();6667    return chain.eq('QUARTZ');68  });69}7071let modulesNames: any;72export function getModuleNames(api: ApiPromise): string[] {73  if (typeof modulesNames === 'undefined')74    modulesNames = api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());75  return modulesNames;76}7778export async function missingRequiredPallets(requiredPallets: string[]): Promise<string[]> {79  return await usingApi(async api => {80    const pallets = getModuleNames(api);8182    return requiredPallets.filter(p => !pallets.includes(p));83  });84}8586export async function checkPalletsPresence(requiredPallets: string[]): Promise<boolean> {87  return (await missingRequiredPallets(requiredPallets)).length == 0;88}8990export async function requirePallets(mocha: Context, requiredPallets: string[]) {91  const missingPallets = await missingRequiredPallets(requiredPallets);9293  if (missingPallets.length > 0) {94    const skippingTestMsg = `\tSkipping test "${mocha.test?.title}".`;95    const missingPalletsMsg = `\tThe following pallets are missing:\n\t- ${missingPallets.join('\n\t- ')}`;96    const skipMsg = `${skippingTestMsg}\n${missingPalletsMsg}`;9798    console.error('\x1b[38:5:208m%s\x1b[0m', skipMsg);99100    mocha.skip();101  }102}103104export function bigIntToSub(api: ApiPromise, number: bigint) {105  return api.registry.createType('AccountId', '0x' + number.toString(16).padStart(64, '0')).toJSON();106}107108export function bigIntToDecimals(number: bigint, decimals = 18): string {109  const numberStr = number.toString();110  const dotPos = numberStr.length - decimals;111112  if (dotPos <= 0) {113    return '0.' + '0'.repeat(Math.abs(dotPos)) + numberStr;114  } else {115    const intPart = numberStr.substring(0, dotPos);116    const fractPart = numberStr.substring(dotPos);117    return intPart + '.' + fractPart;118  }119}120121export function normalizeAccountId(input: string | AccountId | CrossAccountId | IKeyringPair): CrossAccountId {122  if (typeof input === 'string') {123    if (input.length >= 47) {124      return {Substrate: input};125    } else if (input.length === 42 && input.startsWith('0x')) {126      return {Ethereum: input.toLowerCase()};127    } else if (input.length === 40 && !input.startsWith('0x')) {128      return {Ethereum: '0x' + input.toLowerCase()};129    } else {130      throw new Error(`Unknown address format: "${input}"`);131    }132  }133  if ('address' in input) {134    return {Substrate: input.address};135  }136  if ('Ethereum' in input) {137    return {138      Ethereum: input.Ethereum.toLowerCase(),139    };140  } else if ('ethereum' in input) {141    return {142      Ethereum: (input as any).ethereum.toLowerCase(),143    };144  } else if ('Substrate' in input) {145    return input;146  } else if ('substrate' in input) {147    return {148      Substrate: (input as any).substrate,149    };150  }151152  // AccountId153  return {Substrate: input.toString()};154}155export function toSubstrateAddress(input: string | CrossAccountId | IKeyringPair): string {156  input = normalizeAccountId(input);157  if ('Substrate' in input) {158    return input.Substrate;159  } else {160    return evmToAddress(input.Ethereum);161  }162}163164export const U128_MAX = (1n << 128n) - 1n;165166const MICROUNIQUE = 1_000_000_000_000n;167const MILLIUNIQUE = 1_000n * MICROUNIQUE;168const CENTIUNIQUE = 10n * MILLIUNIQUE;169export const UNIQUE = 100n * CENTIUNIQUE;170171interface GenericResult<T> {172  success: boolean;173  data: T | null;174}175176interface CreateCollectionResult {177  success: boolean;178  collectionId: number;179}180181interface CreateItemResult {182  success: boolean;183  collectionId: number;184  itemId: number;185  recipient?: CrossAccountId;186  amount?: number;187}188189interface DestroyItemResult {190  success: boolean;191  collectionId: number;192  itemId: number;193  owner: CrossAccountId;194  amount: number;195}196197interface TransferResult {198  collectionId: number;199  itemId: number;200  sender?: CrossAccountId;201  recipient?: CrossAccountId;202  value: bigint;203}204205interface IReFungibleOwner {206  fraction: BN;207  owner: number[];208}209210interface IGetMessage {211  checkMsgUnqMethod: string;212  checkMsgTrsMethod: string;213  checkMsgSysMethod: string;214}215216export interface IFungibleTokenDataType {217  value: number;218}219220export interface IChainLimits {221  collectionNumbersLimit: number;222  accountTokenOwnershipLimit: number;223  collectionsAdminsLimit: number;224  customDataLimit: number;225  nftSponsorTransferTimeout: number;226  fungibleSponsorTransferTimeout: number;227  refungibleSponsorTransferTimeout: number;228  //offchainSchemaLimit: number;229  //constOnChainSchemaLimit: number;230}231232export interface IReFungibleTokenDataType {233  owner: IReFungibleOwner[];234}235236export function uniqueEventMessage(events: EventRecord[]): IGetMessage {237  let checkMsgUnqMethod = '';238  let checkMsgTrsMethod = '';239  let checkMsgSysMethod = '';240  events.forEach(({event: {method, section}}) => {241    if (section === 'common') {242      checkMsgUnqMethod = method;243    } else if (section === 'treasury') {244      checkMsgTrsMethod = method;245    } else if (section === 'system') {246      checkMsgSysMethod = method;247    } else { return null; }248  });249  const result: IGetMessage = {250    checkMsgUnqMethod,251    checkMsgTrsMethod,252    checkMsgSysMethod,253  };254  return result;255}256257export function getEvent<T extends Event>(events: EventRecord[], check: (event: IEvent<AnyTuple>) => event is T): T | undefined {258  const event = events.find(r => check(r.event));259  if (!event) return;260  return event.event as T;261}262263export function getGenericResult<T>(events: EventRecord[]): GenericResult<T>;264export function getGenericResult<T>(265  events: EventRecord[],266  expectSection: string,267  expectMethod: string,268  extractAction: (data: GenericEventData) => T269): GenericResult<T>;270271export function getGenericResult<T>(272  events: EventRecord[],273  expectSection?: string,274  expectMethod?: string,275  extractAction?: (data: GenericEventData) => T,276): GenericResult<T> {277  let success = false;278  let successData = null;279280  events.forEach(({event: {data, method, section}}) => {281    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);282    if (method === 'ExtrinsicSuccess') {283      success = true;284    } else if ((expectSection == section) && (expectMethod == method)) {285      successData = extractAction!(data as any);286    }287  });288289  const result: GenericResult<T> = {290    success,291    data: successData,292  };293  return result;294}295296export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {297  const genericResult = getGenericResult(events, 'common', 'CollectionCreated', (data) => parseInt(data[0].toString(), 10));298  const result: CreateCollectionResult = {299    success: genericResult.success,300    collectionId: genericResult.data ?? 0,301  };302  return result;303}304305export function getCreateItemsResult(events: EventRecord[]): CreateItemResult[] {306  const results: CreateItemResult[] = [];307308  const genericResult = getGenericResult<CreateItemResult[]>(events, 'common', 'ItemCreated', (data) => {309    const collectionId = parseInt(data[0].toString(), 10);310    const itemId = parseInt(data[1].toString(), 10);311    const recipient = normalizeAccountId(data[2].toJSON() as any);312    const amount = parseInt(data[3].toString(), 10);313314    const itemRes: CreateItemResult = {315      success: true,316      collectionId,317      itemId,318      recipient,319      amount,320    };321322    results.push(itemRes);323    return results;324  });325326  if (!genericResult.success) return [];327  return results;328}329330export function getCreateItemResult(events: EventRecord[]): CreateItemResult {331  const genericResult = getGenericResult(events, 'common', 'ItemCreated', (data) => data.map(function(value) { return value.toJSON(); }));332333  if (genericResult.data == null)334    return {335      success: genericResult.success,336      collectionId: 0,337      itemId: 0,338      amount: 0,339    };340  else341    return {342      success: genericResult.success,343      collectionId: genericResult.data[0] as number,344      itemId: genericResult.data[1] as number,345      recipient: normalizeAccountId(genericResult.data![2] as any),346      amount: genericResult.data[3] as number,347    };348}349350export function getDestroyItemsResult(events: EventRecord[]): DestroyItemResult[] {351  const results: DestroyItemResult[] = [];352353  const genericResult = getGenericResult<DestroyItemResult[]>(events, 'common', 'ItemDestroyed', (data) => {354    const collectionId = parseInt(data[0].toString(), 10);355    const itemId = parseInt(data[1].toString(), 10);356    const owner = normalizeAccountId(data[2].toJSON() as any);357    const amount = parseInt(data[3].toString(), 10);358359    const itemRes: DestroyItemResult = {360      success: true,361      collectionId,362      itemId,363      owner,364      amount,365    };366367    results.push(itemRes);368    return results;369  });370371  if (!genericResult.success) return [];372  return results;373}374375export function getTransferResult(api: ApiPromise, events: EventRecord[]): TransferResult {376  for (const {event} of events) {377    if (api.events.common.Transfer.is(event)) {378      const [collection, token, sender, recipient, value] = event.data;379      return {380        collectionId: collection.toNumber(),381        itemId: token.toNumber(),382        sender: normalizeAccountId(sender.toJSON() as any),383        recipient: normalizeAccountId(recipient.toJSON() as any),384        value: value.toBigInt(),385      };386    }387  }388  throw new Error('no transfer event');389}390391interface Nft {392  type: 'NFT';393}394395interface Fungible {396  type: 'Fungible';397  decimalPoints: number;398}399400interface ReFungible {401  type: 'ReFungible';402}403404export type CollectionMode = Nft | Fungible | ReFungible;405406export type Property = {407  key: any,408  value: any,409};410411type Permission = {412  mutable: boolean;413  collectionAdmin: boolean;414  tokenOwner: boolean;415}416417type PropertyPermission = {418  key: any;419  permission: Permission;420}421422export type CreateCollectionParams = {423  mode: CollectionMode,424  name: string,425  description: string,426  tokenPrefix: string,427  properties?: Array<Property>,428  propPerm?: Array<PropertyPermission>429};430431const defaultCreateCollectionParams: CreateCollectionParams = {432  description: 'description',433  mode: {type: 'NFT'},434  name: 'name',435  tokenPrefix: 'prefix',436  properties: [{key: 'ERC721Metadata', value: '1'}],437};438439export async function440createCollection(441  api: ApiPromise,442  sender: IKeyringPair,443  params: Partial<CreateCollectionParams> = {},444): Promise<CreateCollectionResult> {445  const {name, description, mode, tokenPrefix, properties} = {...defaultCreateCollectionParams, ...params};446447  let modeprm = {};448  if (mode.type === 'NFT') {449    modeprm = {nft: null};450  } else if (mode.type === 'Fungible') {451    modeprm = {fungible: mode.decimalPoints};452  } else if (mode.type === 'ReFungible') {453    modeprm = {refungible: null};454  }455456  const tx = api.tx.unique.createCollectionEx({457    name: strToUTF16(name),458    description: strToUTF16(description),459    tokenPrefix: strToUTF16(tokenPrefix),460    mode: modeprm as any,461    properties,462  });463  const events = await executeTransaction(api, sender, tx);464  return getCreateCollectionResult(events);465}466467export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {468  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};469470  let collectionId = 0;471  await usingApi(async (api, privateKeyWrapper) => {472    // Get number of collections before the transaction473    const collectionCountBefore = await getCreatedCollectionCount(api);474475    // Run the CreateCollection transaction476    const alicePrivateKey = privateKeyWrapper('//Alice');477478    const result = await createCollection(api, alicePrivateKey, params);479480    // Get number of collections after the transaction481    const collectionCountAfter = await getCreatedCollectionCount(api);482483    // Get the collection484    const collection = await queryCollectionExpectSuccess(api, result.collectionId);485486    // What to expect487    // tslint:disable-next-line:no-unused-expression488    expect(result.success).to.be.true;489    expect(result.collectionId).to.be.equal(collectionCountAfter);490    // tslint:disable-next-line:no-unused-expression491    expect(collection).to.be.not.null;492    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');493    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicePrivateKey));494    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);495    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);496    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);497498    collectionId = result.collectionId;499  });500501  return collectionId;502}503504export async function createCollectionWithPropsExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {505  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};506507  let collectionId = 0;508  await usingApi(async (api, privateKeyWrapper) => {509    // Get number of collections before the transaction510    const collectionCountBefore = await getCreatedCollectionCount(api);511512    // Run the CreateCollection transaction513    const alicePrivateKey = privateKeyWrapper('//Alice');514515    let modeprm = {};516    if (mode.type === 'NFT') {517      modeprm = {nft: null};518    } else if (mode.type === 'Fungible') {519      modeprm = {fungible: mode.decimalPoints};520    } else if (mode.type === 'ReFungible') {521      modeprm = {refungible: null};522    }523524    const tx = api.tx.unique.createCollectionEx({name: strToUTF16(name), description: strToUTF16(description), tokenPrefix: strToUTF16(tokenPrefix), mode: modeprm as any, properties: params.properties, tokenPropertyPermissions: params.propPerm});525    const events = await submitTransactionAsync(alicePrivateKey, tx);526    const result = getCreateCollectionResult(events);527528    // Get number of collections after the transaction529    const collectionCountAfter = await getCreatedCollectionCount(api);530531    // Get the collection532    const collection = await queryCollectionExpectSuccess(api, result.collectionId);533534    // What to expect535    // tslint:disable-next-line:no-unused-expression536    expect(result.success).to.be.true;537    expect(result.collectionId).to.be.equal(collectionCountAfter);538    // tslint:disable-next-line:no-unused-expression539    expect(collection).to.be.not.null;540    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');541    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicePrivateKey));542    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);543    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);544    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);545546547    collectionId = result.collectionId;548  });549550  return collectionId;551}552553export async function createCollectionWithPropsExpectFailure(params: Partial<CreateCollectionParams> = {}) {554  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};555556  await usingApi(async (api, privateKeyWrapper) => {557    // Get number of collections before the transaction558    const collectionCountBefore = await getCreatedCollectionCount(api);559560    // Run the CreateCollection transaction561    const alicePrivateKey = privateKeyWrapper('//Alice');562563    let modeprm = {};564    if (mode.type === 'NFT') {565      modeprm = {nft: null};566    } else if (mode.type === 'Fungible') {567      modeprm = {fungible: mode.decimalPoints};568    } else if (mode.type === 'ReFungible') {569      modeprm = {refungible: null};570    }571572    const tx = api.tx.unique.createCollectionEx({name: strToUTF16(name), description: strToUTF16(description), tokenPrefix: strToUTF16(tokenPrefix), mode: modeprm as any, properties: params.properties, tokenPropertyPermissions: params.propPerm});573    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;574575576    // Get number of collections after the transaction577    const collectionCountAfter = await getCreatedCollectionCount(api);578579    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');580  });581}582583export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {584  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};585586  let modeprm = {};587  if (mode.type === 'NFT') {588    modeprm = {nft: null};589  } else if (mode.type === 'Fungible') {590    modeprm = {fungible: mode.decimalPoints};591  } else if (mode.type === 'ReFungible') {592    modeprm = {refungible: null};593  }594595  await usingApi(async (api, privateKeyWrapper) => {596    // Get number of collections before the transaction597    const collectionCountBefore = await getCreatedCollectionCount(api);598599    // Run the CreateCollection transaction600    const alicePrivateKey = privateKeyWrapper('//Alice');601    const tx = api.tx.unique.createCollectionEx({name: strToUTF16(name), description: strToUTF16(description), tokenPrefix: strToUTF16(tokenPrefix), mode: modeprm as any});602    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;603604    // Get number of collections after the transaction605    const collectionCountAfter = await getCreatedCollectionCount(api);606607    // What to expect608    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');609  });610}611612export async function findUnusedAddress(api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair, seedAddition = ''): Promise<IKeyringPair> {613  let bal = 0n;614  let unused;615  do {616    const randomSeed = 'seed' + Math.floor(Math.random() * Math.floor(10000)) + seedAddition;617    unused = privateKeyWrapper(`//${randomSeed}`);618    bal = (await api.query.system.account(unused.address)).data.free.toBigInt();619  } while (bal !== 0n);620  return unused;621}622623export async function getAllowance(api: ApiPromise, collectionId: number, owner: CrossAccountId | string | IKeyringPair, approved: CrossAccountId | string | IKeyringPair, tokenId: number) {624  return (await api.rpc.unique.allowance(collectionId, normalizeAccountId(owner), normalizeAccountId(approved), tokenId)).toBigInt();625}626627export function findUnusedAddresses(api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair, amount: number): Promise<IKeyringPair[]> {628  return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, privateKeyWrapper, '_' + Date.now())));629}630631export async function findNotExistingCollection(api: ApiPromise): Promise<number> {632  const totalNumber = await getCreatedCollectionCount(api);633  const newCollection: number = totalNumber + 1;634  return newCollection;635}636637function getDestroyResult(events: EventRecord[]): boolean {638  let success = false;639  events.forEach(({event: {method}}) => {640    if (method == 'ExtrinsicSuccess') {641      success = true;642    }643  });644  return success;645}646647export async function destroyCollectionExpectFailure(collectionId: number, senderSeed = '//Alice') {648  await usingApi(async (api, privateKeyWrapper) => {649    // Run the DestroyCollection transaction650    const alicePrivateKey = privateKeyWrapper(senderSeed);651    const tx = api.tx.unique.destroyCollection(collectionId);652    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;653  });654}655656export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed = '//Alice') {657  await usingApi(async (api, privateKeyWrapper) => {658    // Run the DestroyCollection transaction659    const alicePrivateKey = privateKeyWrapper(senderSeed);660    const tx = api.tx.unique.destroyCollection(collectionId);661    const events = await submitTransactionAsync(alicePrivateKey, tx);662    const result = getDestroyResult(events);663    expect(result).to.be.true;664665    // What to expect666    expect(await getDetailedCollectionInfo(api, collectionId)).to.be.null;667  });668}669670export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {671  await usingApi(async (api) => {672    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);673    const events = await submitTransactionAsync(sender, tx);674    const result = getGenericResult(events);675676    expect(result.success).to.be.true;677  });678}679680export const setCollectionPermissionsExpectSuccess = async (sender: IKeyringPair, collectionId: number, permissions: any) => {681  await usingApi(async(api) => {682    const tx = api.tx.unique.setCollectionPermissions(collectionId, permissions);683    const events = await submitTransactionAsync(sender, tx);684    const result = getGenericResult(events);685686    expect(result.success).to.be.true;687  });688};689690export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {691  await usingApi(async (api) => {692    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);693    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;694    const result = getGenericResult(events);695696    expect(result.success).to.be.false;697  });698}699700export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string, sender = '//Alice') {701  await usingApi(async (api, privateKeyWrapper) => {702703    // Run the transaction704    const senderPrivateKey = privateKeyWrapper(sender);705    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);706    const events = await submitTransactionAsync(senderPrivateKey, tx);707    const result = getGenericResult(events);708709    // Get the collection710    const collection = await queryCollectionExpectSuccess(api, collectionId);711712    // What to expect713    expect(result.success).to.be.true;714    expect(collection.sponsorship.toJSON()).to.deep.equal({715      unconfirmed: sponsor,716    });717  });718}719720export async function removeCollectionSponsorExpectSuccess(collectionId: number, sender = '//Alice') {721  await usingApi(async (api, privateKeyWrapper) => {722723    // Run the transaction724    const alicePrivateKey = privateKeyWrapper(sender);725    const tx = api.tx.unique.removeCollectionSponsor(collectionId);726    const events = await submitTransactionAsync(alicePrivateKey, tx);727    const result = getGenericResult(events);728729    // Get the collection730    const collection = await queryCollectionExpectSuccess(api, collectionId);731732    // What to expect733    expect(result.success).to.be.true;734    expect(collection.sponsorship.toJSON()).to.be.deep.equal({disabled: null});735  });736}737738export async function removeCollectionSponsorExpectFailure(collectionId: number, senderSeed = '//Alice') {739  await usingApi(async (api, privateKeyWrapper) => {740741    // Run the transaction742    const alicePrivateKey = privateKeyWrapper(senderSeed);743    const tx = api.tx.unique.removeCollectionSponsor(collectionId);744    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;745  });746}747748export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed = '//Alice') {749  await usingApi(async (api, privateKeyWrapper) => {750751    // Run the transaction752    const alicePrivateKey = privateKeyWrapper(senderSeed);753    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);754    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;755  });756}757758export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed = '//Alice') {759  await usingApi(async (api, privateKeyWrapper) => {760761    // Run the transaction762    const sender = privateKeyWrapper(senderSeed);763    await confirmSponsorshipByKeyExpectSuccess(collectionId, sender);764  });765}766767export async function confirmSponsorshipByKeyExpectSuccess(collectionId: number, sender: IKeyringPair) {768  await usingApi(async (api, privateKeyWrapper) => {769770    // Run the transaction771    const tx = api.tx.unique.confirmSponsorship(collectionId);772    const events = await submitTransactionAsync(sender, tx);773    const result = getGenericResult(events);774775    // Get the collection776    const collection = await queryCollectionExpectSuccess(api, collectionId);777778    // What to expect779    expect(result.success).to.be.true;780    expect(collection.sponsorship.toJSON()).to.be.deep.equal({781      confirmed: sender.address,782    });783  });784}785786787export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed = '//Alice') {788  await usingApi(async (api, privateKeyWrapper) => {789790    // Run the transaction791    const sender = privateKeyWrapper(senderSeed);792    const tx = api.tx.unique.confirmSponsorship(collectionId);793    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;794  });795}796797export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {798  await usingApi(async (api) => {799    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);800    const events = await submitTransactionAsync(sender, tx);801    const result = getGenericResult(events);802803    expect(result.success).to.be.true;804  });805}806807export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {808  await usingApi(async (api) => {809    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);810    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;811    const result = getGenericResult(events);812813    expect(result.success).to.be.false;814  });815}816817export async function setTransferFlagExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {818819  await usingApi(async (api) => {820821    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);822    const events = await submitTransactionAsync(sender, tx);823    const result = getGenericResult(events);824825    expect(result.success).to.be.true;826  });827}828829export async function setTransferFlagExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {830831  await usingApi(async (api) => {832833    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);834    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;835    const result = getGenericResult(events);836837    expect(result.success).to.be.false;838  });839}840841export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {842  await usingApi(async (api) => {843    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);844    const events = await submitTransactionAsync(sender, tx);845    const result = getGenericResult(events);846847    expect(result.success).to.be.true;848  });849}850851export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {852  await usingApi(async (api) => {853    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);854    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;855    const result = getGenericResult(events);856857    expect(result.success).to.be.false;858  });859}860861export async function getNextSponsored(862  api: ApiPromise,863  collectionId: number,864  account: string | CrossAccountId,865  tokenId: number,866): Promise<number> {867  return Number((await api.rpc.unique.nextSponsored(collectionId, account, tokenId)).unwrapOr(-1));868}869870export async function toggleContractAllowlistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, value = true) {871  await usingApi(async (api) => {872    const tx = api.tx.unique.toggleContractAllowList(contractAddress, value);873    const events = await submitTransactionAsync(sender, tx);874    const result = getGenericResult(events);875876    expect(result.success).to.be.true;877  });878}879880export async function isAllowlistedInContract(contractAddress: AccountId | string, user: string) {881  let allowlisted = false;882  await usingApi(async (api) => {883    allowlisted = (await api.query.unique.contractAllowList(contractAddress, user)).toJSON() as boolean;884  });885  return allowlisted;886}887888export async function addToContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {889  await usingApi(async (api) => {890    const tx = api.tx.unique.addToContractAllowList(contractAddress.toString(), user.toString());891    const events = await submitTransactionAsync(sender, tx);892    const result = getGenericResult(events);893894    expect(result.success).to.be.true;895  });896}897898export async function removeFromContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {899  await usingApi(async (api) => {900    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());901    const events = await submitTransactionAsync(sender, tx);902    const result = getGenericResult(events);903904    expect(result.success).to.be.true;905  });906}907908export async function removeFromContractAllowListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {909  await usingApi(async (api) => {910    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());911    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;912    const result = getGenericResult(events);913914    expect(result.success).to.be.false;915  });916}917918export interface CreateFungibleData {919  readonly Value: bigint;920}921922export interface CreateReFungibleData { }923export interface CreateNftData { }924925export type CreateItemData = {926  NFT: CreateNftData;927} | {928  Fungible: CreateFungibleData;929} | {930  ReFungible: CreateReFungibleData;931};932933export async function burnItem(api: ApiPromise, sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint) : Promise<boolean> {934  const tx = api.tx.unique.burnItem(collectionId, tokenId, value);935  const events = await submitTransactionAsync(sender, tx);936  return getGenericResult(events).success;937}938939export async function burnItemExpectSuccess(sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint = 1) {940  await usingApi(async (api) => {941    const balanceBefore = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);942    // if burning token by admin - use adminButnItemExpectSuccess943    expect(balanceBefore >= BigInt(value)).to.be.true;944945    expect(await burnItem(api, sender, collectionId, tokenId, value)).to.be.true;946947    const balanceAfter = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);948    expect(balanceAfter + BigInt(value)).to.be.equal(balanceBefore);949  });950}951952export async function burnItemExpectFailure(sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint = 1) {953  await usingApi(async (api) => {954    const tx = api.tx.unique.burnItem(collectionId, tokenId, value);955956    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;957    const result = getCreateCollectionResult(events);958    // tslint:disable-next-line:no-unused-expression959    expect(result.success).to.be.false;960  });961}962963export async function burnFromExpectSuccess(sender: IKeyringPair, from: IKeyringPair | CrossAccountId, collectionId: number, tokenId: number, value: number | bigint = 1) {964  await usingApi(async (api) => {965    const tx = api.tx.unique.burnFrom(collectionId, normalizeAccountId(from), tokenId, value);966    const events = await submitTransactionAsync(sender, tx);967    return getGenericResult(events).success;968  });969}970971export async function972approve(973  api: ApiPromise,974  collectionId: number,975  tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string | IKeyringPair, amount: number | bigint,976) {977  const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);978  const events = await submitTransactionAsync(owner, approveUniqueTx);979  return getGenericResult(events).success;980}981982export async function983approveExpectSuccess(984  collectionId: number,985  tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string, amount: number | bigint = 1,986) {987  await usingApi(async (api: ApiPromise) => {988    const result = await approve(api, collectionId, tokenId, owner, approved, amount);989    expect(result).to.be.true;990991    expect(await getAllowance(api, collectionId, owner, approved, tokenId)).to.be.equal(BigInt(amount));992  });993}994995export async function adminApproveFromExpectSuccess(996  collectionId: number,997  tokenId: number, admin: IKeyringPair, owner: CrossAccountId | string, approved: CrossAccountId | string, amount: number | bigint = 1,998) {999  await usingApi(async (api: ApiPromise) => {1000    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);1001    const events = await submitTransactionAsync(admin, approveUniqueTx);1002    const result = getGenericResult(events);1003    expect(result.success).to.be.true;10041005    expect(await getAllowance(api, collectionId, owner, approved, tokenId)).to.be.equal(BigInt(amount));1006  });1007}10081009export async function1010transferFrom(1011  api: ApiPromise,1012  collectionId: number,1013  tokenId: number,1014  accountApproved: IKeyringPair,1015  accountFrom: IKeyringPair | CrossAccountId,1016  accountTo: IKeyringPair | CrossAccountId,1017  value: number | bigint,1018) {1019  const from = normalizeAccountId(accountFrom);1020  const to = normalizeAccountId(accountTo);1021  const transferFromTx = api.tx.unique.transferFrom(from, to, collectionId, tokenId, value);1022  const events = await submitTransactionAsync(accountApproved, transferFromTx);1023  return getGenericResult(events).success;1024}10251026export async function1027transferFromExpectSuccess(1028  collectionId: number,1029  tokenId: number,1030  accountApproved: IKeyringPair,1031  accountFrom: IKeyringPair | CrossAccountId,1032  accountTo: IKeyringPair | CrossAccountId,1033  value: number | bigint = 1,1034  type = 'NFT',1035) {1036  await usingApi(async (api: ApiPromise) => {1037    const from = normalizeAccountId(accountFrom);1038    const to = normalizeAccountId(accountTo);1039    let balanceBefore = 0n;1040    if (type === 'Fungible' || type === 'ReFungible') {1041      balanceBefore = await getBalance(api, collectionId, to, tokenId);1042    }1043    expect(await transferFrom(api, collectionId, tokenId, accountApproved, accountFrom, accountTo, value)).to.be.true;1044    if (type === 'NFT') {1045      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);1046    }1047    if (type === 'Fungible') {1048      const balanceAfter = await getBalance(api, collectionId, to, tokenId);1049      if (JSON.stringify(to) !== JSON.stringify(from)) {1050        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));1051      } else {1052        expect(balanceAfter).to.be.equal(balanceBefore);1053      }1054    }1055    if (type === 'ReFungible') {1056      expect(await getBalance(api, collectionId, to, tokenId)).to.be.equal(balanceBefore + BigInt(value));1057    }1058  });1059}10601061export async function1062transferFromExpectFail(1063  collectionId: number,1064  tokenId: number,1065  accountApproved: IKeyringPair,1066  accountFrom: IKeyringPair,1067  accountTo: IKeyringPair,1068  value: number | bigint = 1,1069) {1070  await usingApi(async (api: ApiPromise) => {1071    const transferFromTx = api.tx.unique.transferFrom(normalizeAccountId(accountFrom.address), normalizeAccountId(accountTo.address), collectionId, tokenId, value);1072    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;1073    const result = getCreateCollectionResult(events);1074    // tslint:disable-next-line:no-unused-expression1075    expect(result.success).to.be.false;1076  });1077}10781079/* eslint no-async-promise-executor: "off" */1080export async function getBlockNumber(api: ApiPromise): Promise<number> {1081  return new Promise<number>(async (resolve) => {1082    const unsubscribe = await api.rpc.chain.subscribeNewHeads((head) => {1083      unsubscribe();1084      resolve(head.number.toNumber());1085    });1086  });1087}10881089export async function addCollectionAdminExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | CrossAccountId) {1090  await usingApi(async (api) => {1091    const changeAdminTx = api.tx.unique.addCollectionAdmin(collectionId, normalizeAccountId(address));1092    const events = await submitTransactionAsync(sender, changeAdminTx);1093    const result = getCreateCollectionResult(events);1094    expect(result.success).to.be.true;1095  });1096}10971098export async function adminApproveFromExpectFail(1099  collectionId: number,1100  tokenId: number, admin: IKeyringPair, owner: CrossAccountId | string, approved: CrossAccountId | string, amount: number | bigint = 1,1101) {1102  await usingApi(async (api: ApiPromise) => {1103    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);1104    const events = await expect(submitTransactionAsync(admin, approveUniqueTx)).to.be.rejected;1105    const result = getGenericResult(events);1106    expect(result.success).to.be.false;1107  });1108}11091110export async function1111getFreeBalance(account: IKeyringPair): Promise<bigint> {1112  let balance = 0n;1113  await usingApi(async (api) => {1114    balance = BigInt((await api.query.system.account(account.address)).data.free.toString());1115  });11161117  return balance;1118}11191120export async function paraSiblingSovereignAccount(paraid: number): Promise<string> {1121  return usingApi(async api => {1122    // We are getting a *sibling* parachain sovereign account,1123    // so we need a sibling prefix: encoded(b"sibl") == 0x7369626c1124    const siblingPrefix = '0x7369626c';11251126    const encodedParaId = api.createType('u32', paraid).toHex(true).substring(2);1127    const suffix = '000000000000000000000000000000000000000000000000';11281129    return siblingPrefix + encodedParaId + suffix;1130  });1131}11321133export async function transferBalanceTo(api: ApiPromise, source: IKeyringPair, target: string, amount = 1000n * UNIQUE) {1134  const tx = api.tx.balances.transfer(target, amount);1135  const events = await submitTransactionAsync(source, tx);1136  const result = getGenericResult(events);1137  expect(result.success).to.be.true;1138}11391140export async function1141scheduleExpectSuccess(1142  operationTx: any,1143  sender: IKeyringPair,1144  blockSchedule: number,1145  scheduledId: string,1146  period = 1,1147  repetitions = 1,1148) {1149  await usingApi(async (api: ApiPromise) => {1150    const blockNumber: number | undefined = await getBlockNumber(api);1151    const expectedBlockNumber = blockNumber + blockSchedule;11521153    expect(blockNumber).to.be.greaterThan(0);1154    const scheduleTx = api.tx.scheduler.scheduleNamed( // schedule1155      scheduledId,1156      expectedBlockNumber,1157      repetitions > 1 ? [period, repetitions] : null,1158      0,1159      {Value: operationTx as any},1160    );11611162    const events = await submitTransactionAsync(sender, scheduleTx);1163    expect(getGenericResult(events).success).to.be.true;1164  });1165}11661167export async function1168scheduleExpectFailure(1169  operationTx: any,1170  sender: IKeyringPair,1171  blockSchedule: number,1172  scheduledId: string,1173  period = 1,1174  repetitions = 1,1175) {1176  await usingApi(async (api: ApiPromise) => {1177    const blockNumber: number | undefined = await getBlockNumber(api);1178    const expectedBlockNumber = blockNumber + blockSchedule;11791180    expect(blockNumber).to.be.greaterThan(0);1181    const scheduleTx = api.tx.scheduler.scheduleNamed( // schedule1182      scheduledId,1183      expectedBlockNumber,1184      repetitions <= 1 ? null : [period, repetitions],1185      0,1186      {Value: operationTx as any},1187    );11881189    //const events =1190    await expect(submitTransactionExpectFailAsync(sender, scheduleTx)).to.be.rejected;1191    //expect(getGenericResult(events).success).to.be.false;1192  });1193}11941195export async function1196scheduleTransferAndWaitExpectSuccess(1197  collectionId: number,1198  tokenId: number,1199  sender: IKeyringPair,1200  recipient: IKeyringPair,1201  value: number | bigint = 1,1202  blockSchedule: number,1203  scheduledId: string,1204) {1205  await usingApi(async (api: ApiPromise) => {1206    await scheduleTransferExpectSuccess(collectionId, tokenId, sender, recipient, value, blockSchedule, scheduledId);12071208    const recipientBalanceBefore = (await api.query.system.account(recipient.address)).data.free.toBigInt();12091210    // sleep for n + 1 blocks1211    await waitNewBlocks(blockSchedule + 1);12121213    const recipientBalanceAfter = (await api.query.system.account(recipient.address)).data.free.toBigInt();12141215    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(recipient.address));1216    expect(recipientBalanceAfter).to.be.equal(recipientBalanceBefore);1217  });1218}12191220export async function1221scheduleTransferExpectSuccess(1222  collectionId: number,1223  tokenId: number,1224  sender: IKeyringPair,1225  recipient: IKeyringPair,1226  value: number | bigint = 1,1227  blockSchedule: number,1228  scheduledId: string,1229) {1230  await usingApi(async (api: ApiPromise) => {1231    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value);12321233    await scheduleExpectSuccess(transferTx, sender, blockSchedule, scheduledId);12341235    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(sender.address));1236  });1237}12381239export async function1240scheduleTransferFundsPeriodicExpectSuccess(1241  amount: bigint,1242  sender: IKeyringPair,1243  recipient: IKeyringPair,1244  blockSchedule: number,1245  scheduledId: string,1246  period: number,1247  repetitions: number,1248) {1249  await usingApi(async (api: ApiPromise) => {1250    const transferTx = api.tx.balances.transfer(recipient.address, amount);12511252    const balanceBefore = await getFreeBalance(recipient);12531254    await scheduleExpectSuccess(transferTx, sender, blockSchedule, scheduledId, period, repetitions);12551256    expect(await getFreeBalance(recipient)).to.be.equal(balanceBefore);1257  });1258}12591260export async function1261transfer(1262  api: ApiPromise,1263  collectionId: number,1264  tokenId: number,1265  sender: IKeyringPair,1266  recipient: IKeyringPair | CrossAccountId,1267  value: number | bigint,1268) : Promise<boolean> {1269  const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1270  const events = await executeTransaction(api, sender, transferTx);1271  return getGenericResult(events).success;1272}12731274export async function1275transferExpectSuccess(1276  collectionId: number,1277  tokenId: number,1278  sender: IKeyringPair,1279  recipient: IKeyringPair | CrossAccountId,1280  value: number | bigint = 1,1281  type = 'NFT',1282) {1283  await usingApi(async (api: ApiPromise) => {1284    const from = normalizeAccountId(sender);1285    const to = normalizeAccountId(recipient);12861287    let balanceBefore = 0n;1288    if (type === 'Fungible' || type === 'ReFungible') {1289      balanceBefore = await getBalance(api, collectionId, to, tokenId);1290    }12911292    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1293    const events = await executeTransaction(api, sender, transferTx);1294    const result = getTransferResult(api, events);12951296    expect(result.collectionId).to.be.equal(collectionId);1297    expect(result.itemId).to.be.equal(tokenId);1298    expect(result.sender).to.be.deep.equal(normalizeAccountId(sender.address));1299    expect(result.recipient).to.be.deep.equal(to);1300    expect(result.value).to.be.equal(BigInt(value));13011302    if (type === 'NFT') {1303      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);1304    }1305    if (type === 'Fungible' || type === 'ReFungible') {1306      const balanceAfter = await getBalance(api, collectionId, to, tokenId);1307      if (JSON.stringify(to) !== JSON.stringify(from)) {1308        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));1309      } else {1310        expect(balanceAfter).to.be.equal(balanceBefore);1311      }1312    }1313  });1314}13151316export async function1317transferExpectFailure(1318  collectionId: number,1319  tokenId: number,1320  sender: IKeyringPair,1321  recipient: IKeyringPair | CrossAccountId,1322  value: number | bigint = 1,1323) {1324  await usingApi(async (api: ApiPromise) => {1325    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1326    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;1327    const result = getGenericResult(events);1328    // if (events && Array.isArray(events)) {1329    //   const result = getCreateCollectionResult(events);1330    // tslint:disable-next-line:no-unused-expression1331    expect(result.success).to.be.false;1332    //}1333  });1334}13351336export async function1337approveExpectFail(1338  collectionId: number,1339  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1,1340) {1341  await usingApi(async (api: ApiPromise) => {1342    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved.address), collectionId, tokenId, amount);1343    const events = await expect(submitTransactionExpectFailAsync(owner, approveUniqueTx)).to.be.rejected;1344    const result = getCreateCollectionResult(events);1345    // tslint:disable-next-line:no-unused-expression1346    expect(result.success).to.be.false;1347  });1348}13491350export async function getBalance(1351  api: ApiPromise,1352  collectionId: number,1353  owner: string | CrossAccountId | IKeyringPair,1354  token: number,1355): Promise<bigint> {1356  return (await api.rpc.unique.balance(collectionId, normalizeAccountId(owner), token)).toBigInt();1357}1358export async function getTokenOwner(1359  api: ApiPromise,1360  collectionId: number,1361  token: number,1362): Promise<CrossAccountId> {1363  const owner = (await api.rpc.unique.tokenOwner(collectionId, token)).toJSON() as any;1364  if (owner == null) throw new Error('owner == null');1365  return normalizeAccountId(owner);1366}1367export async function getTopmostTokenOwner(1368  api: ApiPromise,1369  collectionId: number,1370  token: number,1371): Promise<CrossAccountId> {1372  const owner = (await api.rpc.unique.topmostTokenOwner(collectionId, token)).toJSON() as any;1373  if (owner == null) throw new Error('owner == null');1374  return normalizeAccountId(owner);1375}1376export async function getTokenChildren(1377  api: ApiPromise,1378  collectionId: number,1379  tokenId: number,1380): Promise<UpDataStructsTokenChild[]> {1381  return (await api.rpc.unique.tokenChildren(collectionId, tokenId)).toJSON() as any;1382}1383export async function isTokenExists(1384  api: ApiPromise,1385  collectionId: number,1386  token: number,1387): Promise<boolean> {1388  return (await api.rpc.unique.tokenExists(collectionId, token)).toJSON();1389}1390export async function getLastTokenId(1391  api: ApiPromise,1392  collectionId: number,1393): Promise<number> {1394  return (await api.rpc.unique.lastTokenId(collectionId)).toJSON();1395}1396export async function getAdminList(1397  api: ApiPromise,1398  collectionId: number,1399): Promise<string[]> {1400  return (await api.rpc.unique.adminlist(collectionId)).toHuman() as any;1401}1402export async function getTokenProperties(1403  api: ApiPromise,1404  collectionId: number,1405  tokenId: number,1406  propertyKeys: string[],1407): Promise<UpDataStructsProperty[]> {1408  return (await api.rpc.unique.tokenProperties(collectionId, tokenId, propertyKeys)).toHuman() as any;1409}14101411export async function createFungibleItemExpectSuccess(1412  sender: IKeyringPair,1413  collectionId: number,1414  data: CreateFungibleData,1415  owner: CrossAccountId | string = sender.address,1416) {1417  return await usingApi(async (api) => {1418    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), {Fungible: data});14191420    const events = await submitTransactionAsync(sender, tx);1421    const result = getCreateItemResult(events);14221423    expect(result.success).to.be.true;1424    return result.itemId;1425  });1426}14271428export async function createMultipleItemsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any, owner: CrossAccountId | string = sender.address) {1429  await usingApi(async (api) => {1430    const to = normalizeAccountId(owner);1431    const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);14321433    const events = await submitTransactionAsync(sender, tx);1434    expect(getGenericResult(events).success).to.be.true;1435  });1436}14371438export async function createMultipleItemsWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any, owner: CrossAccountId | string = sender.address) {1439  await usingApi(async (api) => {1440    const to = normalizeAccountId(owner);1441    const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);14421443    const events = await submitTransactionAsync(sender, tx);1444    const result = getCreateItemsResult(events);14451446    for (const res of result) {1447      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1448    }1449  });1450}14511452export async function createMultipleItemsExWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any) {1453  await usingApi(async (api) => {1454    const tx = api.tx.unique.createMultipleItemsEx(collectionId, itemsData);14551456    const events = await submitTransactionAsync(sender, tx);1457    const result = getCreateItemsResult(events);14581459    for (const res of result) {1460      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1461    }1462  });1463}14641465export async function createItemWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, props:  Array<Property>, owner: CrossAccountId | string = sender.address) {1466  let newItemId = 0;1467  await usingApi(async (api) => {1468    const to = normalizeAccountId(owner);1469    const itemCountBefore = await getLastTokenId(api, collectionId);1470    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);14711472    let tx;1473    if (createMode === 'Fungible') {1474      const createData = {fungible: {value: 10}};1475      tx = api.tx.unique.createItem(collectionId, to, createData as any);1476    } else if (createMode === 'ReFungible') {1477      const createData = {refungible: {pieces: 100}};1478      tx = api.tx.unique.createItem(collectionId, to, createData as any);1479    } else {1480      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}});1481      tx = api.tx.unique.createItem(collectionId, to, data as UpDataStructsCreateItemData);1482    }14831484    const events = await submitTransactionAsync(sender, tx);1485    const result = getCreateItemResult(events);14861487    const itemCountAfter = await getLastTokenId(api, collectionId);1488    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);14891490    if (createMode === 'NFT') {1491      expect(await api.rpc.unique.tokenProperties(collectionId, result.itemId)).not.to.be.empty;1492    }14931494    // What to expect1495    // tslint:disable-next-line:no-unused-expression1496    expect(result.success).to.be.true;1497    if (createMode === 'Fungible') {1498      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1499    } else {1500      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1501    }1502    expect(collectionId).to.be.equal(result.collectionId);1503    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1504    expect(to).to.be.deep.equal(result.recipient);1505    newItemId = result.itemId;1506  });1507  return newItemId;1508}15091510export async function createItemWithPropsExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, props: Array<Property>, owner: CrossAccountId | string = sender.address) {1511  await usingApi(async (api) => {15121513    let tx;1514    if (createMode === 'NFT') {1515      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}}) as UpDataStructsCreateItemData;1516      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), data);1517    } else {1518      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);1519    }152015211522    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1523    if(events.message && events.message.toString().indexOf('1002: Verification Error') > -1) return;1524    const result = getCreateItemResult(events);15251526    expect(result.success).to.be.false;1527  });1528}15291530export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1531  let newItemId = 0;1532  await usingApi(async (api) => {1533    const to = normalizeAccountId(owner);1534    const itemCountBefore = await getLastTokenId(api, collectionId);1535    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);15361537    let tx;1538    if (createMode === 'Fungible') {1539      const createData = {fungible: {value: 10}};1540      tx = api.tx.unique.createItem(collectionId, to, createData as any);1541    } else if (createMode === 'ReFungible') {1542      const createData = {refungible: {pieces: 100}};1543      tx = api.tx.unique.createItem(collectionId, to, createData as any);1544    } else {1545      const createData = {nft: {}};1546      tx = api.tx.unique.createItem(collectionId, to, createData as any);1547    }15481549    const events = await executeTransaction(api, sender, tx);1550    const result = getCreateItemResult(events);15511552    const itemCountAfter = await getLastTokenId(api, collectionId);1553    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);15541555    // What to expect1556    // tslint:disable-next-line:no-unused-expression1557    expect(result.success).to.be.true;1558    if (createMode === 'Fungible') {1559      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1560    } else {1561      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1562    }1563    expect(collectionId).to.be.equal(result.collectionId);1564    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1565    expect(to).to.be.deep.equal(result.recipient);1566    newItemId = result.itemId;1567  });1568  return newItemId;1569}15701571export async function createRefungibleToken(api: ApiPromise, sender: IKeyringPair, collectionId: number, amount: bigint, owner: CrossAccountId | IKeyringPair | string = sender.address) : Promise<CreateItemResult> {1572  const createData = {refungible: {pieces: amount}};1573  const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createData as any);15741575  const events = await submitTransactionAsync(sender, tx);1576  return  getCreateItemResult(events);1577}15781579export async function createItemExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1580  await usingApi(async (api) => {1581    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);15821583    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1584    const result = getCreateItemResult(events);15851586    expect(result.success).to.be.false;1587  });1588}15891590export async function setPublicAccessModeExpectSuccess(1591  sender: IKeyringPair, collectionId: number,1592  accessMode: 'Normal' | 'AllowList',1593) {1594  await usingApi(async (api) => {15951596    // Run the transaction1597    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});1598    const events = await submitTransactionAsync(sender, tx);1599    const result = getGenericResult(events);16001601    // Get the collection1602    const collection = await queryCollectionExpectSuccess(api, collectionId);16031604    // What to expect1605    // tslint:disable-next-line:no-unused-expression1606    expect(result.success).to.be.true;1607    expect(collection.permissions.access.toHuman()).to.be.equal(accessMode);1608  });1609}16101611export async function setPublicAccessModeExpectFail(1612  sender: IKeyringPair, collectionId: number,1613  accessMode: 'Normal' | 'AllowList',1614) {1615  await usingApi(async (api) => {16161617    // Run the transaction1618    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});1619    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1620    const result = getGenericResult(events);16211622    // What to expect1623    // tslint:disable-next-line:no-unused-expression1624    expect(result.success).to.be.false;1625  });1626}16271628export async function enableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1629  await setPublicAccessModeExpectSuccess(sender, collectionId, 'AllowList');1630}16311632export async function enableAllowListExpectFail(sender: IKeyringPair, collectionId: number) {1633  await setPublicAccessModeExpectFail(sender, collectionId, 'AllowList');1634}16351636export async function disableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1637  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');1638}16391640export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {1641  await usingApi(async (api) => {16421643    // Run the transaction1644    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1645    const events = await submitTransactionAsync(sender, tx);1646    const result = getGenericResult(events);1647    expect(result.success).to.be.true;16481649    // Get the collection1650    const collection = await queryCollectionExpectSuccess(api, collectionId);16511652    expect(collection.permissions.mintMode.toHuman()).to.be.equal(enabled);1653  });1654}16551656export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {1657  await setMintPermissionExpectSuccess(sender, collectionId, true);1658}16591660export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {1661  await usingApi(async (api) => {1662    // Run the transaction1663    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1664    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1665    const result = getCreateCollectionResult(events);1666    // tslint:disable-next-line:no-unused-expression1667    expect(result.success).to.be.false;1668  });1669}16701671export async function setChainLimitsExpectFailure(sender: IKeyringPair, limits: IChainLimits) {1672  await usingApi(async (api) => {1673    // Run the transaction1674    const tx = api.tx.unique.setChainLimits(limits);1675    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1676    const result = getCreateCollectionResult(events);1677    // tslint:disable-next-line:no-unused-expression1678    expect(result.success).to.be.false;1679  });1680}16811682export async function isAllowlisted(api: ApiPromise, collectionId: number, address: string | CrossAccountId | IKeyringPair) {1683  return (await api.rpc.unique.allowed(collectionId, normalizeAccountId(address))).toJSON();1684}16851686export async function addToAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId | CrossAccountId) {1687  await usingApi(async (api) => {1688    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.false;16891690    // Run the transaction1691    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1692    const events = await submitTransactionAsync(sender, tx);1693    const result = getGenericResult(events);1694    expect(result.success).to.be.true;16951696    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;1697  });1698}16991700export async function addToAllowListAgainExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1701  await usingApi(async (api) => {17021703    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;17041705    // Run the transaction1706    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1707    const events = await submitTransactionAsync(sender, tx);1708    const result = getGenericResult(events);1709    expect(result.success).to.be.true;17101711    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;1712  });1713}17141715export async function addToAllowListExpectFail(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1716  await usingApi(async (api) => {17171718    // Run the transaction1719    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1720    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1721    const result = getGenericResult(events);17221723    // What to expect1724    // tslint:disable-next-line:no-unused-expression1725    expect(result.success).to.be.false;1726  });1727}17281729export async function removeFromAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1730  await usingApi(async (api) => {1731    // Run the transaction1732    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1733    const events = await submitTransactionAsync(sender, tx);1734    const result = getGenericResult(events);17351736    // What to expect1737    // tslint:disable-next-line:no-unused-expression1738    expect(result.success).to.be.true;1739  });1740}17411742export async function removeFromAllowListExpectFailure(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1743  await usingApi(async (api) => {1744    // Run the transaction1745    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1746    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1747    const result = getGenericResult(events);17481749    // What to expect1750    // tslint:disable-next-line:no-unused-expression1751    expect(result.success).to.be.false;1752  });1753}17541755export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)1756  : Promise<UpDataStructsRpcCollection | null> => {1757  return (await api.rpc.unique.collectionById(collectionId)).unwrapOr(null);1758};17591760export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {1761  // set global object - collectionsCount1762  return (await api.rpc.unique.collectionStats()).created.toNumber();1763};17641765export async function queryCollectionExpectSuccess(api: ApiPromise, collectionId: number): Promise<UpDataStructsRpcCollection> {1766  return (await api.rpc.unique.collectionById(collectionId)).unwrap();1767}17681769export const describe_xcm = (1770  process.env.RUN_XCM_TESTS1771    ? describe1772    : describe.skip1773);17741775export async function waitNewBlocks(blocksCount = 1): Promise<void> {1776  await usingApi(async (api) => {1777    const promise = new Promise<void>(async (resolve) => {1778      const unsubscribe = await api.rpc.chain.subscribeNewHeads(() => {1779        if (blocksCount > 0) {1780          blocksCount--;1781        } else {1782          unsubscribe();1783          resolve();1784        }1785      });1786    });1787    return promise;1788  });1789}17901791export async function waitEvent(1792  api: ApiPromise,1793  maxBlocksToWait: number,1794  eventSection: string,1795  eventMethod: string,1796): Promise<EventRecord | null> {17971798  const promise = new Promise<EventRecord | null>(async (resolve) => {1799    const unsubscribe = await api.rpc.chain.subscribeNewHeads(async header => {1800      const blockNumber = header.number.toHuman();1801      const blockHash = header.hash;1802      const eventIdStr = `${eventSection}.${eventMethod}`;1803      const waitLimitStr = `wait blocks remaining: ${maxBlocksToWait}`;18041805      console.log(`[Block #${blockNumber}] Waiting for event \`${eventIdStr}\` (${waitLimitStr})`);18061807      const apiAt = await api.at(blockHash);1808      const eventRecords = await apiAt.query.system.events();18091810      const neededEvent = eventRecords.find(r => {1811        return r.event.section == eventSection && r.event.method == eventMethod;1812      });18131814      if (neededEvent) {1815        unsubscribe();1816        resolve(neededEvent);1817      } else if (maxBlocksToWait > 0) {1818        maxBlocksToWait--;1819      } else {1820        console.log(`Event \`${eventIdStr}\` is NOT found`);18211822        unsubscribe();1823        resolve(null);1824      }1825    });1826  });1827  return promise;1828}18291830export async function repartitionRFT(1831  api: ApiPromise,1832  collectionId: number,1833  sender: IKeyringPair,1834  tokenId: number,1835  amount: bigint,1836): Promise<boolean> {1837  const tx = api.tx.unique.repartition(collectionId, tokenId, amount);1838  const events = await submitTransactionAsync(sender, tx);1839  const result = getGenericResult(events);18401841  return result.success;1842}18431844export async function itApi(name: string, cb: (apis: { api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair }) => any, opts: { only?: boolean, skip?: boolean } = {}) {1845  let i: any = it;1846  if (opts.only) i = i.only;1847  else if (opts.skip) i = i.skip;1848  i(name, async () => {1849    await usingApi(async (api, privateKeyWrapper) => {1850      await cb({api, privateKeyWrapper});1851    });1852  });1853}18541855itApi.only = (name: string, cb: (apis: { api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair }) => any) => itApi(name, cb, {only: true});1856itApi.skip = (name: string, cb: (apis: { api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair }) => any) => itApi(name, cb, {skip: true});18571858let accountSeed = 10000;1859export function generateKeyringPair(keyring: Keyring) {1860  const privateKey = `0xDEADBEEF${(Date.now() + (accountSeed++)).toString(16).padStart(64 - 8, '0')}`;1861  return keyring.addFromUri(privateKey);1862}18631864export async function expectSubstrateEventsAtBlock(api: ApiPromise, blockNumber: AnyNumber | BlockNumber, section: string, methods: string[], dryRun = false) {1865  const blockHash = await api.rpc.chain.getBlockHash(blockNumber);1866  const subEvents = (await api.query.system.events.at(blockHash))1867    .filter(x => x.event.section === section)1868    .map((x) => x.toHuman());1869  const events = methods.map((m) => {1870    return {1871      event: {1872        method: m,1873        section,1874      },1875    };1876  });1877  if (!dryRun) {1878    expect(subEvents).to.be.like(events);1879  }1880  return subEvents;1881}