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

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import '../interfaces/augment-api-rpc';18import '../interfaces/augment-api-query';19import {ApiPromise} from '@polkadot/api';20import type {AccountId, EventRecord, Event} from '@polkadot/types/interfaces';21import type {GenericEventData} from '@polkadot/types';22import {AnyTuple, IEvent, IKeyringPair} from '@polkadot/types/types';23import {evmToAddress} from '@polkadot/util-crypto';24import BN from 'bn.js';25import chai from 'chai';26import chaiAsPromised from 'chai-as-promised';27import {default as usingApi, executeTransaction, submitTransactionAsync, submitTransactionExpectFailAsync} from '../substrate/substrate-api';28import {hexToStr, strToUTF16, utf16ToStr} from './util';29import {UpDataStructsRpcCollection, UpDataStructsCreateItemData, UpDataStructsProperty} from '@polkadot/types/lookup';30import {UpDataStructsTokenChild} from '../interfaces';3132chai.use(chaiAsPromised);33const expect = chai.expect;3435export type CrossAccountId = {36  Substrate: string,37} | {38  Ethereum: string,39};4041export function normalizeAccountId(input: string | AccountId | CrossAccountId | IKeyringPair): CrossAccountId {42  if (typeof input === 'string') {43    if (input.length >= 47) {44      return {Substrate: input};45    } else if (input.length === 42 && input.startsWith('0x')) {46      return {Ethereum: input.toLowerCase()};47    } else if (input.length === 40 && !input.startsWith('0x')) {48      return {Ethereum: '0x' + input.toLowerCase()};49    } else {50      throw new Error(`Unknown address format: "${input}"`);51    }52  }53  if ('address' in input) {54    return {Substrate: input.address};55  }56  if ('Ethereum' in input) {57    return {58      Ethereum: input.Ethereum.toLowerCase(),59    };60  } else if ('ethereum' in input) {61    return {62      Ethereum: (input as any).ethereum.toLowerCase(),63    };64  } else if ('Substrate' in input) {65    return input;66  } else if ('substrate' in input) {67    return {68      Substrate: (input as any).substrate,69    };70  }7172  // AccountId73  return {Substrate: input.toString()};74}75export function toSubstrateAddress(input: string | CrossAccountId | IKeyringPair): string {76  input = normalizeAccountId(input);77  if ('Substrate' in input) {78    return input.Substrate;79  } else {80    return evmToAddress(input.Ethereum);81  }82}8384export const U128_MAX = (1n << 128n) - 1n;8586const MICROUNIQUE = 1_000_000_000_000n;87const MILLIUNIQUE = 1_000n * MICROUNIQUE;88const CENTIUNIQUE = 10n * MILLIUNIQUE;89export const UNIQUE = 100n * CENTIUNIQUE;9091interface GenericResult<T> {92  success: boolean;93  data: T | null;94}9596interface CreateCollectionResult {97  success: boolean;98  collectionId: number;99}100101interface CreateItemResult {102  success: boolean;103  collectionId: number;104  itemId: number;105  recipient?: CrossAccountId;106}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<T>(events: EventRecord[]): GenericResult<T>;175export function getGenericResult<T>(176  events: EventRecord[],177  expectSection: string,178  expectMethod: string,179  extractAction: (data: GenericEventData) => T180): GenericResult<T>;181182export function getGenericResult<T>(183  events: EventRecord[],184  expectSection?: string,185  expectMethod?: string,186  extractAction?: (data: GenericEventData) => T,187): GenericResult<T> {188  let success = false;189  let successData = null;190191  events.forEach(({event: {data, method, section}}) => {192    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);193    if (method === 'ExtrinsicSuccess') {194      success = true;195    } else if ((expectSection == section) && (expectMethod == method)) {196      successData = extractAction!(data as any);197    }198  });199200  const result: GenericResult<T> = {201    success,202    data: successData,203  };204  return result;205}206207export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {208  const genericResult = getGenericResult(events, 'common', 'CollectionCreated', (data) => parseInt(data[0].toString(), 10));209  const result: CreateCollectionResult = {210    success: genericResult.success,211    collectionId: genericResult.data ?? 0,212  };213  return result;214}215216export function getCreateItemsResult(events: EventRecord[]): CreateItemResult[] {217  const results: CreateItemResult[] = [];218  219  const genericResult = getGenericResult<CreateItemResult[]>(events, 'common', 'ItemCreated', (data) => {220    const collectionId = parseInt(data[0].toString(), 10);221    const itemId = parseInt(data[1].toString(), 10);222    const recipient = normalizeAccountId(data[2].toJSON() as any);223224    const itemRes: CreateItemResult = {225      success: true,226      collectionId,227      itemId,228      recipient,229    };230231    results.push(itemRes);232    return results;233  });234235  if (!genericResult.success) return [];236  return results;237}238239export function getCreateItemResult(events: EventRecord[]): CreateItemResult {240  const genericResult = getGenericResult<[number, number, CrossAccountId?]>(events, 'common', 'ItemCreated', (data) => [241    parseInt(data[0].toString(), 10),242    parseInt(data[1].toString(), 10),243    normalizeAccountId(data[2].toJSON() as any),244  ]);245246  if (genericResult.data == null) genericResult.data = [0, 0];247248  const result: CreateItemResult = {249    success: genericResult.success,250    collectionId: genericResult.data[0],251    itemId: genericResult.data[1],252    recipient: genericResult.data![2],253  };254  255  return result;256}257258export function getTransferResult(api: ApiPromise, events: EventRecord[]): TransferResult {259  for (const {event} of events) {260    if (api.events.common.Transfer.is(event)) {261      const [collection, token, sender, recipient, value] = event.data;262      return {263        collectionId: collection.toNumber(),264        itemId: token.toNumber(),265        sender: normalizeAccountId(sender.toJSON() as any),266        recipient: normalizeAccountId(recipient.toJSON() as any),267        value: value.toBigInt(),268      };269    }270  }271  throw new Error('no transfer event');272}273274interface Nft {275  type: 'NFT';276}277278interface Fungible {279  type: 'Fungible';280  decimalPoints: number;281}282283interface ReFungible {284  type: 'ReFungible';285}286287export type CollectionMode = Nft | Fungible | ReFungible;288289export type Property = {290  key: any,291  value: any,292};293294type Permission = {295  mutable: boolean;296  collectionAdmin: boolean;297  tokenOwner: boolean;298}299300type PropertyPermission = {301  key: any;302  permission: Permission;303}304305export type CreateCollectionParams = {306  mode: CollectionMode,307  name: string,308  description: string,309  tokenPrefix: string,310  properties?: Array<Property>,311  propPerm?: Array<PropertyPermission>312};313314const defaultCreateCollectionParams: CreateCollectionParams = {315  description: 'description',316  mode: {type: 'NFT'},317  name: 'name',318  tokenPrefix: 'prefix',319};320321export async function322createCollection(323  api: ApiPromise,324  sender: IKeyringPair,325  params: Partial<CreateCollectionParams> = {},326): Promise<CreateCollectionResult> {327  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};328329  let modeprm = {};330  if (mode.type === 'NFT') {331    modeprm = {nft: null};332  } else if (mode.type === 'Fungible') {333    modeprm = {fungible: mode.decimalPoints};334  } else if (mode.type === 'ReFungible') {335    modeprm = {refungible: null};336  }337338  const tx = api.tx.unique.createCollectionEx({339    name: strToUTF16(name),340    description: strToUTF16(description),341    tokenPrefix: strToUTF16(tokenPrefix),342    mode: modeprm as any,343  });344  const events = await submitTransactionAsync(sender, tx);345  return getCreateCollectionResult(events);346}347348export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {349  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};350351  let collectionId = 0;352  await usingApi(async (api, privateKeyWrapper) => {353    // Get number of collections before the transaction354    const collectionCountBefore = await getCreatedCollectionCount(api);355356    // Run the CreateCollection transaction357    const alicePrivateKey = privateKeyWrapper('//Alice');358359    const result = await createCollection(api, alicePrivateKey, params);360361    // Get number of collections after the transaction362    const collectionCountAfter = await getCreatedCollectionCount(api);363364    // Get the collection365    const collection = await queryCollectionExpectSuccess(api, result.collectionId);366367    // What to expect368    // tslint:disable-next-line:no-unused-expression369    expect(result.success).to.be.true;370    expect(result.collectionId).to.be.equal(collectionCountAfter);371    // tslint:disable-next-line:no-unused-expression372    expect(collection).to.be.not.null;373    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');374    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicePrivateKey));375    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);376    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);377    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);378379    collectionId = result.collectionId;380  });381382  return collectionId;383}384385export async function createCollectionWithPropsExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {386  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};387388  let collectionId = 0;389  await usingApi(async (api, privateKeyWrapper) => {390    // Get number of collections before the transaction391    const collectionCountBefore = await getCreatedCollectionCount(api);392393    // Run the CreateCollection transaction394    const alicePrivateKey = privateKeyWrapper('//Alice');395396    let modeprm = {};397    if (mode.type === 'NFT') {398      modeprm = {nft: null};399    } else if (mode.type === 'Fungible') {400      modeprm = {fungible: mode.decimalPoints};401    } else if (mode.type === 'ReFungible') {402      modeprm = {refungible: null};403    }404405    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});406    const events = await submitTransactionAsync(alicePrivateKey, tx);407    const result = getCreateCollectionResult(events);408409    // Get number of collections after the transaction410    const collectionCountAfter = await getCreatedCollectionCount(api);411412    // Get the collection413    const collection = await queryCollectionExpectSuccess(api, result.collectionId);414415    // What to expect416    // tslint:disable-next-line:no-unused-expression417    expect(result.success).to.be.true;418    expect(result.collectionId).to.be.equal(collectionCountAfter);419    // tslint:disable-next-line:no-unused-expression420    expect(collection).to.be.not.null;421    expect(collectionCountAfter).to.be.equal(collectionCountBefore + 1, 'Error: NFT collection NOT created.');422    expect(collection.owner.toString()).to.be.equal(toSubstrateAddress(alicePrivateKey));423    expect(utf16ToStr(collection.name.toJSON() as any)).to.be.equal(name);424    expect(utf16ToStr(collection.description.toJSON() as any)).to.be.equal(description);425    expect(hexToStr(collection.tokenPrefix.toJSON())).to.be.equal(tokenPrefix);426427428    collectionId = result.collectionId;429  });430431  return collectionId;432}433434export async function createCollectionWithPropsExpectFailure(params: Partial<CreateCollectionParams> = {}) {435  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};436437  await usingApi(async (api, privateKeyWrapper) => {438    // Get number of collections before the transaction439    const collectionCountBefore = await getCreatedCollectionCount(api);440441    // Run the CreateCollection transaction442    const alicePrivateKey = privateKeyWrapper('//Alice');443444    let modeprm = {};445    if (mode.type === 'NFT') {446      modeprm = {nft: null};447    } else if (mode.type === 'Fungible') {448      modeprm = {fungible: mode.decimalPoints};449    } else if (mode.type === 'ReFungible') {450      modeprm = {refungible: null};451    }452453    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});454    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;455456457    // Get number of collections after the transaction458    const collectionCountAfter = await getCreatedCollectionCount(api);459460    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');461  });462}463464export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {465  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};466467  let modeprm = {};468  if (mode.type === 'NFT') {469    modeprm = {nft: null};470  } else if (mode.type === 'Fungible') {471    modeprm = {fungible: mode.decimalPoints};472  } else if (mode.type === 'ReFungible') {473    modeprm = {refungible: null};474  }475476  await usingApi(async (api, privateKeyWrapper) => {477    // Get number of collections before the transaction478    const collectionCountBefore = await getCreatedCollectionCount(api);479480    // Run the CreateCollection transaction481    const alicePrivateKey = privateKeyWrapper('//Alice');482    const tx = api.tx.unique.createCollectionEx({name: strToUTF16(name), description: strToUTF16(description), tokenPrefix: strToUTF16(tokenPrefix), mode: modeprm as any});483    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;484485    // Get number of collections after the transaction486    const collectionCountAfter = await getCreatedCollectionCount(api);487488    // What to expect489    expect(collectionCountAfter).to.be.equal(collectionCountBefore, 'Error: Collection with incorrect data created.');490  });491}492493export async function findUnusedAddress(api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair, seedAddition = ''): Promise<IKeyringPair> {494  let bal = 0n;495  let unused;496  do {497    const randomSeed = 'seed' + Math.floor(Math.random() * Math.floor(10000)) + seedAddition;498    unused = privateKeyWrapper(`//${randomSeed}`);499    bal = (await api.query.system.account(unused.address)).data.free.toBigInt();500  } while (bal !== 0n);501  return unused;502}503504export async function getAllowance(api: ApiPromise, collectionId: number, owner: CrossAccountId | string | IKeyringPair, approved: CrossAccountId | string | IKeyringPair, tokenId: number) {505  return (await api.rpc.unique.allowance(collectionId, normalizeAccountId(owner), normalizeAccountId(approved), tokenId)).toBigInt();506}507508export function findUnusedAddresses(api: ApiPromise, privateKeyWrapper: (account: string) => IKeyringPair, amount: number): Promise<IKeyringPair[]> {509  return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, privateKeyWrapper, '_' + Date.now())));510}511512export async function findNotExistingCollection(api: ApiPromise): Promise<number> {513  const totalNumber = await getCreatedCollectionCount(api);514  const newCollection: number = totalNumber + 1;515  return newCollection;516}517518function getDestroyResult(events: EventRecord[]): boolean {519  let success = false;520  events.forEach(({event: {method}}) => {521    if (method == 'ExtrinsicSuccess') {522      success = true;523    }524  });525  return success;526}527528export async function destroyCollectionExpectFailure(collectionId: number, senderSeed = '//Alice') {529  await usingApi(async (api, privateKeyWrapper) => {530    // Run the DestroyCollection transaction531    const alicePrivateKey = privateKeyWrapper(senderSeed);532    const tx = api.tx.unique.destroyCollection(collectionId);533    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;534  });535}536537export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed = '//Alice') {538  await usingApi(async (api, privateKeyWrapper) => {539    // Run the DestroyCollection transaction540    const alicePrivateKey = privateKeyWrapper(senderSeed);541    const tx = api.tx.unique.destroyCollection(collectionId);542    const events = await submitTransactionAsync(alicePrivateKey, tx);543    const result = getDestroyResult(events);544    expect(result).to.be.true;545546    // What to expect547    expect(await getDetailedCollectionInfo(api, collectionId)).to.be.null;548  });549}550551export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {552  await usingApi(async (api) => {553    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);554    const events = await submitTransactionAsync(sender, tx);555    const result = getGenericResult(events);556557    expect(result.success).to.be.true;558  });559}560561export const setCollectionPermissionsExpectSuccess = async (sender: IKeyringPair, collectionId: number, permissions: any) => {562  await usingApi(async(api) => {563    const tx = api.tx.unique.setCollectionPermissions(collectionId, permissions);564    const events = await submitTransactionAsync(sender, tx);565    const result = getGenericResult(events);566567    expect(result.success).to.be.true;568  });569};570571export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {572  await usingApi(async (api) => {573    const tx = api.tx.unique.setCollectionLimits(collectionId, limits);574    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;575    const result = getGenericResult(events);576577    expect(result.success).to.be.false;578  });579}580581export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string, sender = '//Alice') {582  await usingApi(async (api, privateKeyWrapper) => {583584    // Run the transaction585    const senderPrivateKey = privateKeyWrapper(sender);586    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);587    const events = await submitTransactionAsync(senderPrivateKey, tx);588    const result = getGenericResult(events);589590    // Get the collection591    const collection = await queryCollectionExpectSuccess(api, collectionId);592593    // What to expect594    expect(result.success).to.be.true;595    expect(collection.sponsorship.toJSON()).to.deep.equal({596      unconfirmed: sponsor,597    });598  });599}600601export async function removeCollectionSponsorExpectSuccess(collectionId: number, sender = '//Alice') {602  await usingApi(async (api, privateKeyWrapper) => {603604    // Run the transaction605    const alicePrivateKey = privateKeyWrapper(sender);606    const tx = api.tx.unique.removeCollectionSponsor(collectionId);607    const events = await submitTransactionAsync(alicePrivateKey, tx);608    const result = getGenericResult(events);609610    // Get the collection611    const collection = await queryCollectionExpectSuccess(api, collectionId);612613    // What to expect614    expect(result.success).to.be.true;615    expect(collection.sponsorship.toJSON()).to.be.deep.equal({disabled: null});616  });617}618619export async function removeCollectionSponsorExpectFailure(collectionId: number, senderSeed = '//Alice') {620  await usingApi(async (api, privateKeyWrapper) => {621622    // Run the transaction623    const alicePrivateKey = privateKeyWrapper(senderSeed);624    const tx = api.tx.unique.removeCollectionSponsor(collectionId);625    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;626  });627}628629export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed = '//Alice') {630  await usingApi(async (api, privateKeyWrapper) => {631632    // Run the transaction633    const alicePrivateKey = privateKeyWrapper(senderSeed);634    const tx = api.tx.unique.setCollectionSponsor(collectionId, sponsor);635    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;636  });637}638639export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed = '//Alice') {640  await usingApi(async (api, privateKeyWrapper) => {641642    // Run the transaction643    const sender = privateKeyWrapper(senderSeed);644    await confirmSponsorshipByKeyExpectSuccess(collectionId, sender);645  });646}647648export async function confirmSponsorshipByKeyExpectSuccess(collectionId: number, sender: IKeyringPair) {649  await usingApi(async (api, privateKeyWrapper) => {650651    // Run the transaction652    const tx = api.tx.unique.confirmSponsorship(collectionId);653    const events = await submitTransactionAsync(sender, tx);654    const result = getGenericResult(events);655656    // Get the collection657    const collection = await queryCollectionExpectSuccess(api, collectionId);658659    // What to expect660    expect(result.success).to.be.true;661    expect(collection.sponsorship.toJSON()).to.be.deep.equal({662      confirmed: sender.address,663    });664  });665}666667668export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed = '//Alice') {669  await usingApi(async (api, privateKeyWrapper) => {670671    // Run the transaction672    const sender = privateKeyWrapper(senderSeed);673    const tx = api.tx.unique.confirmSponsorship(collectionId);674    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;675  });676}677678export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {679  await usingApi(async (api) => {680    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);681    const events = await submitTransactionAsync(sender, tx);682    const result = getGenericResult(events);683684    expect(result.success).to.be.true;685  });686}687688export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {689  await usingApi(async (api) => {690    const tx = api.tx.unique.enableContractSponsoring(contractAddress, enable);691    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;692    const result = getGenericResult(events);693694    expect(result.success).to.be.false;695  });696}697698export async function setTransferFlagExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {699700  await usingApi(async (api) => {701702    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);703    const events = await submitTransactionAsync(sender, tx);704    const result = getGenericResult(events);705706    expect(result.success).to.be.true;707  });708}709710export async function setTransferFlagExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {711712  await usingApi(async (api) => {713714    const tx = api.tx.unique.setTransfersEnabledFlag(collectionId, enabled);715    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;716    const result = getGenericResult(events);717718    expect(result.success).to.be.false;719  });720}721722export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {723  await usingApi(async (api) => {724    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);725    const events = await submitTransactionAsync(sender, tx);726    const result = getGenericResult(events);727728    expect(result.success).to.be.true;729  });730}731732export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {733  await usingApi(async (api) => {734    const tx = api.tx.unique.setContractSponsoringRateLimit(contractAddress, rateLimit);735    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;736    const result = getGenericResult(events);737738    expect(result.success).to.be.false;739  });740}741742export async function getNextSponsored(743  api: ApiPromise,744  collectionId: number,745  account: string | CrossAccountId,746  tokenId: number,747): Promise<number> {748  return Number((await api.rpc.unique.nextSponsored(collectionId, account, tokenId)).unwrapOr(-1));749}750751export async function toggleContractAllowlistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, value = true) {752  await usingApi(async (api) => {753    const tx = api.tx.unique.toggleContractAllowList(contractAddress, value);754    const events = await submitTransactionAsync(sender, tx);755    const result = getGenericResult(events);756757    expect(result.success).to.be.true;758  });759}760761export async function isAllowlistedInContract(contractAddress: AccountId | string, user: string) {762  let allowlisted = false;763  await usingApi(async (api) => {764    allowlisted = (await api.query.unique.contractAllowList(contractAddress, user)).toJSON() as boolean;765  });766  return allowlisted;767}768769export async function addToContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {770  await usingApi(async (api) => {771    const tx = api.tx.unique.addToContractAllowList(contractAddress.toString(), user.toString());772    const events = await submitTransactionAsync(sender, tx);773    const result = getGenericResult(events);774775    expect(result.success).to.be.true;776  });777}778779export async function removeFromContractAllowListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {780  await usingApi(async (api) => {781    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());782    const events = await submitTransactionAsync(sender, tx);783    const result = getGenericResult(events);784785    expect(result.success).to.be.true;786  });787}788789export async function removeFromContractAllowListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {790  await usingApi(async (api) => {791    const tx = api.tx.unique.removeFromContractAllowList(contractAddress.toString(), user.toString());792    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;793    const result = getGenericResult(events);794795    expect(result.success).to.be.false;796  });797}798799export interface CreateFungibleData {800  readonly Value: bigint;801}802803export interface CreateReFungibleData { }804export interface CreateNftData { }805806export type CreateItemData = {807  NFT: CreateNftData;808} | {809  Fungible: CreateFungibleData;810} | {811  ReFungible: CreateReFungibleData;812};813814export async function burnItem(api: ApiPromise, sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint) : Promise<boolean> {815  const tx = api.tx.unique.burnItem(collectionId, tokenId, value);816  const events = await submitTransactionAsync(sender, tx);817  return getGenericResult(events).success;818}819820export async function burnItemExpectSuccess(sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint = 1) {821  await usingApi(async (api) => {822    const balanceBefore = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);823    // if burning token by admin - use adminButnItemExpectSuccess824    expect(balanceBefore >= BigInt(value)).to.be.true;825826    expect(await burnItem(api, sender, collectionId, tokenId, value)).to.be.true;827828    const balanceAfter = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);829    expect(balanceAfter + BigInt(value)).to.be.equal(balanceBefore);830  });831}832833export async function burnItemExpectFailure(sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint = 1) {834  await usingApi(async (api) => {835    const tx = api.tx.unique.burnItem(collectionId, tokenId, value);836837    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;838    const result = getCreateCollectionResult(events);839    // tslint:disable-next-line:no-unused-expression840    expect(result.success).to.be.false;841  });842}843844export async function burnFromExpectSuccess(sender: IKeyringPair, from: IKeyringPair | CrossAccountId, collectionId: number, tokenId: number, value: number | bigint = 1) {845  await usingApi(async (api) => {846    const tx = api.tx.unique.burnFrom(collectionId, normalizeAccountId(from), tokenId, value);847    const events = await submitTransactionAsync(sender, tx);848    return getGenericResult(events).success;849  });850}851852export async function853approve(854  api: ApiPromise,855  collectionId: number,856  tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string | IKeyringPair, amount: number | bigint,857) {858  const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);859  const events = await submitTransactionAsync(owner, approveUniqueTx);860  return getGenericResult(events).success;861}862863export async function864approveExpectSuccess(865  collectionId: number,866  tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string, amount: number | bigint = 1,867) {868  await usingApi(async (api: ApiPromise) => {869    const result = await approve(api, collectionId, tokenId, owner, approved, amount);870    expect(result).to.be.true;871872    expect(await getAllowance(api, collectionId, owner, approved, tokenId)).to.be.equal(BigInt(amount));873  });874}875876export async function adminApproveFromExpectSuccess(877  collectionId: number,878  tokenId: number, admin: IKeyringPair, owner: CrossAccountId | string, approved: CrossAccountId | string, amount: number | bigint = 1,879) {880  await usingApi(async (api: ApiPromise) => {881    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);882    const events = await submitTransactionAsync(admin, approveUniqueTx);883    const result = getGenericResult(events);884    expect(result.success).to.be.true;885886    expect(await getAllowance(api, collectionId, owner, approved, tokenId)).to.be.equal(BigInt(amount));887  });888}889890export async function891transferFrom(892  api: ApiPromise,893  collectionId: number,894  tokenId: number,895  accountApproved: IKeyringPair,896  accountFrom: IKeyringPair | CrossAccountId,897  accountTo: IKeyringPair | CrossAccountId,898  value: number | bigint,899) {900  const from = normalizeAccountId(accountFrom);901  const to = normalizeAccountId(accountTo);902  const transferFromTx = api.tx.unique.transferFrom(from, to, collectionId, tokenId, value);903  const events = await submitTransactionAsync(accountApproved, transferFromTx);904  return getGenericResult(events).success;905}906907export async function908transferFromExpectSuccess(909  collectionId: number,910  tokenId: number,911  accountApproved: IKeyringPair,912  accountFrom: IKeyringPair | CrossAccountId,913  accountTo: IKeyringPair | CrossAccountId,914  value: number | bigint = 1,915  type = 'NFT',916) {917  await usingApi(async (api: ApiPromise) => {918    const from = normalizeAccountId(accountFrom);919    const to = normalizeAccountId(accountTo);920    let balanceBefore = 0n;921    if (type === 'Fungible' || type === 'ReFungible') {922      balanceBefore = await getBalance(api, collectionId, to, tokenId);923    }924    expect(await transferFrom(api, collectionId, tokenId, accountApproved, accountFrom, accountTo, value)).to.be.true;925    if (type === 'NFT') {926      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);927    }928    if (type === 'Fungible') {929      const balanceAfter = await getBalance(api, collectionId, to, tokenId);930      if (JSON.stringify(to) !== JSON.stringify(from)) {931        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));932      } else {933        expect(balanceAfter).to.be.equal(balanceBefore);934      }935    }936    if (type === 'ReFungible') {937      expect(await getBalance(api, collectionId, to, tokenId)).to.be.equal(balanceBefore + BigInt(value));938    }939  });940}941942export async function943transferFromExpectFail(944  collectionId: number,945  tokenId: number,946  accountApproved: IKeyringPair,947  accountFrom: IKeyringPair,948  accountTo: IKeyringPair,949  value: number | bigint = 1,950) {951  await usingApi(async (api: ApiPromise) => {952    const transferFromTx = api.tx.unique.transferFrom(normalizeAccountId(accountFrom.address), normalizeAccountId(accountTo.address), collectionId, tokenId, value);953    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;954    const result = getCreateCollectionResult(events);955    // tslint:disable-next-line:no-unused-expression956    expect(result.success).to.be.false;957  });958}959960/* eslint no-async-promise-executor: "off" */961export async function getBlockNumber(api: ApiPromise): Promise<number> {962  return new Promise<number>(async (resolve) => {963    const unsubscribe = await api.rpc.chain.subscribeNewHeads((head) => {964      unsubscribe();965      resolve(head.number.toNumber());966    });967  });968}969970export async function addCollectionAdminExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | CrossAccountId) {971  await usingApi(async (api) => {972    const changeAdminTx = api.tx.unique.addCollectionAdmin(collectionId, normalizeAccountId(address));973    const events = await submitTransactionAsync(sender, changeAdminTx);974    const result = getCreateCollectionResult(events);975    expect(result.success).to.be.true;976  });977}978979export async function adminApproveFromExpectFail(980  collectionId: number,981  tokenId: number, admin: IKeyringPair, owner: CrossAccountId | string, approved: CrossAccountId | string, amount: number | bigint = 1,982) {983  await usingApi(async (api: ApiPromise) => {984    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);985    const events = await expect(submitTransactionAsync(admin, approveUniqueTx)).to.be.rejected;986    const result = getGenericResult(events);987    expect(result.success).to.be.false;988  });989}990991export async function992getFreeBalance(account: IKeyringPair): Promise<bigint> {993  let balance = 0n;994  await usingApi(async (api) => {995    balance = BigInt((await api.query.system.account(account.address)).data.free.toString());996  });997998  return balance;999}10001001export async function transferBalanceTo(api: ApiPromise, source: IKeyringPair, target: string, amount = 1000n * UNIQUE) {1002  const tx = api.tx.balances.transfer(target, amount);1003  const events = await submitTransactionAsync(source, tx);1004  const result = getGenericResult(events);1005  expect(result.success).to.be.true;1006}10071008export async function1009scheduleExpectSuccess(1010  operationTx: any,1011  sender: IKeyringPair,1012  blockSchedule: number,1013  scheduledId: string,1014  period = 1,1015  repetitions = 1,1016) {1017  await usingApi(async (api: ApiPromise) => {1018    const blockNumber: number | undefined = await getBlockNumber(api);1019    const expectedBlockNumber = blockNumber + blockSchedule;10201021    expect(blockNumber).to.be.greaterThan(0);1022    const scheduleTx = api.tx.scheduler.scheduleNamed( // schedule1023      scheduledId,1024      expectedBlockNumber, 1025      repetitions > 1 ? [period, repetitions] : null, 1026      0, 1027      {Value: operationTx as any},1028    );10291030    const events = await submitTransactionAsync(sender, scheduleTx);1031    expect(getGenericResult(events).success).to.be.true;1032  });1033}10341035export async function1036scheduleExpectFailure(1037  operationTx: any,1038  sender: IKeyringPair,1039  blockSchedule: number,1040  scheduledId: string,1041  period = 1,1042  repetitions = 1,1043) {1044  await usingApi(async (api: ApiPromise) => {1045    const blockNumber: number | undefined = await getBlockNumber(api);1046    const expectedBlockNumber = blockNumber + blockSchedule;10471048    expect(blockNumber).to.be.greaterThan(0);1049    const scheduleTx = api.tx.scheduler.scheduleNamed( // schedule1050      scheduledId,1051      expectedBlockNumber, 1052      repetitions <= 1 ? null : [period, repetitions], 1053      0, 1054      {Value: operationTx as any},1055    );10561057    //const events = 1058    await expect(submitTransactionExpectFailAsync(sender, scheduleTx)).to.be.rejected;1059    //expect(getGenericResult(events).success).to.be.false;1060  });1061}10621063export async function1064scheduleTransferAndWaitExpectSuccess(1065  collectionId: number,1066  tokenId: number,1067  sender: IKeyringPair,1068  recipient: IKeyringPair,1069  value: number | bigint = 1,1070  blockSchedule: number,1071  scheduledId: string,1072) {1073  await usingApi(async (api: ApiPromise) => {1074    await scheduleTransferExpectSuccess(collectionId, tokenId, sender, recipient, value, blockSchedule, scheduledId);10751076    const recipientBalanceBefore = (await api.query.system.account(recipient.address)).data.free.toBigInt();10771078    // sleep for n + 1 blocks1079    await waitNewBlocks(blockSchedule + 1);10801081    const recipientBalanceAfter = (await api.query.system.account(recipient.address)).data.free.toBigInt();10821083    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(recipient.address));1084    expect(recipientBalanceAfter).to.be.equal(recipientBalanceBefore);1085  });1086}10871088export async function1089scheduleTransferExpectSuccess(1090  collectionId: number,1091  tokenId: number,1092  sender: IKeyringPair,1093  recipient: IKeyringPair,1094  value: number | bigint = 1,1095  blockSchedule: number,1096  scheduledId: string,1097) {1098  await usingApi(async (api: ApiPromise) => {1099    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value);11001101    await scheduleExpectSuccess(transferTx, sender, blockSchedule, scheduledId);11021103    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(sender.address));1104  });1105}11061107export async function1108scheduleTransferFundsPeriodicExpectSuccess(1109  amount: bigint,1110  sender: IKeyringPair,1111  recipient: IKeyringPair,1112  blockSchedule: number,1113  scheduledId: string,1114  period: number,1115  repetitions: number,1116) {1117  await usingApi(async (api: ApiPromise) => {1118    const transferTx = api.tx.balances.transfer(recipient.address, amount);11191120    const balanceBefore = await getFreeBalance(recipient);1121    1122    await scheduleExpectSuccess(transferTx, sender, blockSchedule, scheduledId, period, repetitions);11231124    expect(await getFreeBalance(recipient)).to.be.equal(balanceBefore);1125  });1126}11271128export async function1129transfer(1130  api: ApiPromise,1131  collectionId: number,1132  tokenId: number,1133  sender: IKeyringPair,1134  recipient: IKeyringPair | CrossAccountId,1135  value: number | bigint,1136) : Promise<boolean> {1137  const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1138  const events = await executeTransaction(api, sender, transferTx);1139  return getGenericResult(events).success;1140}11411142export async function1143transferExpectSuccess(1144  collectionId: number,1145  tokenId: number,1146  sender: IKeyringPair,1147  recipient: IKeyringPair | CrossAccountId,1148  value: number | bigint = 1,1149  type = 'NFT',1150) {1151  await usingApi(async (api: ApiPromise) => {1152    const from = normalizeAccountId(sender);1153    const to = normalizeAccountId(recipient);11541155    let balanceBefore = 0n;1156    if (type === 'Fungible' || type === 'ReFungible') {1157      balanceBefore = await getBalance(api, collectionId, to, tokenId);1158    }11591160    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1161    const events = await executeTransaction(api, sender, transferTx);1162    const result = getTransferResult(api, events);11631164    expect(result.collectionId).to.be.equal(collectionId);1165    expect(result.itemId).to.be.equal(tokenId);1166    expect(result.sender).to.be.deep.equal(normalizeAccountId(sender.address));1167    expect(result.recipient).to.be.deep.equal(to);1168    expect(result.value).to.be.equal(BigInt(value));11691170    if (type === 'NFT') {1171      expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);1172    }1173    if (type === 'Fungible' || type === 'ReFungible') {1174      const balanceAfter = await getBalance(api, collectionId, to, tokenId);1175      if (JSON.stringify(to) !== JSON.stringify(from)) {1176        expect(balanceAfter - balanceBefore).to.be.equal(BigInt(value));1177      } else {1178        expect(balanceAfter).to.be.equal(balanceBefore);1179      }1180    }1181  });1182}11831184export async function1185transferExpectFailure(1186  collectionId: number,1187  tokenId: number,1188  sender: IKeyringPair,1189  recipient: IKeyringPair | CrossAccountId,1190  value: number | bigint = 1,1191) {1192  await usingApi(async (api: ApiPromise) => {1193    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);1194    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;1195    const result = getGenericResult(events);1196    // if (events && Array.isArray(events)) {1197    //   const result = getCreateCollectionResult(events);1198    // tslint:disable-next-line:no-unused-expression1199    expect(result.success).to.be.false;1200    //}1201  });1202}12031204export async function1205approveExpectFail(1206  collectionId: number,1207  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1,1208) {1209  await usingApi(async (api: ApiPromise) => {1210    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved.address), collectionId, tokenId, amount);1211    const events = await expect(submitTransactionExpectFailAsync(owner, approveUniqueTx)).to.be.rejected;1212    const result = getCreateCollectionResult(events);1213    // tslint:disable-next-line:no-unused-expression1214    expect(result.success).to.be.false;1215  });1216}12171218export async function getBalance(1219  api: ApiPromise,1220  collectionId: number,1221  owner: string | CrossAccountId | IKeyringPair,1222  token: number,1223): Promise<bigint> {1224  return (await api.rpc.unique.balance(collectionId, normalizeAccountId(owner), token)).toBigInt();1225}1226export async function getTokenOwner(1227  api: ApiPromise,1228  collectionId: number,1229  token: number,1230): Promise<CrossAccountId> {1231  const owner = (await api.rpc.unique.tokenOwner(collectionId, token)).toJSON() as any;1232  if (owner == null) throw new Error('owner == null');1233  return normalizeAccountId(owner);1234}1235export async function getTopmostTokenOwner(1236  api: ApiPromise,1237  collectionId: number,1238  token: number,1239): Promise<CrossAccountId> {1240  const owner = (await api.rpc.unique.topmostTokenOwner(collectionId, token)).toJSON() as any;1241  if (owner == null) throw new Error('owner == null');1242  return normalizeAccountId(owner);1243}1244export async function getTokenChildren(1245  api: ApiPromise,1246  collectionId: number,1247  tokenId: number,1248): Promise<UpDataStructsTokenChild[]> {1249  return (await api.rpc.unique.tokenChildren(collectionId, tokenId)).toJSON() as any;1250}1251export async function isTokenExists(1252  api: ApiPromise,1253  collectionId: number,1254  token: number,1255): Promise<boolean> {1256  return (await api.rpc.unique.tokenExists(collectionId, token)).toJSON();1257}1258export async function getLastTokenId(1259  api: ApiPromise,1260  collectionId: number,1261): Promise<number> {1262  return (await api.rpc.unique.lastTokenId(collectionId)).toJSON();1263}1264export async function getAdminList(1265  api: ApiPromise,1266  collectionId: number,1267): Promise<string[]> {1268  return (await api.rpc.unique.adminlist(collectionId)).toHuman() as any;1269}1270export async function getTokenProperties(1271  api: ApiPromise,1272  collectionId: number,1273  tokenId: number,1274  propertyKeys: string[],1275): Promise<UpDataStructsProperty[]> {1276  return (await api.rpc.unique.tokenProperties(collectionId, tokenId, propertyKeys)).toHuman() as any;1277}12781279export async function createFungibleItemExpectSuccess(1280  sender: IKeyringPair,1281  collectionId: number,1282  data: CreateFungibleData,1283  owner: CrossAccountId | string = sender.address,1284) {1285  return await usingApi(async (api) => {1286    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), {Fungible: data});12871288    const events = await submitTransactionAsync(sender, tx);1289    const result = getCreateItemResult(events);12901291    expect(result.success).to.be.true;1292    return result.itemId;1293  });1294}12951296export async function createMultipleItemsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any, owner: CrossAccountId | string = sender.address) {1297  await usingApi(async (api) => {1298    const to = normalizeAccountId(owner);1299    const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);13001301    const events = await submitTransactionAsync(sender, tx);1302    expect(getGenericResult(events).success).to.be.true;1303  });1304}13051306export async function createMultipleItemsWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any, owner: CrossAccountId | string = sender.address) {1307  await usingApi(async (api) => {1308    const to = normalizeAccountId(owner);1309    const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);13101311    const events = await submitTransactionAsync(sender, tx);1312    const result = getCreateItemsResult(events);13131314    for (const res of result) {1315      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1316    }1317  });1318}13191320export async function createMultipleItemsExWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, itemsData: any) {1321  await usingApi(async (api) => {1322    const tx = api.tx.unique.createMultipleItemsEx(collectionId, itemsData);13231324    const events = await submitTransactionAsync(sender, tx);1325    const result = getCreateItemsResult(events);13261327    for (const res of result) {1328      expect(await api.rpc.unique.tokenProperties(collectionId, res.itemId)).not.to.be.empty;1329    }1330  });1331}13321333export async function createItemWithPropsExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, props:  Array<Property>, owner: CrossAccountId | string = sender.address) {1334  let newItemId = 0;1335  await usingApi(async (api) => {1336    const to = normalizeAccountId(owner);1337    const itemCountBefore = await getLastTokenId(api, collectionId);1338    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);13391340    let tx;1341    if (createMode === 'Fungible') {1342      const createData = {fungible: {value: 10}};1343      tx = api.tx.unique.createItem(collectionId, to, createData as any);1344    } else if (createMode === 'ReFungible') {1345      const createData = {refungible: {pieces: 100}};1346      tx = api.tx.unique.createItem(collectionId, to, createData as any);1347    } else {1348      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}});1349      tx = api.tx.unique.createItem(collectionId, to, data as UpDataStructsCreateItemData);1350    }13511352    const events = await submitTransactionAsync(sender, tx);1353    const result = getCreateItemResult(events);13541355    const itemCountAfter = await getLastTokenId(api, collectionId);1356    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);13571358    if (createMode === 'NFT') {1359      expect(await api.rpc.unique.tokenProperties(collectionId, result.itemId)).not.to.be.empty;1360    }13611362    // What to expect1363    // tslint:disable-next-line:no-unused-expression1364    expect(result.success).to.be.true;1365    if (createMode === 'Fungible') {1366      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1367    } else {1368      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1369    }1370    expect(collectionId).to.be.equal(result.collectionId);1371    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1372    expect(to).to.be.deep.equal(result.recipient);1373    newItemId = result.itemId;1374  });1375  return newItemId;1376}13771378export async function createItemWithPropsExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, props: Array<Property>, owner: CrossAccountId | string = sender.address) {1379  await usingApi(async (api) => {13801381    let tx;1382    if (createMode === 'NFT') {1383      const data = api.createType('UpDataStructsCreateItemData', {NFT: {properties: props}}) as UpDataStructsCreateItemData;1384      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), data);1385    } else {1386      tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);1387    }138813891390    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1391    if(events.message && events.message.toString().indexOf('1002: Verification Error') > -1) return;1392    const result = getCreateItemResult(events);13931394    expect(result.success).to.be.false;1395  });1396}13971398export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1399  let newItemId = 0;1400  await usingApi(async (api) => {1401    const to = normalizeAccountId(owner);1402    const itemCountBefore = await getLastTokenId(api, collectionId);1403    const itemBalanceBefore = await getBalance(api, collectionId, to, newItemId);14041405    let tx;1406    if (createMode === 'Fungible') {1407      const createData = {fungible: {value: 10}};1408      tx = api.tx.unique.createItem(collectionId, to, createData as any);1409    } else if (createMode === 'ReFungible') {1410      const createData = {refungible: {pieces: 100}};1411      tx = api.tx.unique.createItem(collectionId, to, createData as any);1412    } else {1413      const createData = {nft: {}};1414      tx = api.tx.unique.createItem(collectionId, to, createData as any);1415    }14161417    const events = await executeTransaction(api, sender, tx);1418    const result = getCreateItemResult(events);14191420    const itemCountAfter = await getLastTokenId(api, collectionId);1421    const itemBalanceAfter = await getBalance(api, collectionId, to, newItemId);14221423    // What to expect1424    // tslint:disable-next-line:no-unused-expression1425    expect(result.success).to.be.true;1426    if (createMode === 'Fungible') {1427      expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);1428    } else {1429      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);1430    }1431    expect(collectionId).to.be.equal(result.collectionId);1432    expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());1433    expect(to).to.be.deep.equal(result.recipient);1434    newItemId = result.itemId;1435  });1436  return newItemId;1437}14381439export async function createRefungibleToken(api: ApiPromise, sender: IKeyringPair, collectionId: number, amount: bigint, owner: CrossAccountId | IKeyringPair | string = sender.address) : Promise<CreateItemResult> {1440  const createData = {refungible: {pieces: amount}};1441  const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createData as any);14421443  const events = await submitTransactionAsync(sender, tx);1444  return  getCreateItemResult(events);1445}14461447export async function createItemExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {1448  await usingApi(async (api) => {1449    const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);14501451    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1452    const result = getCreateItemResult(events);14531454    expect(result.success).to.be.false;1455  });1456}14571458export async function setPublicAccessModeExpectSuccess(1459  sender: IKeyringPair, collectionId: number,1460  accessMode: 'Normal' | 'AllowList',1461) {1462  await usingApi(async (api) => {14631464    // Run the transaction1465    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});1466    const events = await submitTransactionAsync(sender, tx);1467    const result = getGenericResult(events);14681469    // Get the collection1470    const collection = await queryCollectionExpectSuccess(api, collectionId);14711472    // What to expect1473    // tslint:disable-next-line:no-unused-expression1474    expect(result.success).to.be.true;1475    expect(collection.permissions.access.toHuman()).to.be.equal(accessMode);1476  });1477}14781479export async function setPublicAccessModeExpectFail(1480  sender: IKeyringPair, collectionId: number,1481  accessMode: 'Normal' | 'AllowList',1482) {1483  await usingApi(async (api) => {14841485    // Run the transaction1486    const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: accessMode});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 enableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1497  await setPublicAccessModeExpectSuccess(sender, collectionId, 'AllowList');1498}14991500export async function enableAllowListExpectFail(sender: IKeyringPair, collectionId: number) {1501  await setPublicAccessModeExpectFail(sender, collectionId, 'AllowList');1502}15031504export async function disableAllowListExpectSuccess(sender: IKeyringPair, collectionId: number) {1505  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');1506}15071508export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {1509  await usingApi(async (api) => {15101511    // Run the transaction1512    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1513    const events = await submitTransactionAsync(sender, tx);1514    const result = getGenericResult(events);1515    expect(result.success).to.be.true;15161517    // Get the collection1518    const collection = await queryCollectionExpectSuccess(api, collectionId);15191520    expect(collection.permissions.mintMode.toHuman()).to.be.equal(enabled);1521  });1522}15231524export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {1525  await setMintPermissionExpectSuccess(sender, collectionId, true);1526}15271528export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {1529  await usingApi(async (api) => {1530    // Run the transaction1531    const tx = api.tx.unique.setCollectionPermissions(collectionId, {mintMode: enabled});1532    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1533    const result = getCreateCollectionResult(events);1534    // tslint:disable-next-line:no-unused-expression1535    expect(result.success).to.be.false;1536  });1537}15381539export async function setChainLimitsExpectFailure(sender: IKeyringPair, limits: IChainLimits) {1540  await usingApi(async (api) => {1541    // Run the transaction1542    const tx = api.tx.unique.setChainLimits(limits);1543    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1544    const result = getCreateCollectionResult(events);1545    // tslint:disable-next-line:no-unused-expression1546    expect(result.success).to.be.false;1547  });1548}15491550export async function isAllowlisted(api: ApiPromise, collectionId: number, address: string | CrossAccountId) {1551  return (await api.rpc.unique.allowed(collectionId, normalizeAccountId(address))).toJSON();1552}15531554export async function addToAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId | CrossAccountId) {1555  await usingApi(async (api) => {1556    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.false;15571558    // Run the transaction1559    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1560    const events = await submitTransactionAsync(sender, tx);1561    const result = getGenericResult(events);1562    expect(result.success).to.be.true;15631564    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;1565  });1566}15671568export async function addToAllowListAgainExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1569  await usingApi(async (api) => {15701571    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;15721573    // Run the transaction1574    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1575    const events = await submitTransactionAsync(sender, tx);1576    const result = getGenericResult(events);1577    expect(result.success).to.be.true;15781579    expect(await isAllowlisted(api, collectionId, normalizeAccountId(address))).to.be.true;1580  });1581}15821583export async function addToAllowListExpectFail(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1584  await usingApi(async (api) => {15851586    // Run the transaction1587    const tx = api.tx.unique.addToAllowList(collectionId, normalizeAccountId(address));1588    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1589    const result = getGenericResult(events);15901591    // What to expect1592    // tslint:disable-next-line:no-unused-expression1593    expect(result.success).to.be.false;1594  });1595}15961597export async function removeFromAllowListExpectSuccess(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1598  await usingApi(async (api) => {1599    // Run the transaction1600    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1601    const events = await submitTransactionAsync(sender, tx);1602    const result = getGenericResult(events);16031604    // What to expect1605    // tslint:disable-next-line:no-unused-expression1606    expect(result.success).to.be.true;1607  });1608}16091610export async function removeFromAllowListExpectFailure(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1611  await usingApi(async (api) => {1612    // Run the transaction1613    const tx = api.tx.unique.removeFromAllowList(collectionId, normalizeAccountId(address));1614    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1615    const result = getGenericResult(events);16161617    // What to expect1618    // tslint:disable-next-line:no-unused-expression1619    expect(result.success).to.be.false;1620  });1621}16221623export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)1624  : Promise<UpDataStructsRpcCollection | null> => {1625  return (await api.rpc.unique.collectionById(collectionId)).unwrapOr(null);1626};16271628export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {1629  // set global object - collectionsCount1630  return (await api.rpc.unique.collectionStats()).created.toNumber();1631};16321633export async function queryCollectionExpectSuccess(api: ApiPromise, collectionId: number): Promise<UpDataStructsRpcCollection> {1634  return (await api.rpc.unique.collectionById(collectionId)).unwrap();1635}16361637export async function waitNewBlocks(blocksCount = 1): Promise<void> {1638  await usingApi(async (api) => {1639    const promise = new Promise<void>(async (resolve) => {1640      const unsubscribe = await api.rpc.chain.subscribeNewHeads(() => {1641        if (blocksCount > 0) {1642          blocksCount--;1643        } else {1644          unsubscribe();1645          resolve();1646        }1647      });1648    });1649    return promise;1650  });1651}16521653export async function repartitionRFT(1654  api: ApiPromise,1655  collectionId: number,1656  sender: IKeyringPair,1657  tokenId: number,1658  amount: bigint,1659): Promise<boolean> {1660  const tx = api.tx.unique.repartition(collectionId, tokenId, amount);1661  const events = await submitTransactionAsync(sender, tx);1662  const result = getGenericResult(events);16631664  return result.success;1665}