git.delta.rocks / unique-network / refs/commits / afa958b4c036

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 {default as usingApi, executeTransaction, submitTransactionAsync, submitTransactionExpectFailAsync} from '../substrate/substrate-api';28import {hexToStr, strToUTF16, utf16ToStr} from './util';29import {UpDataStructsRpcCollection, UpDataStructsCreateItemData, UpDataStructsProperty} from '@polkadot/types/lookup';3031chai.use(chaiAsPromised);32const expect = chai.expect;3334export type CrossAccountId = {35  Substrate: string,36} | {37  Ethereum: string,38};3940export function normalizeAccountId(input: string | AccountId | CrossAccountId | IKeyringPair): CrossAccountId {41  if (typeof input === 'string') {42    if (input.length === 48 || input.length === 47) {43      return {Substrate: input};44    } else if (input.length === 42 && input.startsWith('0x')) {45      return {Ethereum: input.toLowerCase()};46    } else if (input.length === 40 && !input.startsWith('0x')) {47      return {Ethereum: '0x' + input.toLowerCase()};48    } else {49      throw new Error(`Unknown address format: "${input}"`);50    }51  }52  if ('address' in input) {53    return {Substrate: input.address};54  }55  if ('Ethereum' in input) {56    return {57      Ethereum: input.Ethereum.toLowerCase(),58    };59  } else if ('ethereum' in input) {60    return {61      Ethereum: (input as any).ethereum.toLowerCase(),62    };63  } else if ('Substrate' in input) {64    return input;65  } else if ('substrate' in input) {66    return {67      Substrate: (input as any).substrate,68    };69  }7071  // AccountId72  return {Substrate: input.toString()};73}74export function toSubstrateAddress(input: string | CrossAccountId | IKeyringPair): string {75  input = normalizeAccountId(input);76  if ('Substrate' in input) {77    return input.Substrate;78  } else {79    return evmToAddress(input.Ethereum);80  }81}8283export const U128_MAX = (1n << 128n) - 1n;8485const MICROUNIQUE = 1_000_000_000_000n;86const MILLIUNIQUE = 1_000n * MICROUNIQUE;87const CENTIUNIQUE = 10n * MILLIUNIQUE;88export const UNIQUE = 100n * CENTIUNIQUE;8990type GenericResult = {91  success: boolean,92};9394interface CreateCollectionResult {95  success: boolean;96  collectionId: number;97}9899interface CreateItemResult {100  success: boolean;101  collectionId: number;102  itemId: number;103  recipient?: CrossAccountId;104}105106interface TransferResult {107  collectionId: number;108  itemId: number;109  sender?: CrossAccountId;110  recipient?: CrossAccountId;111  value: bigint;112}113114interface IReFungibleOwner {115  fraction: BN;116  owner: number[];117}118119interface IGetMessage {120  checkMsgUnqMethod: string;121  checkMsgTrsMethod: string;122  checkMsgSysMethod: string;123}124125export interface IFungibleTokenDataType {126  value: number;127}128129export interface IChainLimits {130  collectionNumbersLimit: number;131  accountTokenOwnershipLimit: number;132  collectionsAdminsLimit: number;133  customDataLimit: number;134  nftSponsorTransferTimeout: number;135  fungibleSponsorTransferTimeout: number;136  refungibleSponsorTransferTimeout: number;137  //offchainSchemaLimit: number;138  //constOnChainSchemaLimit: number;139}140141export interface IReFungibleTokenDataType {142  owner: IReFungibleOwner[];143}144145export function uniqueEventMessage(events: EventRecord[]): IGetMessage {146  let checkMsgUnqMethod = '';147  let checkMsgTrsMethod = '';148  let checkMsgSysMethod = '';149  events.forEach(({event: {method, section}}) => {150    if (section === 'common') {151      checkMsgUnqMethod = method;152    } else if (section === 'treasury') {153      checkMsgTrsMethod = method;154    } else if (section === 'system') {155      checkMsgSysMethod = method;156    } else { return null; }157  });158  const result: IGetMessage = {159    checkMsgUnqMethod,160    checkMsgTrsMethod,161    checkMsgSysMethod,162  };163  return result;164}165166export function getEvent<T extends Event>(events: EventRecord[], check: (event: IEvent<AnyTuple>) => event is T): T | undefined {167  const event = events.find(r => check(r.event));168  if (!event) return;169  return event.event as T;170}171172export function getGenericResult(events: EventRecord[]): GenericResult {173  const result: GenericResult = {174    success: false,175  };176  events.forEach(({event: {method}}) => {177    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);178    if (method === 'ExtrinsicSuccess') {179      result.success = true;180    }181  });182  return result;183}184185186187export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {188  let success = false;189  let collectionId = 0;190  events.forEach(({event: {data, method, section}}) => {191    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);192    if (method == 'ExtrinsicSuccess') {193      success = true;194    } else if ((section == 'common') && (method == 'CollectionCreated')) {195      collectionId = parseInt(data[0].toString(), 10);196    }197  });198  const result: CreateCollectionResult = {199    success,200    collectionId,201  };202  return result;203}204205export function getCreateItemsResult(events: EventRecord[]): CreateItemResult[] {206  let success = false;207  let collectionId = 0;208  let itemId = 0;209  let recipient;210211  const results : CreateItemResult[]  = [];212213  events.forEach(({event: {data, method, section}}) => {214    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);215    if (method == 'ExtrinsicSuccess') {216      success = true;217    } else if ((section == 'common') && (method == 'ItemCreated')) {218      collectionId = parseInt(data[0].toString(), 10);219      itemId = parseInt(data[1].toString(), 10);220      recipient = normalizeAccountId(data[2].toJSON() as any);221222      const itemRes: CreateItemResult = {223        success,224        collectionId,225        itemId,226        recipient,227      };228229      results.push(itemRes);230    }231  });232233  return results;234}235236export function getCreateItemResult(events: EventRecord[]): CreateItemResult {237  let success = false;238  let collectionId = 0;239  let itemId = 0;240  let recipient;241  events.forEach(({event: {data, method, section}}) => {242    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);243    if (method == 'ExtrinsicSuccess') {244      success = true;245    } else if ((section == 'common') && (method == 'ItemCreated')) {246      collectionId = parseInt(data[0].toString(), 10);247      itemId = parseInt(data[1].toString(), 10);248      recipient = normalizeAccountId(data[2].toJSON() as any);249    }250  });251  const result: CreateItemResult = {252    success,253    collectionId,254    itemId,255    recipient,256  };257  return result;258}259260export function getTransferResult(api: ApiPromise, events: EventRecord[]): TransferResult {261  for (const {event} of events) {262    if (api.events.common.Transfer.is(event)) {263      const [collection, token, sender, recipient, value] = event.data;264      return {265        collectionId: collection.toNumber(),266        itemId: token.toNumber(),267        sender: normalizeAccountId(sender.toJSON() as any),268        recipient: normalizeAccountId(recipient.toJSON() as any),269        value: value.toBigInt(),270      };271    }272  }273  throw new Error('no transfer event');274}275276interface Nft {277  type: 'NFT';278}279280interface Fungible {281  type: 'Fungible';282  decimalPoints: number;283}284285interface ReFungible {286  type: 'ReFungible';287}288289type CollectionMode = Nft | Fungible | ReFungible;290291export type Property = {292  key: any,293  value: any,294};295296type Permission = {297  mutable: boolean;298  collectionAdmin: boolean;299  tokenOwner: boolean;300}301302type PropertyPermission = {303  key: any;304  permission: Permission;305}306307export type CreateCollectionParams = {308  mode: CollectionMode,309  name: string,310  description: string,311  tokenPrefix: string,312  properties?: Array<Property>,313  propPerm?: Array<PropertyPermission>314};315316const defaultCreateCollectionParams: CreateCollectionParams = {317  description: 'description',318  mode: {type: 'NFT'},319  name: 'name',320  tokenPrefix: 'prefix',321};322323export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {324  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};325326  let collectionId = 0;327  await usingApi(async (api, privateKeyWrapper) => {328    // Get number of collections before the transaction329    const collectionCountBefore = await getCreatedCollectionCount(api);330331    // Run the CreateCollection transaction332    const alicePrivateKey = privateKeyWrapper('//Alice');333334    let modeprm = {};335    if (mode.type === 'NFT') {336      modeprm = {nft: null};337    } else if (mode.type === 'Fungible') {338      modeprm = {fungible: mode.decimalPoints};339    } else if (mode.type === 'ReFungible') {340      modeprm = {refungible: null};341    }342343    const tx = api.tx.unique.createCollectionEx({344      name: strToUTF16(name),345      description: strToUTF16(description),346      tokenPrefix: strToUTF16(tokenPrefix),347      mode: modeprm as any,348    });349    const events = await submitTransactionAsync(alicePrivateKey, tx);350    const result = getCreateCollectionResult(events);351352    // Get number of collections after the transaction353    const collectionCountAfter = await getCreatedCollectionCount(api);354355    // Get the collection356    const collection = await queryCollectionExpectSuccess(api, result.collectionId);357358    // What to expect359    // tslint:disable-next-line:no-unused-expression360    expect(result.success).to.be.true;361    expect(result.collectionId).to.be.equal(collectionCountAfter);362    // tslint:disable-next-line:no-unused-expression363    expect(collection).to.be.not.null;364    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');365    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicesPublicKey));366    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);367    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);368    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);369370    collectionId = result.collectionId;371  });372373  return collectionId;374}375376export async function createCollectionWithPropsExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {377  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};378379  let collectionId = 0;380  await usingApi(async (api, privateKeyWrapper) => {381    // Get number of collections before the transaction382    const collectionCountBefore = await getCreatedCollectionCount(api);383384    // Run the CreateCollection transaction385    const alicePrivateKey = privateKeyWrapper('//Alice');386387    let modeprm = {};388    if (mode.type === 'NFT') {389      modeprm = {nft: null};390    } else if (mode.type === 'Fungible') {391      modeprm = {fungible: mode.decimalPoints};392    } else if (mode.type === 'ReFungible') {393      modeprm = {refungible: null};394    }395396    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});397    const events = await submitTransactionAsync(alicePrivateKey, tx);398    const result = getCreateCollectionResult(events);399400    // Get number of collections after the transaction401    const collectionCountAfter = await getCreatedCollectionCount(api);402403    // Get the collection404    const collection = await queryCollectionExpectSuccess(api, result.collectionId);405406    // What to expect407    // tslint:disable-next-line:no-unused-expression408    expect(result.success).to.be.true;409    expect(result.collectionId).to.be.equal(collectionCountAfter);410    // tslint:disable-next-line:no-unused-expression411    expect(collection).to.be.not.null;412    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');413    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicesPublicKey));414    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);415    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);416    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);417418419    collectionId = result.collectionId;420  });421422  return collectionId;423}424425export async function createCollectionWithPropsExpectFailure(params: Partial<CreateCollectionParams> = {}) {426  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};427428  await usingApi(async (api, privateKeyWrapper) => {429    // Get number of collections before the transaction430    const collectionCountBefore = await getCreatedCollectionCount(api);431432    // Run the CreateCollection transaction433    const alicePrivateKey = privateKeyWrapper('//Alice');434435    let modeprm = {};436    if (mode.type === 'NFT') {437      modeprm = {nft: null};438    } else if (mode.type === 'Fungible') {439      modeprm = {fungible: mode.decimalPoints};440    } else if (mode.type === 'ReFungible') {441      modeprm = {refungible: null};442    }443444    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});445    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;446447448    // Get number of collections after the transaction449    const collectionCountAfter = await getCreatedCollectionCount(api);450451    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');452  });453}454455export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {456  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};457458  let modeprm = {};459  if (mode.type === 'NFT') {460    modeprm = {nft: null};461  } else if (mode.type === 'Fungible') {462    modeprm = {fungible: mode.decimalPoints};463  } else if (mode.type === 'ReFungible') {464    modeprm = {refungible: null};465  }466467  await usingApi(async (api, privateKeyWrapper) => {468    // Get number of collections before the transaction469    const collectionCountBefore = await getCreatedCollectionCount(api);470471    // Run the CreateCollection transaction472    const alicePrivateKey = privateKeyWrapper('//Alice');473    const tx = api.tx.unique.createCollectionEx({name: strToUTF16(name), description: strToUTF16(description), tokenPrefix: strToUTF16(tokenPrefix), mode: modeprm as any});474    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;475476    // Get number of collections after the transaction477    const collectionCountAfter = await getCreatedCollectionCount(api);478479    // What to expect480    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');481  });482}483484export async function findUnusedAddress(api: ApiPromise, seedAddition = ''): Promise<IKeyringPair> {485  let bal = 0n;486  let unused;487  do {488    const randomSeed = 'seed' + Math.floor(Math.random() * Math.floor(10000)) + seedAddition;489    const keyring = new Keyring({type: 'sr25519'});490    unused = keyring.addFromUri(`//${randomSeed}`);491    bal = (await api.query.system.account(unused.address)).data.free.toBigInt();492  } while (bal !== 0n);493  return unused;494}495496export async function getAllowance(api: ApiPromise, collectionId: number, owner: CrossAccountId | string, approved: CrossAccountId | string, tokenId: number) {497  return (await api.rpc.unique.allowance(collectionId, normalizeAccountId(owner), normalizeAccountId(approved), tokenId)).toBigInt();498}499500export function findUnusedAddresses(api: ApiPromise, amount: number): Promise<IKeyringPair[]> {501  return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, '_' + Date.now())));502}503504export async function findNotExistingCollection(api: ApiPromise): Promise<number> {505  const totalNumber = await getCreatedCollectionCount(api);506  const newCollection: number = totalNumber + 1;507  return newCollection;508}509510function getDestroyResult(events: EventRecord[]): boolean {511  let success = false;512  events.forEach(({event: {method}}) => {513    if (method == 'ExtrinsicSuccess') {514      success = true;515    }516  });517  return success;518}519520export async function destroyCollectionExpectFailure(collectionId: number, senderSeed = '//Alice') {521  await usingApi(async (api, privateKeyWrapper) => {522    // Run the DestroyCollection transaction523    const alicePrivateKey = privateKeyWrapper(senderSeed);524    const tx = api.tx.unique.destroyCollection(collectionId);525    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;526  });527}528529export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed = '//Alice') {530  await usingApi(async (api, privateKeyWrapper) => {531    // Run the DestroyCollection transaction532    const alicePrivateKey = privateKeyWrapper(senderSeed);533    const tx = api.tx.unique.destroyCollection(collectionId);534    const events = await submitTransactionAsync(alicePrivateKey, tx);535    const result = getDestroyResult(events);536    expect(result).to.be.true;537538    // What to expect539    expect(await getDetailedCollectionInfo(api, collectionId)).to.be.null;540  });541}542543export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {544  await usingApi(async (api) => {545    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);546    const events = await submitTransactionAsync(sender, tx);547    const result = getGenericResult(events);548549    expect(result.success).to.be.true;550  });551}552553export const setCollectionPermissionsExpectSuccess = async (sender: IKeyringPair, collectionId: number, permissions: {mintMode?: boolean, access?: 'Normal' | 'AllowList', nesting?: 'Disabled' | 'Owner' | {OwnerRestricted: number[]}}) => {554  await usingApi(async(api) => {555    const tx = api.tx.unique.setCollectionPermissions(collectionId, permissions);556    const events = await submitTransactionAsync(sender, tx);557    const result = getGenericResult(events);558559    expect(result.success).to.be.true;560  });561};562563export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {564  await usingApi(async (api) => {565    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);566    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;567    const result = getGenericResult(events);568569    expect(result.success).to.be.false;570  });571}572573export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string, sender = '//Alice') {574  await usingApi(async (api, privateKeyWrapper) => {575576    // Run the transaction577    const senderPrivateKey = privateKeyWrapper(sender);578    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);579    const events = await submitTransactionAsync(senderPrivateKey, tx);580    const result = getGenericResult(events);581582    // Get the collection583    const collection = await queryCollectionExpectSuccess(api, collectionId);584585    // What to expect586    expect(result.success).to.be.true;587    expect(collection.sponsorship.toJSON()).to.deep.equal({588      unconfirmed: sponsor,589    });590  });591}592593export async function removeCollectionSponsorExpectSuccess(collectionId: number, sender = '//Alice') {594  await usingApi(async (api, privateKeyWrapper) => {595596    // Run the transaction597    const alicePrivateKey = privateKeyWrapper(sender);598    const tx = api.tx.unique.removeCollectionSponsor(collectionId);599    const events = await submitTransactionAsync(alicePrivateKey, tx);600    const result = getGenericResult(events);601602    // Get the collection603    const collection = await queryCollectionExpectSuccess(api, collectionId);604605    // What to expect606    expect(result.success).to.be.true;607    expect(collection.sponsorship.toJSON()).to.be.deep.equal({disabled: null});608  });609}610611export async function removeCollectionSponsorExpectFailure(collectionId: number, senderSeed = '//Alice') {612  await usingApi(async (api, privateKeyWrapper) => {613614    // Run the transaction615    const alicePrivateKey = privateKeyWrapper(senderSeed);616    const tx = api.tx.unique.removeCollectionSponsor(collectionId);617    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;618  });619}620621export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed = '//Alice') {622  await usingApi(async (api, privateKeyWrapper) => {623624    // Run the transaction625    const alicePrivateKey = privateKeyWrapper(senderSeed);626    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);627    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;628  });629}630631export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed = '//Alice') {632  await usingApi(async (api, privateKeyWrapper) => {633634    // Run the transaction635    const sender = privateKeyWrapper(senderSeed);636    await confirmSponsorshipByKeyExpectSuccess(collectionId, sender);637  });638}639640export async function confirmSponsorshipByKeyExpectSuccess(collectionId: number, sender: IKeyringPair) {641  await usingApi(async (api, privateKeyWrapper) => {642643    // Run the transaction644    const tx = api.tx.unique.confirmSponsorship(collectionId);645    const events = await submitTransactionAsync(sender, tx);646    const result = getGenericResult(events);647648    // Get the collection649    const collection = await queryCollectionExpectSuccess(api, collectionId);650651    // What to expect652    expect(result.success).to.be.true;653    expect(collection.sponsorship.toJSON()).to.be.deep.equal({654      confirmed: sender.address,655    });656  });657}658659660export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed = '//Alice') {661  await usingApi(async (api, privateKeyWrapper) => {662663    // Run the transaction664    const sender = privateKeyWrapper(senderSeed);665    const tx = api.tx.unique.confirmSponsorship(collectionId);666    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;667  });668}669670export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {671  await usingApi(async (api) => {672    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);673    const events = await submitTransactionAsync(sender, tx);674    const result = getGenericResult(events);675676    expect(result.success).to.be.true;677  });678}679680export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {681  await usingApi(async (api) => {682    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);683    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;684    const result = getGenericResult(events);685686    expect(result.success).to.be.false;687  });688}689690export async function setTransferFlagExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {691692  await usingApi(async (api) => {693694    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);695    const events = await submitTransactionAsync(sender, tx);696    const result = getGenericResult(events);697698    expect(result.success).to.be.true;699  });700}701702export async function setTransferFlagExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {703704  await usingApi(async (api) => {705706    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);707    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;708    const result = getGenericResult(events);709710    expect(result.success).to.be.false;711  });712}713714export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {715  await usingApi(async (api) => {716    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);717    const events = await submitTransactionAsync(sender, tx);718    const result = getGenericResult(events);719720    expect(result.success).to.be.true;721  });722}723724export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {725  await usingApi(async (api) => {726    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);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 getNextSponsored(735  api: ApiPromise,736  collectionId: number,737  account: string | CrossAccountId,738  tokenId: number,739): Promise<number> {740  return Number((await api.rpc.unique.nextSponsored(collectionId, account, tokenId)).unwrapOr(-1));741}742743export async function toggleContractAllowlistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, value = true) {744  await usingApi(async (api) => {745    const tx = api.tx.unique.toggleContractAllowList(contractAddress, value);746    const events = await submitTransactionAsync(sender, tx);747    const result = getGenericResult(events);748749    expect(result.success).to.be.true;750  });751}752753export async function isAllowlistedInContract(contractAddress: AccountId | string, user: string) {754  let allowlisted = false;755  await usingApi(async (api) => {756    allowlisted = (await api.query.unique.contractAllowList(contractAddress, user)).toJSON() as boolean;757  });758  return allowlisted;759}760761export async function addToContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {762  await usingApi(async (api) => {763    const tx = api.tx.unique.addToContractAllowList(contractAddress.toString(), user.toString());764    const events = await submitTransactionAsync(sender, tx);765    const result = getGenericResult(events);766767    expect(result.success).to.be.true;768  });769}770771export async function removeFromContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {772  await usingApi(async (api) => {773    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());774    const events = await submitTransactionAsync(sender, tx);775    const result = getGenericResult(events);776777    expect(result.success).to.be.true;778  });779}780781export async function removeFromContractAllowListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {782  await usingApi(async (api) => {783    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());784    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;785    const result = getGenericResult(events);786787    expect(result.success).to.be.false;788  });789}790791export interface CreateFungibleData {792  readonly Value: bigint;793}794795export interface CreateReFungibleData { }796export interface CreateNftData { }797798export type CreateItemData = {799  NFT: CreateNftData;800} | {801  Fungible: CreateFungibleData;802} | {803  ReFungible: CreateReFungibleData;804};805806export async function burnItemExpectSuccess(sender: IKeyringPair, collectionId: number, tokenId: number, value = 1) {807  await usingApi(async (api) => {808    const balanceBefore = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);809    // if burning token by admin - use adminButnItemExpectSuccess810    expect(balanceBefore >= BigInt(value)).to.be.true;811812    const tx = api.tx.unique.burnItem(collectionId, tokenId, value);813    const events = await submitTransactionAsync(sender, tx);814    const result = getGenericResult(events);815    expect(result.success).to.be.true;816817    const balanceAfter = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);818    expect(balanceAfter + BigInt(value)).to.be.equal(balanceBefore);819  });820}821822export async function823approveExpectSuccess(824  collectionId: number,825  tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string, amount: number | bigint = 1,826) {827  await usingApi(async (api: ApiPromise) => {828    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);829    const events = await submitTransactionAsync(owner, approveUniqueTx);830    const result = getGenericResult(events);831    expect(result.success).to.be.true;832833    expect(await getAllowance(api, collectionId, owner.address, approved, tokenId)).to.be.equal(BigInt(amount));834  });835}836837export async function adminApproveFromExpectSuccess(838  collectionId: number,839  tokenId: number, admin: IKeyringPair, owner: CrossAccountId | string, approved: CrossAccountId | string, amount: number | bigint = 1,840) {841  await usingApi(async (api: ApiPromise) => {842    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);843    const events = await submitTransactionAsync(admin, approveUniqueTx);844    const result = getGenericResult(events);845    expect(result.success).to.be.true;846847    expect(await getAllowance(api, collectionId, owner, approved, tokenId)).to.be.equal(BigInt(amount));848  });849}850851export async function852transferFromExpectSuccess(853  collectionId: number,854  tokenId: number,855  accountApproved: IKeyringPair,856  accountFrom: IKeyringPair | CrossAccountId,857  accountTo: IKeyringPair | CrossAccountId,858  value: number | bigint = 1,859  type = 'NFT',860) {861  await usingApi(async (api: ApiPromise) => {862    const from = normalizeAccountId(accountFrom);863    const to = normalizeAccountId(accountTo);864    let balanceBefore = 0n;865    if (type === 'Fungible' || type === 'ReFungible') {866      balanceBefore = await getBalance(api, collectionId, to, tokenId);867    }868    const transferFromTx = api.tx.unique.transferFrom(normalizeAccountId(accountFrom), to, collectionId, tokenId, value);869    const events = await submitTransactionAsync(accountApproved, transferFromTx);870    const result = getCreateItemResult(events);871    // tslint:disable-next-line:no-unused-expression872    expect(result.success).to.be.true;873    if (type === 'NFT') {874      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);875    }876    if (type === 'Fungible') {877      const balanceAfter = await getBalance(api, collectionId, to, tokenId);878      if (JSON.stringify(to) !== JSON.stringify(from)) {879        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));880      } else {881        expect(balanceAfter).to.be.equal(balanceBefore);882      }883    }884    if (type === 'ReFungible') {885      expect(await getBalance(api, collectionId, to, tokenId)).to.be.equal(balanceBefore + BigInt(value));886    }887  });888}889890export async function891transferFromExpectFail(892  collectionId: number,893  tokenId: number,894  accountApproved: IKeyringPair,895  accountFrom: IKeyringPair,896  accountTo: IKeyringPair,897  value: number | bigint = 1,898) {899  await usingApi(async (api: ApiPromise) => {900    const transferFromTx = api.tx.unique.transferFrom(normalizeAccountId(accountFrom.address), normalizeAccountId(accountTo.address), collectionId, tokenId, value);901    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;902    const result = getCreateCollectionResult(events);903    // tslint:disable-next-line:no-unused-expression904    expect(result.success).to.be.false;905  });906}907908/* eslint no-async-promise-executor: "off" */909export async function getBlockNumber(api: ApiPromise): Promise<number> {910  return new Promise<number>(async (resolve) => {911    const unsubscribe = await api.rpc.chain.subscribeNewHeads((head) => {912      unsubscribe();913      resolve(head.number.toNumber());914    });915  });916}917918export async function addCollectionAdminExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | CrossAccountId) {919  await usingApi(async (api) => {920    const changeAdminTx = api.tx.unique.addCollectionAdmin(collectionId, normalizeAccountId(address));921    const events = await submitTransactionAsync(sender, changeAdminTx);922    const result = getCreateCollectionResult(events);923    expect(result.success).to.be.true;924  });925}926927export async function928getFreeBalance(account: IKeyringPair): Promise<bigint> {929  let balance = 0n;930  await usingApi(async (api) => {931    balance = BigInt((await api.query.system.account(account.address)).data.free.toString());932  });933934  return balance;935}936937export async function transferBalanceTo(api: ApiPromise, source: IKeyringPair, target: string, amount = 1000n * UNIQUE) {938  const tx = api.tx.balances.transfer(target, amount);939  const events = await submitTransactionAsync(source, tx);940  const result = getGenericResult(events);941  expect(result.success).to.be.true;942}943944export async function945scheduleExpectSuccess(946  operationTx: any,947  sender: IKeyringPair,948  blockSchedule: number,949  scheduledId: string,950  period = 1,951  repetitions = 1,952) {953  await usingApi(async (api: ApiPromise) => {954    const blockNumber: number | undefined = await getBlockNumber(api);955    const expectedBlockNumber = blockNumber + blockSchedule;956957    expect(blockNumber).to.be.greaterThan(0);958    const scheduleTx = api.tx.scheduler.scheduleNamed( // schedule959      scheduledId,960      expectedBlockNumber, 961      repetitions > 1 ? [period, repetitions] : null, 962      0, 963      {value: operationTx as any},964    );965966    const events = await submitTransactionAsync(sender, scheduleTx);967    expect(getGenericResult(events).success).to.be.true;968  });969}970971export async function972scheduleExpectFailure(973  operationTx: any,974  sender: IKeyringPair,975  blockSchedule: number,976  scheduledId: string,977  period = 1,978  repetitions = 1,979) {980  await usingApi(async (api: ApiPromise) => {981    const blockNumber: number | undefined = await getBlockNumber(api);982    const expectedBlockNumber = blockNumber + blockSchedule;983984    expect(blockNumber).to.be.greaterThan(0);985    const scheduleTx = api.tx.scheduler.scheduleNamed( // schedule986      scheduledId,987      expectedBlockNumber, 988      repetitions <= 1 ? null : [period, repetitions], 989      0, 990      {value: operationTx as any},991    );992993    //const events = 994    await expect(submitTransactionExpectFailAsync(sender, scheduleTx)).to.be.rejected;995    //expect(getGenericResult(events).success).to.be.false;996  });997}998999export async function1000scheduleTransferAndWaitExpectSuccess(1001  collectionId: number,1002  tokenId: number,1003  sender: IKeyringPair,1004  recipient: IKeyringPair,1005  value: number | bigint = 1,1006  blockSchedule: number,1007  scheduledId: string,1008) {1009  await usingApi(async (api: ApiPromise) => {1010    await scheduleTransferExpectSuccess(collectionId, tokenId, sender, recipient, value, blockSchedule, scheduledId);10111012    const recipientBalanceBefore = (await api.query.system.account(recipient.address)).data.free.toBigInt();10131014    // sleep for n + 1 blocks1015    await waitNewBlocks(blockSchedule + 1);10161017    const recipientBalanceAfter = (await api.query.system.account(recipient.address)).data.free.toBigInt();10181019    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(recipient.address));1020    expect(recipientBalanceAfter).to.be.equal(recipientBalanceBefore);1021  });1022}10231024export async function1025scheduleTransferExpectSuccess(1026  collectionId: number,1027  tokenId: number,1028  sender: IKeyringPair,1029  recipient: IKeyringPair,1030  value: number | bigint = 1,1031  blockSchedule: number,1032  scheduledId: string,1033) {1034  await usingApi(async (api: ApiPromise) => {1035    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value);10361037    await scheduleExpectSuccess(transferTx, sender, blockSchedule, scheduledId);10381039    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(sender.address));1040  });1041}10421043export async function1044scheduleTransferFundsPeriodicExpectSuccess(1045  amount: bigint,1046  sender: IKeyringPair,1047  recipient: IKeyringPair,1048  blockSchedule: number,1049  scheduledId: string,1050  period: number,1051  repetitions: number,1052) {1053  await usingApi(async (api: ApiPromise) => {1054    const transferTx = api.tx.balances.transfer(recipient.address, amount);10551056    const balanceBefore = await getFreeBalance(recipient);1057    1058    await scheduleExpectSuccess(transferTx, sender, blockSchedule, scheduledId, period, repetitions);10591060    expect(await getFreeBalance(recipient)).to.be.equal(balanceBefore);1061  });1062}10631064export async function1065transferExpectSuccess(1066  collectionId: number,1067  tokenId: number,1068  sender: IKeyringPair,1069  recipient: IKeyringPair | CrossAccountId,1070  value: number | bigint = 1,1071  type = 'NFT',1072) {1073  await usingApi(async (api: ApiPromise) => {1074    const from = normalizeAccountId(sender);1075    const to = normalizeAccountId(recipient);10761077    let balanceBefore = 0n;1078    if (type === 'Fungible') {1079      balanceBefore = await getBalance(api, collectionId, to, tokenId);1080    }1081    const transferTx = api.tx.unique.transfer(to, collectionId, tokenId, value);1082    const events = await executeTransaction(api, sender, transferTx);10831084    const result = getTransferResult(api, events);1085    expect(result.collectionId).to.be.equal(collectionId);1086    expect(result.itemId).to.be.equal(tokenId);1087    expect(result.sender).to.be.deep.equal(normalizeAccountId(sender.address));1088    expect(result.recipient).to.be.deep.equal(to);1089    expect(result.value).to.be.equal(BigInt(value));10901091    if (type === 'NFT') {1092      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);1093    }1094    if (type === 'Fungible') {1095      const balanceAfter = await getBalance(api, collectionId, to, tokenId);1096      if (JSON.stringify(to) !== JSON.stringify(from)) {1097        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));1098      } else {1099        expect(balanceAfter).to.be.equal(balanceBefore);1100      }1101    }1102    if (type === 'ReFungible') {1103      expect(await getBalance(api, collectionId, to, tokenId) >= value).to.be.true;1104    }1105  });1106}11071108export async function1109transferExpectFailure(1110  collectionId: number,1111  tokenId: number,1112  sender: IKeyringPair,1113  recipient: IKeyringPair | CrossAccountId,1114  value: number | bigint = 1,1115) {1116  await usingApi(async (api: ApiPromise) => {1117    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1118    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;1119    const result = getGenericResult(events);1120    // if (events && Array.isArray(events)) {1121    //   const result = getCreateCollectionResult(events);1122    // tslint:disable-next-line:no-unused-expression1123    expect(result.success).to.be.false;1124    //}1125  });1126}11271128export async function1129approveExpectFail(1130  collectionId: number,1131  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1,1132) {1133  await usingApi(async (api: ApiPromise) => {1134    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved.address), collectionId, tokenId, amount);1135    const events = await expect(submitTransactionExpectFailAsync(owner, approveUniqueTx)).to.be.rejected;1136    const result = getCreateCollectionResult(events);1137    // tslint:disable-next-line:no-unused-expression1138    expect(result.success).to.be.false;1139  });1140}11411142export async function getBalance(1143  api: ApiPromise,1144  collectionId: number,1145  owner: string | CrossAccountId,1146  token: number,1147): Promise<bigint> {1148  return (await api.rpc.unique.balance(collectionId, normalizeAccountId(owner), token)).toBigInt();1149}1150export async function getTokenOwner(1151  api: ApiPromise,1152  collectionId: number,1153  token: number,1154): Promise<CrossAccountId> {1155  const owner = (await api.rpc.unique.tokenOwner(collectionId, token)).toJSON() as any;1156  if (owner == null) throw new Error('owner == null');1157  return normalizeAccountId(owner);1158}1159export async function getTopmostTokenOwner(1160  api: ApiPromise,1161  collectionId: number,1162  token: number,1163): Promise<CrossAccountId> {1164  const owner = (await api.rpc.unique.topmostTokenOwner(collectionId, token)).toJSON() as any;1165  if (owner == null) throw new Error('owner == null');1166  return normalizeAccountId(owner);1167}1168export async function isTokenExists(1169  api: ApiPromise,1170  collectionId: number,1171  token: number,1172): Promise<boolean> {1173  return (await api.rpc.unique.tokenExists(collectionId, token)).toJSON();1174}1175export async function getLastTokenId(1176  api: ApiPromise,1177  collectionId: number,1178): Promise<number> {1179  return (await api.rpc.unique.lastTokenId(collectionId)).toJSON();1180}1181export async function getAdminList(1182  api: ApiPromise,1183  collectionId: number,1184): Promise<string[]> {1185  return (await api.rpc.unique.adminlist(collectionId)).toHuman() as any;1186}1187export async function getTokenProperties(1188  api: ApiPromise,1189  collectionId: number,1190  tokenId: number,1191  propertyKeys: string[],1192): Promise<UpDataStructsProperty[]> {1193  return (await api.rpc.unique.tokenProperties(collectionId, tokenId, propertyKeys)).toHuman() as any;1194}11951196export async function createFungibleItemExpectSuccess(1197  sender: IKeyringPair,1198  collectionId: number,1199  data: CreateFungibleData,1200  owner: CrossAccountId | string = sender.address,1201) {1202  return await usingApi(async (api) => {1203    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), {Fungible: data});12041205    const events = await submitTransactionAsync(sender, tx);1206    const result = getCreateItemResult(events);12071208    expect(result.success).to.be.true;1209    return result.itemId;1210  });1211}12121213export async function createMultipleItemsWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any, owner: CrossAccountId | string = sender.address) {1214  await usingApi(async (api) => {1215    const to = normalizeAccountId(owner);1216    const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);12171218    const events = await submitTransactionAsync(sender, tx);1219    const result = getCreateItemsResult(events);12201221    for (const res of result) {1222      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1223    }1224  });1225}12261227export async function createMultipleItemsExWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any) {1228  await usingApi(async (api) => {1229    const tx = api.tx.unique.createMultipleItemsEx(collectionId, itemsData);12301231    const events = await submitTransactionAsync(sender, tx);1232    const result = getCreateItemsResult(events);12331234    for (const res of result) {1235      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1236    }1237  });1238}12391240export async function createItemWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, props:  Array<Property>, owner: CrossAccountId | string = sender.address) {1241  let newItemId = 0;1242  await usingApi(async (api) => {1243    const to = normalizeAccountId(owner);1244    const itemCountBefore = await getLastTokenId(api, collectionId);1245    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);12461247    let tx;1248    if (createMode === 'Fungible') {1249      const createData = {fungible: {value: 10}};1250      tx = api.tx.unique.createItem(collectionId, to, createData as any);1251    } else if (createMode === 'ReFungible') {1252      const createData = {refungible: {pieces: 100}};1253      tx = api.tx.unique.createItem(collectionId, to, createData as any);1254    } else {1255      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}});1256      tx = api.tx.unique.createItem(collectionId, to, data as UpDataStructsCreateItemData);1257    }12581259    const events = await submitTransactionAsync(sender, tx);1260    const result = getCreateItemResult(events);12611262    const itemCountAfter = await getLastTokenId(api, collectionId);1263    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);12641265    if (createMode === 'NFT') {1266      expect(await api.rpc.unique.tokenProperties(collectionId, result.itemId)).not.to.be.empty;1267    }12681269    // What to expect1270    // tslint:disable-next-line:no-unused-expression1271    expect(result.success).to.be.true;1272    if (createMode === 'Fungible') {1273      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1274    } else {1275      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1276    }1277    expect(collectionId).to.be.equal(result.collectionId);1278    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1279    expect(to).to.be.deep.equal(result.recipient);1280    newItemId = result.itemId;1281  });1282  return newItemId;1283}12841285export async function createItemWithPropsExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, props: Array<Property>, owner: CrossAccountId | string = sender.address) {1286  await usingApi(async (api) => {12871288    let tx;1289    if (createMode === 'NFT') {1290      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}});1291      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), data);1292    } else {1293      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);1294    }129512961297    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1298    if(events.message && events.message.toString().indexOf('1002: Verification Error') > -1) return;1299    const result = getCreateItemResult(events);13001301    expect(result.success).to.be.false;1302  });1303}13041305export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1306  let newItemId = 0;1307  await usingApi(async (api) => {1308    const to = normalizeAccountId(owner);1309    const itemCountBefore = await getLastTokenId(api, collectionId);1310    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);13111312    let tx;1313    if (createMode === 'Fungible') {1314      const createData = {fungible: {value: 10}};1315      tx = api.tx.unique.createItem(collectionId, to, createData as any);1316    } else if (createMode === 'ReFungible') {1317      const createData = {refungible: {pieces: 100}};1318      tx = api.tx.unique.createItem(collectionId, to, createData as any);1319    } else {1320      const createData = {nft: {}};1321      tx = api.tx.unique.createItem(collectionId, to, createData as any);1322    }13231324    const events = await submitTransactionAsync(sender, tx);1325    const result = getCreateItemResult(events);13261327    const itemCountAfter = await getLastTokenId(api, collectionId);1328    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);13291330    // What to expect1331    // tslint:disable-next-line:no-unused-expression1332    expect(result.success).to.be.true;1333    if (createMode === 'Fungible') {1334      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1335    } else {1336      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1337    }1338    expect(collectionId).to.be.equal(result.collectionId);1339    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1340    expect(to).to.be.deep.equal(result.recipient);1341    newItemId = result.itemId;1342  });1343  return newItemId;1344}13451346export async function createItemExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1347  await usingApi(async (api) => {1348    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);13491350    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1351    const result = getCreateItemResult(events);13521353    expect(result.success).to.be.false;1354  });1355}13561357export async function setPublicAccessModeExpectSuccess(1358  sender: IKeyringPair, collectionId: number,1359  accessMode: 'Normal' | 'AllowList',1360) {1361  await usingApi(async (api) => {13621363    // Run the transaction1364    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});1365    const events = await submitTransactionAsync(sender, tx);1366    const result = getGenericResult(events);13671368    // Get the collection1369    const collection = await queryCollectionExpectSuccess(api, collectionId);13701371    // What to expect1372    // tslint:disable-next-line:no-unused-expression1373    expect(result.success).to.be.true;1374    expect(collection.permissions.access.toHuman()).to.be.equal(accessMode);1375  });1376}13771378export async function setPublicAccessModeExpectFail(1379  sender: IKeyringPair, collectionId: number,1380  accessMode: 'Normal' | 'AllowList',1381) {1382  await usingApi(async (api) => {13831384    // Run the transaction1385    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});1386    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1387    const result = getGenericResult(events);13881389    // What to expect1390    // tslint:disable-next-line:no-unused-expression1391    expect(result.success).to.be.false;1392  });1393}13941395export async function enableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1396  await setPublicAccessModeExpectSuccess(sender, collectionId, 'AllowList');1397}13981399export async function enableAllowListExpectFail(sender: IKeyringPair, collectionId: number) {1400  await setPublicAccessModeExpectFail(sender, collectionId, 'AllowList');1401}14021403export async function disableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1404  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');1405}14061407export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {1408  await usingApi(async (api) => {14091410    // Run the transaction1411    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1412    const events = await submitTransactionAsync(sender, tx);1413    const result = getGenericResult(events);1414    expect(result.success).to.be.true;14151416    // Get the collection1417    const collection = await queryCollectionExpectSuccess(api, collectionId);14181419    expect(collection.permissions.mintMode.toHuman()).to.be.equal(enabled);1420  });1421}14221423export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {1424  await setMintPermissionExpectSuccess(sender, collectionId, true);1425}14261427export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {1428  await usingApi(async (api) => {1429    // Run the transaction1430    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1431    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1432    const result = getCreateCollectionResult(events);1433    // tslint:disable-next-line:no-unused-expression1434    expect(result.success).to.be.false;1435  });1436}14371438export async function setChainLimitsExpectFailure(sender: IKeyringPair, limits: IChainLimits) {1439  await usingApi(async (api) => {1440    // Run the transaction1441    const tx = api.tx.unique.setChainLimits(limits);1442    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1443    const result = getCreateCollectionResult(events);1444    // tslint:disable-next-line:no-unused-expression1445    expect(result.success).to.be.false;1446  });1447}14481449export async function isAllowlisted(api: ApiPromise, collectionId: number, address: string | CrossAccountId) {1450  return (await api.rpc.unique.allowed(collectionId, normalizeAccountId(address))).toJSON();1451}14521453export async function addToAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId | CrossAccountId) {1454  await usingApi(async (api) => {1455    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.false;14561457    // Run the transaction1458    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1459    const events = await submitTransactionAsync(sender, tx);1460    const result = getGenericResult(events);1461    expect(result.success).to.be.true;14621463    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;1464  });1465}14661467export async function addToAllowListAgainExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1468  await usingApi(async (api) => {14691470    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;14711472    // Run the transaction1473    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1474    const events = await submitTransactionAsync(sender, tx);1475    const result = getGenericResult(events);1476    expect(result.success).to.be.true;14771478    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;1479  });1480}14811482export async function addToAllowListExpectFail(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1483  await usingApi(async (api) => {14841485    // Run the transaction1486    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1487    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1488    const result = getGenericResult(events);14891490    // What to expect1491    // tslint:disable-next-line:no-unused-expression1492    expect(result.success).to.be.false;1493  });1494}14951496export async function removeFromAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1497  await usingApi(async (api) => {1498    // Run the transaction1499    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1500    const events = await submitTransactionAsync(sender, tx);1501    const result = getGenericResult(events);15021503    // What to expect1504    // tslint:disable-next-line:no-unused-expression1505    expect(result.success).to.be.true;1506  });1507}15081509export async function removeFromAllowListExpectFailure(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1510  await usingApi(async (api) => {1511    // Run the transaction1512    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1513    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1514    const result = getGenericResult(events);15151516    // What to expect1517    // tslint:disable-next-line:no-unused-expression1518    expect(result.success).to.be.false;1519  });1520}15211522export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)1523  : Promise<UpDataStructsRpcCollection | null> => {1524  return (await api.rpc.unique.collectionById(collectionId)).unwrapOr(null);1525};15261527export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {1528  // set global object - collectionsCount1529  return (await api.rpc.unique.collectionStats()).created.toNumber();1530};15311532export async function queryCollectionExpectSuccess(api: ApiPromise, collectionId: number): Promise<UpDataStructsRpcCollection> {1533  return (await api.rpc.unique.collectionById(collectionId)).unwrap();1534}15351536export async function waitNewBlocks(blocksCount = 1): Promise<void> {1537  await usingApi(async (api) => {1538    const promise = new Promise<void>(async (resolve) => {1539      const unsubscribe = await api.rpc.chain.subscribeNewHeads(() => {1540        if (blocksCount > 0) {1541          blocksCount--;1542        } else {1543          unsubscribe();1544          resolve();1545        }1546      });1547    });1548    return promise;1549  });1550}