git.delta.rocks / unique-network / refs/commits / 4d135e3fe0d2

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} from '@polkadot/types/interfaces';21import {AnyTuple, IEvent, IKeyringPair} from '@polkadot/types/types';22import {evmToAddress} from '@polkadot/util-crypto';23import BN from 'bn.js';24import chai from 'chai';25import chaiAsPromised from 'chai-as-promised';26import {alicesPublicKey} from '../accounts';27import privateKey from '../substrate/privateKey';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';3233chai.use(chaiAsPromised);34const expect = chai.expect;3536export type CrossAccountId = {37  Substrate: string,38} | {39  Ethereum: string,40};4142export function normalizeAccountId(input: string | AccountId | CrossAccountId | IKeyringPair): CrossAccountId {43  if (typeof input === 'string') {44    if (input.length === 48 || input.length === 47) {45      return {Substrate: input};46    } else if (input.length === 42 && input.startsWith('0x')) {47      return {Ethereum: input.toLowerCase()};48    } else if (input.length === 40 && !input.startsWith('0x')) {49      return {Ethereum: '0x' + input.toLowerCase()};50    } else {51      throw new Error(`Unknown address format: "${input}"`);52    }53  }54  if ('address' in input) {55    return {Substrate: input.address};56  }57  if ('Ethereum' in input) {58    return {59      Ethereum: input.Ethereum.toLowerCase(),60    };61  } else if ('ethereum' in input) {62    return {63      Ethereum: (input as any).ethereum.toLowerCase(),64    };65  } else if ('Substrate' in input) {66    return input;67  } else if ('substrate' in input) {68    return {69      Substrate: (input as any).substrate,70    };71  }7273  // AccountId74  return {Substrate: input.toString()};75}76export function toSubstrateAddress(input: string | CrossAccountId | IKeyringPair): string {77  input = normalizeAccountId(input);78  if ('Substrate' in input) {79    return input.Substrate;80  } else {81    return evmToAddress(input.Ethereum);82  }83}8485export const U128_MAX = (1n << 128n) - 1n;8687const MICROUNIQUE = 1_000_000_000_000n;88const MILLIUNIQUE = 1_000n * MICROUNIQUE;89const CENTIUNIQUE = 10n * MILLIUNIQUE;90export const UNIQUE = 100n * CENTIUNIQUE;9192type GenericResult = {93  success: boolean,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}107108interface TransferResult {109  collectionId: number;110  itemId: number;111  sender?: CrossAccountId;112  recipient?: CrossAccountId;113  value: bigint;114}115116interface IReFungibleOwner {117  fraction: BN;118  owner: number[];119}120121interface IGetMessage {122  checkMsgUnqMethod: string;123  checkMsgTrsMethod: string;124  checkMsgSysMethod: string;125}126127export interface IFungibleTokenDataType {128  value: number;129}130131export interface IChainLimits {132  collectionNumbersLimit: number;133  accountTokenOwnershipLimit: number;134  collectionsAdminsLimit: number;135  customDataLimit: number;136  nftSponsorTransferTimeout: number;137  fungibleSponsorTransferTimeout: number;138  refungibleSponsorTransferTimeout: number;139  //offchainSchemaLimit: number;140  //constOnChainSchemaLimit: number;141}142143export interface IReFungibleTokenDataType {144  owner: IReFungibleOwner[];145}146147export function uniqueEventMessage(events: EventRecord[]): IGetMessage {148  let checkMsgUnqMethod = '';149  let checkMsgTrsMethod = '';150  let checkMsgSysMethod = '';151  events.forEach(({event: {method, section}}) => {152    if (section === 'common') {153      checkMsgUnqMethod = method;154    } else if (section === 'treasury') {155      checkMsgTrsMethod = method;156    } else if (section === 'system') {157      checkMsgSysMethod = method;158    } else { return null; }159  });160  const result: IGetMessage = {161    checkMsgUnqMethod,162    checkMsgTrsMethod,163    checkMsgSysMethod,164  };165  return result;166}167168export function getEvent<T extends Event>(events: EventRecord[], check: (event: IEvent<AnyTuple>) => event is T): T | undefined {169  const event = events.find(r => check(r.event));170  if (!event) return;171  return event.event as T;172}173174export function getGenericResult(events: EventRecord[]): GenericResult {175  const result: GenericResult = {176    success: false,177  };178  events.forEach(({event: {method}}) => {179    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);180    if (method === 'ExtrinsicSuccess') {181      result.success = true;182    }183  });184  return result;185}186187188189export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {190  let success = false;191  let collectionId = 0;192  events.forEach(({event: {data, method, section}}) => {193    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);194    if (method == 'ExtrinsicSuccess') {195      success = true;196    } else if ((section == 'common') && (method == 'CollectionCreated')) {197      collectionId = parseInt(data[0].toString(), 10);198    }199  });200  const result: CreateCollectionResult = {201    success,202    collectionId,203  };204  return result;205}206207export function getCreateItemsResult(events: EventRecord[]): CreateItemResult[] {208  let success = false;209  let collectionId = 0;210  let itemId = 0;211  let recipient;212213  const results : CreateItemResult[]  = [];214215  events.forEach(({event: {data, method, section}}) => {216    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);217    if (method == 'ExtrinsicSuccess') {218      success = true;219    } else if ((section == 'common') && (method == 'ItemCreated')) {220      collectionId = parseInt(data[0].toString(), 10);221      itemId = parseInt(data[1].toString(), 10);222      recipient = normalizeAccountId(data[2].toJSON() as any);223224      const itemRes: CreateItemResult = {225        success,226        collectionId,227        itemId,228        recipient,229      };230231      results.push(itemRes);232    }233  });234235  return results;236}237238export function getCreateItemResult(events: EventRecord[]): CreateItemResult {239  let success = false;240  let collectionId = 0;241  let itemId = 0;242  let recipient;243  events.forEach(({event: {data, method, section}}) => {244    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);245    if (method == 'ExtrinsicSuccess') {246      success = true;247    } else if ((section == 'common') && (method == 'ItemCreated')) {248      collectionId = parseInt(data[0].toString(), 10);249      itemId = parseInt(data[1].toString(), 10);250      recipient = normalizeAccountId(data[2].toJSON() as any);251    }252  });253  const result: CreateItemResult = {254    success,255    collectionId,256    itemId,257    recipient,258  };259  return result;260}261262export function getTransferResult(api: ApiPromise, events: EventRecord[]): TransferResult {263  for (const {event} of events) {264    if (api.events.common.Transfer.is(event)) {265      const [collection, token, sender, recipient, value] = event.data;266      return {267        collectionId: collection.toNumber(),268        itemId: token.toNumber(),269        sender: normalizeAccountId(sender.toJSON() as any),270        recipient: normalizeAccountId(recipient.toJSON() as any),271        value: value.toBigInt(),272      };273    }274  }275  throw new Error('no transfer event');276}277278interface Nft {279  type: 'NFT';280}281282interface Fungible {283  type: 'Fungible';284  decimalPoints: number;285}286287interface ReFungible {288  type: 'ReFungible';289}290291type CollectionMode = Nft | Fungible | ReFungible;292293export type Property = {294  key: any,295  value: any,296};297298type Permission = {299  mutable: boolean;300  collectionAdmin: boolean;301  tokenOwner: boolean;302}303304type PropertyPermission = {305  key: any;306  permission: Permission;307}308309export type CreateCollectionParams = {310  mode: CollectionMode,311  name: string,312  description: string,313  tokenPrefix: string,314  properties?: Array<Property>,315  propPerm?: Array<PropertyPermission>316};317318const defaultCreateCollectionParams: CreateCollectionParams = {319  description: 'description',320  mode: {type: 'NFT'},321  name: 'name',322  tokenPrefix: 'prefix',323};324325export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {326  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};327328  let collectionId = 0;329  await usingApi(async (api) => {330    // Get number of collections before the transaction331    const collectionCountBefore = await getCreatedCollectionCount(api);332333    // Run the CreateCollection transaction334    const alicePrivateKey = privateKey('//Alice');335336    let modeprm = {};337    if (mode.type === 'NFT') {338      modeprm = {nft: null};339    } else if (mode.type === 'Fungible') {340      modeprm = {fungible: mode.decimalPoints};341    } else if (mode.type === 'ReFungible') {342      modeprm = {refungible: null};343    }344345    const tx = api.tx.unique.createCollectionEx({346      name: strToUTF16(name),347      description: strToUTF16(description),348      tokenPrefix: strToUTF16(tokenPrefix),349      mode: modeprm as any,350    });351    const events = await submitTransactionAsync(alicePrivateKey, tx);352    const result = getCreateCollectionResult(events);353354    // Get number of collections after the transaction355    const collectionCountAfter = await getCreatedCollectionCount(api);356357    // Get the collection358    const collection = await queryCollectionExpectSuccess(api, result.collectionId);359360    // What to expect361    // tslint:disable-next-line:no-unused-expression362    expect(result.success).to.be.true;363    expect(result.collectionId).to.be.equal(collectionCountAfter);364    // tslint:disable-next-line:no-unused-expression365    expect(collection).to.be.not.null;366    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');367    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicesPublicKey));368    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);369    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);370    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);371372    collectionId = result.collectionId;373  });374375  return collectionId;376}377378export async function createCollectionWithPropsExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {379  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};380381  let collectionId = 0;382  await usingApi(async (api) => {383    // Get number of collections before the transaction384    const collectionCountBefore = await getCreatedCollectionCount(api);385386    // Run the CreateCollection transaction387    const alicePrivateKey = privateKey('//Alice');388389    let modeprm = {};390    if (mode.type === 'NFT') {391      modeprm = {nft: null};392    } else if (mode.type === 'Fungible') {393      modeprm = {fungible: mode.decimalPoints};394    } else if (mode.type === 'ReFungible') {395      modeprm = {refungible: null};396    }397398    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});399    const events = await submitTransactionAsync(alicePrivateKey, tx);400    const result = getCreateCollectionResult(events);401402    // Get number of collections after the transaction403    const collectionCountAfter = await getCreatedCollectionCount(api);404405    // Get the collection406    const collection = await queryCollectionExpectSuccess(api, result.collectionId);407408    // What to expect409    // tslint:disable-next-line:no-unused-expression410    expect(result.success).to.be.true;411    expect(result.collectionId).to.be.equal(collectionCountAfter);412    // tslint:disable-next-line:no-unused-expression413    expect(collection).to.be.not.null;414    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');415    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicesPublicKey));416    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);417    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);418    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);419420421    collectionId = result.collectionId;422  });423424  return collectionId;425}426427export async function createCollectionWithPropsExpectFailure(params: Partial<CreateCollectionParams> = {}) {428  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};429430  await usingApi(async (api) => {431    // Get number of collections before the transaction432    const collectionCountBefore = await getCreatedCollectionCount(api);433434    // Run the CreateCollection transaction435    const alicePrivateKey = privateKey('//Alice');436437    let modeprm = {};438    if (mode.type === 'NFT') {439      modeprm = {nft: null};440    } else if (mode.type === 'Fungible') {441      modeprm = {fungible: mode.decimalPoints};442    } else if (mode.type === 'ReFungible') {443      modeprm = {refungible: null};444    }445446    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});447    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;448449450    // Get number of collections after the transaction451    const collectionCountAfter = await getCreatedCollectionCount(api);452453    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');454  });455}456457export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {458  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};459460  let modeprm = {};461  if (mode.type === 'NFT') {462    modeprm = {nft: null};463  } else if (mode.type === 'Fungible') {464    modeprm = {fungible: mode.decimalPoints};465  } else if (mode.type === 'ReFungible') {466    modeprm = {refungible: null};467  }468469  await usingApi(async (api) => {470    // Get number of collections before the transaction471    const collectionCountBefore = await getCreatedCollectionCount(api);472473    // Run the CreateCollection transaction474    const alicePrivateKey = privateKey('//Alice');475    const tx = api.tx.unique.createCollectionEx({name: strToUTF16(name), description: strToUTF16(description), tokenPrefix: strToUTF16(tokenPrefix), mode: modeprm as any});476    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;477478    // Get number of collections after the transaction479    const collectionCountAfter = await getCreatedCollectionCount(api);480481    // What to expect482    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');483  });484}485486export async function findUnusedAddress(api: ApiPromise, seedAddition = ''): Promise<IKeyringPair> {487  let bal = 0n;488  let unused;489  do {490    const randomSeed = 'seed' + Math.floor(Math.random() * Math.floor(10000)) + seedAddition;491    const keyring = new Keyring({type: 'sr25519'});492    unused = keyring.addFromUri(`//${randomSeed}`);493    bal = (await api.query.system.account(unused.address)).data.free.toBigInt();494  } while (bal !== 0n);495  return unused;496}497498export async function getAllowance(api: ApiPromise, collectionId: number, owner: CrossAccountId | string, approved: CrossAccountId | string, tokenId: number) {499  return (await api.rpc.unique.allowance(collectionId, normalizeAccountId(owner), normalizeAccountId(approved), tokenId)).toBigInt();500}501502export function findUnusedAddresses(api: ApiPromise, amount: number): Promise<IKeyringPair[]> {503  return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, '_' + Date.now())));504}505506export async function findNotExistingCollection(api: ApiPromise): Promise<number> {507  const totalNumber = await getCreatedCollectionCount(api);508  const newCollection: number = totalNumber + 1;509  return newCollection;510}511512function getDestroyResult(events: EventRecord[]): boolean {513  let success = false;514  events.forEach(({event: {method}}) => {515    if (method == 'ExtrinsicSuccess') {516      success = true;517    }518  });519  return success;520}521522export async function destroyCollectionExpectFailure(collectionId: number, senderSeed = '//Alice') {523  await usingApi(async (api) => {524    // Run the DestroyCollection transaction525    const alicePrivateKey = privateKey(senderSeed);526    const tx = api.tx.unique.destroyCollection(collectionId);527    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;528  });529}530531export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed = '//Alice') {532  await usingApi(async (api) => {533    // Run the DestroyCollection transaction534    const alicePrivateKey = privateKey(senderSeed);535    const tx = api.tx.unique.destroyCollection(collectionId);536    const events = await submitTransactionAsync(alicePrivateKey, tx);537    const result = getDestroyResult(events);538    expect(result).to.be.true;539540    // What to expect541    expect(await getDetailedCollectionInfo(api, collectionId)).to.be.null;542  });543}544545export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {546  await usingApi(async (api) => {547    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);548    const events = await submitTransactionAsync(sender, tx);549    const result = getGenericResult(events);550551    expect(result.success).to.be.true;552  });553}554555export const setCollectionPermissionsExpectSuccess = async (sender: IKeyringPair, collectionId: number, permissions: {mintMode?: boolean, access?: 'Normal' | 'AllowList', nesting?: 'Disabled' | 'Owner' | {OwnerRestricted: number[]}}) => {556  await usingApi(async(api) => {557    const tx = api.tx.unique.setCollectionPermissions(collectionId, permissions);558    const events = await submitTransactionAsync(sender, tx);559    const result = getGenericResult(events);560561    expect(result.success).to.be.true;562  });563};564565export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {566  await usingApi(async (api) => {567    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);568    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;569    const result = getGenericResult(events);570571    expect(result.success).to.be.false;572  });573}574575export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string, sender = '//Alice') {576  await usingApi(async (api) => {577578    // Run the transaction579    const senderPrivateKey = privateKey(sender);580    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);581    const events = await submitTransactionAsync(senderPrivateKey, tx);582    const result = getGenericResult(events);583584    // Get the collection585    const collection = await queryCollectionExpectSuccess(api, collectionId);586587    // What to expect588    expect(result.success).to.be.true;589    expect(collection.sponsorship.toJSON()).to.deep.equal({590      unconfirmed: sponsor,591    });592  });593}594595export async function removeCollectionSponsorExpectSuccess(collectionId: number, sender = '//Alice') {596  await usingApi(async (api) => {597598    // Run the transaction599    const alicePrivateKey = privateKey(sender);600    const tx = api.tx.unique.removeCollectionSponsor(collectionId);601    const events = await submitTransactionAsync(alicePrivateKey, tx);602    const result = getGenericResult(events);603604    // Get the collection605    const collection = await queryCollectionExpectSuccess(api, collectionId);606607    // What to expect608    expect(result.success).to.be.true;609    expect(collection.sponsorship.toJSON()).to.be.deep.equal({disabled: null});610  });611}612613export async function removeCollectionSponsorExpectFailure(collectionId: number, senderSeed = '//Alice') {614  await usingApi(async (api) => {615616    // Run the transaction617    const alicePrivateKey = privateKey(senderSeed);618    const tx = api.tx.unique.removeCollectionSponsor(collectionId);619    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;620  });621}622623export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed = '//Alice') {624  await usingApi(async (api) => {625626    // Run the transaction627    const alicePrivateKey = privateKey(senderSeed);628    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);629    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;630  });631}632633export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed = '//Alice') {634  await usingApi(async (api) => {635636    // Run the transaction637    const sender = privateKey(senderSeed);638    const tx = api.tx.unique.confirmSponsorship(collectionId);639    const events = await submitTransactionAsync(sender, tx);640    const result = getGenericResult(events);641642    // Get the collection643    const collection = await queryCollectionExpectSuccess(api, collectionId);644645    // What to expect646    expect(result.success).to.be.true;647    expect(collection.sponsorship.toJSON()).to.be.deep.equal({648      confirmed: sender.address,649    });650  });651}652653654export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed = '//Alice') {655  await usingApi(async (api) => {656657    // Run the transaction658    const sender = privateKey(senderSeed);659    const tx = api.tx.unique.confirmSponsorship(collectionId);660    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;661  });662}663664export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {665  await usingApi(async (api) => {666    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);667    const events = await submitTransactionAsync(sender, tx);668    const result = getGenericResult(events);669670    expect(result.success).to.be.true;671  });672}673674export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {675  await usingApi(async (api) => {676    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);677    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;678    const result = getGenericResult(events);679680    expect(result.success).to.be.false;681  });682}683684export async function setTransferFlagExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {685686  await usingApi(async (api) => {687688    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);689    const events = await submitTransactionAsync(sender, tx);690    const result = getGenericResult(events);691692    expect(result.success).to.be.true;693  });694}695696export async function setTransferFlagExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {697698  await usingApi(async (api) => {699700    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);701    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;702    const result = getGenericResult(events);703704    expect(result.success).to.be.false;705  });706}707708export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {709  await usingApi(async (api) => {710    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);711    const events = await submitTransactionAsync(sender, tx);712    const result = getGenericResult(events);713714    expect(result.success).to.be.true;715  });716}717718export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {719  await usingApi(async (api) => {720    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);721    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;722    const result = getGenericResult(events);723724    expect(result.success).to.be.false;725  });726}727728export async function getNextSponsored(729  api: ApiPromise,730  collectionId: number,731  account: string | CrossAccountId,732  tokenId: number,733): Promise<number> {734  return Number((await api.rpc.unique.nextSponsored(collectionId, account, tokenId)).unwrapOr(-1));735}736737export async function toggleContractAllowlistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, value = true) {738  await usingApi(async (api) => {739    const tx = api.tx.unique.toggleContractAllowList(contractAddress, value);740    const events = await submitTransactionAsync(sender, tx);741    const result = getGenericResult(events);742743    expect(result.success).to.be.true;744  });745}746747export async function isAllowlistedInContract(contractAddress: AccountId | string, user: string) {748  let allowlisted = false;749  await usingApi(async (api) => {750    allowlisted = (await api.query.unique.contractAllowList(contractAddress, user)).toJSON() as boolean;751  });752  return allowlisted;753}754755export async function addToContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {756  await usingApi(async (api) => {757    const tx = api.tx.unique.addToContractAllowList(contractAddress.toString(), user.toString());758    const events = await submitTransactionAsync(sender, tx);759    const result = getGenericResult(events);760761    expect(result.success).to.be.true;762  });763}764765export async function removeFromContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {766  await usingApi(async (api) => {767    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());768    const events = await submitTransactionAsync(sender, tx);769    const result = getGenericResult(events);770771    expect(result.success).to.be.true;772  });773}774775export async function removeFromContractAllowListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {776  await usingApi(async (api) => {777    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());778    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;779    const result = getGenericResult(events);780781    expect(result.success).to.be.false;782  });783}784785export interface CreateFungibleData {786  readonly Value: bigint;787}788789export interface CreateReFungibleData { }790export interface CreateNftData { }791792export type CreateItemData = {793  NFT: CreateNftData;794} | {795  Fungible: CreateFungibleData;796} | {797  ReFungible: CreateReFungibleData;798};799800export async function burnItemExpectSuccess(sender: IKeyringPair, collectionId: number, tokenId: number, value = 1) {801  await usingApi(async (api) => {802    const balanceBefore = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);803    // if burning token by admin - use adminButnItemExpectSuccess804    expect(balanceBefore >= BigInt(value)).to.be.true;805806    const tx = api.tx.unique.burnItem(collectionId, tokenId, value);807    const events = await submitTransactionAsync(sender, tx);808    const result = getGenericResult(events);809    expect(result.success).to.be.true;810811    const balanceAfter = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);812    expect(balanceAfter + BigInt(value)).to.be.equal(balanceBefore);813  });814}815816export async function817approveExpectSuccess(818  collectionId: number,819  tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string, amount: number | bigint = 1,820) {821  await usingApi(async (api: ApiPromise) => {822    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);823    const events = await submitTransactionAsync(owner, approveUniqueTx);824    const result = getGenericResult(events);825    expect(result.success).to.be.true;826827    expect(await getAllowance(api, collectionId, owner.address, approved, tokenId)).to.be.equal(BigInt(amount));828  });829}830831export async function adminApproveFromExpectSuccess(832  collectionId: number,833  tokenId: number, admin: IKeyringPair, owner: CrossAccountId | string, approved: CrossAccountId | string, amount: number | bigint = 1,834) {835  await usingApi(async (api: ApiPromise) => {836    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);837    const events = await submitTransactionAsync(admin, approveUniqueTx);838    const result = getGenericResult(events);839    expect(result.success).to.be.true;840841    expect(await getAllowance(api, collectionId, owner, approved, tokenId)).to.be.equal(BigInt(amount));842  });843}844845export async function846transferFromExpectSuccess(847  collectionId: number,848  tokenId: number,849  accountApproved: IKeyringPair,850  accountFrom: IKeyringPair | CrossAccountId,851  accountTo: IKeyringPair | CrossAccountId,852  value: number | bigint = 1,853  type = 'NFT',854) {855  await usingApi(async (api: ApiPromise) => {856    const from = normalizeAccountId(accountFrom);857    const to = normalizeAccountId(accountTo);858    let balanceBefore = 0n;859    if (type === 'Fungible' || type === 'ReFungible') {860      balanceBefore = await getBalance(api, collectionId, to, tokenId);861    }862    const transferFromTx = api.tx.unique.transferFrom(normalizeAccountId(accountFrom), to, collectionId, tokenId, value);863    const events = await submitTransactionAsync(accountApproved, transferFromTx);864    const result = getCreateItemResult(events);865    // tslint:disable-next-line:no-unused-expression866    expect(result.success).to.be.true;867    if (type === 'NFT') {868      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);869    }870    if (type === 'Fungible') {871      const balanceAfter = await getBalance(api, collectionId, to, tokenId);872      if (JSON.stringify(to) !== JSON.stringify(from)) {873        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));874      } else {875        expect(balanceAfter).to.be.equal(balanceBefore);876      }877    }878    if (type === 'ReFungible') {879      expect(await getBalance(api, collectionId, to, tokenId)).to.be.equal(balanceBefore + BigInt(value));880    }881  });882}883884export async function885transferFromExpectFail(886  collectionId: number,887  tokenId: number,888  accountApproved: IKeyringPair,889  accountFrom: IKeyringPair,890  accountTo: IKeyringPair,891  value: number | bigint = 1,892) {893  await usingApi(async (api: ApiPromise) => {894    const transferFromTx = api.tx.unique.transferFrom(normalizeAccountId(accountFrom.address), normalizeAccountId(accountTo.address), collectionId, tokenId, value);895    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;896    const result = getCreateCollectionResult(events);897    // tslint:disable-next-line:no-unused-expression898    expect(result.success).to.be.false;899  });900}901902/* eslint no-async-promise-executor: "off" */903async function getBlockNumber(api: ApiPromise): Promise<number> {904  return new Promise<number>(async (resolve) => {905    const unsubscribe = await api.rpc.chain.subscribeNewHeads((head) => {906      unsubscribe();907      resolve(head.number.toNumber());908    });909  });910}911912export async function addCollectionAdminExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | CrossAccountId) {913  await usingApi(async (api) => {914    const changeAdminTx = api.tx.unique.addCollectionAdmin(collectionId, normalizeAccountId(address));915    const events = await submitTransactionAsync(sender, changeAdminTx);916    const result = getCreateCollectionResult(events);917    expect(result.success).to.be.true;918  });919}920921export async function922getFreeBalance(account: IKeyringPair): Promise<bigint> {923  let balance = 0n;924  await usingApi(async (api) => {925    balance = BigInt((await api.query.system.account(account.address)).data.free.toString());926  });927928  return balance;929}930931export async function transferBalanceTo(api: ApiPromise, source: IKeyringPair, target: string, amount = 1000n * UNIQUE) {932  const tx = api.tx.balances.transfer(target, amount);933  const events = await submitTransactionAsync(source, tx);934  const result = getGenericResult(events);935  expect(result.success).to.be.true;936}937938export async function939scheduleTransferExpectSuccess(940  collectionId: number,941  tokenId: number,942  sender: IKeyringPair,943  recipient: IKeyringPair,944  value: number | bigint = 1,945  blockSchedule: number,946) {947  await usingApi(async (api: ApiPromise) => {948    const blockNumber: number | undefined = await getBlockNumber(api);949    const expectedBlockNumber = blockNumber + blockSchedule;950951    expect(blockNumber).to.be.greaterThan(0);952    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value);953    const scheduleTx = api.tx.scheduler.schedule(expectedBlockNumber, null, 0, transferTx as any);954955    await submitTransactionAsync(sender, scheduleTx);956957    const recipientBalanceBefore = (await api.query.system.account(recipient.address)).data.free.toBigInt();958959    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(sender.address));960961    // sleep for 4 blocks962    await waitNewBlocks(blockSchedule + 1);963964    const recipientBalanceAfter = (await api.query.system.account(recipient.address)).data.free.toBigInt();965966    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(recipient.address));967    expect(recipientBalanceAfter).to.be.equal(recipientBalanceBefore);968  });969}970971972export async function973transferExpectSuccess(974  collectionId: number,975  tokenId: number,976  sender: IKeyringPair,977  recipient: IKeyringPair | CrossAccountId,978  value: number | bigint = 1,979  type = 'NFT',980) {981  await usingApi(async (api: ApiPromise) => {982    const from = normalizeAccountId(sender);983    const to = normalizeAccountId(recipient);984985    let balanceBefore = 0n;986    if (type === 'Fungible') {987      balanceBefore = await getBalance(api, collectionId, to, tokenId);988    }989    const transferTx = api.tx.unique.transfer(to, collectionId, tokenId, value);990    const events = await executeTransaction(api, sender, transferTx);991992    const result = getTransferResult(api, events);993    expect(result.collectionId).to.be.equal(collectionId);994    expect(result.itemId).to.be.equal(tokenId);995    expect(result.sender).to.be.deep.equal(normalizeAccountId(sender.address));996    expect(result.recipient).to.be.deep.equal(to);997    expect(result.value).to.be.equal(BigInt(value));998999    if (type === 'NFT') {1000      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);1001    }1002    if (type === 'Fungible') {1003      const balanceAfter = await getBalance(api, collectionId, to, tokenId);1004      if (JSON.stringify(to) !== JSON.stringify(from)) {1005        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));1006      } else {1007        expect(balanceAfter).to.be.equal(balanceBefore);1008      }1009    }1010    if (type === 'ReFungible') {1011      expect(await getBalance(api, collectionId, to, tokenId) >= value).to.be.true;1012    }1013  });1014}10151016export async function1017transferExpectFailure(1018  collectionId: number,1019  tokenId: number,1020  sender: IKeyringPair,1021  recipient: IKeyringPair | CrossAccountId,1022  value: number | bigint = 1,1023) {1024  await usingApi(async (api: ApiPromise) => {1025    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1026    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;1027    const result = getGenericResult(events);1028    // if (events && Array.isArray(events)) {1029    //   const result = getCreateCollectionResult(events);1030    // tslint:disable-next-line:no-unused-expression1031    expect(result.success).to.be.false;1032    //}1033  });1034}10351036export async function1037approveExpectFail(1038  collectionId: number,1039  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1,1040) {1041  await usingApi(async (api: ApiPromise) => {1042    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved.address), collectionId, tokenId, amount);1043    const events = await expect(submitTransactionExpectFailAsync(owner, approveUniqueTx)).to.be.rejected;1044    const result = getCreateCollectionResult(events);1045    // tslint:disable-next-line:no-unused-expression1046    expect(result.success).to.be.false;1047  });1048}10491050export async function getBalance(1051  api: ApiPromise,1052  collectionId: number,1053  owner: string | CrossAccountId,1054  token: number,1055): Promise<bigint> {1056  return (await api.rpc.unique.balance(collectionId, normalizeAccountId(owner), token)).toBigInt();1057}1058export async function getTokenOwner(1059  api: ApiPromise,1060  collectionId: number,1061  token: number,1062): Promise<CrossAccountId> {1063  const owner = (await api.rpc.unique.tokenOwner(collectionId, token)).toJSON() as any;1064  if (owner == null) throw new Error('owner == null');1065  return normalizeAccountId(owner);1066}1067export async function getTopmostTokenOwner(1068  api: ApiPromise,1069  collectionId: number,1070  token: number,1071): Promise<CrossAccountId> {1072  const owner = (await api.rpc.unique.topmostTokenOwner(collectionId, token)).toJSON() as any;1073  if (owner == null) throw new Error('owner == null');1074  return normalizeAccountId(owner);1075}1076export async function getTokenChildren(1077  api: ApiPromise,1078  collectionId: number,1079  tokenId: number,1080): Promise<UpDataStructsTokenChild[]> {1081  return (await api.rpc.unique.tokenChildren(collectionId, tokenId)).toJSON() as any;1082}1083export async function isTokenExists(1084  api: ApiPromise,1085  collectionId: number,1086  token: number,1087): Promise<boolean> {1088  return (await api.rpc.unique.tokenExists(collectionId, token)).toJSON();1089}1090export async function getLastTokenId(1091  api: ApiPromise,1092  collectionId: number,1093): Promise<number> {1094  return (await api.rpc.unique.lastTokenId(collectionId)).toJSON();1095}1096export async function getAdminList(1097  api: ApiPromise,1098  collectionId: number,1099): Promise<string[]> {1100  return (await api.rpc.unique.adminlist(collectionId)).toHuman() as any;1101}1102export async function getTokenProperties(1103  api: ApiPromise,1104  collectionId: number,1105  tokenId: number,1106  propertyKeys: string[],1107): Promise<UpDataStructsProperty[]> {1108  return (await api.rpc.unique.tokenProperties(collectionId, tokenId, propertyKeys)).toHuman() as any;1109}11101111export async function createFungibleItemExpectSuccess(1112  sender: IKeyringPair,1113  collectionId: number,1114  data: CreateFungibleData,1115  owner: CrossAccountId | string = sender.address,1116) {1117  return await usingApi(async (api) => {1118    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), {Fungible: data});11191120    const events = await submitTransactionAsync(sender, tx);1121    const result = getCreateItemResult(events);11221123    expect(result.success).to.be.true;1124    return result.itemId;1125  });1126}11271128export async function createMultipleItemsWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any, owner: CrossAccountId | string = sender.address) {1129  await usingApi(async (api) => {1130    const to = normalizeAccountId(owner);1131    const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);11321133    const events = await submitTransactionAsync(sender, tx);1134    const result = getCreateItemsResult(events);11351136    for (const res of result) {1137      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1138    }1139  });1140}11411142export async function createMultipleItemsExWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any) {1143  await usingApi(async (api) => {1144    const tx = api.tx.unique.createMultipleItemsEx(collectionId, itemsData);11451146    const events = await submitTransactionAsync(sender, tx);1147    const result = getCreateItemsResult(events);11481149    for (const res of result) {1150      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1151    }1152  });1153}11541155export async function createItemWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, props:  Array<Property>, owner: CrossAccountId | string = sender.address) {1156  let newItemId = 0;1157  await usingApi(async (api) => {1158    const to = normalizeAccountId(owner);1159    const itemCountBefore = await getLastTokenId(api, collectionId);1160    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);11611162    let tx;1163    if (createMode === 'Fungible') {1164      const createData = {fungible: {value: 10}};1165      tx = api.tx.unique.createItem(collectionId, to, createData as any);1166    } else if (createMode === 'ReFungible') {1167      const createData = {refungible: {pieces: 100}};1168      tx = api.tx.unique.createItem(collectionId, to, createData as any);1169    } else {1170      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}});1171      tx = api.tx.unique.createItem(collectionId, to, data as UpDataStructsCreateItemData);1172    }11731174    const events = await submitTransactionAsync(sender, tx);1175    const result = getCreateItemResult(events);11761177    const itemCountAfter = await getLastTokenId(api, collectionId);1178    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);11791180    if (createMode === 'NFT') {1181      expect(await api.rpc.unique.tokenProperties(collectionId, result.itemId)).not.to.be.empty;1182    }11831184    // What to expect1185    // tslint:disable-next-line:no-unused-expression1186    expect(result.success).to.be.true;1187    if (createMode === 'Fungible') {1188      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1189    } else {1190      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1191    }1192    expect(collectionId).to.be.equal(result.collectionId);1193    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1194    expect(to).to.be.deep.equal(result.recipient);1195    newItemId = result.itemId;1196  });1197  return newItemId;1198}11991200export async function createItemWithPropsExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, props: Array<Property>, owner: CrossAccountId | string = sender.address) {1201  await usingApi(async (api) => {12021203    let tx;1204    if (createMode === 'NFT') {1205      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}});1206      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), data);1207    } else {1208      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);1209    }121012111212    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1213    if(events.message && events.message.toString().indexOf('1002: Verification Error') > -1) return;1214    const result = getCreateItemResult(events);12151216    expect(result.success).to.be.false;1217  });1218}12191220export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1221  let newItemId = 0;1222  await usingApi(async (api) => {1223    const to = normalizeAccountId(owner);1224    const itemCountBefore = await getLastTokenId(api, collectionId);1225    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);12261227    let tx;1228    if (createMode === 'Fungible') {1229      const createData = {fungible: {value: 10}};1230      tx = api.tx.unique.createItem(collectionId, to, createData as any);1231    } else if (createMode === 'ReFungible') {1232      const createData = {refungible: {pieces: 100}};1233      tx = api.tx.unique.createItem(collectionId, to, createData as any);1234    } else {1235      const createData = {nft: {}};1236      tx = api.tx.unique.createItem(collectionId, to, createData as any);1237    }12381239    const events = await submitTransactionAsync(sender, tx);1240    const result = getCreateItemResult(events);12411242    const itemCountAfter = await getLastTokenId(api, collectionId);1243    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);12441245    // What to expect1246    // tslint:disable-next-line:no-unused-expression1247    expect(result.success).to.be.true;1248    if (createMode === 'Fungible') {1249      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1250    } else {1251      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1252    }1253    expect(collectionId).to.be.equal(result.collectionId);1254    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1255    expect(to).to.be.deep.equal(result.recipient);1256    newItemId = result.itemId;1257  });1258  return newItemId;1259}12601261export async function createItemExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1262  await usingApi(async (api) => {1263    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);12641265    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1266    const result = getCreateItemResult(events);12671268    expect(result.success).to.be.false;1269  });1270}12711272export async function setPublicAccessModeExpectSuccess(1273  sender: IKeyringPair, collectionId: number,1274  accessMode: 'Normal' | 'AllowList',1275) {1276  await usingApi(async (api) => {12771278    // Run the transaction1279    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});1280    const events = await submitTransactionAsync(sender, tx);1281    const result = getGenericResult(events);12821283    // Get the collection1284    const collection = await queryCollectionExpectSuccess(api, collectionId);12851286    // What to expect1287    // tslint:disable-next-line:no-unused-expression1288    expect(result.success).to.be.true;1289    expect(collection.permissions.access.toHuman()).to.be.equal(accessMode);1290  });1291}12921293export async function setPublicAccessModeExpectFail(1294  sender: IKeyringPair, collectionId: number,1295  accessMode: 'Normal' | 'AllowList',1296) {1297  await usingApi(async (api) => {12981299    // Run the transaction1300    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});1301    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1302    const result = getGenericResult(events);13031304    // What to expect1305    // tslint:disable-next-line:no-unused-expression1306    expect(result.success).to.be.false;1307  });1308}13091310export async function enableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1311  await setPublicAccessModeExpectSuccess(sender, collectionId, 'AllowList');1312}13131314export async function enableAllowListExpectFail(sender: IKeyringPair, collectionId: number) {1315  await setPublicAccessModeExpectFail(sender, collectionId, 'AllowList');1316}13171318export async function disableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1319  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');1320}13211322export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {1323  await usingApi(async (api) => {13241325    // Run the transaction1326    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1327    const events = await submitTransactionAsync(sender, tx);1328    const result = getGenericResult(events);1329    expect(result.success).to.be.true;13301331    // Get the collection1332    const collection = await queryCollectionExpectSuccess(api, collectionId);13331334    expect(collection.permissions.mintMode.toHuman()).to.be.equal(enabled);1335  });1336}13371338export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {1339  await setMintPermissionExpectSuccess(sender, collectionId, true);1340}13411342export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {1343  await usingApi(async (api) => {1344    // Run the transaction1345    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1346    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1347    const result = getCreateCollectionResult(events);1348    // tslint:disable-next-line:no-unused-expression1349    expect(result.success).to.be.false;1350  });1351}13521353export async function setChainLimitsExpectFailure(sender: IKeyringPair, limits: IChainLimits) {1354  await usingApi(async (api) => {1355    // Run the transaction1356    const tx = api.tx.unique.setChainLimits(limits);1357    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1358    const result = getCreateCollectionResult(events);1359    // tslint:disable-next-line:no-unused-expression1360    expect(result.success).to.be.false;1361  });1362}13631364export async function isAllowlisted(api: ApiPromise, collectionId: number, address: string | CrossAccountId) {1365  return (await api.rpc.unique.allowed(collectionId, normalizeAccountId(address))).toJSON();1366}13671368export async function addToAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId | CrossAccountId) {1369  await usingApi(async (api) => {1370    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.false;13711372    // Run the transaction1373    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1374    const events = await submitTransactionAsync(sender, tx);1375    const result = getGenericResult(events);1376    expect(result.success).to.be.true;13771378    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;1379  });1380}13811382export async function addToAllowListAgainExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1383  await usingApi(async (api) => {13841385    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;13861387    // Run the transaction1388    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1389    const events = await submitTransactionAsync(sender, tx);1390    const result = getGenericResult(events);1391    expect(result.success).to.be.true;13921393    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;1394  });1395}13961397export async function addToAllowListExpectFail(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1398  await usingApi(async (api) => {13991400    // Run the transaction1401    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1402    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1403    const result = getGenericResult(events);14041405    // What to expect1406    // tslint:disable-next-line:no-unused-expression1407    expect(result.success).to.be.false;1408  });1409}14101411export async function removeFromAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1412  await usingApi(async (api) => {1413    // Run the transaction1414    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1415    const events = await submitTransactionAsync(sender, tx);1416    const result = getGenericResult(events);14171418    // What to expect1419    // tslint:disable-next-line:no-unused-expression1420    expect(result.success).to.be.true;1421  });1422}14231424export async function removeFromAllowListExpectFailure(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1425  await usingApi(async (api) => {1426    // Run the transaction1427    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1428    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1429    const result = getGenericResult(events);14301431    // What to expect1432    // tslint:disable-next-line:no-unused-expression1433    expect(result.success).to.be.false;1434  });1435}14361437export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)1438  : Promise<UpDataStructsRpcCollection | null> => {1439  return (await api.rpc.unique.collectionById(collectionId)).unwrapOr(null);1440};14411442export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {1443  // set global object - collectionsCount1444  return (await api.rpc.unique.collectionStats()).created.toNumber();1445};14461447export async function queryCollectionExpectSuccess(api: ApiPromise, collectionId: number): Promise<UpDataStructsRpcCollection> {1448  return (await api.rpc.unique.collectionById(collectionId)).unwrap();1449}14501451export async function waitNewBlocks(blocksCount = 1): Promise<void> {1452  await usingApi(async (api) => {1453    const promise = new Promise<void>(async (resolve) => {1454      const unsubscribe = await api.rpc.chain.subscribeNewHeads(() => {1455        if (blocksCount > 0) {1456          blocksCount--;1457        } else {1458          unsubscribe();1459          resolve();1460        }1461      });1462    });1463    return promise;1464  });1465}