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

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};437438export async function439createCollection(440  api: ApiPromise,441  sender: IKeyringPair,442  params: Partial<CreateCollectionParams> = {},443): Promise<CreateCollectionResult> {444  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};445446  let modeprm = {};447  if (mode.type === 'NFT') {448    modeprm = {nft: null};449  } else if (mode.type === 'Fungible') {450    modeprm = {fungible: mode.decimalPoints};451  } else if (mode.type === 'ReFungible') {452    modeprm = {refungible: null};453  }454455  const tx = api.tx.unique.createCollectionEx({456    name: strToUTF16(name),457    description: strToUTF16(description),458    tokenPrefix: strToUTF16(tokenPrefix),459    mode: modeprm as any,460  });461  const events = await executeTransaction(api, sender, tx);462  return getCreateCollectionResult(events);463}464465export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {466  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};467468  let collectionId = 0;469  await usingApi(async (api, privateKeyWrapper) => {470    // Get number of collections before the transaction471    const collectionCountBefore = await getCreatedCollectionCount(api);472473    // Run the CreateCollection transaction474    const alicePrivateKey = privateKeyWrapper('//Alice');475476    const result = await createCollection(api, alicePrivateKey, params);477478    // Get number of collections after the transaction479    const collectionCountAfter = await getCreatedCollectionCount(api);480481    // Get the collection482    const collection = await queryCollectionExpectSuccess(api, result.collectionId);483484    // What to expect485    // tslint:disable-next-line:no-unused-expression486    expect(result.success).to.be.true;487    expect(result.collectionId).to.be.equal(collectionCountAfter);488    // tslint:disable-next-line:no-unused-expression489    expect(collection).to.be.not.null;490    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');491    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicePrivateKey));492    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);493    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);494    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);495496    collectionId = result.collectionId;497  });498499  return collectionId;500}501502export async function createCollectionWithPropsExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {503  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};504505  let collectionId = 0;506  await usingApi(async (api, privateKeyWrapper) => {507    // Get number of collections before the transaction508    const collectionCountBefore = await getCreatedCollectionCount(api);509510    // Run the CreateCollection transaction511    const alicePrivateKey = privateKeyWrapper('//Alice');512513    let modeprm = {};514    if (mode.type === 'NFT') {515      modeprm = {nft: null};516    } else if (mode.type === 'Fungible') {517      modeprm = {fungible: mode.decimalPoints};518    } else if (mode.type === 'ReFungible') {519      modeprm = {refungible: null};520    }521522    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});523    const events = await submitTransactionAsync(alicePrivateKey, tx);524    const result = getCreateCollectionResult(events);525526    // Get number of collections after the transaction527    const collectionCountAfter = await getCreatedCollectionCount(api);528529    // Get the collection530    const collection = await queryCollectionExpectSuccess(api, result.collectionId);531532    // What to expect533    // tslint:disable-next-line:no-unused-expression534    expect(result.success).to.be.true;535    expect(result.collectionId).to.be.equal(collectionCountAfter);536    // tslint:disable-next-line:no-unused-expression537    expect(collection).to.be.not.null;538    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');539    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicePrivateKey));540    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);541    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);542    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);543544545    collectionId = result.collectionId;546  });547548  return collectionId;549}550551export async function createCollectionWithPropsExpectFailure(params: Partial<CreateCollectionParams> = {}) {552  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};553554  await usingApi(async (api, privateKeyWrapper) => {555    // Get number of collections before the transaction556    const collectionCountBefore = await getCreatedCollectionCount(api);557558    // Run the CreateCollection transaction559    const alicePrivateKey = privateKeyWrapper('//Alice');560561    let modeprm = {};562    if (mode.type === 'NFT') {563      modeprm = {nft: null};564    } else if (mode.type === 'Fungible') {565      modeprm = {fungible: mode.decimalPoints};566    } else if (mode.type === 'ReFungible') {567      modeprm = {refungible: null};568    }569570    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});571    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;572573574    // Get number of collections after the transaction575    const collectionCountAfter = await getCreatedCollectionCount(api);576577    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');578  });579}580581export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {582  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};583584  let modeprm = {};585  if (mode.type === 'NFT') {586    modeprm = {nft: null};587  } else if (mode.type === 'Fungible') {588    modeprm = {fungible: mode.decimalPoints};589  } else if (mode.type === 'ReFungible') {590    modeprm = {refungible: null};591  }592593  await usingApi(async (api, privateKeyWrapper) => {594    // Get number of collections before the transaction595    const collectionCountBefore = await getCreatedCollectionCount(api);596597    // Run the CreateCollection transaction598    const alicePrivateKey = privateKeyWrapper('//Alice');599    const tx = api.tx.unique.createCollectionEx({name: strToUTF16(name), description: strToUTF16(description), tokenPrefix: strToUTF16(tokenPrefix), mode: modeprm as any});600    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;601602    // Get number of collections after the transaction603    const collectionCountAfter = await getCreatedCollectionCount(api);604605    // What to expect606    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');607  });608}609610export async function findUnusedAddress(api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair, seedAddition = ''): Promise<IKeyringPair> {611  let bal = 0n;612  let unused;613  do {614    const randomSeed = 'seed' + Math.floor(Math.random() * Math.floor(10000)) + seedAddition;615    unused = privateKeyWrapper(`//${randomSeed}`);616    bal = (await api.query.system.account(unused.address)).data.free.toBigInt();617  } while (bal !== 0n);618  return unused;619}620621export async function getAllowance(api: ApiPromise, collectionId: number, owner: CrossAccountId | string | IKeyringPair, approved: CrossAccountId | string | IKeyringPair, tokenId: number) {622  return (await api.rpc.unique.allowance(collectionId, normalizeAccountId(owner), normalizeAccountId(approved), tokenId)).toBigInt();623}624625export function findUnusedAddresses(api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair, amount: number): Promise<IKeyringPair[]> {626  return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, privateKeyWrapper, '_' + Date.now())));627}628629export async function findNotExistingCollection(api: ApiPromise): Promise<number> {630  const totalNumber = await getCreatedCollectionCount(api);631  const newCollection: number = totalNumber + 1;632  return newCollection;633}634635function getDestroyResult(events: EventRecord[]): boolean {636  let success = false;637  events.forEach(({event: {method}}) => {638    if (method == 'ExtrinsicSuccess') {639      success = true;640    }641  });642  return success;643}644645export async function destroyCollectionExpectFailure(collectionId: number, senderSeed = '//Alice') {646  await usingApi(async (api, privateKeyWrapper) => {647    // Run the DestroyCollection transaction648    const alicePrivateKey = privateKeyWrapper(senderSeed);649    const tx = api.tx.unique.destroyCollection(collectionId);650    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;651  });652}653654export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed = '//Alice') {655  await usingApi(async (api, privateKeyWrapper) => {656    // Run the DestroyCollection transaction657    const alicePrivateKey = privateKeyWrapper(senderSeed);658    const tx = api.tx.unique.destroyCollection(collectionId);659    const events = await submitTransactionAsync(alicePrivateKey, tx);660    const result = getDestroyResult(events);661    expect(result).to.be.true;662663    // What to expect664    expect(await getDetailedCollectionInfo(api, collectionId)).to.be.null;665  });666}667668export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {669  await usingApi(async (api) => {670    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);671    const events = await submitTransactionAsync(sender, tx);672    const result = getGenericResult(events);673674    expect(result.success).to.be.true;675  });676}677678export const setCollectionPermissionsExpectSuccess = async (sender: IKeyringPair, collectionId: number, permissions: any) => {679  await usingApi(async(api) => {680    const tx = api.tx.unique.setCollectionPermissions(collectionId, permissions);681    const events = await submitTransactionAsync(sender, tx);682    const result = getGenericResult(events);683684    expect(result.success).to.be.true;685  });686};687688export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {689  await usingApi(async (api) => {690    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);691    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;692    const result = getGenericResult(events);693694    expect(result.success).to.be.false;695  });696}697698export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string, sender = '//Alice') {699  await usingApi(async (api, privateKeyWrapper) => {700701    // Run the transaction702    const senderPrivateKey = privateKeyWrapper(sender);703    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);704    const events = await submitTransactionAsync(senderPrivateKey, tx);705    const result = getGenericResult(events);706707    // Get the collection708    const collection = await queryCollectionExpectSuccess(api, collectionId);709710    // What to expect711    expect(result.success).to.be.true;712    expect(collection.sponsorship.toJSON()).to.deep.equal({713      unconfirmed: sponsor,714    });715  });716}717718export async function removeCollectionSponsorExpectSuccess(collectionId: number, sender = '//Alice') {719  await usingApi(async (api, privateKeyWrapper) => {720721    // Run the transaction722    const alicePrivateKey = privateKeyWrapper(sender);723    const tx = api.tx.unique.removeCollectionSponsor(collectionId);724    const events = await submitTransactionAsync(alicePrivateKey, tx);725    const result = getGenericResult(events);726727    // Get the collection728    const collection = await queryCollectionExpectSuccess(api, collectionId);729730    // What to expect731    expect(result.success).to.be.true;732    expect(collection.sponsorship.toJSON()).to.be.deep.equal({disabled: null});733  });734}735736export async function removeCollectionSponsorExpectFailure(collectionId: number, senderSeed = '//Alice') {737  await usingApi(async (api, privateKeyWrapper) => {738739    // Run the transaction740    const alicePrivateKey = privateKeyWrapper(senderSeed);741    const tx = api.tx.unique.removeCollectionSponsor(collectionId);742    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;743  });744}745746export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed = '//Alice') {747  await usingApi(async (api, privateKeyWrapper) => {748749    // Run the transaction750    const alicePrivateKey = privateKeyWrapper(senderSeed);751    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);752    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;753  });754}755756export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed = '//Alice') {757  await usingApi(async (api, privateKeyWrapper) => {758759    // Run the transaction760    const sender = privateKeyWrapper(senderSeed);761    await confirmSponsorshipByKeyExpectSuccess(collectionId, sender);762  });763}764765export async function confirmSponsorshipByKeyExpectSuccess(collectionId: number, sender: IKeyringPair) {766  await usingApi(async (api, privateKeyWrapper) => {767768    // Run the transaction769    const tx = api.tx.unique.confirmSponsorship(collectionId);770    const events = await submitTransactionAsync(sender, tx);771    const result = getGenericResult(events);772773    // Get the collection774    const collection = await queryCollectionExpectSuccess(api, collectionId);775776    // What to expect777    expect(result.success).to.be.true;778    expect(collection.sponsorship.toJSON()).to.be.deep.equal({779      confirmed: sender.address,780    });781  });782}783784785export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed = '//Alice') {786  await usingApi(async (api, privateKeyWrapper) => {787788    // Run the transaction789    const sender = privateKeyWrapper(senderSeed);790    const tx = api.tx.unique.confirmSponsorship(collectionId);791    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;792  });793}794795export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {796  await usingApi(async (api) => {797    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);798    const events = await submitTransactionAsync(sender, tx);799    const result = getGenericResult(events);800801    expect(result.success).to.be.true;802  });803}804805export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {806  await usingApi(async (api) => {807    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);808    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;809    const result = getGenericResult(events);810811    expect(result.success).to.be.false;812  });813}814815export async function setTransferFlagExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {816817  await usingApi(async (api) => {818819    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);820    const events = await submitTransactionAsync(sender, tx);821    const result = getGenericResult(events);822823    expect(result.success).to.be.true;824  });825}826827export async function setTransferFlagExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {828829  await usingApi(async (api) => {830831    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);832    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;833    const result = getGenericResult(events);834835    expect(result.success).to.be.false;836  });837}838839export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {840  await usingApi(async (api) => {841    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);842    const events = await submitTransactionAsync(sender, tx);843    const result = getGenericResult(events);844845    expect(result.success).to.be.true;846  });847}848849export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {850  await usingApi(async (api) => {851    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);852    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;853    const result = getGenericResult(events);854855    expect(result.success).to.be.false;856  });857}858859export async function getNextSponsored(860  api: ApiPromise,861  collectionId: number,862  account: string | CrossAccountId,863  tokenId: number,864): Promise<number> {865  return Number((await api.rpc.unique.nextSponsored(collectionId, account, tokenId)).unwrapOr(-1));866}867868export async function toggleContractAllowlistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, value = true) {869  await usingApi(async (api) => {870    const tx = api.tx.unique.toggleContractAllowList(contractAddress, value);871    const events = await submitTransactionAsync(sender, tx);872    const result = getGenericResult(events);873874    expect(result.success).to.be.true;875  });876}877878export async function isAllowlistedInContract(contractAddress: AccountId | string, user: string) {879  let allowlisted = false;880  await usingApi(async (api) => {881    allowlisted = (await api.query.unique.contractAllowList(contractAddress, user)).toJSON() as boolean;882  });883  return allowlisted;884}885886export async function addToContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {887  await usingApi(async (api) => {888    const tx = api.tx.unique.addToContractAllowList(contractAddress.toString(), user.toString());889    const events = await submitTransactionAsync(sender, tx);890    const result = getGenericResult(events);891892    expect(result.success).to.be.true;893  });894}895896export async function removeFromContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {897  await usingApi(async (api) => {898    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());899    const events = await submitTransactionAsync(sender, tx);900    const result = getGenericResult(events);901902    expect(result.success).to.be.true;903  });904}905906export async function removeFromContractAllowListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {907  await usingApi(async (api) => {908    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());909    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;910    const result = getGenericResult(events);911912    expect(result.success).to.be.false;913  });914}915916export interface CreateFungibleData {917  readonly Value: bigint;918}919920export interface CreateReFungibleData { }921export interface CreateNftData { }922923export type CreateItemData = {924  NFT: CreateNftData;925} | {926  Fungible: CreateFungibleData;927} | {928  ReFungible: CreateReFungibleData;929};930931export async function burnItem(api: ApiPromise, sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint) : Promise<boolean> {932  const tx = api.tx.unique.burnItem(collectionId, tokenId, value);933  const events = await submitTransactionAsync(sender, tx);934  return getGenericResult(events).success;935}936937export async function burnItemExpectSuccess(sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint = 1) {938  await usingApi(async (api) => {939    const balanceBefore = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);940    // if burning token by admin - use adminButnItemExpectSuccess941    expect(balanceBefore >= BigInt(value)).to.be.true;942943    expect(await burnItem(api, sender, collectionId, tokenId, value)).to.be.true;944945    const balanceAfter = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);946    expect(balanceAfter + BigInt(value)).to.be.equal(balanceBefore);947  });948}949950export async function burnItemExpectFailure(sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint = 1) {951  await usingApi(async (api) => {952    const tx = api.tx.unique.burnItem(collectionId, tokenId, value);953954    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;955    const result = getCreateCollectionResult(events);956    // tslint:disable-next-line:no-unused-expression957    expect(result.success).to.be.false;958  });959}960961export async function burnFromExpectSuccess(sender: IKeyringPair, from: IKeyringPair | CrossAccountId, collectionId: number, tokenId: number, value: number | bigint = 1) {962  await usingApi(async (api) => {963    const tx = api.tx.unique.burnFrom(collectionId, normalizeAccountId(from), tokenId, value);964    const events = await submitTransactionAsync(sender, tx);965    return getGenericResult(events).success;966  });967}968969export async function970approve(971  api: ApiPromise,972  collectionId: number,973  tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string | IKeyringPair, amount: number | bigint,974) {975  const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);976  const events = await submitTransactionAsync(owner, approveUniqueTx);977  return getGenericResult(events).success;978}979980export async function981approveExpectSuccess(982  collectionId: number,983  tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string, amount: number | bigint = 1,984) {985  await usingApi(async (api: ApiPromise) => {986    const result = await approve(api, collectionId, tokenId, owner, approved, amount);987    expect(result).to.be.true;988989    expect(await getAllowance(api, collectionId, owner, approved, tokenId)).to.be.equal(BigInt(amount));990  });991}992993export async function adminApproveFromExpectSuccess(994  collectionId: number,995  tokenId: number, admin: IKeyringPair, owner: CrossAccountId | string, approved: CrossAccountId | string, amount: number | bigint = 1,996) {997  await usingApi(async (api: ApiPromise) => {998    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);999    const events = await submitTransactionAsync(admin, approveUniqueTx);1000    const result = getGenericResult(events);1001    expect(result.success).to.be.true;10021003    expect(await getAllowance(api, collectionId, owner, approved, tokenId)).to.be.equal(BigInt(amount));1004  });1005}10061007export async function1008transferFrom(1009  api: ApiPromise,1010  collectionId: number,1011  tokenId: number,1012  accountApproved: IKeyringPair,1013  accountFrom: IKeyringPair | CrossAccountId,1014  accountTo: IKeyringPair | CrossAccountId,1015  value: number | bigint,1016) {1017  const from = normalizeAccountId(accountFrom);1018  const to = normalizeAccountId(accountTo);1019  const transferFromTx = api.tx.unique.transferFrom(from, to, collectionId, tokenId, value);1020  const events = await submitTransactionAsync(accountApproved, transferFromTx);1021  return getGenericResult(events).success;1022}10231024export async function1025transferFromExpectSuccess(1026  collectionId: number,1027  tokenId: number,1028  accountApproved: IKeyringPair,1029  accountFrom: IKeyringPair | CrossAccountId,1030  accountTo: IKeyringPair | CrossAccountId,1031  value: number | bigint = 1,1032  type = 'NFT',1033) {1034  await usingApi(async (api: ApiPromise) => {1035    const from = normalizeAccountId(accountFrom);1036    const to = normalizeAccountId(accountTo);1037    let balanceBefore = 0n;1038    if (type === 'Fungible' || type === 'ReFungible') {1039      balanceBefore = await getBalance(api, collectionId, to, tokenId);1040    }1041    expect(await transferFrom(api, collectionId, tokenId, accountApproved, accountFrom, accountTo, value)).to.be.true;1042    if (type === 'NFT') {1043      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);1044    }1045    if (type === 'Fungible') {1046      const balanceAfter = await getBalance(api, collectionId, to, tokenId);1047      if (JSON.stringify(to) !== JSON.stringify(from)) {1048        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));1049      } else {1050        expect(balanceAfter).to.be.equal(balanceBefore);1051      }1052    }1053    if (type === 'ReFungible') {1054      expect(await getBalance(api, collectionId, to, tokenId)).to.be.equal(balanceBefore + BigInt(value));1055    }1056  });1057}10581059export async function1060transferFromExpectFail(1061  collectionId: number,1062  tokenId: number,1063  accountApproved: IKeyringPair,1064  accountFrom: IKeyringPair,1065  accountTo: IKeyringPair,1066  value: number | bigint = 1,1067) {1068  await usingApi(async (api: ApiPromise) => {1069    const transferFromTx = api.tx.unique.transferFrom(normalizeAccountId(accountFrom.address), normalizeAccountId(accountTo.address), collectionId, tokenId, value);1070    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;1071    const result = getCreateCollectionResult(events);1072    // tslint:disable-next-line:no-unused-expression1073    expect(result.success).to.be.false;1074  });1075}10761077/* eslint no-async-promise-executor: "off" */1078export async function getBlockNumber(api: ApiPromise): Promise<number> {1079  return new Promise<number>(async (resolve) => {1080    const unsubscribe = await api.rpc.chain.subscribeNewHeads((head) => {1081      unsubscribe();1082      resolve(head.number.toNumber());1083    });1084  });1085}10861087export async function addCollectionAdminExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | CrossAccountId) {1088  await usingApi(async (api) => {1089    const changeAdminTx = api.tx.unique.addCollectionAdmin(collectionId, normalizeAccountId(address));1090    const events = await submitTransactionAsync(sender, changeAdminTx);1091    const result = getCreateCollectionResult(events);1092    expect(result.success).to.be.true;1093  });1094}10951096export async function adminApproveFromExpectFail(1097  collectionId: number,1098  tokenId: number, admin: IKeyringPair, owner: CrossAccountId | string, approved: CrossAccountId | string, amount: number | bigint = 1,1099) {1100  await usingApi(async (api: ApiPromise) => {1101    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);1102    const events = await expect(submitTransactionAsync(admin, approveUniqueTx)).to.be.rejected;1103    const result = getGenericResult(events);1104    expect(result.success).to.be.false;1105  });1106}11071108export async function1109getFreeBalance(account: IKeyringPair): Promise<bigint> {1110  let balance = 0n;1111  await usingApi(async (api) => {1112    balance = BigInt((await api.query.system.account(account.address)).data.free.toString());1113  });11141115  return balance;1116}11171118export async function paraSiblingSovereignAccount(paraid: number): Promise<string> {1119  return usingApi(async api => {1120    // We are getting a *sibling* parachain sovereign account,1121    // so we need a sibling prefix: encoded(b"sibl") == 0x7369626c1122    const siblingPrefix = '0x7369626c';11231124    const encodedParaId = api.createType('u32', paraid).toHex(true).substring(2);1125    const suffix = '000000000000000000000000000000000000000000000000';11261127    return siblingPrefix + encodedParaId + suffix;1128  });1129}11301131export async function transferBalanceTo(api: ApiPromise, source: IKeyringPair, target: string, amount = 1000n * UNIQUE) {1132  const tx = api.tx.balances.transfer(target, amount);1133  const events = await submitTransactionAsync(source, tx);1134  const result = getGenericResult(events);1135  expect(result.success).to.be.true;1136}11371138export async function scheduleAt(1139  api: ApiPromise,1140  operationTx: any,1141  sender: IKeyringPair,1142  executionBlockNumber: number,1143  scheduledId: string,1144  period = 1,1145  repetitions = 1,1146): Promise<any> {1147  const scheduleTx = api.tx.scheduler.scheduleNamed(1148    scheduledId,1149    executionBlockNumber, 1150    repetitions > 1 ? [period, repetitions] : null, 1151    0, 1152    {Value: operationTx as any},1153  );11541155  return executeTransaction(api, sender, scheduleTx);1156}11571158export async function scheduleAfter(1159  api: ApiPromise,1160  operationTx: any,1161  sender: IKeyringPair,1162  blocksBeforeExecution: number,1163  scheduledId: string,1164  period = 1,1165  repetitions = 1,1166): Promise<any> {1167  const scheduleTx = api.tx.scheduler.scheduleNamedAfter(1168    scheduledId,1169    blocksBeforeExecution, 1170    repetitions > 1 ? [period, repetitions] : null, 1171    0, 1172    {Value: operationTx as any},1173  );11741175  return executeTransaction(api, sender, scheduleTx);1176}11771178export async function cancelScheduled(1179  api: ApiPromise,1180  sender: IKeyringPair,1181  scheduledId: string,1182): Promise<any> {1183  const cancelTx = api.tx.scheduler.cancelNamed(scheduledId);1184  return executeTransaction(api, sender, cancelTx);1185}11861187export async function1188scheduleTransferExpectSuccess(1189  api: ApiPromise,1190  collectionId: number,1191  tokenId: number,1192  sender: IKeyringPair,1193  recipient: IKeyringPair,1194  transferAmount: number | bigint = 1,1195  blocksBeforeExecution: number,1196  scheduledId: string,1197  scheduleMethod: 'at' | 'after' = 'at',1198) {1199  const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, transferAmount);12001201  if (scheduleMethod == 'at') {1202    const blockNumber: number | undefined = await getBlockNumber(api);1203    const expectedBlockNumber = blockNumber + blocksBeforeExecution;1204    //expect(expectedBlockNumber).to.be.greaterThan(0);12051206    await expect(scheduleAt(api, transferTx, sender, expectedBlockNumber, scheduledId)).to.not.be.rejected;1207  } else {1208    await expect(scheduleAfter(api, transferTx, sender, blocksBeforeExecution, scheduledId)).to.not.be.rejected;1209  }12101211  expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(sender.address));1212}12131214export async function1215scheduleTransferAndWaitExpectSuccess(1216  api: ApiPromise,1217  collectionId: number,1218  tokenId: number,1219  sender: IKeyringPair,1220  recipient: IKeyringPair,1221  transferAmount: number | bigint = 1,1222  blocksBeforeExecution: number,1223  scheduledId: string,1224  scheduleMethod: 'at' | 'after' = 'at',1225) {1226  await scheduleTransferExpectSuccess(1227    api, 1228    collectionId, 1229    tokenId, 1230    sender, 1231    recipient, 1232    transferAmount, 1233    blocksBeforeExecution, 1234    scheduledId, 1235    scheduleMethod,1236  );12371238  const recipientBalanceBefore = await getFreeBalance(recipient);12391240  // sleep for n + 1 blocks1241  await waitNewBlocks(blocksBeforeExecution + 1);12421243  const recipientBalanceAfter = await getFreeBalance(recipient);12441245  expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(recipient.address));1246  expect(recipientBalanceAfter).to.be.equal(recipientBalanceBefore);1247}12481249export async function1250scheduleTransferFundsExpectSuccess(1251  api: ApiPromise,1252  amount: bigint,1253  sender: IKeyringPair,1254  recipient: IKeyringPair,1255  blocksBeforeExecution: number,1256  scheduledId: string,1257  period = 1,1258  repetitions = 1,1259) {1260  const transferTx = api.tx.balances.transfer(recipient.address, amount);12611262<<<<<<< HEAD1263    const balanceBefore = await getFreeBalance(recipient);12641265    await scheduleExpectSuccess(transferTx, sender, blockSchedule, scheduledId, period, repetitions);1266=======1267  const balanceBefore = await getFreeBalance(recipient);1268  1269  await expect(scheduleAfter(api, transferTx, sender, blocksBeforeExecution, scheduledId, period, repetitions)).to.not.be.rejected;1270>>>>>>> test(scheduler): enable and add more coverage, leave sponsorship disabled12711272  expect(await getFreeBalance(recipient)).to.be.equal(balanceBefore);1273}12741275export async function1276transfer(1277  api: ApiPromise,1278  collectionId: number,1279  tokenId: number,1280  sender: IKeyringPair,1281  recipient: IKeyringPair | CrossAccountId,1282  value: number | bigint,1283) : Promise<boolean> {1284  const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1285  const events = await executeTransaction(api, sender, transferTx);1286  return getGenericResult(events).success;1287}12881289export async function1290transferExpectSuccess(1291  collectionId: number,1292  tokenId: number,1293  sender: IKeyringPair,1294  recipient: IKeyringPair | CrossAccountId,1295  value: number | bigint = 1,1296  type = 'NFT',1297) {1298  await usingApi(async (api: ApiPromise) => {1299    const from = normalizeAccountId(sender);1300    const to = normalizeAccountId(recipient);13011302    let balanceBefore = 0n;1303    if (type === 'Fungible' || type === 'ReFungible') {1304      balanceBefore = await getBalance(api, collectionId, to, tokenId);1305    }13061307    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1308    const events = await executeTransaction(api, sender, transferTx);1309    const result = getTransferResult(api, events);13101311    expect(result.collectionId).to.be.equal(collectionId);1312    expect(result.itemId).to.be.equal(tokenId);1313    expect(result.sender).to.be.deep.equal(normalizeAccountId(sender.address));1314    expect(result.recipient).to.be.deep.equal(to);1315    expect(result.value).to.be.equal(BigInt(value));13161317    if (type === 'NFT') {1318      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);1319    }1320    if (type === 'Fungible' || type === 'ReFungible') {1321      const balanceAfter = await getBalance(api, collectionId, to, tokenId);1322      if (JSON.stringify(to) !== JSON.stringify(from)) {1323        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));1324      } else {1325        expect(balanceAfter).to.be.equal(balanceBefore);1326      }1327    }1328  });1329}13301331export async function1332transferExpectFailure(1333  collectionId: number,1334  tokenId: number,1335  sender: IKeyringPair,1336  recipient: IKeyringPair | CrossAccountId,1337  value: number | bigint = 1,1338) {1339  await usingApi(async (api: ApiPromise) => {1340    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1341    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;1342    const result = getGenericResult(events);1343    // if (events && Array.isArray(events)) {1344    //   const result = getCreateCollectionResult(events);1345    // tslint:disable-next-line:no-unused-expression1346    expect(result.success).to.be.false;1347    //}1348  });1349}13501351export async function1352approveExpectFail(1353  collectionId: number,1354  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1,1355) {1356  await usingApi(async (api: ApiPromise) => {1357    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved.address), collectionId, tokenId, amount);1358    const events = await expect(submitTransactionExpectFailAsync(owner, approveUniqueTx)).to.be.rejected;1359    const result = getCreateCollectionResult(events);1360    // tslint:disable-next-line:no-unused-expression1361    expect(result.success).to.be.false;1362  });1363}13641365export async function getBalance(1366  api: ApiPromise,1367  collectionId: number,1368  owner: string | CrossAccountId | IKeyringPair,1369  token: number,1370): Promise<bigint> {1371  return (await api.rpc.unique.balance(collectionId, normalizeAccountId(owner), token)).toBigInt();1372}1373export async function getTokenOwner(1374  api: ApiPromise,1375  collectionId: number,1376  token: number,1377): Promise<CrossAccountId> {1378  const owner = (await api.rpc.unique.tokenOwner(collectionId, token)).toJSON() as any;1379  if (owner == null) throw new Error('owner == null');1380  return normalizeAccountId(owner);1381}1382export async function getTopmostTokenOwner(1383  api: ApiPromise,1384  collectionId: number,1385  token: number,1386): Promise<CrossAccountId> {1387  const owner = (await api.rpc.unique.topmostTokenOwner(collectionId, token)).toJSON() as any;1388  if (owner == null) throw new Error('owner == null');1389  return normalizeAccountId(owner);1390}1391export async function getTokenChildren(1392  api: ApiPromise,1393  collectionId: number,1394  tokenId: number,1395): Promise<UpDataStructsTokenChild[]> {1396  return (await api.rpc.unique.tokenChildren(collectionId, tokenId)).toJSON() as any;1397}1398export async function isTokenExists(1399  api: ApiPromise,1400  collectionId: number,1401  token: number,1402): Promise<boolean> {1403  return (await api.rpc.unique.tokenExists(collectionId, token)).toJSON();1404}1405export async function getLastTokenId(1406  api: ApiPromise,1407  collectionId: number,1408): Promise<number> {1409  return (await api.rpc.unique.lastTokenId(collectionId)).toJSON();1410}1411export async function getAdminList(1412  api: ApiPromise,1413  collectionId: number,1414): Promise<string[]> {1415  return (await api.rpc.unique.adminlist(collectionId)).toHuman() as any;1416}1417export async function getTokenProperties(1418  api: ApiPromise,1419  collectionId: number,1420  tokenId: number,1421  propertyKeys: string[],1422): Promise<UpDataStructsProperty[]> {1423  return (await api.rpc.unique.tokenProperties(collectionId, tokenId, propertyKeys)).toHuman() as any;1424}14251426export async function createFungibleItemExpectSuccess(1427  sender: IKeyringPair,1428  collectionId: number,1429  data: CreateFungibleData,1430  owner: CrossAccountId | string = sender.address,1431) {1432  return await usingApi(async (api) => {1433    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), {Fungible: data});14341435    const events = await submitTransactionAsync(sender, tx);1436    const result = getCreateItemResult(events);14371438    expect(result.success).to.be.true;1439    return result.itemId;1440  });1441}14421443export async function createMultipleItemsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any, owner: CrossAccountId | string = sender.address) {1444  await usingApi(async (api) => {1445    const to = normalizeAccountId(owner);1446    const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);14471448    const events = await submitTransactionAsync(sender, tx);1449    expect(getGenericResult(events).success).to.be.true;1450  });1451}14521453export async function createMultipleItemsWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any, owner: CrossAccountId | string = sender.address) {1454  await usingApi(async (api) => {1455    const to = normalizeAccountId(owner);1456    const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);14571458    const events = await submitTransactionAsync(sender, tx);1459    const result = getCreateItemsResult(events);14601461    for (const res of result) {1462      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1463    }1464  });1465}14661467export async function createMultipleItemsExWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any) {1468  await usingApi(async (api) => {1469    const tx = api.tx.unique.createMultipleItemsEx(collectionId, itemsData);14701471    const events = await submitTransactionAsync(sender, tx);1472    const result = getCreateItemsResult(events);14731474    for (const res of result) {1475      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1476    }1477  });1478}14791480export async function createItemWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, props:  Array<Property>, owner: CrossAccountId | string = sender.address) {1481  let newItemId = 0;1482  await usingApi(async (api) => {1483    const to = normalizeAccountId(owner);1484    const itemCountBefore = await getLastTokenId(api, collectionId);1485    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);14861487    let tx;1488    if (createMode === 'Fungible') {1489      const createData = {fungible: {value: 10}};1490      tx = api.tx.unique.createItem(collectionId, to, createData as any);1491    } else if (createMode === 'ReFungible') {1492      const createData = {refungible: {pieces: 100}};1493      tx = api.tx.unique.createItem(collectionId, to, createData as any);1494    } else {1495      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}});1496      tx = api.tx.unique.createItem(collectionId, to, data as UpDataStructsCreateItemData);1497    }14981499    const events = await submitTransactionAsync(sender, tx);1500    const result = getCreateItemResult(events);15011502    const itemCountAfter = await getLastTokenId(api, collectionId);1503    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);15041505    if (createMode === 'NFT') {1506      expect(await api.rpc.unique.tokenProperties(collectionId, result.itemId)).not.to.be.empty;1507    }15081509    // What to expect1510    // tslint:disable-next-line:no-unused-expression1511    expect(result.success).to.be.true;1512    if (createMode === 'Fungible') {1513      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1514    } else {1515      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1516    }1517    expect(collectionId).to.be.equal(result.collectionId);1518    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1519    expect(to).to.be.deep.equal(result.recipient);1520    newItemId = result.itemId;1521  });1522  return newItemId;1523}15241525export async function createItemWithPropsExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, props: Array<Property>, owner: CrossAccountId | string = sender.address) {1526  await usingApi(async (api) => {15271528    let tx;1529    if (createMode === 'NFT') {1530      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}}) as UpDataStructsCreateItemData;1531      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), data);1532    } else {1533      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);1534    }153515361537    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1538    if(events.message && events.message.toString().indexOf('1002: Verification Error') > -1) return;1539    const result = getCreateItemResult(events);15401541    expect(result.success).to.be.false;1542  });1543}15441545export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1546  let newItemId = 0;1547  await usingApi(async (api) => {1548    const to = normalizeAccountId(owner);1549    const itemCountBefore = await getLastTokenId(api, collectionId);1550    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);15511552    let tx;1553    if (createMode === 'Fungible') {1554      const createData = {fungible: {value: 10}};1555      tx = api.tx.unique.createItem(collectionId, to, createData as any);1556    } else if (createMode === 'ReFungible') {1557      const createData = {refungible: {pieces: 100}};1558      tx = api.tx.unique.createItem(collectionId, to, createData as any);1559    } else {1560      const createData = {nft: {}};1561      tx = api.tx.unique.createItem(collectionId, to, createData as any);1562    }15631564    const events = await executeTransaction(api, sender, tx);1565    const result = getCreateItemResult(events);15661567    const itemCountAfter = await getLastTokenId(api, collectionId);1568    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);15691570    // What to expect1571    // tslint:disable-next-line:no-unused-expression1572    expect(result.success).to.be.true;1573    if (createMode === 'Fungible') {1574      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1575    } else {1576      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1577    }1578    expect(collectionId).to.be.equal(result.collectionId);1579    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1580    expect(to).to.be.deep.equal(result.recipient);1581    newItemId = result.itemId;1582  });1583  return newItemId;1584}15851586export async function createRefungibleToken(api: ApiPromise, sender: IKeyringPair, collectionId: number, amount: bigint, owner: CrossAccountId | IKeyringPair | string = sender.address) : Promise<CreateItemResult> {1587  const createData = {refungible: {pieces: amount}};1588  const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createData as any);15891590  const events = await submitTransactionAsync(sender, tx);1591  return  getCreateItemResult(events);1592}15931594export async function createItemExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1595  await usingApi(async (api) => {1596    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);15971598    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1599    const result = getCreateItemResult(events);16001601    expect(result.success).to.be.false;1602  });1603}16041605export async function setPublicAccessModeExpectSuccess(1606  sender: IKeyringPair, collectionId: number,1607  accessMode: 'Normal' | 'AllowList',1608) {1609  await usingApi(async (api) => {16101611    // Run the transaction1612    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});1613    const events = await submitTransactionAsync(sender, tx);1614    const result = getGenericResult(events);16151616    // Get the collection1617    const collection = await queryCollectionExpectSuccess(api, collectionId);16181619    // What to expect1620    // tslint:disable-next-line:no-unused-expression1621    expect(result.success).to.be.true;1622    expect(collection.permissions.access.toHuman()).to.be.equal(accessMode);1623  });1624}16251626export async function setPublicAccessModeExpectFail(1627  sender: IKeyringPair, collectionId: number,1628  accessMode: 'Normal' | 'AllowList',1629) {1630  await usingApi(async (api) => {16311632    // Run the transaction1633    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});1634    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1635    const result = getGenericResult(events);16361637    // What to expect1638    // tslint:disable-next-line:no-unused-expression1639    expect(result.success).to.be.false;1640  });1641}16421643export async function enableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1644  await setPublicAccessModeExpectSuccess(sender, collectionId, 'AllowList');1645}16461647export async function enableAllowListExpectFail(sender: IKeyringPair, collectionId: number) {1648  await setPublicAccessModeExpectFail(sender, collectionId, 'AllowList');1649}16501651export async function disableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1652  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');1653}16541655export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {1656  await usingApi(async (api) => {16571658    // Run the transaction1659    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1660    const events = await submitTransactionAsync(sender, tx);1661    const result = getGenericResult(events);1662    expect(result.success).to.be.true;16631664    // Get the collection1665    const collection = await queryCollectionExpectSuccess(api, collectionId);16661667    expect(collection.permissions.mintMode.toHuman()).to.be.equal(enabled);1668  });1669}16701671export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {1672  await setMintPermissionExpectSuccess(sender, collectionId, true);1673}16741675export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {1676  await usingApi(async (api) => {1677    // Run the transaction1678    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1679    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1680    const result = getCreateCollectionResult(events);1681    // tslint:disable-next-line:no-unused-expression1682    expect(result.success).to.be.false;1683  });1684}16851686export async function setChainLimitsExpectFailure(sender: IKeyringPair, limits: IChainLimits) {1687  await usingApi(async (api) => {1688    // Run the transaction1689    const tx = api.tx.unique.setChainLimits(limits);1690    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1691    const result = getCreateCollectionResult(events);1692    // tslint:disable-next-line:no-unused-expression1693    expect(result.success).to.be.false;1694  });1695}16961697export async function isAllowlisted(api: ApiPromise, collectionId: number, address: string | CrossAccountId | IKeyringPair) {1698  return (await api.rpc.unique.allowed(collectionId, normalizeAccountId(address))).toJSON();1699}17001701export async function addToAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId | CrossAccountId) {1702  await usingApi(async (api) => {1703    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.false;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 addToAllowListAgainExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1716  await usingApi(async (api) => {17171718    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;17191720    // Run the transaction1721    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1722    const events = await submitTransactionAsync(sender, tx);1723    const result = getGenericResult(events);1724    expect(result.success).to.be.true;17251726    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;1727  });1728}17291730export async function addToAllowListExpectFail(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1731  await usingApi(async (api) => {17321733    // Run the transaction1734    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1735    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1736    const result = getGenericResult(events);17371738    // What to expect1739    // tslint:disable-next-line:no-unused-expression1740    expect(result.success).to.be.false;1741  });1742}17431744export async function removeFromAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1745  await usingApi(async (api) => {1746    // Run the transaction1747    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1748    const events = await submitTransactionAsync(sender, tx);1749    const result = getGenericResult(events);17501751    // What to expect1752    // tslint:disable-next-line:no-unused-expression1753    expect(result.success).to.be.true;1754  });1755}17561757export async function removeFromAllowListExpectFailure(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1758  await usingApi(async (api) => {1759    // Run the transaction1760    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1761    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1762    const result = getGenericResult(events);17631764    // What to expect1765    // tslint:disable-next-line:no-unused-expression1766    expect(result.success).to.be.false;1767  });1768}17691770export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)1771  : Promise<UpDataStructsRpcCollection | null> => {1772  return (await api.rpc.unique.collectionById(collectionId)).unwrapOr(null);1773};17741775export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {1776  // set global object - collectionsCount1777  return (await api.rpc.unique.collectionStats()).created.toNumber();1778};17791780export async function queryCollectionExpectSuccess(api: ApiPromise, collectionId: number): Promise<UpDataStructsRpcCollection> {1781  return (await api.rpc.unique.collectionById(collectionId)).unwrap();1782}17831784export const describe_xcm = (1785  process.env.RUN_XCM_TESTS1786    ? describe1787    : describe.skip1788);17891790export async function waitNewBlocks(blocksCount = 1): Promise<void> {1791  await usingApi(async (api) => {1792    const promise = new Promise<void>(async (resolve) => {1793      const unsubscribe = await api.rpc.chain.subscribeNewHeads(() => {1794        if (blocksCount > 0) {1795          blocksCount--;1796        } else {1797          unsubscribe();1798          resolve();1799        }1800      });1801    });1802    return promise;1803  });1804}18051806export async function waitEvent(1807  api: ApiPromise,1808  maxBlocksToWait: number,1809  eventSection: string,1810  eventMethod: string,1811): Promise<EventRecord | null> {18121813  const promise = new Promise<EventRecord | null>(async (resolve) => {1814    const unsubscribe = await api.rpc.chain.subscribeNewHeads(async header => {1815      const blockNumber = header.number.toHuman();1816      const blockHash = header.hash;1817      const eventIdStr = `${eventSection}.${eventMethod}`;1818      const waitLimitStr = `wait blocks remaining: ${maxBlocksToWait}`;18191820      console.log(`[Block #${blockNumber}] Waiting for event \`${eventIdStr}\` (${waitLimitStr})`);18211822      const apiAt = await api.at(blockHash);1823      const eventRecords = await apiAt.query.system.events();18241825      const neededEvent = eventRecords.find(r => {1826        return r.event.section == eventSection && r.event.method == eventMethod;1827      });18281829      if (neededEvent) {1830        unsubscribe();1831        resolve(neededEvent);1832      } else if (maxBlocksToWait > 0) {1833        maxBlocksToWait--;1834      } else {1835        console.log(`Event \`${eventIdStr}\` is NOT found`);18361837        unsubscribe();1838        resolve(null);1839      }1840    });1841  });1842  return promise;1843}18441845export async function repartitionRFT(1846  api: ApiPromise,1847  collectionId: number,1848  sender: IKeyringPair,1849  tokenId: number,1850  amount: bigint,1851): Promise<boolean> {1852  const tx = api.tx.unique.repartition(collectionId, tokenId, amount);1853  const events = await submitTransactionAsync(sender, tx);1854  const result = getGenericResult(events);18551856  return result.success;1857}18581859export async function itApi(name: string, cb: (apis: { api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair }) => any, opts: { only?: boolean, skip?: boolean } = {}) {1860  let i: any = it;1861  if (opts.only) i = i.only;1862  else if (opts.skip) i = i.skip;1863  i(name, async () => {1864    await usingApi(async (api, privateKeyWrapper) => {1865      await cb({api, privateKeyWrapper});1866    });1867  });1868}18691870itApi.only = (name: string, cb: (apis: { api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair }) => any) => itApi(name, cb, {only: true});1871itApi.skip = (name: string, cb: (apis: { api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair }) => any) => itApi(name, cb, {skip: true});18721873let accountSeed = 10000;1874export function generateKeyringPair(keyring: Keyring) {1875  const privateKey = `0xDEADBEEF${(Date.now() + (accountSeed++)).toString(16).padStart(64 - 8, '0')}`;1876  return keyring.addFromUri(privateKey);1877}18781879export async function expectSubstrateEventsAtBlock(api: ApiPromise, blockNumber: AnyNumber | BlockNumber, section: string, methods: string[], dryRun = false) {1880  const blockHash = await api.rpc.chain.getBlockHash(blockNumber);1881  const subEvents = (await api.query.system.events.at(blockHash))1882    .filter(x => x.event.section === section)1883    .map((x) => x.toHuman());1884  const events = methods.map((m) => {1885    return {1886      event: {1887        method: m,1888        section,1889      },1890    };1891  });1892  if (!dryRun) {1893    expect(subEvents).to.be.like(events);1894  }1895  return subEvents;1896}