git.delta.rocks / unique-network / refs/commits / 9aa0a891160d

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} from '@polkadot/api';20import type {AccountId, EventRecord, Event} 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 BN from 'bn.js';25import chai from 'chai';26import chaiAsPromised from 'chai-as-promised';27import {default as usingApi, executeTransaction, submitTransactionAsync, submitTransactionExpectFailAsync} from '../substrate/substrate-api';28import {hexToStr, strToUTF16, utf16ToStr} from './util';29import {UpDataStructsRpcCollection, UpDataStructsCreateItemData, UpDataStructsProperty} from '@polkadot/types/lookup';30import {UpDataStructsTokenChild} from '../interfaces';3132chai.use(chaiAsPromised);33const expect = chai.expect;3435export type CrossAccountId = {36  Substrate: string,37} | {38  Ethereum: string,39};4041export function normalizeAccountId(input: string | AccountId | CrossAccountId | IKeyringPair): CrossAccountId {42  if (typeof input === 'string') {43    if (input.length >= 47) {44      return {Substrate: input};45    } else if (input.length === 42 && input.startsWith('0x')) {46      return {Ethereum: input.toLowerCase()};47    } else if (input.length === 40 && !input.startsWith('0x')) {48      return {Ethereum: '0x' + input.toLowerCase()};49    } else {50      throw new Error(`Unknown address format: "${input}"`);51    }52  }53  if ('address' in input) {54    return {Substrate: input.address};55  }56  if ('Ethereum' in input) {57    return {58      Ethereum: input.Ethereum.toLowerCase(),59    };60  } else if ('ethereum' in input) {61    return {62      Ethereum: (input as any).ethereum.toLowerCase(),63    };64  } else if ('Substrate' in input) {65    return input;66  } else if ('substrate' in input) {67    return {68      Substrate: (input as any).substrate,69    };70  }7172  // AccountId73  return {Substrate: input.toString()};74}75export function toSubstrateAddress(input: string | CrossAccountId | IKeyringPair): string {76  input = normalizeAccountId(input);77  if ('Substrate' in input) {78    return input.Substrate;79  } else {80    return evmToAddress(input.Ethereum);81  }82}8384export const U128_MAX = (1n << 128n) - 1n;8586const MICROUNIQUE = 1_000_000_000_000n;87const MILLIUNIQUE = 1_000n * MICROUNIQUE;88const CENTIUNIQUE = 10n * MILLIUNIQUE;89export const UNIQUE = 100n * CENTIUNIQUE;9091interface GenericResult<T> {92  success: boolean;93  data: T | null;94}9596interface CreateCollectionResult {97  success: boolean;98  collectionId: number;99}100101interface CreateItemResult {102  success: boolean;103  collectionId: number;104  itemId: number;105  recipient?: CrossAccountId;106  amount?: number;107}108109interface DestroyItemResult {110  success: boolean;111  collectionId: number;112  itemId: number;113  owner: CrossAccountId;114  amount: number;115}116117interface TransferResult {118  collectionId: number;119  itemId: number;120  sender?: CrossAccountId;121  recipient?: CrossAccountId;122  value: bigint;123}124125interface IReFungibleOwner {126  fraction: BN;127  owner: number[];128}129130interface IGetMessage {131  checkMsgUnqMethod: string;132  checkMsgTrsMethod: string;133  checkMsgSysMethod: string;134}135136export interface IFungibleTokenDataType {137  value: number;138}139140export interface IChainLimits {141  collectionNumbersLimit: number;142  accountTokenOwnershipLimit: number;143  collectionsAdminsLimit: number;144  customDataLimit: number;145  nftSponsorTransferTimeout: number;146  fungibleSponsorTransferTimeout: number;147  refungibleSponsorTransferTimeout: number;148  //offchainSchemaLimit: number;149  //constOnChainSchemaLimit: number;150}151152export interface IReFungibleTokenDataType {153  owner: IReFungibleOwner[];154}155156export function uniqueEventMessage(events: EventRecord[]): IGetMessage {157  let checkMsgUnqMethod = '';158  let checkMsgTrsMethod = '';159  let checkMsgSysMethod = '';160  events.forEach(({event: {method, section}}) => {161    if (section === 'common') {162      checkMsgUnqMethod = method;163    } else if (section === 'treasury') {164      checkMsgTrsMethod = method;165    } else if (section === 'system') {166      checkMsgSysMethod = method;167    } else { return null; }168  });169  const result: IGetMessage = {170    checkMsgUnqMethod,171    checkMsgTrsMethod,172    checkMsgSysMethod,173  };174  return result;175}176177export function getEvent<T extends Event>(events: EventRecord[], check: (event: IEvent<AnyTuple>) => event is T): T | undefined {178  const event = events.find(r => check(r.event));179  if (!event) return;180  return event.event as T;181}182183export function getGenericResult<T>(events: EventRecord[]): GenericResult<T>;184export function getGenericResult<T>(185  events: EventRecord[],186  expectSection: string,187  expectMethod: string,188  extractAction: (data: GenericEventData) => T189): GenericResult<T>;190191export function getGenericResult<T>(192  events: EventRecord[],193  expectSection?: string,194  expectMethod?: string,195  extractAction?: (data: GenericEventData) => T,196): GenericResult<T> {197  let success = false;198  let successData = null;199200  events.forEach(({event: {data, method, section}}) => {201    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);202    if (method === 'ExtrinsicSuccess') {203      success = true;204    } else if ((expectSection == section) && (expectMethod == method)) {205      successData = extractAction!(data as any);206    }207  });208209  const result: GenericResult<T> = {210    success,211    data: successData,212  };213  return result;214}215216export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {217  const genericResult = getGenericResult(events, 'common', 'CollectionCreated', (data) => parseInt(data[0].toString(), 10));218  const result: CreateCollectionResult = {219    success: genericResult.success,220    collectionId: genericResult.data ?? 0,221  };222  return result;223}224225export function getCreateItemsResult(events: EventRecord[]): CreateItemResult[] {226  const results: CreateItemResult[] = [];227  228  const genericResult = getGenericResult<CreateItemResult[]>(events, 'common', 'ItemCreated', (data) => {229    const collectionId = parseInt(data[0].toString(), 10);230    const itemId = parseInt(data[1].toString(), 10);231    const recipient = normalizeAccountId(data[2].toJSON() as any);232    const amount = parseInt(data[3].toString(), 10);233234    const itemRes: CreateItemResult = {235      success: true,236      collectionId,237      itemId,238      recipient,239      amount,240    };241242    results.push(itemRes);243    return results;244  });245246  if (!genericResult.success) return [];247  return results;248}249250export function getCreateItemResult(events: EventRecord[]): CreateItemResult {251  const genericResult = getGenericResult<[number, number, CrossAccountId?]>(events, 'common', 'ItemCreated', (data) => [252    parseInt(data[0].toString(), 10),253    parseInt(data[1].toString(), 10),254    normalizeAccountId(data[2].toJSON() as any),255  ]);256257  if (genericResult.data == null) genericResult.data = [0, 0];258259  const result: CreateItemResult = {260    success: genericResult.success,261    collectionId: genericResult.data[0],262    itemId: genericResult.data[1],263    recipient: genericResult.data![2],264  };265  266  return result;267}268269export function getDestroyItemsResult(events: EventRecord[]): DestroyItemResult[] {270  const results: DestroyItemResult[] = [];271  272  const genericResult = getGenericResult<DestroyItemResult[]>(events, 'common', 'ItemDestroyed', (data) => {273    const collectionId = parseInt(data[0].toString(), 10);274    const itemId = parseInt(data[1].toString(), 10);275    const owner = normalizeAccountId(data[2].toJSON() as any);276    const amount = parseInt(data[3].toString(), 10);277278    const itemRes: DestroyItemResult = {279      success: true,280      collectionId,281      itemId,282      owner,283      amount,284    };285286    results.push(itemRes);287    return results;288  });289290  if (!genericResult.success) return [];291  return results;292}293294export function getTransferResult(api: ApiPromise, events: EventRecord[]): TransferResult {295  for (const {event} of events) {296    if (api.events.common.Transfer.is(event)) {297      const [collection, token, sender, recipient, value] = event.data;298      return {299        collectionId: collection.toNumber(),300        itemId: token.toNumber(),301        sender: normalizeAccountId(sender.toJSON() as any),302        recipient: normalizeAccountId(recipient.toJSON() as any),303        value: value.toBigInt(),304      };305    }306  }307  throw new Error('no transfer event');308}309310interface Nft {311  type: 'NFT';312}313314interface Fungible {315  type: 'Fungible';316  decimalPoints: number;317}318319interface ReFungible {320  type: 'ReFungible';321}322323export type CollectionMode = Nft | Fungible | ReFungible;324325export type Property = {326  key: any,327  value: any,328};329330type Permission = {331  mutable: boolean;332  collectionAdmin: boolean;333  tokenOwner: boolean;334}335336type PropertyPermission = {337  key: any;338  permission: Permission;339}340341export type CreateCollectionParams = {342  mode: CollectionMode,343  name: string,344  description: string,345  tokenPrefix: string,346  properties?: Array<Property>,347  propPerm?: Array<PropertyPermission>348};349350const defaultCreateCollectionParams: CreateCollectionParams = {351  description: 'description',352  mode: {type: 'NFT'},353  name: 'name',354  tokenPrefix: 'prefix',355};356357export async function358createCollection(359  api: ApiPromise,360  sender: IKeyringPair,361  params: Partial<CreateCollectionParams> = {},362): Promise<CreateCollectionResult> {363  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};364365  let modeprm = {};366  if (mode.type === 'NFT') {367    modeprm = {nft: null};368  } else if (mode.type === 'Fungible') {369    modeprm = {fungible: mode.decimalPoints};370  } else if (mode.type === 'ReFungible') {371    modeprm = {refungible: null};372  }373374  const tx = api.tx.unique.createCollectionEx({375    name: strToUTF16(name),376    description: strToUTF16(description),377    tokenPrefix: strToUTF16(tokenPrefix),378    mode: modeprm as any,379  });380  const events = await submitTransactionAsync(sender, tx);381  return getCreateCollectionResult(events);382}383384export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {385  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};386387  let collectionId = 0;388  await usingApi(async (api, privateKeyWrapper) => {389    // Get number of collections before the transaction390    const collectionCountBefore = await getCreatedCollectionCount(api);391392    // Run the CreateCollection transaction393    const alicePrivateKey = privateKeyWrapper('//Alice');394395    const result = await createCollection(api, alicePrivateKey, params);396397    // Get number of collections after the transaction398    const collectionCountAfter = await getCreatedCollectionCount(api);399400    // Get the collection401    const collection = await queryCollectionExpectSuccess(api, result.collectionId);402403    // What to expect404    // tslint:disable-next-line:no-unused-expression405    expect(result.success).to.be.true;406    expect(result.collectionId).to.be.equal(collectionCountAfter);407    // tslint:disable-next-line:no-unused-expression408    expect(collection).to.be.not.null;409    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');410    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicePrivateKey));411    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);412    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);413    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);414415    collectionId = result.collectionId;416  });417418  return collectionId;419}420421export async function createCollectionWithPropsExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {422  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};423424  let collectionId = 0;425  await usingApi(async (api, privateKeyWrapper) => {426    // Get number of collections before the transaction427    const collectionCountBefore = await getCreatedCollectionCount(api);428429    // Run the CreateCollection transaction430    const alicePrivateKey = privateKeyWrapper('//Alice');431432    let modeprm = {};433    if (mode.type === 'NFT') {434      modeprm = {nft: null};435    } else if (mode.type === 'Fungible') {436      modeprm = {fungible: mode.decimalPoints};437    } else if (mode.type === 'ReFungible') {438      modeprm = {refungible: null};439    }440441    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});442    const events = await submitTransactionAsync(alicePrivateKey, tx);443    const result = getCreateCollectionResult(events);444445    // Get number of collections after the transaction446    const collectionCountAfter = await getCreatedCollectionCount(api);447448    // Get the collection449    const collection = await queryCollectionExpectSuccess(api, result.collectionId);450451    // What to expect452    // tslint:disable-next-line:no-unused-expression453    expect(result.success).to.be.true;454    expect(result.collectionId).to.be.equal(collectionCountAfter);455    // tslint:disable-next-line:no-unused-expression456    expect(collection).to.be.not.null;457    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');458    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicePrivateKey));459    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);460    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);461    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);462463464    collectionId = result.collectionId;465  });466467  return collectionId;468}469470export async function createCollectionWithPropsExpectFailure(params: Partial<CreateCollectionParams> = {}) {471  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};472473  await usingApi(async (api, privateKeyWrapper) => {474    // Get number of collections before the transaction475    const collectionCountBefore = await getCreatedCollectionCount(api);476477    // Run the CreateCollection transaction478    const alicePrivateKey = privateKeyWrapper('//Alice');479480    let modeprm = {};481    if (mode.type === 'NFT') {482      modeprm = {nft: null};483    } else if (mode.type === 'Fungible') {484      modeprm = {fungible: mode.decimalPoints};485    } else if (mode.type === 'ReFungible') {486      modeprm = {refungible: null};487    }488489    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});490    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;491492493    // Get number of collections after the transaction494    const collectionCountAfter = await getCreatedCollectionCount(api);495496    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');497  });498}499500export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {501  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};502503  let modeprm = {};504  if (mode.type === 'NFT') {505    modeprm = {nft: null};506  } else if (mode.type === 'Fungible') {507    modeprm = {fungible: mode.decimalPoints};508  } else if (mode.type === 'ReFungible') {509    modeprm = {refungible: null};510  }511512  await usingApi(async (api, privateKeyWrapper) => {513    // Get number of collections before the transaction514    const collectionCountBefore = await getCreatedCollectionCount(api);515516    // Run the CreateCollection transaction517    const alicePrivateKey = privateKeyWrapper('//Alice');518    const tx = api.tx.unique.createCollectionEx({name: strToUTF16(name), description: strToUTF16(description), tokenPrefix: strToUTF16(tokenPrefix), mode: modeprm as any});519    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;520521    // Get number of collections after the transaction522    const collectionCountAfter = await getCreatedCollectionCount(api);523524    // What to expect525    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');526  });527}528529export async function findUnusedAddress(api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair, seedAddition = ''): Promise<IKeyringPair> {530  let bal = 0n;531  let unused;532  do {533    const randomSeed = 'seed' + Math.floor(Math.random() * Math.floor(10000)) + seedAddition;534    unused = privateKeyWrapper(`//${randomSeed}`);535    bal = (await api.query.system.account(unused.address)).data.free.toBigInt();536  } while (bal !== 0n);537  return unused;538}539540export async function getAllowance(api: ApiPromise, collectionId: number, owner: CrossAccountId | string | IKeyringPair, approved: CrossAccountId | string | IKeyringPair, tokenId: number) {541  return (await api.rpc.unique.allowance(collectionId, normalizeAccountId(owner), normalizeAccountId(approved), tokenId)).toBigInt();542}543544export function findUnusedAddresses(api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair, amount: number): Promise<IKeyringPair[]> {545  return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, privateKeyWrapper, '_' + Date.now())));546}547548export async function findNotExistingCollection(api: ApiPromise): Promise<number> {549  const totalNumber = await getCreatedCollectionCount(api);550  const newCollection: number = totalNumber + 1;551  return newCollection;552}553554function getDestroyResult(events: EventRecord[]): boolean {555  let success = false;556  events.forEach(({event: {method}}) => {557    if (method == 'ExtrinsicSuccess') {558      success = true;559    }560  });561  return success;562}563564export async function destroyCollectionExpectFailure(collectionId: number, senderSeed = '//Alice') {565  await usingApi(async (api, privateKeyWrapper) => {566    // Run the DestroyCollection transaction567    const alicePrivateKey = privateKeyWrapper(senderSeed);568    const tx = api.tx.unique.destroyCollection(collectionId);569    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;570  });571}572573export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed = '//Alice') {574  await usingApi(async (api, privateKeyWrapper) => {575    // Run the DestroyCollection transaction576    const alicePrivateKey = privateKeyWrapper(senderSeed);577    const tx = api.tx.unique.destroyCollection(collectionId);578    const events = await submitTransactionAsync(alicePrivateKey, tx);579    const result = getDestroyResult(events);580    expect(result).to.be.true;581582    // What to expect583    expect(await getDetailedCollectionInfo(api, collectionId)).to.be.null;584  });585}586587export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {588  await usingApi(async (api) => {589    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);590    const events = await submitTransactionAsync(sender, tx);591    const result = getGenericResult(events);592593    expect(result.success).to.be.true;594  });595}596597export const setCollectionPermissionsExpectSuccess = async (sender: IKeyringPair, collectionId: number, permissions: any) => {598  await usingApi(async(api) => {599    const tx = api.tx.unique.setCollectionPermissions(collectionId, permissions);600    const events = await submitTransactionAsync(sender, tx);601    const result = getGenericResult(events);602603    expect(result.success).to.be.true;604  });605};606607export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {608  await usingApi(async (api) => {609    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);610    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;611    const result = getGenericResult(events);612613    expect(result.success).to.be.false;614  });615}616617export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string, sender = '//Alice') {618  await usingApi(async (api, privateKeyWrapper) => {619620    // Run the transaction621    const senderPrivateKey = privateKeyWrapper(sender);622    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);623    const events = await submitTransactionAsync(senderPrivateKey, tx);624    const result = getGenericResult(events);625626    // Get the collection627    const collection = await queryCollectionExpectSuccess(api, collectionId);628629    // What to expect630    expect(result.success).to.be.true;631    expect(collection.sponsorship.toJSON()).to.deep.equal({632      unconfirmed: sponsor,633    });634  });635}636637export async function removeCollectionSponsorExpectSuccess(collectionId: number, sender = '//Alice') {638  await usingApi(async (api, privateKeyWrapper) => {639640    // Run the transaction641    const alicePrivateKey = privateKeyWrapper(sender);642    const tx = api.tx.unique.removeCollectionSponsor(collectionId);643    const events = await submitTransactionAsync(alicePrivateKey, tx);644    const result = getGenericResult(events);645646    // Get the collection647    const collection = await queryCollectionExpectSuccess(api, collectionId);648649    // What to expect650    expect(result.success).to.be.true;651    expect(collection.sponsorship.toJSON()).to.be.deep.equal({disabled: null});652  });653}654655export async function removeCollectionSponsorExpectFailure(collectionId: number, senderSeed = '//Alice') {656  await usingApi(async (api, privateKeyWrapper) => {657658    // Run the transaction659    const alicePrivateKey = privateKeyWrapper(senderSeed);660    const tx = api.tx.unique.removeCollectionSponsor(collectionId);661    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;662  });663}664665export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed = '//Alice') {666  await usingApi(async (api, privateKeyWrapper) => {667668    // Run the transaction669    const alicePrivateKey = privateKeyWrapper(senderSeed);670    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);671    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;672  });673}674675export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed = '//Alice') {676  await usingApi(async (api, privateKeyWrapper) => {677678    // Run the transaction679    const sender = privateKeyWrapper(senderSeed);680    await confirmSponsorshipByKeyExpectSuccess(collectionId, sender);681  });682}683684export async function confirmSponsorshipByKeyExpectSuccess(collectionId: number, sender: IKeyringPair) {685  await usingApi(async (api, privateKeyWrapper) => {686687    // Run the transaction688    const tx = api.tx.unique.confirmSponsorship(collectionId);689    const events = await submitTransactionAsync(sender, tx);690    const result = getGenericResult(events);691692    // Get the collection693    const collection = await queryCollectionExpectSuccess(api, collectionId);694695    // What to expect696    expect(result.success).to.be.true;697    expect(collection.sponsorship.toJSON()).to.be.deep.equal({698      confirmed: sender.address,699    });700  });701}702703704export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed = '//Alice') {705  await usingApi(async (api, privateKeyWrapper) => {706707    // Run the transaction708    const sender = privateKeyWrapper(senderSeed);709    const tx = api.tx.unique.confirmSponsorship(collectionId);710    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;711  });712}713714export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {715  await usingApi(async (api) => {716    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);717    const events = await submitTransactionAsync(sender, tx);718    const result = getGenericResult(events);719720    expect(result.success).to.be.true;721  });722}723724export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {725  await usingApi(async (api) => {726    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);727    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;728    const result = getGenericResult(events);729730    expect(result.success).to.be.false;731  });732}733734export async function setTransferFlagExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {735736  await usingApi(async (api) => {737738    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);739    const events = await submitTransactionAsync(sender, tx);740    const result = getGenericResult(events);741742    expect(result.success).to.be.true;743  });744}745746export async function setTransferFlagExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {747748  await usingApi(async (api) => {749750    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);751    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;752    const result = getGenericResult(events);753754    expect(result.success).to.be.false;755  });756}757758export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {759  await usingApi(async (api) => {760    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);761    const events = await submitTransactionAsync(sender, tx);762    const result = getGenericResult(events);763764    expect(result.success).to.be.true;765  });766}767768export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {769  await usingApi(async (api) => {770    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);771    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;772    const result = getGenericResult(events);773774    expect(result.success).to.be.false;775  });776}777778export async function getNextSponsored(779  api: ApiPromise,780  collectionId: number,781  account: string | CrossAccountId,782  tokenId: number,783): Promise<number> {784  return Number((await api.rpc.unique.nextSponsored(collectionId, account, tokenId)).unwrapOr(-1));785}786787export async function toggleContractAllowlistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, value = true) {788  await usingApi(async (api) => {789    const tx = api.tx.unique.toggleContractAllowList(contractAddress, value);790    const events = await submitTransactionAsync(sender, tx);791    const result = getGenericResult(events);792793    expect(result.success).to.be.true;794  });795}796797export async function isAllowlistedInContract(contractAddress: AccountId | string, user: string) {798  let allowlisted = false;799  await usingApi(async (api) => {800    allowlisted = (await api.query.unique.contractAllowList(contractAddress, user)).toJSON() as boolean;801  });802  return allowlisted;803}804805export async function addToContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {806  await usingApi(async (api) => {807    const tx = api.tx.unique.addToContractAllowList(contractAddress.toString(), user.toString());808    const events = await submitTransactionAsync(sender, tx);809    const result = getGenericResult(events);810811    expect(result.success).to.be.true;812  });813}814815export async function removeFromContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {816  await usingApi(async (api) => {817    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());818    const events = await submitTransactionAsync(sender, tx);819    const result = getGenericResult(events);820821    expect(result.success).to.be.true;822  });823}824825export async function removeFromContractAllowListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {826  await usingApi(async (api) => {827    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());828    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;829    const result = getGenericResult(events);830831    expect(result.success).to.be.false;832  });833}834835export interface CreateFungibleData {836  readonly Value: bigint;837}838839export interface CreateReFungibleData { }840export interface CreateNftData { }841842export type CreateItemData = {843  NFT: CreateNftData;844} | {845  Fungible: CreateFungibleData;846} | {847  ReFungible: CreateReFungibleData;848};849850export async function burnItem(api: ApiPromise, sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint) : Promise<boolean> {851  const tx = api.tx.unique.burnItem(collectionId, tokenId, value);852  const events = await submitTransactionAsync(sender, tx);853  return getGenericResult(events).success;854}855856export async function burnItemExpectSuccess(sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint = 1) {857  await usingApi(async (api) => {858    const balanceBefore = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);859    // if burning token by admin - use adminButnItemExpectSuccess860    expect(balanceBefore >= BigInt(value)).to.be.true;861862    expect(await burnItem(api, sender, collectionId, tokenId, value)).to.be.true;863864    const balanceAfter = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);865    expect(balanceAfter + BigInt(value)).to.be.equal(balanceBefore);866  });867}868869export async function burnItemExpectFailure(sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint = 1) {870  await usingApi(async (api) => {871    const tx = api.tx.unique.burnItem(collectionId, tokenId, value);872873    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;874    const result = getCreateCollectionResult(events);875    // tslint:disable-next-line:no-unused-expression876    expect(result.success).to.be.false;877  });878}879880export async function burnFromExpectSuccess(sender: IKeyringPair, from: IKeyringPair | CrossAccountId, collectionId: number, tokenId: number, value: number | bigint = 1) {881  await usingApi(async (api) => {882    const tx = api.tx.unique.burnFrom(collectionId, normalizeAccountId(from), tokenId, value);883    const events = await submitTransactionAsync(sender, tx);884    return getGenericResult(events).success;885  });886}887888export async function889approve(890  api: ApiPromise,891  collectionId: number,892  tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string | IKeyringPair, amount: number | bigint,893) {894  const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);895  const events = await submitTransactionAsync(owner, approveUniqueTx);896  return getGenericResult(events).success;897}898899export async function900approveExpectSuccess(901  collectionId: number,902  tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string, amount: number | bigint = 1,903) {904  await usingApi(async (api: ApiPromise) => {905    const result = await approve(api, collectionId, tokenId, owner, approved, amount);906    expect(result).to.be.true;907908    expect(await getAllowance(api, collectionId, owner, approved, tokenId)).to.be.equal(BigInt(amount));909  });910}911912export async function adminApproveFromExpectSuccess(913  collectionId: number,914  tokenId: number, admin: IKeyringPair, owner: CrossAccountId | string, approved: CrossAccountId | string, amount: number | bigint = 1,915) {916  await usingApi(async (api: ApiPromise) => {917    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);918    const events = await submitTransactionAsync(admin, approveUniqueTx);919    const result = getGenericResult(events);920    expect(result.success).to.be.true;921922    expect(await getAllowance(api, collectionId, owner, approved, tokenId)).to.be.equal(BigInt(amount));923  });924}925926export async function927transferFrom(928  api: ApiPromise,929  collectionId: number,930  tokenId: number,931  accountApproved: IKeyringPair,932  accountFrom: IKeyringPair | CrossAccountId,933  accountTo: IKeyringPair | CrossAccountId,934  value: number | bigint,935) {936  const from = normalizeAccountId(accountFrom);937  const to = normalizeAccountId(accountTo);938  const transferFromTx = api.tx.unique.transferFrom(from, to, collectionId, tokenId, value);939  const events = await submitTransactionAsync(accountApproved, transferFromTx);940  return getGenericResult(events).success;941}942943export async function944transferFromExpectSuccess(945  collectionId: number,946  tokenId: number,947  accountApproved: IKeyringPair,948  accountFrom: IKeyringPair | CrossAccountId,949  accountTo: IKeyringPair | CrossAccountId,950  value: number | bigint = 1,951  type = 'NFT',952) {953  await usingApi(async (api: ApiPromise) => {954    const from = normalizeAccountId(accountFrom);955    const to = normalizeAccountId(accountTo);956    let balanceBefore = 0n;957    if (type === 'Fungible' || type === 'ReFungible') {958      balanceBefore = await getBalance(api, collectionId, to, tokenId);959    }960    expect(await transferFrom(api, collectionId, tokenId, accountApproved, accountFrom, accountTo, value)).to.be.true;961    if (type === 'NFT') {962      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);963    }964    if (type === 'Fungible') {965      const balanceAfter = await getBalance(api, collectionId, to, tokenId);966      if (JSON.stringify(to) !== JSON.stringify(from)) {967        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));968      } else {969        expect(balanceAfter).to.be.equal(balanceBefore);970      }971    }972    if (type === 'ReFungible') {973      expect(await getBalance(api, collectionId, to, tokenId)).to.be.equal(balanceBefore + BigInt(value));974    }975  });976}977978export async function979transferFromExpectFail(980  collectionId: number,981  tokenId: number,982  accountApproved: IKeyringPair,983  accountFrom: IKeyringPair,984  accountTo: IKeyringPair,985  value: number | bigint = 1,986) {987  await usingApi(async (api: ApiPromise) => {988    const transferFromTx = api.tx.unique.transferFrom(normalizeAccountId(accountFrom.address), normalizeAccountId(accountTo.address), collectionId, tokenId, value);989    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;990    const result = getCreateCollectionResult(events);991    // tslint:disable-next-line:no-unused-expression992    expect(result.success).to.be.false;993  });994}995996/* eslint no-async-promise-executor: "off" */997export async function getBlockNumber(api: ApiPromise): Promise<number> {998  return new Promise<number>(async (resolve) => {999    const unsubscribe = await api.rpc.chain.subscribeNewHeads((head) => {1000      unsubscribe();1001      resolve(head.number.toNumber());1002    });1003  });1004}10051006export async function addCollectionAdminExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | CrossAccountId) {1007  await usingApi(async (api) => {1008    const changeAdminTx = api.tx.unique.addCollectionAdmin(collectionId, normalizeAccountId(address));1009    const events = await submitTransactionAsync(sender, changeAdminTx);1010    const result = getCreateCollectionResult(events);1011    expect(result.success).to.be.true;1012  });1013}10141015export async function adminApproveFromExpectFail(1016  collectionId: number,1017  tokenId: number, admin: IKeyringPair, owner: CrossAccountId | string, approved: CrossAccountId | string, amount: number | bigint = 1,1018) {1019  await usingApi(async (api: ApiPromise) => {1020    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);1021    const events = await expect(submitTransactionAsync(admin, approveUniqueTx)).to.be.rejected;1022    const result = getGenericResult(events);1023    expect(result.success).to.be.false;1024  });1025}10261027export async function1028getFreeBalance(account: IKeyringPair): Promise<bigint> {1029  let balance = 0n;1030  await usingApi(async (api) => {1031    balance = BigInt((await api.query.system.account(account.address)).data.free.toString());1032  });10331034  return balance;1035}10361037export async function transferBalanceTo(api: ApiPromise, source: IKeyringPair, target: string, amount = 1000n * UNIQUE) {1038  const tx = api.tx.balances.transfer(target, amount);1039  const events = await submitTransactionAsync(source, tx);1040  const result = getGenericResult(events);1041  expect(result.success).to.be.true;1042}10431044export async function1045scheduleExpectSuccess(1046  operationTx: any,1047  sender: IKeyringPair,1048  blockSchedule: number,1049  scheduledId: string,1050  period = 1,1051  repetitions = 1,1052) {1053  await usingApi(async (api: ApiPromise) => {1054    const blockNumber: number | undefined = await getBlockNumber(api);1055    const expectedBlockNumber = blockNumber + blockSchedule;10561057    expect(blockNumber).to.be.greaterThan(0);1058    const scheduleTx = api.tx.scheduler.scheduleNamed( // schedule1059      scheduledId,1060      expectedBlockNumber, 1061      repetitions > 1 ? [period, repetitions] : null, 1062      0, 1063      {Value: operationTx as any},1064    );10651066    const events = await submitTransactionAsync(sender, scheduleTx);1067    expect(getGenericResult(events).success).to.be.true;1068  });1069}10701071export async function1072scheduleExpectFailure(1073  operationTx: any,1074  sender: IKeyringPair,1075  blockSchedule: number,1076  scheduledId: string,1077  period = 1,1078  repetitions = 1,1079) {1080  await usingApi(async (api: ApiPromise) => {1081    const blockNumber: number | undefined = await getBlockNumber(api);1082    const expectedBlockNumber = blockNumber + blockSchedule;10831084    expect(blockNumber).to.be.greaterThan(0);1085    const scheduleTx = api.tx.scheduler.scheduleNamed( // schedule1086      scheduledId,1087      expectedBlockNumber, 1088      repetitions <= 1 ? null : [period, repetitions], 1089      0, 1090      {Value: operationTx as any},1091    );10921093    //const events = 1094    await expect(submitTransactionExpectFailAsync(sender, scheduleTx)).to.be.rejected;1095    //expect(getGenericResult(events).success).to.be.false;1096  });1097}10981099export async function1100scheduleTransferAndWaitExpectSuccess(1101  collectionId: number,1102  tokenId: number,1103  sender: IKeyringPair,1104  recipient: IKeyringPair,1105  value: number | bigint = 1,1106  blockSchedule: number,1107  scheduledId: string,1108) {1109  await usingApi(async (api: ApiPromise) => {1110    await scheduleTransferExpectSuccess(collectionId, tokenId, sender, recipient, value, blockSchedule, scheduledId);11111112    const recipientBalanceBefore = (await api.query.system.account(recipient.address)).data.free.toBigInt();11131114    // sleep for n + 1 blocks1115    await waitNewBlocks(blockSchedule + 1);11161117    const recipientBalanceAfter = (await api.query.system.account(recipient.address)).data.free.toBigInt();11181119    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(recipient.address));1120    expect(recipientBalanceAfter).to.be.equal(recipientBalanceBefore);1121  });1122}11231124export async function1125scheduleTransferExpectSuccess(1126  collectionId: number,1127  tokenId: number,1128  sender: IKeyringPair,1129  recipient: IKeyringPair,1130  value: number | bigint = 1,1131  blockSchedule: number,1132  scheduledId: string,1133) {1134  await usingApi(async (api: ApiPromise) => {1135    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value);11361137    await scheduleExpectSuccess(transferTx, sender, blockSchedule, scheduledId);11381139    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(sender.address));1140  });1141}11421143export async function1144scheduleTransferFundsPeriodicExpectSuccess(1145  amount: bigint,1146  sender: IKeyringPair,1147  recipient: IKeyringPair,1148  blockSchedule: number,1149  scheduledId: string,1150  period: number,1151  repetitions: number,1152) {1153  await usingApi(async (api: ApiPromise) => {1154    const transferTx = api.tx.balances.transfer(recipient.address, amount);11551156    const balanceBefore = await getFreeBalance(recipient);1157    1158    await scheduleExpectSuccess(transferTx, sender, blockSchedule, scheduledId, period, repetitions);11591160    expect(await getFreeBalance(recipient)).to.be.equal(balanceBefore);1161  });1162}11631164export async function1165transfer(1166  api: ApiPromise,1167  collectionId: number,1168  tokenId: number,1169  sender: IKeyringPair,1170  recipient: IKeyringPair | CrossAccountId,1171  value: number | bigint,1172) : Promise<boolean> {1173  const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1174  const events = await executeTransaction(api, sender, transferTx);1175  return getGenericResult(events).success;1176}11771178export async function1179transferExpectSuccess(1180  collectionId: number,1181  tokenId: number,1182  sender: IKeyringPair,1183  recipient: IKeyringPair | CrossAccountId,1184  value: number | bigint = 1,1185  type = 'NFT',1186) {1187  await usingApi(async (api: ApiPromise) => {1188    const from = normalizeAccountId(sender);1189    const to = normalizeAccountId(recipient);11901191    let balanceBefore = 0n;1192    if (type === 'Fungible' || type === 'ReFungible') {1193      balanceBefore = await getBalance(api, collectionId, to, tokenId);1194    }11951196    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1197    const events = await executeTransaction(api, sender, transferTx);1198    const result = getTransferResult(api, events);11991200    expect(result.collectionId).to.be.equal(collectionId);1201    expect(result.itemId).to.be.equal(tokenId);1202    expect(result.sender).to.be.deep.equal(normalizeAccountId(sender.address));1203    expect(result.recipient).to.be.deep.equal(to);1204    expect(result.value).to.be.equal(BigInt(value));12051206    if (type === 'NFT') {1207      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);1208    }1209    if (type === 'Fungible' || type === 'ReFungible') {1210      const balanceAfter = await getBalance(api, collectionId, to, tokenId);1211      if (JSON.stringify(to) !== JSON.stringify(from)) {1212        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));1213      } else {1214        expect(balanceAfter).to.be.equal(balanceBefore);1215      }1216    }1217  });1218}12191220export async function1221transferExpectFailure(1222  collectionId: number,1223  tokenId: number,1224  sender: IKeyringPair,1225  recipient: IKeyringPair | CrossAccountId,1226  value: number | bigint = 1,1227) {1228  await usingApi(async (api: ApiPromise) => {1229    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1230    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;1231    const result = getGenericResult(events);1232    // if (events && Array.isArray(events)) {1233    //   const result = getCreateCollectionResult(events);1234    // tslint:disable-next-line:no-unused-expression1235    expect(result.success).to.be.false;1236    //}1237  });1238}12391240export async function1241approveExpectFail(1242  collectionId: number,1243  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1,1244) {1245  await usingApi(async (api: ApiPromise) => {1246    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved.address), collectionId, tokenId, amount);1247    const events = await expect(submitTransactionExpectFailAsync(owner, approveUniqueTx)).to.be.rejected;1248    const result = getCreateCollectionResult(events);1249    // tslint:disable-next-line:no-unused-expression1250    expect(result.success).to.be.false;1251  });1252}12531254export async function getBalance(1255  api: ApiPromise,1256  collectionId: number,1257  owner: string | CrossAccountId | IKeyringPair,1258  token: number,1259): Promise<bigint> {1260  return (await api.rpc.unique.balance(collectionId, normalizeAccountId(owner), token)).toBigInt();1261}1262export async function getTokenOwner(1263  api: ApiPromise,1264  collectionId: number,1265  token: number,1266): Promise<CrossAccountId> {1267  const owner = (await api.rpc.unique.tokenOwner(collectionId, token)).toJSON() as any;1268  if (owner == null) throw new Error('owner == null');1269  return normalizeAccountId(owner);1270}1271export async function getTopmostTokenOwner(1272  api: ApiPromise,1273  collectionId: number,1274  token: number,1275): Promise<CrossAccountId> {1276  const owner = (await api.rpc.unique.topmostTokenOwner(collectionId, token)).toJSON() as any;1277  if (owner == null) throw new Error('owner == null');1278  return normalizeAccountId(owner);1279}1280export async function getTokenChildren(1281  api: ApiPromise,1282  collectionId: number,1283  tokenId: number,1284): Promise<UpDataStructsTokenChild[]> {1285  return (await api.rpc.unique.tokenChildren(collectionId, tokenId)).toJSON() as any;1286}1287export async function isTokenExists(1288  api: ApiPromise,1289  collectionId: number,1290  token: number,1291): Promise<boolean> {1292  return (await api.rpc.unique.tokenExists(collectionId, token)).toJSON();1293}1294export async function getLastTokenId(1295  api: ApiPromise,1296  collectionId: number,1297): Promise<number> {1298  return (await api.rpc.unique.lastTokenId(collectionId)).toJSON();1299}1300export async function getAdminList(1301  api: ApiPromise,1302  collectionId: number,1303): Promise<string[]> {1304  return (await api.rpc.unique.adminlist(collectionId)).toHuman() as any;1305}1306export async function getTokenProperties(1307  api: ApiPromise,1308  collectionId: number,1309  tokenId: number,1310  propertyKeys: string[],1311): Promise<UpDataStructsProperty[]> {1312  return (await api.rpc.unique.tokenProperties(collectionId, tokenId, propertyKeys)).toHuman() as any;1313}13141315export async function createFungibleItemExpectSuccess(1316  sender: IKeyringPair,1317  collectionId: number,1318  data: CreateFungibleData,1319  owner: CrossAccountId | string = sender.address,1320) {1321  return await usingApi(async (api) => {1322    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), {Fungible: data});13231324    const events = await submitTransactionAsync(sender, tx);1325    const result = getCreateItemResult(events);13261327    expect(result.success).to.be.true;1328    return result.itemId;1329  });1330}13311332export async function createMultipleItemsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any, owner: CrossAccountId | string = sender.address) {1333  await usingApi(async (api) => {1334    const to = normalizeAccountId(owner);1335    const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);13361337    const events = await submitTransactionAsync(sender, tx);1338    expect(getGenericResult(events).success).to.be.true;1339  });1340}13411342export async function createMultipleItemsWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any, owner: CrossAccountId | string = sender.address) {1343  await usingApi(async (api) => {1344    const to = normalizeAccountId(owner);1345    const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);13461347    const events = await submitTransactionAsync(sender, tx);1348    const result = getCreateItemsResult(events);13491350    for (const res of result) {1351      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1352    }1353  });1354}13551356export async function createMultipleItemsExWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any) {1357  await usingApi(async (api) => {1358    const tx = api.tx.unique.createMultipleItemsEx(collectionId, itemsData);13591360    const events = await submitTransactionAsync(sender, tx);1361    const result = getCreateItemsResult(events);13621363    for (const res of result) {1364      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1365    }1366  });1367}13681369export async function createItemWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, props:  Array<Property>, owner: CrossAccountId | string = sender.address) {1370  let newItemId = 0;1371  await usingApi(async (api) => {1372    const to = normalizeAccountId(owner);1373    const itemCountBefore = await getLastTokenId(api, collectionId);1374    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);13751376    let tx;1377    if (createMode === 'Fungible') {1378      const createData = {fungible: {value: 10}};1379      tx = api.tx.unique.createItem(collectionId, to, createData as any);1380    } else if (createMode === 'ReFungible') {1381      const createData = {refungible: {pieces: 100}};1382      tx = api.tx.unique.createItem(collectionId, to, createData as any);1383    } else {1384      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}});1385      tx = api.tx.unique.createItem(collectionId, to, data as UpDataStructsCreateItemData);1386    }13871388    const events = await submitTransactionAsync(sender, tx);1389    const result = getCreateItemResult(events);13901391    const itemCountAfter = await getLastTokenId(api, collectionId);1392    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);13931394    if (createMode === 'NFT') {1395      expect(await api.rpc.unique.tokenProperties(collectionId, result.itemId)).not.to.be.empty;1396    }13971398    // What to expect1399    // tslint:disable-next-line:no-unused-expression1400    expect(result.success).to.be.true;1401    if (createMode === 'Fungible') {1402      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1403    } else {1404      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1405    }1406    expect(collectionId).to.be.equal(result.collectionId);1407    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1408    expect(to).to.be.deep.equal(result.recipient);1409    newItemId = result.itemId;1410  });1411  return newItemId;1412}14131414export async function createItemWithPropsExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, props: Array<Property>, owner: CrossAccountId | string = sender.address) {1415  await usingApi(async (api) => {14161417    let tx;1418    if (createMode === 'NFT') {1419      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}}) as UpDataStructsCreateItemData;1420      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), data);1421    } else {1422      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);1423    }142414251426    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1427    if(events.message && events.message.toString().indexOf('1002: Verification Error') > -1) return;1428    const result = getCreateItemResult(events);14291430    expect(result.success).to.be.false;1431  });1432}14331434export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1435  let newItemId = 0;1436  await usingApi(async (api) => {1437    const to = normalizeAccountId(owner);1438    const itemCountBefore = await getLastTokenId(api, collectionId);1439    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);14401441    let tx;1442    if (createMode === 'Fungible') {1443      const createData = {fungible: {value: 10}};1444      tx = api.tx.unique.createItem(collectionId, to, createData as any);1445    } else if (createMode === 'ReFungible') {1446      const createData = {refungible: {pieces: 100}};1447      tx = api.tx.unique.createItem(collectionId, to, createData as any);1448    } else {1449      const createData = {nft: {}};1450      tx = api.tx.unique.createItem(collectionId, to, createData as any);1451    }14521453    const events = await executeTransaction(api, sender, tx);1454    const result = getCreateItemResult(events);14551456    const itemCountAfter = await getLastTokenId(api, collectionId);1457    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);14581459    // What to expect1460    // tslint:disable-next-line:no-unused-expression1461    expect(result.success).to.be.true;1462    if (createMode === 'Fungible') {1463      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1464    } else {1465      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1466    }1467    expect(collectionId).to.be.equal(result.collectionId);1468    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1469    expect(to).to.be.deep.equal(result.recipient);1470    newItemId = result.itemId;1471  });1472  return newItemId;1473}14741475export async function createRefungibleToken(api: ApiPromise, sender: IKeyringPair, collectionId: number, amount: bigint, owner: CrossAccountId | IKeyringPair | string = sender.address) : Promise<CreateItemResult> {1476  const createData = {refungible: {pieces: amount}};1477  const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createData as any);14781479  const events = await submitTransactionAsync(sender, tx);1480  return  getCreateItemResult(events);1481}14821483export async function createItemExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1484  await usingApi(async (api) => {1485    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);14861487    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1488    const result = getCreateItemResult(events);14891490    expect(result.success).to.be.false;1491  });1492}14931494export async function setPublicAccessModeExpectSuccess(1495  sender: IKeyringPair, collectionId: number,1496  accessMode: 'Normal' | 'AllowList',1497) {1498  await usingApi(async (api) => {14991500    // Run the transaction1501    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});1502    const events = await submitTransactionAsync(sender, tx);1503    const result = getGenericResult(events);15041505    // Get the collection1506    const collection = await queryCollectionExpectSuccess(api, collectionId);15071508    // What to expect1509    // tslint:disable-next-line:no-unused-expression1510    expect(result.success).to.be.true;1511    expect(collection.permissions.access.toHuman()).to.be.equal(accessMode);1512  });1513}15141515export async function setPublicAccessModeExpectFail(1516  sender: IKeyringPair, collectionId: number,1517  accessMode: 'Normal' | 'AllowList',1518) {1519  await usingApi(async (api) => {15201521    // Run the transaction1522    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});1523    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1524    const result = getGenericResult(events);15251526    // What to expect1527    // tslint:disable-next-line:no-unused-expression1528    expect(result.success).to.be.false;1529  });1530}15311532export async function enableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1533  await setPublicAccessModeExpectSuccess(sender, collectionId, 'AllowList');1534}15351536export async function enableAllowListExpectFail(sender: IKeyringPair, collectionId: number) {1537  await setPublicAccessModeExpectFail(sender, collectionId, 'AllowList');1538}15391540export async function disableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1541  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');1542}15431544export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {1545  await usingApi(async (api) => {15461547    // Run the transaction1548    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1549    const events = await submitTransactionAsync(sender, tx);1550    const result = getGenericResult(events);1551    expect(result.success).to.be.true;15521553    // Get the collection1554    const collection = await queryCollectionExpectSuccess(api, collectionId);15551556    expect(collection.permissions.mintMode.toHuman()).to.be.equal(enabled);1557  });1558}15591560export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {1561  await setMintPermissionExpectSuccess(sender, collectionId, true);1562}15631564export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {1565  await usingApi(async (api) => {1566    // Run the transaction1567    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1568    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1569    const result = getCreateCollectionResult(events);1570    // tslint:disable-next-line:no-unused-expression1571    expect(result.success).to.be.false;1572  });1573}15741575export async function setChainLimitsExpectFailure(sender: IKeyringPair, limits: IChainLimits) {1576  await usingApi(async (api) => {1577    // Run the transaction1578    const tx = api.tx.unique.setChainLimits(limits);1579    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1580    const result = getCreateCollectionResult(events);1581    // tslint:disable-next-line:no-unused-expression1582    expect(result.success).to.be.false;1583  });1584}15851586export async function isAllowlisted(api: ApiPromise, collectionId: number, address: string | CrossAccountId) {1587  return (await api.rpc.unique.allowed(collectionId, normalizeAccountId(address))).toJSON();1588}15891590export async function addToAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId | CrossAccountId) {1591  await usingApi(async (api) => {1592    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.false;15931594    // Run the transaction1595    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1596    const events = await submitTransactionAsync(sender, tx);1597    const result = getGenericResult(events);1598    expect(result.success).to.be.true;15991600    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;1601  });1602}16031604export async function addToAllowListAgainExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1605  await usingApi(async (api) => {16061607    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;16081609    // Run the transaction1610    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1611    const events = await submitTransactionAsync(sender, tx);1612    const result = getGenericResult(events);1613    expect(result.success).to.be.true;16141615    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;1616  });1617}16181619export async function addToAllowListExpectFail(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1620  await usingApi(async (api) => {16211622    // Run the transaction1623    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1624    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1625    const result = getGenericResult(events);16261627    // What to expect1628    // tslint:disable-next-line:no-unused-expression1629    expect(result.success).to.be.false;1630  });1631}16321633export async function removeFromAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1634  await usingApi(async (api) => {1635    // Run the transaction1636    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1637    const events = await submitTransactionAsync(sender, tx);1638    const result = getGenericResult(events);16391640    // What to expect1641    // tslint:disable-next-line:no-unused-expression1642    expect(result.success).to.be.true;1643  });1644}16451646export async function removeFromAllowListExpectFailure(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1647  await usingApi(async (api) => {1648    // Run the transaction1649    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1650    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1651    const result = getGenericResult(events);16521653    // What to expect1654    // tslint:disable-next-line:no-unused-expression1655    expect(result.success).to.be.false;1656  });1657}16581659export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)1660  : Promise<UpDataStructsRpcCollection | null> => {1661  return (await api.rpc.unique.collectionById(collectionId)).unwrapOr(null);1662};16631664export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {1665  // set global object - collectionsCount1666  return (await api.rpc.unique.collectionStats()).created.toNumber();1667};16681669export async function queryCollectionExpectSuccess(api: ApiPromise, collectionId: number): Promise<UpDataStructsRpcCollection> {1670  return (await api.rpc.unique.collectionById(collectionId)).unwrap();1671}16721673export async function waitNewBlocks(blocksCount = 1): Promise<void> {1674  await usingApi(async (api) => {1675    const promise = new Promise<void>(async (resolve) => {1676      const unsubscribe = await api.rpc.chain.subscribeNewHeads(() => {1677        if (blocksCount > 0) {1678          blocksCount--;1679        } else {1680          unsubscribe();1681          resolve();1682        }1683      });1684    });1685    return promise;1686  });1687}16881689export async function repartitionRFT(1690  api: ApiPromise,1691  collectionId: number,1692  sender: IKeyringPair,1693  tokenId: number,1694  amount: bigint,1695): Promise<boolean> {1696  const tx = api.tx.unique.repartition(collectionId, tokenId, amount);1697  const events = await submitTransactionAsync(sender, tx);1698  const result = getGenericResult(events);16991700  return result.success;1701}