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

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// SPDX-License-Identifier: Apache-2.034/* eslint-disable @typescript-eslint/no-var-requires */5/* eslint-disable function-call-argument-newline */6/* eslint-disable no-prototype-builtins */78import {ApiPromise, WsProvider, Keyring} from '@polkadot/api';9import {ApiInterfaceEvents, SignerOptions} from '@polkadot/api/types';10import {encodeAddress, decodeAddress, keccakAsHex, evmToAddress, addressToEvm, base58Encode, blake2AsU8a} from '@polkadot/util-crypto';11import {IKeyringPair} from '@polkadot/types/types';12import {hexToU8a} from '@polkadot/util/hex';13import {u8aConcat} from '@polkadot/util/u8a';14import {15  IApiListeners,16  IBlock,17  IEvent,18  IChainProperties,19  ICollectionCreationOptions,20  ICollectionLimits,21  ICollectionPermissions,22  ICrossAccountId,23  ICrossAccountIdLower,24  ILogger,25  INestingPermissions,26  IProperty,27  IStakingInfo,28  ISchedulerOptions,29  ISubstrateBalance,30  IToken,31  ITokenPropertyPermission,32  ITransactionResult,33  IUniqueHelperLog,34  TApiAllowedListeners,35  TEthereumAccount,36  TSigner,37  TSubstrateAccount,38  TNetworks,39  IForeignAssetMetadata,40  AcalaAssetMetadata,41  MoonbeamAssetInfo,42  DemocracyStandardAccountVote,43  IEthCrossAccountId,44} from './types';45import {RuntimeDispatchInfo} from '@polkadot/types/interfaces';46import type {Vec} from '@polkadot/types-codec';47import {FrameSystemEventRecord} from '@polkadot/types/lookup';4849export class CrossAccountId implements ICrossAccountId {50  Substrate?: TSubstrateAccount;51  Ethereum?: TEthereumAccount;5253  constructor(account: ICrossAccountId) {54    if (account.Substrate) this.Substrate = account.Substrate;55    if (account.Ethereum) this.Ethereum = account.Ethereum;56  }5758  static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {59    switch (domain) {60      case 'Substrate': return new CrossAccountId({Substrate: account.address});61      case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();62    }63  }6465  static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {66    return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});67  }6869  static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {70    return encodeAddress(decodeAddress(address), ss58Format);71  }7273  static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {74    return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});75  }7677  withNormalizedSubstrate(ss58Format = 42): CrossAccountId {78    if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);79    return this;80  }8182  static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {83    return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));84  }8586  toEthereum(): CrossAccountId {87    if (this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});88    return this;89  }9091  static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {92    return evmToAddress(address, ss58Format);93  }9495  toSubstrate(ss58Format?: number): CrossAccountId {96    if (this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});97    return this;98  }99100  toLowerCase(): CrossAccountId {101    if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();102    if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();103    return this;104  }105}106107const nesting = {108  toChecksumAddress(address: string): string {109    if (typeof address === 'undefined') return '';110111    if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);112113    address = address.toLowerCase().replace(/^0x/i,'');114    const addressHash = keccakAsHex(address).replace(/^0x/i,'');115    const checksumAddress = ['0x'];116117    for (let i = 0; i < address.length; i++) {118      // If ith character is 8 to f then make it uppercase119      if (parseInt(addressHash[i], 16) > 7) {120        checksumAddress.push(address[i].toUpperCase());121      } else {122        checksumAddress.push(address[i]);123      }124    }125    return checksumAddress.join('');126  },127  tokenIdToAddress(collectionId: number, tokenId: number) {128    return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8, '0')}${tokenId.toString(16).padStart(8, '0')}`);129  },130};131132class UniqueUtil {133  static transactionStatus = {134    NOT_READY: 'NotReady',135    FAIL: 'Fail',136    SUCCESS: 'Success',137  };138139  static chainLogType = {140    EXTRINSIC: 'extrinsic',141    RPC: 'rpc',142  };143144  static getTokenAccount(token: IToken): CrossAccountId {145    return new CrossAccountId({Ethereum: this.getTokenAddress(token)});146  }147148  static getTokenAddress(token: IToken): string {149    return nesting.tokenIdToAddress(token.collectionId, token.tokenId);150  }151152  static getDefaultLogger(): ILogger {153    return {154      log(msg: any, level = 'INFO') {155        console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));156      },157      level: {158        ERROR: 'ERROR',159        WARNING: 'WARNING',160        INFO: 'INFO',161      },162    };163  }164165  static vec2str(arr: string[] | number[]) {166    return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');167  }168169  static str2vec(string: string) {170    if (typeof string !== 'string') return string;171    return Array.from(string).map(x => x.charCodeAt(0));172  }173174  static fromSeed(seed: string, ss58Format = 42) {175    const keyring = new Keyring({type: 'sr25519', ss58Format});176    return keyring.addFromUri(seed);177  }178179  static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {180    if (creationResult.status !== this.transactionStatus.SUCCESS) {181      throw Error('Unable to create collection!');182    }183184    let collectionId = null;185    creationResult.result.events.forEach(({event: {data, method, section}}) => {186      if ((section === 'common') && (method === 'CollectionCreated')) {187        collectionId = parseInt(data[0].toString(), 10);188      }189    });190191    if (collectionId === null) {192      throw Error('No CollectionCreated event was found!');193    }194195    return collectionId;196  }197198  static extractTokensFromCreationResult(creationResult: ITransactionResult): {199    success: boolean,200    tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],201  } {202    if (creationResult.status !== this.transactionStatus.SUCCESS) {203      throw Error('Unable to create tokens!');204    }205    let success = false;206    const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];207    creationResult.result.events.forEach(({event: {data, method, section}}) => {208      if (method === 'ExtrinsicSuccess') {209        success = true;210      } else if ((section === 'common') && (method === 'ItemCreated')) {211        tokens.push({212          collectionId: parseInt(data[0].toString(), 10),213          tokenId: parseInt(data[1].toString(), 10),214          owner: data[2].toHuman(),215          amount: data[3].toBigInt(),216        });217      }218    });219    return {success, tokens};220  }221222  static extractTokensFromBurnResult(burnResult: ITransactionResult): {223    success: boolean,224    tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],225  } {226    if (burnResult.status !== this.transactionStatus.SUCCESS) {227      throw Error('Unable to burn tokens!');228    }229    let success = false;230    const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];231    burnResult.result.events.forEach(({event: {data, method, section}}) => {232      if (method === 'ExtrinsicSuccess') {233        success = true;234      } else if ((section === 'common') && (method === 'ItemDestroyed')) {235        tokens.push({236          collectionId: parseInt(data[0].toString(), 10),237          tokenId: parseInt(data[1].toString(), 10),238          owner: data[2].toHuman(),239          amount: data[3].toBigInt(),240        });241      }242    });243    return {success, tokens};244  }245246  static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {247    let eventId = null;248    events.forEach(({event: {data, method, section}}) => {249      if ((section === expectedSection) && (method === expectedMethod)) {250        eventId = parseInt(data[0].toString(), 10);251      }252    });253254    if (eventId === null) {255      throw Error(`No ${expectedMethod} event was found!`);256    }257    return eventId === collectionId;258  }259260  static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {261    const normalizeAddress = (address: string | ICrossAccountId) => {262      if(typeof address === 'string') return address;263      const obj = {} as any;264      Object.keys(address).forEach(k => {265        obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];266      });267      if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);268      if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();269      return address;270    };271    let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;272    events.forEach(({event: {data, method, section}}) => {273      if ((section === 'common') && (method === 'Transfer')) {274        const hData = (data as any).toJSON();275        transfer = {276          collectionId: hData[0],277          tokenId: hData[1],278          from: normalizeAddress(hData[2]),279          to: normalizeAddress(hData[3]),280          amount: BigInt(hData[4]),281        };282      }283    });284    let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;285    isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);286    isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);287    isSuccess = isSuccess && amount === transfer.amount;288    return isSuccess;289  }290291  static bigIntToDecimals(number: bigint, decimals = 18) {292    const numberStr = number.toString();293    const dotPos = numberStr.length - decimals;294295    if (dotPos <= 0) {296      return '0.' + '0'.repeat(Math.abs(dotPos)) + numberStr;297    } else {298      const intPart = numberStr.substring(0, dotPos);299      const fractPart = numberStr.substring(dotPos);300      return intPart + '.' + fractPart;301    }302  }303}304305class UniqueEventHelper {306  private static extractIndex(index: any): [number, number] | string {307    if(index.toRawType() === '[u8;2]') return [index[0], index[1]];308    return index.toJSON();309  }310311  private static extractSub(data: any, subTypes: any): {[key: string]: any} {312    let obj: any = {};313    let index = 0;314315    if (data.entries) {316      for(const [key, value] of data.entries()) {317        obj[key] = this.extractData(value, subTypes[index]);318        index++;319      }320    } else obj = data.toJSON();321322    return obj;323  }324325  private static toHuman(data: any) {326    return data && data.toHuman ? data.toHuman() : `${data}`;327  }328329  private static extractData(data: any, type: any): any {330    if(!type) return this.toHuman(data);331    if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();332    if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();333    if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);334    return this.toHuman(data);335  }336337  public static extractEvents(events: {event: any, phase: any}[]): IEvent[] {338    const parsedEvents: IEvent[] = [];339340    events.forEach((record) => {341      const {event, phase} = record;342      const types = event.typeDef;343344      const eventData: IEvent = {345        section: event.section.toString(),346        method: event.method.toString(),347        index: this.extractIndex(event.index),348        data: [],349        phase: phase.toJSON(),350      };351352      event.data.forEach((val: any, index: number) => {353        eventData.data.push(this.extractData(val, types[index]));354      });355356      parsedEvents.push(eventData);357    });358359    return parsedEvents;360  }361}362363export class ChainHelperBase {364  helperBase: any;365366  transactionStatus = UniqueUtil.transactionStatus;367  chainLogType = UniqueUtil.chainLogType;368  util: typeof UniqueUtil;369  eventHelper: typeof UniqueEventHelper;370  logger: ILogger;371  api: ApiPromise | null;372  forcedNetwork: TNetworks | null;373  network: TNetworks | null;374  wsEndpoint: string | null;375  chainLog: IUniqueHelperLog[];376  children: ChainHelperBase[];377  address: AddressGroup;378  chain: ChainGroup;379380  constructor(logger?: ILogger, helperBase?: any) {381    this.helperBase = helperBase;382383    this.util = UniqueUtil;384    this.eventHelper = UniqueEventHelper;385    if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();386    this.logger = logger;387    this.api = null;388    this.forcedNetwork = null;389    this.network = null;390    this.wsEndpoint = null;391    this.chainLog = [];392    this.children = [];393    this.address = new AddressGroup(this);394    this.chain = new ChainGroup(this);395  }396397  clone(helperCls: ChainHelperBaseConstructor, options: {[key: string]: any} = {}) {398    Object.setPrototypeOf(helperCls.prototype, this);399    const newHelper = new helperCls(this.logger, options);400401    newHelper.api = this.api;402    newHelper.network = this.network;403    newHelper.forceNetwork = this.forceNetwork;404405    this.children.push(newHelper);406407    return newHelper;408  }409410  getEndpoint(): string {411    if (this.wsEndpoint === null) throw Error('No connection was established');412    return this.wsEndpoint;413  }414415  getApi(): ApiPromise {416    if(this.api === null) throw Error('API not initialized');417    return this.api;418  }419420  async subscribeEvents(expectedEvents: {section: string, names: string[]}[]) {421    const collectedEvents: IEvent[] = [];422    const unsubscribe = await this.getApi().query.system.events((events: Vec<FrameSystemEventRecord>) => {423      const ievents = this.eventHelper.extractEvents(events);424      ievents.forEach((event) => {425        expectedEvents.forEach((e => {426          if (event.section === e.section && e.names.includes(event.method)) {427            collectedEvents.push(event);428          }429        }));430      });431    });432    return {unsubscribe: unsubscribe as any, collectedEvents};433  }434435  clearChainLog(): void {436    this.chainLog = [];437  }438439  forceNetwork(value: TNetworks): void {440    this.forcedNetwork = value;441  }442443  async connect(wsEndpoint: string, listeners?: IApiListeners) {444    if (this.api !== null) throw Error('Already connected');445    const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);446    this.wsEndpoint = wsEndpoint;447    this.api = api;448    this.network = network;449  }450451  async disconnect() {452    for (const child of this.children) {453      child.clearApi();454    }455456    if (this.api === null) return;457    await this.api.disconnect();458    this.clearApi();459  }460461  clearApi() {462    this.api = null;463    this.network = null;464  }465466  static async detectNetwork(api: ApiPromise): Promise<TNetworks> {467    const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;468    const xcmChains = ['rococo', 'westend', 'westmint', 'acala', 'karura', 'moonbeam', 'moonriver'];469470    if(xcmChains.indexOf(spec.specName) > -1) return spec.specName;471472    if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;473    return 'opal';474  }475476  static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TNetworks> {477    const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});478    await api.isReady;479480    const network = await this.detectNetwork(api);481482    await api.disconnect();483484    return network;485  }486487  static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TNetworks | null): Promise<{488    api: ApiPromise;489    network: TNetworks;490  }> {491    if(typeof network === 'undefined' || network === null) network = 'opal';492    const supportedRPC = {493      opal: {494        unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,495      },496      quartz: {497        unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,498      },499      unique: {500        unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,501      },502      rococo: {},503      westend: {},504      moonbeam: {},505      moonriver: {},506      acala: {},507      karura: {},508      westmint: {},509    };510    if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);511    const rpc = supportedRPC[network];512513    // TODO: investigate how to replace rpc in runtime514    // api._rpcCore.addUserInterfaces(rpc);515516    const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});517518    await api.isReadyOrError;519520    if (typeof listeners === 'undefined') listeners = {};521    for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {522      if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;523      api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);524    }525526    return {api, network};527  }528529  getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {530    const {events, status} = data;531    if (status.isReady) {532      return this.transactionStatus.NOT_READY;533    }534    if (status.isBroadcast) {535      return this.transactionStatus.NOT_READY;536    }537    if (status.isInBlock || status.isFinalized) {538      const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');539      if (errors.length > 0) {540        return this.transactionStatus.FAIL;541      }542      if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {543        return this.transactionStatus.SUCCESS;544      }545    }546547    return this.transactionStatus.FAIL;548  }549550  signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {551    const sign = (callback: any) => {552      if(options !== null) return transaction.signAndSend(sender, options, callback);553      return transaction.signAndSend(sender, callback);554    };555    // eslint-disable-next-line no-async-promise-executor556    return new Promise(async (resolve, reject) => {557      try {558        const unsub = await sign((result: any) => {559          const status = this.getTransactionStatus(result);560561          if (status === this.transactionStatus.SUCCESS) {562            this.logger.log(`${label} successful`);563            unsub();564            resolve({result, status, blockHash: result.status.asInBlock.toHuman()});565          } else if (status === this.transactionStatus.FAIL) {566            let moduleError = null;567568            if (result.hasOwnProperty('dispatchError')) {569              const dispatchError = result['dispatchError'];570571              if (dispatchError) {572                if (dispatchError.isModule) {573                  const modErr = dispatchError.asModule;574                  const errorMeta = dispatchError.registry.findMetaError(modErr);575576                  moduleError = `${errorMeta.section}.${errorMeta.name}`;577                } else {578                  moduleError = dispatchError.toHuman();579                }580              } else {581                this.logger.log(result, this.logger.level.ERROR);582              }583            }584585            this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);586            unsub();587            reject({status, moduleError, result});588          }589        });590      } catch (e) {591        this.logger.log(e, this.logger.level.ERROR);592        reject(e);593      }594    });595  }596597  async signTransactionWithoutSending(signer: TSigner, tx: any) {598    const api = this.getApi();599    const signingInfo = await api.derive.tx.signingInfo(signer.address);600601    tx.sign(signer, {602      blockHash: api.genesisHash,603      genesisHash: api.genesisHash,604      runtimeVersion: api.runtimeVersion,605      nonce: signingInfo.nonce,606    });607608    return tx.toHex();609  }610611  async getPaymentInfo(signer: TSigner, tx: any, len: number | null) {612    const api = this.getApi();613    const signingInfo = await api.derive.tx.signingInfo(signer.address);614615    // We need to sign the tx because616    // unsigned transactions does not have an inclusion fee617    tx.sign(signer, {618      blockHash: api.genesisHash,619      genesisHash: api.genesisHash,620      runtimeVersion: api.runtimeVersion,621      nonce: signingInfo.nonce,622    });623624    if (len === null) {625      return (await this.callRpc('api.rpc.payment.queryInfo', [tx.toHex()])) as RuntimeDispatchInfo;626    } else {627      return (await api.call.transactionPaymentApi.queryInfo(tx, len)) as RuntimeDispatchInfo;628    }629  }630631  constructApiCall(apiCall: string, params: any[]) {632    if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);633    let call = this.getApi() as any;634    for(const part of apiCall.slice(4).split('.')) {635      call = call[part];636      if (!call) {637        const advice = part.includes('_') ? ' Looks like it needs to be converted to camel case.' : '';638        throw Error(`Function ${part} of api call ${apiCall} not found.${advice}`);639      }640    }641    return call(...params);642  }643644  async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null/*, failureMessage='expected success'*/) {645    if(this.api === null) throw Error('API not initialized');646    if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);647648    const startTime = (new Date()).getTime();649    let result: ITransactionResult;650    let events: IEvent[] = [];651    try {652      result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;653      events = this.eventHelper.extractEvents(result.result.events);654      const errorEvent = events.find((event) => event.method == 'ExecutedFailed' || event.method == 'CreatedFailed');655      if (errorEvent)656        throw Error(errorEvent.method + ': ' + extrinsic);657    }658    catch(e) {659      if(!(e as object).hasOwnProperty('status')) throw e;660      result = e as ITransactionResult;661    }662663    const endTime = (new Date()).getTime();664665    const log = {666      executedAt: endTime,667      executionTime: endTime - startTime,668      type: this.chainLogType.EXTRINSIC,669      status: result.status,670      call: extrinsic,671      signer: this.getSignerAddress(sender),672      params,673    } as IUniqueHelperLog;674675    let errorMessage = '';676677    if(result.status !== this.transactionStatus.SUCCESS) {678      if (result.moduleError) {679        errorMessage = typeof result.moduleError === 'string'680          ? result.moduleError681          : `${Object.keys(result.moduleError)[0]}: ${Object.values(result.moduleError)[0]}`;682        log.moduleError = errorMessage;683      }684      else if (result.result.dispatchError) log.dispatchError = result.result.dispatchError;685    }686    if(events.length > 0) log.events = events;687688    this.chainLog.push(log);689690    if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) {691      if (result.moduleError) throw Error(`${errorMessage}`);692      else if (result.result.dispatchError) throw Error(JSON.stringify(result.result.dispatchError));693    }694    return result;695  }696697  async callRpc(rpc: string, params?: any[]) {698    if(typeof params === 'undefined') params = [];699    if(this.api === null) throw Error('API not initialized');700    if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);701702    const startTime = (new Date()).getTime();703    let result;704    let error = null;705    const log = {706      type: this.chainLogType.RPC,707      call: rpc,708      params,709    } as IUniqueHelperLog;710711    try {712      result = await this.constructApiCall(rpc, params);713    }714    catch(e) {715      error = e;716    }717718    const endTime = (new Date()).getTime();719720    log.executedAt = endTime;721    log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';722    log.executionTime = endTime - startTime;723724    this.chainLog.push(log);725726    if(error !== null) throw error;727728    return result;729  }730731  getSignerAddress(signer: IKeyringPair | string): string {732    if(typeof signer === 'string') return signer;733    return signer.address;734  }735736  fetchAllPalletNames(): string[] {737    if(this.api === null) throw Error('API not initialized');738    return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());739  }740741  fetchMissingPalletNames(requiredPallets: string[]): string[] {742    const palletNames = this.fetchAllPalletNames();743    return requiredPallets.filter(p => !palletNames.includes(p));744  }745}746747748class HelperGroup<T extends ChainHelperBase> {749  helper: T;750751  constructor(uniqueHelper: T) {752    this.helper = uniqueHelper;753  }754}755756757class CollectionGroup extends HelperGroup<UniqueHelper> {758  /**759 * Get number of blocks when sponsored transaction is available.760 *761 * @param collectionId ID of collection762 * @param tokenId ID of token763 * @param addressObj address for which the sponsorship is checked764 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});765 * @returns number of blocks or null if sponsorship hasn't been set766 */767  async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {768    return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();769  }770771  /**772   * Get the number of created collections.773   *774   * @returns number of created collections775   */776  async getTotalCount(): Promise<number> {777    return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();778  }779780  /**781   * Get information about the collection with additional data,782   * including the number of tokens it contains, its administrators,783   * the normalized address of the collection's owner, and decoded name and description.784   *785   * @param collectionId ID of collection786   * @example await getData(2)787   * @returns collection information object788   */789  async getData(collectionId: number): Promise<{790    id: number;791    name: string;792    description: string;793    tokensCount: number;794    admins: CrossAccountId[];795    normalizedOwner: TSubstrateAccount;796    raw: any797  } | null> {798    const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);799    const humanCollection = collection.toHuman(), collectionData = {800      id: collectionId, name: null, description: null, tokensCount: 0, admins: [],801      raw: humanCollection,802    } as any, jsonCollection = collection.toJSON();803    if (humanCollection === null) return null;804    collectionData.raw.limits = jsonCollection.limits;805    collectionData.raw.permissions = jsonCollection.permissions;806    collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);807    for (const key of ['name', 'description']) {808      collectionData[key] = this.helper.util.vec2str(humanCollection[key]);809    }810811    collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))812      ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)813      : 0;814    collectionData.admins = await this.getAdmins(collectionId);815816    return collectionData;817  }818819  /**820   * Get the addresses of the collection's administrators, optionally normalized.821   *822   * @param collectionId ID of collection823   * @param normalize whether to normalize the addresses to the default ss58 format824   * @example await getAdmins(1)825   * @returns array of administrators826   */827  async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {828    const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();829830    return normalize831      ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())832      : admins;833  }834835  /**836   * Get the addresses added to the collection allow-list, optionally normalized.837   * @param collectionId ID of collection838   * @param normalize whether to normalize the addresses to the default ss58 format839   * @example await getAllowList(1)840   * @returns array of allow-listed addresses841   */842  async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {843    const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();844    return normalize845      ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())846      : allowListed;847  }848849  /**850   * Get the effective limits of the collection instead of null for default values851   *852   * @param collectionId ID of collection853   * @example await getEffectiveLimits(2)854   * @returns object of collection limits855   */856  async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {857    return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();858  }859860  /**861   * Burns the collection if the signer has sufficient permissions and collection is empty.862   *863   * @param signer keyring of signer864   * @param collectionId ID of collection865   * @example await helper.collection.burn(aliceKeyring, 3);866   * @returns ```true``` if extrinsic success, otherwise ```false```867   */868  async burn(signer: TSigner, collectionId: number): Promise<boolean> {869    const result = await this.helper.executeExtrinsic(870      signer,871      'api.tx.unique.destroyCollection', [collectionId],872      true,873    );874875    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');876  }877878  /**879   * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.880   *881   * @param signer keyring of signer882   * @param collectionId ID of collection883   * @param sponsorAddress Sponsor substrate address884   * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")885   * @returns ```true``` if extrinsic success, otherwise ```false```886   */887  async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {888    const result = await this.helper.executeExtrinsic(889      signer,890      'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],891      true,892    );893894    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorSet');895  }896897  /**898   * Confirms consent to sponsor the collection on behalf of the signer.899   *900   * @param signer keyring of signer901   * @param collectionId ID of collection902   * @example confirmSponsorship(aliceKeyring, 10)903   * @returns ```true``` if extrinsic success, otherwise ```false```904   */905  async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {906    const result = await this.helper.executeExtrinsic(907      signer,908      'api.tx.unique.confirmSponsorship', [collectionId],909      true,910    );911912    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'SponsorshipConfirmed');913  }914915  /**916   * Removes the sponsor of a collection, regardless if it consented or not.917   *918   * @param signer keyring of signer919   * @param collectionId ID of collection920   * @example removeSponsor(aliceKeyring, 10)921   * @returns ```true``` if extrinsic success, otherwise ```false```922   */923  async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {924    const result = await this.helper.executeExtrinsic(925      signer,926      'api.tx.unique.removeCollectionSponsor', [collectionId],927      true,928    );929930    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorRemoved');931  }932933  /**934   * Sets the limits of the collection. At least one limit must be specified for a correct call.935   *936   * @param signer keyring of signer937   * @param collectionId ID of collection938   * @param limits collection limits object939   * @example940   * await setLimits(941   *   aliceKeyring,942   *   10,943   *   {944   *     sponsorTransferTimeout: 0,945   *     ownerCanDestroy: false946   *   }947   * )948   * @returns ```true``` if extrinsic success, otherwise ```false```949   */950  async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {951    const result = await this.helper.executeExtrinsic(952      signer,953      'api.tx.unique.setCollectionLimits', [collectionId, limits],954      true,955    );956957    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionLimitSet');958  }959960  /**961   * Changes the owner of the collection to the new Substrate address.962   *963   * @param signer keyring of signer964   * @param collectionId ID of collection965   * @param ownerAddress substrate address of new owner966   * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")967   * @returns ```true``` if extrinsic success, otherwise ```false```968   */969  async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {970    const result = await this.helper.executeExtrinsic(971      signer,972      'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],973      true,974    );975976    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionOwnerChanged');977  }978979  /**980   * Adds a collection administrator.981   *982   * @param signer keyring of signer983   * @param collectionId ID of collection984   * @param adminAddressObj Administrator address (substrate or ethereum)985   * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})986   * @returns ```true``` if extrinsic success, otherwise ```false```987   */988  async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {989    const result = await this.helper.executeExtrinsic(990      signer,991      'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],992      true,993    );994995    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminAdded');996  }997998  /**999   * Removes a collection administrator.1000   *1001   * @param signer keyring of signer1002   * @param collectionId ID of collection1003   * @param adminAddressObj Administrator address (substrate or ethereum)1004   * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})1005   * @returns ```true``` if extrinsic success, otherwise ```false```1006   */1007  async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {1008    const result = await this.helper.executeExtrinsic(1009      signer,1010      'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],1011      true,1012    );10131014    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminRemoved');1015  }10161017  /**1018   * Check if user is in allow list.1019   *1020   * @param collectionId ID of collection1021   * @param user Account to check1022   * @example await getAdmins(1)1023   * @returns is user in allow list1024   */1025  async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {1026    return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();1027  }10281029  /**1030   * Adds an address to allow list1031   * @param signer keyring of signer1032   * @param collectionId ID of collection1033   * @param addressObj address to add to the allow list1034   * @returns ```true``` if extrinsic success, otherwise ```false```1035   */1036  async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1037    const result = await this.helper.executeExtrinsic(1038      signer,1039      'api.tx.unique.addToAllowList', [collectionId, addressObj],1040      true,1041    );10421043    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressAdded');1044  }10451046  /**1047   * Removes an address from allow list1048   *1049   * @param signer keyring of signer1050   * @param collectionId ID of collection1051   * @param addressObj address to remove from the allow list1052   * @returns ```true``` if extrinsic success, otherwise ```false```1053   */1054  async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1055    const result = await this.helper.executeExtrinsic(1056      signer,1057      'api.tx.unique.removeFromAllowList', [collectionId, addressObj],1058      true,1059    );10601061    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressRemoved');1062  }10631064  /**1065   * Sets onchain permissions for selected collection.1066   *1067   * @param signer keyring of signer1068   * @param collectionId ID of collection1069   * @param permissions collection permissions object1070   * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});1071   * @returns ```true``` if extrinsic success, otherwise ```false```1072   */1073  async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {1074    const result = await this.helper.executeExtrinsic(1075      signer,1076      'api.tx.unique.setCollectionPermissions', [collectionId, permissions],1077      true,1078    );10791080    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPermissionSet');1081  }10821083  /**1084   * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.1085   *1086   * @param signer keyring of signer1087   * @param collectionId ID of collection1088   * @param permissions nesting permissions object1089   * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});1090   * @returns ```true``` if extrinsic success, otherwise ```false```1091   */1092  async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {1093    return await this.setPermissions(signer, collectionId, {nesting: permissions});1094  }10951096  /**1097   * Disables nesting for selected collection.1098   *1099   * @param signer keyring of signer1100   * @param collectionId ID of collection1101   * @example disableNesting(aliceKeyring, 10);1102   * @returns ```true``` if extrinsic success, otherwise ```false```1103   */1104  async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {1105    return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});1106  }11071108  /**1109   * Sets onchain properties to the collection.1110   *1111   * @param signer keyring of signer1112   * @param collectionId ID of collection1113   * @param properties array of property objects1114   * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);1115   * @returns ```true``` if extrinsic success, otherwise ```false```1116   */1117  async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {1118    const result = await this.helper.executeExtrinsic(1119      signer,1120      'api.tx.unique.setCollectionProperties', [collectionId, properties],1121      true,1122    );11231124    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');1125  }11261127  /**1128   * Get collection properties.1129   *1130   * @param collectionId ID of collection1131   * @param propertyKeys optionally filter the returned properties to only these keys1132   * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);1133   * @returns array of key-value pairs1134   */1135  async getProperties(collectionId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1136    return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, propertyKeys])).toHuman();1137  }11381139  async getPropertiesConsumedSpace(collectionId: number): Promise<number> {1140    const api = this.helper.getApi();1141    const props = (await api.query.common.collectionProperties(collectionId)).toJSON();11421143    return (props! as any).consumedSpace;1144  }11451146  async getCollectionOptions(collectionId: number) {1147    return (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1148  }11491150  /**1151   * Deletes onchain properties from the collection.1152   *1153   * @param signer keyring of signer1154   * @param collectionId ID of collection1155   * @param propertyKeys array of property keys to delete1156   * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);1157   * @returns ```true``` if extrinsic success, otherwise ```false```1158   */1159  async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {1160    const result = await this.helper.executeExtrinsic(1161      signer,1162      'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],1163      true,1164    );11651166    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');1167  }11681169  /**1170   * Changes the owner of the token.1171   *1172   * @param signer keyring of signer1173   * @param collectionId ID of collection1174   * @param tokenId ID of token1175   * @param addressObj address of a new owner1176   * @param amount amount of tokens to be transfered. For NFT must be set to 1n1177   * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1178   * @returns true if the token success, otherwise false1179   */1180  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1181    const result = await this.helper.executeExtrinsic(1182      signer,1183      'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],1184      true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1185    );11861187    return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);1188  }11891190  /**1191   *1192   * Change ownership of a token(s) on behalf of the owner.1193   *1194   * @param signer keyring of signer1195   * @param collectionId ID of collection1196   * @param tokenId ID of token1197   * @param fromAddressObj address on behalf of which the token will be sent1198   * @param toAddressObj new token owner1199   * @param amount amount of tokens to be transfered. For NFT must be set to 1n1200   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})1201   * @returns true if the token success, otherwise false1202   */1203  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1204    const result = await this.helper.executeExtrinsic(1205      signer,1206      'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1207      true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1208    );1209    return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1210  }12111212  /**1213   *1214   * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1215   *1216   * @param signer keyring of signer1217   * @param collectionId ID of collection1218   * @param tokenId ID of token1219   * @param amount amount of tokens to be burned. For NFT must be set to 1n1220   * @example burnToken(aliceKeyring, 10, 5);1221   * @returns ```true``` if the extrinsic is successful, otherwise ```false```1222   */1223  async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1224    const burnResult = await this.helper.executeExtrinsic(1225      signer,1226      'api.tx.unique.burnItem', [collectionId, tokenId, amount],1227      true, // `Unable to burn token for ${label}`,1228    );1229    const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1230    if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1231    return burnedTokens.success;1232  }12331234  /**1235   * Destroys a concrete instance of NFT on behalf of the owner1236   *1237   * @param signer keyring of signer1238   * @param collectionId ID of collection1239   * @param tokenId ID of token1240   * @param fromAddressObj address on behalf of which the token will be burnt1241   * @param amount amount of tokens to be burned. For NFT must be set to 1n1242   * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1243   * @returns ```true``` if extrinsic success, otherwise ```false```1244   */1245  async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1246    const burnResult = await this.helper.executeExtrinsic(1247      signer,1248      'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1249      true, // `Unable to burn token from for ${label}`,1250    );1251    const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1252    return burnedTokens.success && burnedTokens.tokens.length > 0;1253  }12541255  /**1256   * Set, change, or remove approved address to transfer the ownership of the NFT.1257   *1258   * @param signer keyring of signer1259   * @param collectionId ID of collection1260   * @param tokenId ID of token1261   * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1262   * @param amount amount of token to be approved. For NFT must be set to 1n1263   * @returns ```true``` if extrinsic success, otherwise ```false```1264   */1265  async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1266    const approveResult = await this.helper.executeExtrinsic(1267      signer,1268      'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1269      true, // `Unable to approve token for ${label}`,1270    );12711272    return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1273  }12741275  /**1276   * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1277   *1278   * @param signer keyring of signer1279   * @param collectionId ID of collection1280   * @param tokenId ID of token1281   * @param fromAddressObj Signer's Ethereum address containing her tokens1282   * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1283   * @param amount amount of token to be approved. For NFT must be set to 1n1284   * @returns ```true``` if extrinsic success, otherwise ```false```1285   */1286  async approveTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {1287    const approveResult = await this.helper.executeExtrinsic(1288      signer,1289      'api.tx.unique.approveFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1290      true, // `Unable to approve token for ${label}`,1291    );12921293    return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1294  }12951296  /**1297   * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1298   *1299   * @param signer keyring of signer1300   * @param collectionId ID of collection1301   * @param tokenId ID of token1302   * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1303   * @param amount amount of token to be approved. For NFT must be set to 1n1304   * @returns ```true``` if extrinsic success, otherwise ```false```1305   */1306  async approveTokenFromEth(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1307    const ethMirror = CrossAccountId.fromKeyring(signer).toEthereum();1308    return await this.approveTokenFrom(signer, collectionId, tokenId, ethMirror, toAddressObj, amount);1309  }13101311  /**1312   * Get the amount of token pieces approved to transfer or burn. Normally 0.1313   *1314   * @param collectionId ID of collection1315   * @param tokenId ID of token1316   * @param toAccountObj address which is approved to use token pieces1317   * @param fromAccountObj address which may have allowed the use of its owned tokens1318   * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1319   * @returns number of approved to transfer pieces1320   */1321  async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1322    return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1323  }13241325  /**1326   * Get the last created token ID in a collection1327   *1328   * @param collectionId ID of collection1329   * @example getLastTokenId(10);1330   * @returns id of the last created token1331   */1332  async getLastTokenId(collectionId: number): Promise<number> {1333    return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1334  }13351336  /**1337   * Check if token exists1338   *1339   * @param collectionId ID of collection1340   * @param tokenId ID of token1341   * @example doesTokenExist(10, 20);1342   * @returns true if the token exists, otherwise false1343   */1344  async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {1345    return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1346  }1347}13481349class NFTnRFT extends CollectionGroup {1350  /**1351   * Get tokens owned by account1352   *1353   * @param collectionId ID of collection1354   * @param addressObj tokens owner1355   * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1356   * @returns array of token ids owned by account1357   */1358  async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1359    return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1360  }13611362  /**1363   * Get token data1364   *1365   * @param collectionId ID of collection1366   * @param tokenId ID of token1367   * @param propertyKeys optionally filter the token properties to only these keys1368   * @param blockHashAt optionally query the data at some block with this hash1369   * @example getToken(10, 5);1370   * @returns human readable token data1371   */1372  async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1373    properties: IProperty[];1374    owner: CrossAccountId;1375    normalizedOwner: CrossAccountId;1376  }| null> {1377    let tokenData;1378    if(typeof blockHashAt === 'undefined') {1379      tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1380    }1381    else {1382      if(propertyKeys.length == 0) {1383        const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1384        if(!collection) return null;1385        propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1386      }1387      tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1388    }1389    tokenData = tokenData.toHuman();1390    if (tokenData === null || tokenData.owner === null) return null;1391    const owner = {} as any;1392    for (const key of Object.keys(tokenData.owner)) {1393      owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate'1394        ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key])1395        : tokenData.owner[key];1396    }1397    tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1398    return tokenData;1399  }14001401  /**1402   * Get token's owner1403   * @param collectionId ID of collection1404   * @param tokenId ID of token1405   * @param blockHashAt optionally query the data at the block with this hash1406   * @example getTokenOwner(10, 5);1407   * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1408   */1409  async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1410    let owner;1411    if (typeof blockHashAt === 'undefined') {1412      owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1413    } else {1414      owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1415    }1416    return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1417  }14181419  /**1420   * Recursively find the address that owns the token1421   * @param collectionId ID of collection1422   * @param tokenId ID of token1423   * @param blockHashAt1424   * @example getTokenTopmostOwner(10, 5);1425   * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1426   */1427  async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1428    let owner;1429    if (typeof blockHashAt === 'undefined') {1430      owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1431    } else {1432      owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1433    }14341435    if (owner === null) return null;14361437    return owner.toHuman();1438  }14391440  /**1441   * Nest one token into another1442   * @param signer keyring of signer1443   * @param tokenObj token to be nested1444   * @param rootTokenObj token to be parent1445   * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});1446   * @returns ```true``` if extrinsic success, otherwise ```false```1447   */1448  async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1449    const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1450    const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1451    if(!result) {1452      throw Error('Unable to nest token!');1453    }1454    return result;1455  }14561457  /**1458     * Remove token from nested state1459     * @param signer keyring of signer1460     * @param tokenObj token to unnest1461     * @param rootTokenObj parent of a token1462     * @param toAddressObj address of a new token owner1463     * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});1464     * @returns ```true``` if extrinsic success, otherwise ```false```1465     */1466  async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1467    const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1468    const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1469    if(!result) {1470      throw Error('Unable to unnest token!');1471    }1472    return result;1473  }14741475  /**1476   * Set permissions to change token properties1477   *1478   * @param signer keyring of signer1479   * @param collectionId ID of collection1480   * @param permissions permissions to change a property by the collection admin or token owner1481   * @example setTokenPropertyPermissions(1482   *   aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1483   * )1484   * @returns true if extrinsic success otherwise false1485   */1486  async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1487    const result = await this.helper.executeExtrinsic(1488      signer,1489      'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1490      true,1491    );14921493    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1494  }14951496  /**1497   * Get token property permissions.1498   *1499   * @param collectionId ID of collection1500   * @param propertyKeys optionally filter the returned property permissions to only these keys1501   * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1502   * @returns array of key-permission pairs1503   */1504  async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1505    return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1506  }15071508  /**1509   * Set token properties1510   *1511   * @param signer keyring of signer1512   * @param collectionId ID of collection1513   * @param tokenId ID of token1514   * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1515   * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1516   * @returns ```true``` if extrinsic success, otherwise ```false```1517   */1518  async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1519    const result = await this.helper.executeExtrinsic(1520      signer,1521      'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1522      true,1523    );15241525    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1526  }15271528  /**1529   * Get properties, metadata assigned to a token.1530   *1531   * @param collectionId ID of collection1532   * @param tokenId ID of token1533   * @param propertyKeys optionally filter the returned properties to only these keys1534   * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1535   * @returns array of key-value pairs1536   */1537  async getTokenProperties(collectionId: number, tokenId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1538    return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, propertyKeys])).toHuman();1539  }15401541  /**1542   * Delete the provided properties of a token1543   * @param signer keyring of signer1544   * @param collectionId ID of collection1545   * @param tokenId ID of token1546   * @param propertyKeys property keys to be deleted1547   * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1548   * @returns ```true``` if extrinsic success, otherwise ```false```1549   */1550  async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1551    const result = await this.helper.executeExtrinsic(1552      signer,1553      'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1554      true,1555    );15561557    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1558  }15591560  /**1561   * Mint new collection1562   *1563   * @param signer keyring of signer1564   * @param collectionOptions basic collection options and properties1565   * @param mode NFT or RFT type of a collection1566   * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1567   * @returns object of the created collection1568   */1569  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1570    collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1571    collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1572    for (const key of ['name', 'description', 'tokenPrefix']) {1573      if (typeof collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] === 'string') collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] = this.helper.util.str2vec(collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] as string);1574    }1575    const creationResult = await this.helper.executeExtrinsic(1576      signer,1577      'api.tx.unique.createCollectionEx', [collectionOptions],1578      true, // errorLabel,1579    );1580    return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1581  }15821583  getCollectionObject(_collectionId: number): any {1584    return null;1585  }15861587  getTokenObject(_collectionId: number, _tokenId: number): any {1588    return null;1589  }15901591  /**1592   * Tells whether the given `owner` approves the `operator`.1593   * @param collectionId ID of collection1594   * @param owner owner address1595   * @param operator operator addrees1596   * @returns true if operator is enabled1597   */1598  async allowanceForAll(collectionId: number, owner: ICrossAccountId, operator: ICrossAccountId): Promise<boolean> {1599    return (await this.helper.callRpc('api.rpc.unique.allowanceForAll', [collectionId, owner, operator])).toJSON();1600  }16011602  /** Sets or unsets the approval of a given operator.1603   *  The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1604   *  @param operator Operator1605   *  @param approved Should operator status be granted or revoked?1606   *  @returns ```true``` if extrinsic success, otherwise ```false```1607   */1608  async setAllowanceForAll(signer: TSigner, collectionId: number, operator: ICrossAccountId, approved: boolean): Promise<boolean> {1609    const result = await this.helper.executeExtrinsic(1610      signer,1611      'api.tx.unique.setAllowanceForAll', [collectionId, operator, approved],1612      true,1613    );1614    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'ApprovedForAll');1615  }1616}161716181619class NFTGroup extends NFTnRFT {1620  /**1621   * Get collection object1622   * @param collectionId ID of collection1623   * @example getCollectionObject(2);1624   * @returns instance of UniqueNFTCollection1625   */1626  getCollectionObject(collectionId: number): UniqueNFTCollection {1627    return new UniqueNFTCollection(collectionId, this.helper);1628  }16291630  /**1631   * Get token object1632   * @param collectionId ID of collection1633   * @param tokenId ID of token1634   * @example getTokenObject(10, 5);1635   * @returns instance of UniqueNFTToken1636   */1637  getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1638    return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1639  }16401641  /**1642   * Is token approved to transfer1643   * @param collectionId ID of collection1644   * @param tokenId ID of token1645   * @param toAccountObj address to be approved1646   * @returns ```true``` if extrinsic success, otherwise ```false```1647   */1648  async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1649    return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1650  }16511652  /**1653   * Changes the owner of the token.1654   *1655   * @param signer keyring of signer1656   * @param collectionId ID of collection1657   * @param tokenId ID of token1658   * @param addressObj address of a new owner1659   * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1660   * @returns ```true``` if extrinsic success, otherwise ```false```1661   */1662  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1663    return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1664  }16651666  /**1667   *1668   * Change ownership of a NFT on behalf of the owner.1669   *1670   * @param signer keyring of signer1671   * @param collectionId ID of collection1672   * @param tokenId ID of token1673   * @param fromAddressObj address on behalf of which the token will be sent1674   * @param toAddressObj new token owner1675   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1676   * @returns ```true``` if extrinsic success, otherwise ```false```1677   */1678  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1679    return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1680  }16811682  /**1683   * Get tokens nested in the provided token1684   * @param collectionId ID of collection1685   * @param tokenId ID of token1686   * @param blockHashAt optionally query the data at the block with this hash1687   * @example getTokenChildren(10, 5);1688   * @returns tokens whose depth of nesting is <= 51689   */1690  async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1691    let children;1692    if(typeof blockHashAt === 'undefined') {1693      children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1694    } else {1695      children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1696    }16971698    return children.toJSON().map((x: any) => {1699      return {collectionId: x.collection, tokenId: x.token};1700    });1701  }17021703  /**1704   * Mint new collection1705   * @param signer keyring of signer1706   * @param collectionOptions Collection options1707   * @example1708   * mintCollection(aliceKeyring, {1709   *   name: 'New',1710   *   description: 'New collection',1711   *   tokenPrefix: 'NEW',1712   * })1713   * @returns object of the created collection1714   */1715  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1716    return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1717  }17181719  /**1720   * Mint new token1721   * @param signer keyring of signer1722   * @param data token data1723   * @returns created token object1724   */1725  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1726    const creationResult = await this.helper.executeExtrinsic(1727      signer,1728      'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1729        nft: {1730          properties: data.properties,1731        },1732      }],1733      true,1734    );1735    const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1736    if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1737    if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1738    return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1739  }17401741  /**1742   * Mint multiple NFT tokens1743   * @param signer keyring of signer1744   * @param collectionId ID of collection1745   * @param tokens array of tokens with owner and properties1746   * @example1747   * mintMultipleTokens(aliceKeyring, 10, [{1748   *     owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1749   *     properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1750   *   },{1751   *     owner: {Ethereum: "0x9F0583DbB855d..."},1752   *     properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1753   * }]);1754   * @returns ```true``` if extrinsic success, otherwise ```false```1755   */1756  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1757    const creationResult = await this.helper.executeExtrinsic(1758      signer,1759      'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1760      true,1761    );1762    const collection = this.getCollectionObject(collectionId);1763    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1764  }17651766  /**1767   * Mint multiple NFT tokens with one owner1768   * @param signer keyring of signer1769   * @param collectionId ID of collection1770   * @param owner tokens owner1771   * @param tokens array of tokens with owner and properties1772   * @example1773   * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1774   *   properties: [{1775   *   key: "gender",1776   *   value: "female",1777   *  },{1778   *   key: "age",1779   *   value: "33",1780   *  }],1781   * }]);1782   * @returns array of newly created tokens1783   */1784  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1785    const rawTokens = [];1786    for (const token of tokens) {1787      const raw = {NFT: {properties: token.properties}};1788      rawTokens.push(raw);1789    }1790    const creationResult = await this.helper.executeExtrinsic(1791      signer,1792      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1793      true,1794    );1795    const collection = this.getCollectionObject(collectionId);1796    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1797  }17981799  /**1800   * Set, change, or remove approved address to transfer the ownership of the NFT.1801   *1802   * @param signer keyring of signer1803   * @param collectionId ID of collection1804   * @param tokenId ID of token1805   * @param toAddressObj address to approve1806   * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1807   * @returns ```true``` if extrinsic success, otherwise ```false```1808   */1809  approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1810    return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1811  }1812}181318141815class RFTGroup extends NFTnRFT {1816  /**1817   * Get collection object1818   * @param collectionId ID of collection1819   * @example getCollectionObject(2);1820   * @returns instance of UniqueRFTCollection1821   */1822  getCollectionObject(collectionId: number): UniqueRFTCollection {1823    return new UniqueRFTCollection(collectionId, this.helper);1824  }18251826  /**1827   * Get token object1828   * @param collectionId ID of collection1829   * @param tokenId ID of token1830   * @example getTokenObject(10, 5);1831   * @returns instance of UniqueNFTToken1832   */1833  getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1834    return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1835  }18361837  /**1838   * Get top 10 token owners with the largest number of pieces1839   * @param collectionId ID of collection1840   * @param tokenId ID of token1841   * @example getTokenTop10Owners(10, 5);1842   * @returns array of top 10 owners1843   */1844  async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1845    return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1846  }18471848  /**1849   * Get number of pieces owned by address1850   * @param collectionId ID of collection1851   * @param tokenId ID of token1852   * @param addressObj address token owner1853   * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1854   * @returns number of pieces ownerd by address1855   */1856  async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1857    return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1858  }18591860  /**1861   * Transfer pieces of token to another address1862   * @param signer keyring of signer1863   * @param collectionId ID of collection1864   * @param tokenId ID of token1865   * @param addressObj address of a new owner1866   * @param amount number of pieces to be transfered1867   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1868   * @returns ```true``` if extrinsic success, otherwise ```false```1869   */1870  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1871    return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1872  }18731874  /**1875   * Change ownership of some pieces of RFT on behalf of the owner.1876   * @param signer keyring of signer1877   * @param collectionId ID of collection1878   * @param tokenId ID of token1879   * @param fromAddressObj address on behalf of which the token will be sent1880   * @param toAddressObj new token owner1881   * @param amount number of pieces to be transfered1882   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1883   * @returns ```true``` if extrinsic success, otherwise ```false```1884   */1885  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1886    return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1887  }18881889  /**1890   * Mint new collection1891   * @param signer keyring of signer1892   * @param collectionOptions Collection options1893   * @example1894   * mintCollection(aliceKeyring, {1895   *   name: 'New',1896   *   description: 'New collection',1897   *   tokenPrefix: 'NEW',1898   * })1899   * @returns object of the created collection1900   */1901  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1902    return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1903  }19041905  /**1906   * Mint new token1907   * @param signer keyring of signer1908   * @param data token data1909   * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1910   * @returns created token object1911   */1912  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1913    const creationResult = await this.helper.executeExtrinsic(1914      signer,1915      'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1916        refungible: {1917          pieces: data.pieces,1918          properties: data.properties,1919        },1920      }],1921      true,1922    );1923    const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1924    if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1925    if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1926    return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1927  }19281929  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1930    throw Error('Not implemented');1931    const creationResult = await this.helper.executeExtrinsic(1932      signer,1933      'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1934      true, // `Unable to mint RFT tokens for ${label}`,1935    );1936    const collection = this.getCollectionObject(collectionId);1937    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1938  }19391940  /**1941   * Mint multiple RFT tokens with one owner1942   * @param signer keyring of signer1943   * @param collectionId ID of collection1944   * @param owner tokens owner1945   * @param tokens array of tokens with properties and pieces1946   * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);1947   * @returns array of newly created RFT tokens1948   */1949  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1950    const rawTokens = [];1951    for (const token of tokens) {1952      const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1953      rawTokens.push(raw);1954    }1955    const creationResult = await this.helper.executeExtrinsic(1956      signer,1957      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1958      true,1959    );1960    const collection = this.getCollectionObject(collectionId);1961    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1962  }19631964  /**1965   * Destroys a concrete instance of RFT.1966   * @param signer keyring of signer1967   * @param collectionId ID of collection1968   * @param tokenId ID of token1969   * @param amount number of pieces to be burnt1970   * @example burnToken(aliceKeyring, 10, 5);1971   * @returns ```true``` if the extrinsic is successful, otherwise ```false```1972   */1973  async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1974    return await super.burnToken(signer, collectionId, tokenId, amount);1975  }19761977  /**1978   * Destroys a concrete instance of RFT on behalf of the owner.1979   * @param signer keyring of signer1980   * @param collectionId ID of collection1981   * @param tokenId ID of token1982   * @param fromAddressObj address on behalf of which the token will be burnt1983   * @param amount number of pieces to be burnt1984   * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)1985   * @returns ```true``` if extrinsic success, otherwise ```false```1986   */1987  async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1988    return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1989  }19901991  /**1992   * Set, change, or remove approved address to transfer the ownership of the RFT.1993   *1994   * @param signer keyring of signer1995   * @param collectionId ID of collection1996   * @param tokenId ID of token1997   * @param toAddressObj address to approve1998   * @param amount number of pieces to be approved1999   * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);2000   * @returns true if the token success, otherwise false2001   */2002  approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {2003    return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);2004  }20052006  /**2007   * Get total number of pieces2008   * @param collectionId ID of collection2009   * @param tokenId ID of token2010   * @example getTokenTotalPieces(10, 5);2011   * @returns number of pieces2012   */2013  async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {2014    return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();2015  }20162017  /**2018   * Change number of token pieces. Signer must be the owner of all token pieces.2019   * @param signer keyring of signer2020   * @param collectionId ID of collection2021   * @param tokenId ID of token2022   * @param amount new number of pieces2023   * @example repartitionToken(aliceKeyring, 10, 5, 12345n);2024   * @returns true if the repartion was success, otherwise false2025   */2026  async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {2027    const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);2028    const repartitionResult = await this.helper.executeExtrinsic(2029      signer,2030      'api.tx.unique.repartition', [collectionId, tokenId, amount],2031      true,2032    );2033    if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');2034    return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');2035  }2036}203720382039class FTGroup extends CollectionGroup {2040  /**2041   * Get collection object2042   * @param collectionId ID of collection2043   * @example getCollectionObject(2);2044   * @returns instance of UniqueFTCollection2045   */2046  getCollectionObject(collectionId: number): UniqueFTCollection {2047    return new UniqueFTCollection(collectionId, this.helper);2048  }20492050  /**2051   * Mint new fungible collection2052   * @param signer keyring of signer2053   * @param collectionOptions Collection options2054   * @param decimalPoints number of token decimals2055   * @example2056   * mintCollection(aliceKeyring, {2057   *   name: 'New',2058   *   description: 'New collection',2059   *   tokenPrefix: 'NEW',2060   * }, 18)2061   * @returns newly created fungible collection2062   */2063  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {2064    collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object2065    if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');2066    collectionOptions.mode = {fungible: decimalPoints};2067    for (const key of ['name', 'description', 'tokenPrefix']) {2068      if (typeof collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] === 'string') collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] = this.helper.util.str2vec(collectionOptions[key as 'name' | 'description' | 'tokenPrefix'] as string);2069    }2070    const creationResult = await this.helper.executeExtrinsic(2071      signer,2072      'api.tx.unique.createCollectionEx', [collectionOptions],2073      true,2074    );2075    return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));2076  }20772078  /**2079   * Mint tokens2080   * @param signer keyring of signer2081   * @param collectionId ID of collection2082   * @param owner address owner of new tokens2083   * @param amount amount of tokens to be meanted2084   * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);2085   * @returns ```true``` if extrinsic success, otherwise ```false```2086   */2087  async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {2088    const creationResult = await this.helper.executeExtrinsic(2089      signer,2090      'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {2091        fungible: {2092          value: amount,2093        },2094      }],2095      true, // `Unable to mint fungible tokens for ${label}`,2096    );2097    return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2098  }20992100  /**2101   * Mint multiple Fungible tokens with one owner2102   * @param signer keyring of signer2103   * @param collectionId ID of collection2104   * @param owner tokens owner2105   * @param tokens array of tokens with properties and pieces2106   * @returns ```true``` if extrinsic success, otherwise ```false```2107   */2108  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {2109    const rawTokens = [];2110    for (const token of tokens) {2111      const raw = {Fungible: {Value: token.value}};2112      rawTokens.push(raw);2113    }2114    const creationResult = await this.helper.executeExtrinsic(2115      signer,2116      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],2117      true,2118    );2119    return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2120  }21212122  /**2123   * Get the top 10 owners with the largest balance for the Fungible collection2124   * @param collectionId ID of collection2125   * @example getTop10Owners(10);2126   * @returns array of ```ICrossAccountId```2127   */2128  async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {2129    return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);2130  }21312132  /**2133   * Get account balance2134   * @param collectionId ID of collection2135   * @param addressObj address of owner2136   * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})2137   * @returns amount of fungible tokens owned by address2138   */2139  async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {2140    return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();2141  }21422143  /**2144   * Transfer tokens to address2145   * @param signer keyring of signer2146   * @param collectionId ID of collection2147   * @param toAddressObj address recipient2148   * @param amount amount of tokens to be sent2149   * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2150   * @returns ```true``` if extrinsic success, otherwise ```false```2151   */2152  async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2153    return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);2154  }21552156  /**2157   * Transfer some tokens on behalf of the owner.2158   * @param signer keyring of signer2159   * @param collectionId ID of collection2160   * @param fromAddressObj address on behalf of which tokens will be sent2161   * @param toAddressObj address where token to be sent2162   * @param amount number of tokens to be sent2163   * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);2164   * @returns ```true``` if extrinsic success, otherwise ```false```2165   */2166  async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2167    return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);2168  }21692170  /**2171   * Destroy some amount of tokens2172   * @param signer keyring of signer2173   * @param collectionId ID of collection2174   * @param amount amount of tokens to be destroyed2175   * @example burnTokens(aliceKeyring, 10, 1000n);2176   * @returns ```true``` if extrinsic success, otherwise ```false```2177   */2178  async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {2179    return await super.burnToken(signer, collectionId, 0, amount);2180  }21812182  /**2183   * Burn some tokens on behalf of the owner.2184   * @param signer keyring of signer2185   * @param collectionId ID of collection2186   * @param fromAddressObj address on behalf of which tokens will be burnt2187   * @param amount amount of tokens to be burnt2188   * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2189   * @returns ```true``` if extrinsic success, otherwise ```false```2190   */2191  async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {2192    return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);2193  }21942195  /**2196   * Get total collection supply2197   * @param collectionId2198   * @returns2199   */2200  async getTotalPieces(collectionId: number): Promise<bigint> {2201    return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();2202  }22032204  /**2205   * Set, change, or remove approved address to transfer tokens.2206   *2207   * @param signer keyring of signer2208   * @param collectionId ID of collection2209   * @param toAddressObj address to be approved2210   * @param amount amount of tokens to be approved2211   * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)2212   * @returns ```true``` if extrinsic success, otherwise ```false```2213   */2214  approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {2215    return super.approveToken(signer, collectionId, 0, toAddressObj, amount);2216  }22172218  /**2219   * Get amount of fungible tokens approved to transfer2220   * @param collectionId ID of collection2221   * @param fromAddressObj owner of tokens2222   * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner2223   * @returns number of tokens approved for the transfer2224   */2225  getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2226    return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);2227  }2228}222922302231class ChainGroup extends HelperGroup<ChainHelperBase> {2232  /**2233   * Get system properties of a chain2234   * @example getChainProperties();2235   * @returns ss58Format, token decimals, and token symbol2236   */2237  getChainProperties(): IChainProperties {2238    const properties = (this.helper.getApi() as any).registry.getChainProperties().toJSON();2239    return {2240      ss58Format: properties.ss58Format.toJSON(),2241      tokenDecimals: properties.tokenDecimals.toJSON(),2242      tokenSymbol: properties.tokenSymbol.toJSON(),2243    };2244  }22452246  /**2247   * Get chain header2248   * @example getLatestBlockNumber();2249   * @returns the number of the last block2250   */2251  async getLatestBlockNumber(): Promise<number> {2252    return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();2253  }22542255  /**2256   * Get block hash by block number2257   * @param blockNumber number of block2258   * @example getBlockHashByNumber(12345);2259   * @returns hash of a block2260   */2261  async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2262    const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2263    if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2264    return blockHash;2265  }22662267  // TODO add docs2268  async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2269    const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2270    if (!blockHash) return null;2271    return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2272  }22732274  /**2275   * Get latest relay block2276   * @returns {number} relay block2277   */2278  async getRelayBlockNumber(): Promise<bigint> {2279    const blockNumber = (await this.helper.callRpc('api.query.parachainSystem.validationData')).toJSON().relayParentNumber;2280    return BigInt(blockNumber);2281  }22822283  /**2284   * Get account nonce2285   * @param address substrate address2286   * @example getNonce("5GrwvaEF5zXb26Fz...");2287   * @returns number, account's nonce2288   */2289  async getNonce(address: TSubstrateAccount): Promise<number> {2290    return (await this.helper.callRpc('api.query.system.account', [address])).nonce.toNumber();2291  }2292}22932294class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2295  /**2296 * Get substrate address balance2297 * @param address substrate address2298 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2299 * @returns amount of tokens on address2300 */2301  async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2302    return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2303  }23042305  /**2306   * Transfer tokens to substrate address2307   * @param signer keyring of signer2308   * @param address substrate address of a recipient2309   * @param amount amount of tokens to be transfered2310   * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2311   * @returns ```true``` if extrinsic success, otherwise ```false```2312   */2313  async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2314    const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true/*, `Unable to transfer balance from ${this.helper.getSignerAddress(signer)} to ${address}`*/);23152316    let transfer = {from: null, to: null, amount: 0n} as any;2317    result.result.events.forEach(({event: {data, method, section}}) => {2318      if ((section === 'balances') && (method === 'Transfer')) {2319        transfer = {2320          from: this.helper.address.normalizeSubstrate(data[0]),2321          to: this.helper.address.normalizeSubstrate(data[1]),2322          amount: BigInt(data[2]),2323        };2324      }2325    });2326    const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from2327      && this.helper.address.normalizeSubstrate(address) === transfer.to2328      && BigInt(amount) === transfer.amount;2329    return isSuccess;2330  }23312332  /**2333   * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2334   * @param address substrate address2335   * @returns2336   */2337  async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2338    const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2339    return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2340  }23412342  async getLocked(address: TSubstrateAccount): Promise<[{id: string, amount: bigint, reason: string}]> {2343    const locks = (await this.helper.callRpc('api.query.balances.locks', [address])).toHuman();2344    return locks.map((lock: any) => {return {id: lock.id, amount: BigInt(lock.amount.replace(/,/g, '')), reasons: lock.reasons};});2345  }2346}23472348class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2349  /**2350   * Get ethereum address balance2351   * @param address ethereum address2352   * @example getEthereum("0x9F0583DbB855d...")2353   * @returns amount of tokens on address2354   */2355  async getEthereum(address: TEthereumAccount): Promise<bigint> {2356    return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2357  }23582359  /**2360   * Transfer tokens to address2361   * @param signer keyring of signer2362   * @param address Ethereum address of a recipient2363   * @param amount amount of tokens to be transfered2364   * @example transferToEthereum(alithKeyring, "0x9F0583DbB855d...", 100_000_000_000n);2365   * @returns ```true``` if extrinsic success, otherwise ```false```2366   */2367  async transferToEthereum(signer: TSigner, address: TEthereumAccount, amount: bigint | string): Promise<boolean> {2368    const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true);23692370    let transfer = {from: null, to: null, amount: 0n} as any;2371    result.result.events.forEach(({event: {data, method, section}}) => {2372      if ((section === 'balances') && (method === 'Transfer')) {2373        transfer = {2374          from: data[0].toString(),2375          to: data[1].toString(),2376          amount: BigInt(data[2]),2377        };2378      }2379    });2380    const isSuccess = (typeof signer === 'string' ? signer : signer.address) === transfer.from2381      && address === transfer.to2382      && BigInt(amount) === transfer.amount;2383    return isSuccess;2384  }2385}23862387class BalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2388  subBalanceGroup: SubstrateBalanceGroup<T>;2389  ethBalanceGroup: EthereumBalanceGroup<T>;23902391  constructor(helper: T) {2392    super(helper);2393    this.subBalanceGroup = new SubstrateBalanceGroup(helper);2394    this.ethBalanceGroup = new EthereumBalanceGroup(helper);2395  }23962397  getCollectionCreationPrice(): bigint {2398    return 2n * this.getOneTokenNominal();2399  }2400  /**2401   * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2402   * @example getOneTokenNominal()2403   * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2404   */2405  getOneTokenNominal(): bigint {2406    const chainProperties = this.helper.chain.getChainProperties();2407    return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2408  }24092410  /**2411   * Get substrate address balance2412   * @param address substrate address2413   * @example getSubstrate("5GrwvaEF5zXb26Fz...")2414   * @returns amount of tokens on address2415   */2416  getSubstrate(address: TSubstrateAccount): Promise<bigint> {2417    return this.subBalanceGroup.getSubstrate(address);2418  }24192420  /**2421   * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2422   * @param address substrate address2423   * @returns2424   */2425  getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2426    return this.subBalanceGroup.getSubstrateFull(address);2427  }24282429  /**2430   * Get locked balances2431   * @param address substrate address2432   * @returns locked balances with reason via api.query.balances.locks2433   */2434  getLocked(address: TSubstrateAccount) {2435    return this.subBalanceGroup.getLocked(address);2436  }24372438  /**2439   * Get ethereum address balance2440   * @param address ethereum address2441   * @example getEthereum("0x9F0583DbB855d...")2442   * @returns amount of tokens on address2443   */2444  getEthereum(address: TEthereumAccount): Promise<bigint> {2445    return this.ethBalanceGroup.getEthereum(address);2446  }24472448  /**2449   * Transfer tokens to substrate address2450   * @param signer keyring of signer2451   * @param address substrate address of a recipient2452   * @param amount amount of tokens to be transfered2453   * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2454   * @returns ```true``` if extrinsic success, otherwise ```false```2455   */2456  transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2457    return this.subBalanceGroup.transferToSubstrate(signer, address, amount);2458  }24592460  async forceTransferToSubstrate(signer: TSigner, from: TSubstrateAccount, to: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2461    const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.forceTransfer', [from, to, amount], true);24622463    let transfer = {from: null, to: null, amount: 0n} as any;2464    result.result.events.forEach(({event: {data, method, section}}) => {2465      if ((section === 'balances') && (method === 'Transfer')) {2466        transfer = {2467          from: this.helper.address.normalizeSubstrate(data[0]),2468          to: this.helper.address.normalizeSubstrate(data[1]),2469          amount: BigInt(data[2]),2470        };2471      }2472    });2473    let isSuccess = this.helper.address.normalizeSubstrate(from) === transfer.from;2474    isSuccess = isSuccess && this.helper.address.normalizeSubstrate(to) === transfer.to;2475    isSuccess = isSuccess && BigInt(amount) === transfer.amount;2476    return isSuccess;2477  }24782479  /**2480   * Transfer tokens with the unlock period2481   * @param signer signers Keyring2482   * @param address Substrate address of recipient2483   * @param schedule Schedule params2484   * @example vestedTransfer(signer, recepient.address, 20000, 100, 10, 50 * nominal); // total amount of vested tokens will be 100 * 50 = 50002485   */2486  async vestedTransfer(signer: TSigner, address: TSubstrateAccount, schedule: {start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint}): Promise<void> {2487    const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.vestedTransfer', [address, schedule]);2488    const event = result.result.events2489      .find(e => e.event.section === 'vesting' &&2490            e.event.method === 'VestingScheduleAdded' &&2491            e.event.data[0].toHuman() === signer.address);2492    if (!event) throw Error('Cannot find transfer in events');2493  }24942495  /**2496   * Get schedule for recepient of vested transfer2497   * @param address Substrate address of recipient2498   * @returns2499   */2500  async getVestingSchedules(address: TSubstrateAccount): Promise<{start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint}[]> {2501    const schedule = (await this.helper.callRpc('api.query.vesting.vestingSchedules', [address])).toJSON();2502    return schedule.map((schedule: any) => {2503      return {2504        start: BigInt(schedule.start),2505        period: BigInt(schedule.period),2506        periodCount: BigInt(schedule.periodCount),2507        perPeriod: BigInt(schedule.perPeriod),2508      };2509    });2510  }25112512  /**2513   * Claim vested tokens2514   * @param signer signers Keyring2515   */2516  async claim(signer: TSigner) {2517    const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.claim', []);2518    const event = result.result.events2519      .find(e => e.event.section === 'vesting' &&2520            e.event.method === 'Claimed' &&2521            e.event.data[0].toHuman() === signer.address);2522    if (!event) throw Error('Cannot find claim in events');2523  }2524}25252526class AddressGroup extends HelperGroup<ChainHelperBase> {2527  /**2528   * Normalizes the address to the specified ss58 format, by default ```42```.2529   * @param address substrate address2530   * @param ss58Format format for address conversion, by default ```42```2531   * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2532   * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2533   */2534  normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2535    return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2536  }25372538  /**2539   * Get address in the connected chain format2540   * @param address substrate address2541   * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2542   * @returns address in chain format2543   */2544  normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2545    return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2546  }25472548  /**2549   * Get substrate mirror of an ethereum address2550   * @param ethAddress ethereum address2551   * @param toChainFormat false for normalized account2552   * @example ethToSubstrate('0x9F0583DbB855d...')2553   * @returns substrate mirror of a provided ethereum address2554   */2555  ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): TSubstrateAccount {2556    return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2557  }25582559  /**2560   * Get ethereum mirror of a substrate address2561   * @param subAddress substrate account2562   * @example substrateToEth("5DnSF6RRjwteE3BrC...")2563   * @returns ethereum mirror of a provided substrate address2564   */2565  substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2566    return CrossAccountId.translateSubToEth(subAddress);2567  }25682569  /**2570   * Encode key to substrate address2571   * @param key key for encoding address2572   * @param ss58Format prefix for encoding to the address of the corresponding network2573   * @returns encoded substrate address2574   */2575  encodeSubstrateAddress (key: Uint8Array | string | bigint, ss58Format = 42): string {2576    const u8a :Uint8Array = typeof key === 'string'2577      ? hexToU8a(key)2578      : typeof key === 'bigint'2579        ? hexToU8a(key.toString(16))2580        : key;25812582    if (ss58Format < 0 || ss58Format > 16383 || [46, 47].includes(ss58Format)) {2583      throw new Error(`ss58Format is not valid, received ${typeof ss58Format} "${ss58Format}"`);2584    }25852586    const allowedDecodedLengths = [1, 2, 4, 8, 32, 33];2587    if (!allowedDecodedLengths.includes(u8a.length)) {2588      throw new Error(`key length is not valid, received ${u8a.length}, valid values are ${allowedDecodedLengths.join(', ')}`);2589    }25902591    const u8aPrefix = ss58Format < 642592      ? new Uint8Array([ss58Format])2593      : new Uint8Array([2594        ((ss58Format & 0xfc) >> 2) | 0x40,2595        (ss58Format >> 8) | ((ss58Format & 0x03) << 6),2596      ]);25972598    const input = u8aConcat(u8aPrefix, u8a);25992600    return base58Encode(u8aConcat(2601      input,2602      blake2AsU8a(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1),2603    ));2604  }26052606  /**2607   * Restore substrate address from bigint representation2608   * @param number decimal representation of substrate address2609   * @returns substrate address2610   */2611  restoreCrossAccountFromBigInt(number: bigint): TSubstrateAccount {2612    if (this.helper.api === null) {2613      throw 'Not connected';2614    }2615    const res = this.helper.api.registry.createType('AccountId', '0x' + number.toString(16).padStart(64, '0')).toJSON();2616    if (res === undefined || res === null) {2617      throw 'Restore address error';2618    }2619    return res.toString();2620  }26212622  /**2623   * Convert etherium cross account id to substrate cross account id2624   * @param ethCrossAccount etherium cross account2625   * @returns substrate cross account id2626   */2627  convertCrossAccountFromEthCrossAccount(ethCrossAccount: IEthCrossAccountId): ICrossAccountId {2628    if (ethCrossAccount.sub === '0') {2629      return {Ethereum: ethCrossAccount.eth.toLocaleLowerCase()};2630    }26312632    const ss58 = this.restoreCrossAccountFromBigInt(BigInt(ethCrossAccount.sub));2633    return {Substrate: ss58};2634  }26352636  paraSiblingSovereignAccount(paraid: number) {2637    // We are getting a *sibling* parachain sovereign account,2638    // so we need a sibling prefix: encoded(b"sibl") == 0x7369626c2639    const siblingPrefix = '0x7369626c';26402641    const encodedParaId = this.helper.getApi().createType('u32', paraid).toHex(true).substring(2);2642    const suffix = '000000000000000000000000000000000000000000000000';26432644    return siblingPrefix + encodedParaId + suffix;2645  }2646}26472648class StakingGroup extends HelperGroup<UniqueHelper> {2649  /**2650   * Stake tokens for App Promotion2651   * @param signer keyring of signer2652   * @param amountToStake amount of tokens to stake2653   * @param label extra label for log2654   * @returns2655   */2656  async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2657    if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2658    const _stakeResult = await this.helper.executeExtrinsic(2659      signer, 'api.tx.appPromotion.stake',2660      [amountToStake], true,2661    );2662    // TODO extract info from stakeResult2663    return true;2664  }26652666  /**2667   * Unstake all staked tokens2668   * @param signer keyring of signer2669   * @param amountToUnstake amount of tokens to unstake2670   * @param label extra label for log2671   * @returns block hash where unstake happened2672   */2673  async unstakeAll(signer: TSigner, label?: string): Promise<string> {2674    if(typeof label === 'undefined') label = `${signer.address}`;2675    const unstakeResult = await this.helper.executeExtrinsic(2676      signer, 'api.tx.appPromotion.unstakeAll',2677      [], true,2678    );2679    return unstakeResult.blockHash;2680  }26812682  /**2683   * Unstake the part of a staked tokens2684   * @param signer keyring of signer2685   * @param amount amount of tokens to unstake2686   * @param label extra label for log2687   * @returns block hash where unstake happened2688   */2689  async unstakePartial(signer: TSigner, amount: bigint, label?: string): Promise<string> {2690    if(typeof label === 'undefined') label = `${signer.address}`;2691    const unstakeResult = await this.helper.executeExtrinsic(2692      signer, 'api.tx.appPromotion.unstakePartial',2693      [amount], true,2694    );2695    return unstakeResult.blockHash;2696  }26972698  /**2699   * Get total number of active stakes2700   * @param address substrate address2701   * @returns {number}2702   */2703  async getStakesNumber(address: ICrossAccountId): Promise<number> {2704    if (address.Ethereum) throw Error('only substrate address');2705    return (await this.helper.callRpc('api.query.appPromotion.stakesPerAccount', [address.Substrate])).toNumber();2706  }27072708  /**2709   * Get total staked amount for address2710   * @param address substrate or ethereum address2711   * @returns total staked amount2712   */2713  async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2714    if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2715    return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2716  }27172718  /**2719   * Get total staked per block2720   * @param address substrate or ethereum address2721   * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2722   */2723  async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2724    const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2725    return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2726      return {2727        block: block.toBigInt(),2728        amount: amount.toBigInt(),2729      };2730    });2731  }27322733  /**2734   * Get total pending unstake amount for address2735   * @param address substrate or ethereum address2736   * @returns total pending unstake amount2737   */2738  async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2739    return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2740  }27412742  /**2743   * Get pending unstake amount per block for address2744   * @param address substrate or ethereum address2745   * @returns array of pending stakes. `block` – the number of the block in which the unstake was made. `amount` - the number of tokens unstaked in the block2746   */2747  async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2748    const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2749    const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2750      return {2751        block: block.toBigInt(),2752        amount: amount.toBigInt(),2753      };2754    });2755    return result;2756  }2757}27582759class SchedulerGroup extends HelperGroup<UniqueHelper> {2760  constructor(helper: UniqueHelper) {2761    super(helper);2762  }27632764  cancelScheduled(signer: TSigner, scheduledId: string) {2765    return this.helper.executeExtrinsic(2766      signer,2767      'api.tx.scheduler.cancelNamed',2768      [scheduledId],2769      true,2770    );2771  }27722773  changePriority(signer: TSigner, scheduledId: string, priority: number) {2774    return this.helper.executeExtrinsic(2775      signer,2776      'api.tx.scheduler.changeNamedPriority',2777      [scheduledId, priority],2778      true,2779    );2780  }27812782  scheduleAt<T extends UniqueHelper>(2783    executionBlockNumber: number,2784    options: ISchedulerOptions = {},2785  ) {2786    return this.schedule<T>('schedule', executionBlockNumber, options);2787  }27882789  scheduleAfter<T extends UniqueHelper>(2790    blocksBeforeExecution: number,2791    options: ISchedulerOptions = {},2792  ) {2793    return this.schedule<T>('scheduleAfter', blocksBeforeExecution, options);2794  }27952796  schedule<T extends UniqueHelper>(2797    scheduleFn: 'schedule' | 'scheduleAfter',2798    blocksNum: number,2799    options: ISchedulerOptions = {},2800  ) {2801    // eslint-disable-next-line @typescript-eslint/naming-convention2802    const ScheduledHelperType = ScheduledUniqueHelper(this.helper.helperBase);2803    return this.helper.clone(ScheduledHelperType, {2804      scheduleFn,2805      blocksNum,2806      options,2807    }) as T;2808  }2809}28102811class CollatorSelectionGroup extends HelperGroup<UniqueHelper> {2812  //todo:collator documentation2813  addInvulnerable(signer: TSigner, address: string) {2814    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.addInvulnerable', [address]);2815  }28162817  removeInvulnerable(signer: TSigner, address: string) {2818    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.removeInvulnerable', [address]);2819  }28202821  async getInvulnerables(): Promise<string[]> {2822    return (await this.helper.callRpc('api.query.collatorSelection.invulnerables')).map((x: any) => x.toHuman());2823  }28242825  /** and also total max invulnerables */2826  maxCollators(): number {2827    return (this.helper.getApi().consts.configuration.defaultCollatorSelectionMaxCollators.toJSON() as number);2828  }28292830  async getDesiredCollators(): Promise<number> {2831    return (await this.helper.callRpc('api.query.configuration.collatorSelectionDesiredCollatorsOverride')).toNumber();2832  }28332834  setLicenseBond(signer: TSigner, amount: bigint) {2835    return this.helper.executeExtrinsic(signer, 'api.tx.configuration.setCollatorSelectionLicenseBond', [amount]);2836  }28372838  async getLicenseBond(): Promise<bigint> {2839    return (await this.helper.callRpc('api.query.configuration.collatorSelectionLicenseBondOverride')).toBigInt();2840  }28412842  obtainLicense(signer: TSigner) {2843    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.getLicense', []);2844  }28452846  releaseLicense(signer: TSigner) {2847    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.releaseLicense', []);2848  }28492850  forceReleaseLicense(signer: TSigner, released: string) {2851    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.forceReleaseLicense', [released]);2852  }28532854  async hasLicense(address: string): Promise<bigint> {2855    return (await this.helper.callRpc('api.query.collatorSelection.licenseDepositOf', [address])).toBigInt();2856  }28572858  onboard(signer: TSigner) {2859    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.onboard', []);2860  }28612862  offboard(signer: TSigner) {2863    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.offboard', []);2864  }28652866  async getCandidates(): Promise<string[]> {2867    return (await this.helper.callRpc('api.query.collatorSelection.candidates')).map((x: any) => x.toHuman());2868  }2869}28702871class ForeignAssetsGroup extends HelperGroup<UniqueHelper> {2872  async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {2873    await this.helper.executeExtrinsic(2874      signer,2875      'api.tx.foreignAssets.registerForeignAsset',2876      [ownerAddress, location, metadata],2877      true,2878    );2879  }28802881  async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {2882    await this.helper.executeExtrinsic(2883      signer,2884      'api.tx.foreignAssets.updateForeignAsset',2885      [foreignAssetId, location, metadata],2886      true,2887    );2888  }2889}28902891class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {2892  palletName: string;28932894  constructor(helper: T, palletName: string) {2895    super(helper);28962897    this.palletName = palletName;2898  }28992900  async limitedReserveTransferAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number, weightLimit: any) {2901    await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.limitedReserveTransferAssets`, [destination, beneficiary, assets, feeAssetItem, weightLimit], true);2902  }29032904  async teleportAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number) {2905    await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.teleportAssets`, [destination, beneficiary, assets, feeAssetItem], true);2906  }29072908  async teleportNativeAsset(signer: TSigner, destinationParaId: number, targetAccount: Uint8Array, amount: bigint) {2909    const destination = {2910      V1: {2911        parents: 0,2912        interior: {2913          X1: {2914            Parachain: destinationParaId,2915          },2916        },2917      },2918    };29192920    const beneficiary = {2921      V1: {2922        parents: 0,2923        interior: {2924          X1: {2925            AccountId32: {2926              network: 'Any',2927              id: targetAccount,2928            },2929          },2930        },2931      },2932    };29332934    const assets = {2935      V1: [2936        {2937          id: {2938            Concrete: {2939              parents: 0,2940              interior: 'Here',2941            },2942          },2943          fun: {2944            Fungible: amount,2945          },2946        },2947      ],2948    };29492950    const feeAssetItem = 0;29512952    await this.teleportAssets(signer, destination, beneficiary, assets, feeAssetItem);2953  }2954}29552956class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2957  async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: any) {2958    await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);2959  }29602961  async transferMultiasset(signer: TSigner, asset: any, destination: any, destWeight: any) {2962    await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMultiasset', [asset, destination, destWeight], true);2963  }29642965  async transferMulticurrencies(signer: TSigner, currencies: any[], feeItem: number, destLocation: any, destWeight: any) {2966    await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMulticurrencies', [currencies, feeItem, destLocation, destWeight], true);2967  }2968}29692970class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {2971  async accounts(address: string, currencyId: any) {2972    const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;2973    return BigInt(free);2974  }2975}29762977class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {2978  async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {2979    await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);2980  }29812982  async setMetadata(signer: TSigner, assetId: number, name: string, symbol: string, decimals: number) {2983    await this.helper.executeExtrinsic(signer, 'api.tx.assets.setMetadata', [assetId, name, symbol, decimals], true);2984  }29852986  async mint(signer: TSigner, assetId: number, beneficiary: string, amount: bigint) {2987    await this.helper.executeExtrinsic(signer, 'api.tx.assets.mint', [assetId, beneficiary, amount], true);2988  }29892990  async account(assetId: string | number, address: string) {2991    const accountAsset = (2992      await this.helper.callRpc('api.query.assets.account', [assetId, address])2993    ).toJSON()! as any;29942995    if (accountAsset !== null) {2996      return BigInt(accountAsset['balance']);2997    } else {2998      return null;2999    }3000  }3001}30023003class AcalaAssetRegistryGroup extends HelperGroup<AcalaHelper> {3004  async registerForeignAsset(signer: TSigner, destination: any, metadata: AcalaAssetMetadata) {3005    await this.helper.executeExtrinsic(signer, 'api.tx.assetRegistry.registerForeignAsset', [destination, metadata], true);3006  }3007}30083009class MoonbeamAssetManagerGroup extends HelperGroup<MoonbeamHelper> {3010  makeRegisterForeignAssetProposal(assetInfo: MoonbeamAssetInfo) {3011    const apiPrefix = 'api.tx.assetManager.';30123013    const registerTx = this.helper.constructApiCall(3014      apiPrefix + 'registerForeignAsset',3015      [assetInfo.location, assetInfo.metadata, assetInfo.existentialDeposit, assetInfo.isSufficient],3016    );30173018    const setUnitsTx = this.helper.constructApiCall(3019      apiPrefix + 'setAssetUnitsPerSecond',3020      [assetInfo.location, assetInfo.unitsPerSecond, assetInfo.numAssetsWeightHint],3021    );30223023    const batchCall = this.helper.getApi().tx.utility.batchAll([registerTx, setUnitsTx]);3024    const encodedProposal = batchCall?.method.toHex() || '';3025    return encodedProposal;3026  }30273028  async assetTypeId(location: any) {3029    return await this.helper.callRpc('api.query.assetManager.assetTypeId', [location]);3030  }3031}30323033class MoonbeamDemocracyGroup extends HelperGroup<MoonbeamHelper> {3034  notePreimagePallet: string;30353036  constructor(helper: MoonbeamHelper, options: {[key: string]: any} = {}) {3037    super(helper);3038    this.notePreimagePallet = options.notePreimagePallet;3039  }30403041  async notePreimage(signer: TSigner, encodedProposal: string) {3042    await this.helper.executeExtrinsic(signer, `api.tx.${this.notePreimagePallet}.notePreimage`, [encodedProposal], true);3043  }30443045  externalProposeMajority(proposal: any) {3046    return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposal]);3047  }30483049  fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {3050    return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);3051  }30523053  async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {3054    await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);3055  }3056}30573058class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {3059  collective: string;30603061  constructor(helper: MoonbeamHelper, collective: string) {3062    super(helper);30633064    this.collective = collective;3065  }30663067  async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {3068    await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);3069  }30703071  async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {3072    await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);3073  }30743075  async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: any, lengthBound: number) {3076    await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);3077  }30783079  async proposalCount() {3080    return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));3081  }3082}30833084export type ChainHelperBaseConstructor = new(...args: any[]) => ChainHelperBase;3085export type UniqueHelperConstructor = new(...args: any[]) => UniqueHelper;30863087export class UniqueHelper extends ChainHelperBase {3088  balance: BalanceGroup<UniqueHelper>;3089  collection: CollectionGroup;3090  nft: NFTGroup;3091  rft: RFTGroup;3092  ft: FTGroup;3093  staking: StakingGroup;3094  scheduler: SchedulerGroup;3095  collatorSelection: CollatorSelectionGroup;3096  foreignAssets: ForeignAssetsGroup;3097  xcm: XcmGroup<UniqueHelper>;3098  xTokens: XTokensGroup<UniqueHelper>;3099  tokens: TokensGroup<UniqueHelper>;31003101  constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3102    super(logger, options.helperBase ?? UniqueHelper);31033104    this.balance = new BalanceGroup(this);3105    this.collection = new CollectionGroup(this);3106    this.nft = new NFTGroup(this);3107    this.rft = new RFTGroup(this);3108    this.ft = new FTGroup(this);3109    this.staking = new StakingGroup(this);3110    this.scheduler = new SchedulerGroup(this);3111    this.collatorSelection = new CollatorSelectionGroup(this);3112    this.foreignAssets = new ForeignAssetsGroup(this);3113    this.xcm = new XcmGroup(this, 'polkadotXcm');3114    this.xTokens = new XTokensGroup(this);3115    this.tokens = new TokensGroup(this);3116  }31173118  getSudo<T extends UniqueHelper>() {3119    // eslint-disable-next-line @typescript-eslint/naming-convention3120    const SudoHelperType = SudoHelper(this.helperBase);3121    return this.clone(SudoHelperType) as T;3122  }3123}31243125export class XcmChainHelper extends ChainHelperBase {3126  async connect(wsEndpoint: string, _listeners?: any): Promise<void> {3127    const wsProvider = new WsProvider(wsEndpoint);3128    this.api = new ApiPromise({3129      provider: wsProvider,3130    });3131    await this.api.isReadyOrError;3132    this.network = await UniqueHelper.detectNetwork(this.api);3133  }3134}31353136export class RelayHelper extends XcmChainHelper {3137  balance: SubstrateBalanceGroup<RelayHelper>;3138  xcm: XcmGroup<RelayHelper>;31393140  constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3141    super(logger, options.helperBase ?? RelayHelper);31423143    this.balance = new SubstrateBalanceGroup(this);3144    this.xcm = new XcmGroup(this, 'xcmPallet');3145  }3146}31473148export class WestmintHelper extends XcmChainHelper {3149  balance: SubstrateBalanceGroup<WestmintHelper>;3150  xcm: XcmGroup<WestmintHelper>;3151  assets: AssetsGroup<WestmintHelper>;3152  xTokens: XTokensGroup<WestmintHelper>;31533154  constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3155    super(logger, options.helperBase ?? WestmintHelper);31563157    this.balance = new SubstrateBalanceGroup(this);3158    this.xcm = new XcmGroup(this, 'polkadotXcm');3159    this.assets = new AssetsGroup(this);3160    this.xTokens = new XTokensGroup(this);3161  }3162}31633164export class MoonbeamHelper extends XcmChainHelper {3165  balance: EthereumBalanceGroup<MoonbeamHelper>;3166  assetManager: MoonbeamAssetManagerGroup;3167  assets: AssetsGroup<MoonbeamHelper>;3168  xTokens: XTokensGroup<MoonbeamHelper>;3169  democracy: MoonbeamDemocracyGroup;3170  collective: {3171    council: MoonbeamCollectiveGroup,3172    techCommittee: MoonbeamCollectiveGroup,3173  };31743175  constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3176    super(logger, options.helperBase ?? MoonbeamHelper);31773178    this.balance = new EthereumBalanceGroup(this);3179    this.assetManager = new MoonbeamAssetManagerGroup(this);3180    this.assets = new AssetsGroup(this);3181    this.xTokens = new XTokensGroup(this);3182    this.democracy = new MoonbeamDemocracyGroup(this, options);3183    this.collective = {3184      council: new MoonbeamCollectiveGroup(this, 'councilCollective'),3185      techCommittee: new MoonbeamCollectiveGroup(this, 'techCommitteeCollective'),3186    };3187  }3188}31893190export class AcalaHelper extends XcmChainHelper {3191  balance: SubstrateBalanceGroup<AcalaHelper>;3192  assetRegistry: AcalaAssetRegistryGroup;3193  xTokens: XTokensGroup<AcalaHelper>;3194  tokens: TokensGroup<AcalaHelper>;31953196  constructor(logger?: ILogger, options: {[key: string]: any} = {}) {3197    super(logger, options.helperBase ?? AcalaHelper);31983199    this.balance = new SubstrateBalanceGroup(this);3200    this.assetRegistry = new AcalaAssetRegistryGroup(this);3201    this.xTokens = new XTokensGroup(this);3202    this.tokens = new TokensGroup(this);3203  }32043205  getSudo<T extends AcalaHelper>() {3206    // eslint-disable-next-line @typescript-eslint/naming-convention3207    const SudoHelperType = SudoHelper(this.helperBase);3208    return this.clone(SudoHelperType) as T;3209  }3210}32113212// eslint-disable-next-line @typescript-eslint/naming-convention3213function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {3214  return class extends Base {3215    scheduleFn: 'schedule' | 'scheduleAfter';3216    blocksNum: number;3217    options: ISchedulerOptions;32183219    constructor(...args: any[]) {3220      const logger = args[0] as ILogger;3221      const options = args[1] as {3222        scheduleFn: 'schedule' | 'scheduleAfter',3223        blocksNum: number,3224        options: ISchedulerOptions3225      };32263227      super(logger);32283229      this.scheduleFn = options.scheduleFn;3230      this.blocksNum = options.blocksNum;3231      this.options = options.options;3232    }32333234    executeExtrinsic(sender: IKeyringPair, scheduledExtrinsic: string, scheduledParams: any[], expectSuccess?: boolean): Promise<ITransactionResult> {3235      const scheduledTx = this.constructApiCall(scheduledExtrinsic, scheduledParams);32363237      const mandatorySchedArgs = [3238        this.blocksNum,3239        this.options.periodic ? [this.options.periodic.period, this.options.periodic.repetitions] : null,3240        this.options.priority ?? null,3241        scheduledTx,3242      ];32433244      let schedArgs;3245      let scheduleFn;32463247      if (this.options.scheduledId) {3248        schedArgs = [this.options.scheduledId!, ...mandatorySchedArgs];32493250        if (this.scheduleFn == 'schedule') {3251          scheduleFn = 'scheduleNamed';3252        } else if (this.scheduleFn == 'scheduleAfter') {3253          scheduleFn = 'scheduleNamedAfter';3254        }3255      } else {3256        schedArgs = mandatorySchedArgs;3257        scheduleFn = this.scheduleFn;3258      }32593260      const extrinsic = 'api.tx.scheduler.' +  scheduleFn;32613262      return super.executeExtrinsic(3263        sender,3264        extrinsic,3265        schedArgs,3266        expectSuccess,3267      );3268    }3269  };3270}32713272// eslint-disable-next-line @typescript-eslint/naming-convention3273function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {3274  return class extends Base {3275    constructor(...args: any[]) {3276      super(...args);3277    }32783279    async executeExtrinsic(3280      sender: IKeyringPair,3281      extrinsic: string,3282      params: any[],3283      expectSuccess?: boolean,3284      options: Partial<SignerOptions>|null = null,3285    ): Promise<ITransactionResult> {3286      const call = this.constructApiCall(extrinsic, params);3287      const result = await super.executeExtrinsic(3288        sender,3289        'api.tx.sudo.sudo',3290        [call],3291        expectSuccess,3292        options,3293      );32943295      if (result.status === 'Fail') return result;32963297      const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;3298      if (data.isErr) {3299        if (data.asErr.isModule) {3300          const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;3301          const metaError = super.getApi()?.registry.findMetaError(error);3302          throw new Error(`${metaError.section}.${metaError.name}`);3303        } else {3304          throw new Error(data.asErr.toHuman());3305        }3306      }3307      return result;3308    }3309  };3310}33113312export class UniqueBaseCollection {3313  helper: UniqueHelper;3314  collectionId: number;33153316  constructor(collectionId: number, uniqueHelper: UniqueHelper) {3317    this.collectionId = collectionId;3318    this.helper = uniqueHelper;3319  }33203321  async getData() {3322    return await this.helper.collection.getData(this.collectionId);3323  }33243325  async getLastTokenId() {3326    return await this.helper.collection.getLastTokenId(this.collectionId);3327  }33283329  async doesTokenExist(tokenId: number) {3330    return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);3331  }33323333  async getAdmins() {3334    return await this.helper.collection.getAdmins(this.collectionId);3335  }33363337  async getAllowList() {3338    return await this.helper.collection.getAllowList(this.collectionId);3339  }33403341  async getEffectiveLimits() {3342    return await this.helper.collection.getEffectiveLimits(this.collectionId);3343  }33443345  async getProperties(propertyKeys?: string[] | null) {3346    return await this.helper.collection.getProperties(this.collectionId, propertyKeys);3347  }33483349  async getPropertiesConsumedSpace() {3350    return await this.helper.collection.getPropertiesConsumedSpace(this.collectionId);3351  }33523353  async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {3354    return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);3355  }33563357  async getOptions() {3358    return await this.helper.collection.getCollectionOptions(this.collectionId);3359  }33603361  async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {3362    return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);3363  }33643365  async confirmSponsorship(signer: TSigner) {3366    return await this.helper.collection.confirmSponsorship(signer, this.collectionId);3367  }33683369  async removeSponsor(signer: TSigner) {3370    return await this.helper.collection.removeSponsor(signer, this.collectionId);3371  }33723373  async setLimits(signer: TSigner, limits: ICollectionLimits) {3374    return await this.helper.collection.setLimits(signer, this.collectionId, limits);3375  }33763377  async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {3378    return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);3379  }33803381  async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3382    return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);3383  }33843385  async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {3386    return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);3387  }33883389  async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {3390    return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);3391  }33923393  async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {3394    return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);3395  }33963397  async setProperties(signer: TSigner, properties: IProperty[]) {3398    return await this.helper.collection.setProperties(signer, this.collectionId, properties);3399  }34003401  async deleteProperties(signer: TSigner, propertyKeys: string[]) {3402    return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);3403  }34043405  async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {3406    return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);3407  }34083409  async enableNesting(signer: TSigner, permissions: INestingPermissions) {3410    return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);3411  }34123413  async disableNesting(signer: TSigner) {3414    return await this.helper.collection.disableNesting(signer, this.collectionId);3415  }34163417  async burn(signer: TSigner) {3418    return await this.helper.collection.burn(signer, this.collectionId);3419  }34203421  scheduleAt<T extends UniqueHelper>(3422    executionBlockNumber: number,3423    options: ISchedulerOptions = {},3424  ) {3425    const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3426    return new UniqueBaseCollection(this.collectionId, scheduledHelper);3427  }34283429  scheduleAfter<T extends UniqueHelper>(3430    blocksBeforeExecution: number,3431    options: ISchedulerOptions = {},3432  ) {3433    const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3434    return new UniqueBaseCollection(this.collectionId, scheduledHelper);3435  }34363437  getSudo<T extends UniqueHelper>() {3438    return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());3439  }3440}344134423443export class UniqueNFTCollection extends UniqueBaseCollection {3444  getTokenObject(tokenId: number) {3445    return new UniqueNFToken(tokenId, this);3446  }34473448  async getTokensByAddress(addressObj: ICrossAccountId) {3449    return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);3450  }34513452  async getToken(tokenId: number, blockHashAt?: string) {3453    return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);3454  }34553456  async getTokenOwner(tokenId: number, blockHashAt?: string) {3457    return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3458  }34593460  async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3461    return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3462  }34633464  async getTokenChildren(tokenId: number, blockHashAt?: string) {3465    return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);3466  }34673468  async getPropertyPermissions(propertyKeys: string[] | null = null) {3469    return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);3470  }34713472  async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3473    return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3474  }34753476  async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {3477    const api = this.helper.getApi();3478    const props = (await api.query.nonfungible.tokenProperties(this.collectionId, tokenId)).toJSON();34793480    return (props! as any).consumedSpace;3481  }34823483  async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {3484    return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);3485  }34863487  async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3488    return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);3489  }34903491  async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {3492    return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);3493  }34943495  async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {3496    return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);3497  }34983499  async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3500    return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});3501  }35023503  async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {3504    return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);3505  }35063507  async burnToken(signer: TSigner, tokenId: number) {3508    return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);3509  }35103511  async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {3512    return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);3513  }35143515  async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3516    return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);3517  }35183519  async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3520    return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3521  }35223523  async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3524    return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3525  }35263527  async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3528    return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3529  }35303531  async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3532    return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3533  }35343535  scheduleAt<T extends UniqueHelper>(3536    executionBlockNumber: number,3537    options: ISchedulerOptions = {},3538  ) {3539    const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3540    return new UniqueNFTCollection(this.collectionId, scheduledHelper);3541  }35423543  scheduleAfter<T extends UniqueHelper>(3544    blocksBeforeExecution: number,3545    options: ISchedulerOptions = {},3546  ) {3547    const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3548    return new UniqueNFTCollection(this.collectionId, scheduledHelper);3549  }35503551  getSudo<T extends UniqueHelper>() {3552    return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());3553  }3554}355535563557export class UniqueRFTCollection extends UniqueBaseCollection {3558  getTokenObject(tokenId: number) {3559    return new UniqueRFToken(tokenId, this);3560  }35613562  async getToken(tokenId: number, blockHashAt?: string) {3563    return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);3564  }35653566  async getTokenOwner(tokenId: number, blockHashAt?: string) {3567    return await this.helper.rft.getTokenOwner(this.collectionId, tokenId, blockHashAt);3568  }35693570  async getTokensByAddress(addressObj: ICrossAccountId) {3571    return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);3572  }35733574  async getTop10TokenOwners(tokenId: number) {3575    return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);3576  }35773578  async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {3579    return await this.helper.rft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);3580  }35813582  async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {3583    return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);3584  }35853586  async getTokenTotalPieces(tokenId: number) {3587    return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);3588  }35893590  async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3591    return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);3592  }35933594  async getPropertyPermissions(propertyKeys: string[] | null = null) {3595    return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);3596  }35973598  async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {3599    return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);3600  }36013602  async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {3603    const api = this.helper.getApi();3604    const props = (await api.query.refungible.tokenProperties(this.collectionId, tokenId)).toJSON();36053606    return (props! as any).consumedSpace;3607  }36083609  async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {3610    return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);3611  }36123613  async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3614    return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);3615  }36163617  async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {3618    return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);3619  }36203621  async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {3622    return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);3623  }36243625  async mintToken(signer: TSigner, pieces = 1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {3626    return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});3627  }36283629  async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {3630    return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);3631  }36323633  async burnToken(signer: TSigner, tokenId: number, amount=1n) {3634    return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);3635  }36363637  async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId,  amount=1n) {3638    return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);3639  }36403641  async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {3642    return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);3643  }36443645  async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {3646    return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);3647  }36483649  async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {3650    return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);3651  }36523653  async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {3654    return await this.helper.rft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);3655  }36563657  async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3658    return await this.helper.rft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);3659  }36603661  scheduleAt<T extends UniqueHelper>(3662    executionBlockNumber: number,3663    options: ISchedulerOptions = {},3664  ) {3665    const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3666    return new UniqueRFTCollection(this.collectionId, scheduledHelper);3667  }36683669  scheduleAfter<T extends UniqueHelper>(3670    blocksBeforeExecution: number,3671    options: ISchedulerOptions = {},3672  ) {3673    const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3674    return new UniqueRFTCollection(this.collectionId, scheduledHelper);3675  }36763677  getSudo<T extends UniqueHelper>() {3678    return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());3679  }3680}368136823683export class UniqueFTCollection extends UniqueBaseCollection {3684  async getBalance(addressObj: ICrossAccountId) {3685    return await this.helper.ft.getBalance(this.collectionId, addressObj);3686  }36873688  async getTotalPieces() {3689    return await this.helper.ft.getTotalPieces(this.collectionId);3690  }36913692  async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3693    return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);3694  }36953696  async getTop10Owners() {3697    return await this.helper.ft.getTop10Owners(this.collectionId);3698  }36993700  async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {3701    return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);3702  }37033704  async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {3705    return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);3706  }37073708  async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3709    return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);3710  }37113712  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3713    return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);3714  }37153716  async burnTokens(signer: TSigner, amount=1n) {3717    return await this.helper.ft.burnTokens(signer, this.collectionId, amount);3718  }37193720  async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3721    return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);3722  }37233724  async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3725    return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);3726  }37273728  scheduleAt<T extends UniqueHelper>(3729    executionBlockNumber: number,3730    options: ISchedulerOptions = {},3731  ) {3732    const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);3733    return new UniqueFTCollection(this.collectionId, scheduledHelper);3734  }37353736  scheduleAfter<T extends UniqueHelper>(3737    blocksBeforeExecution: number,3738    options: ISchedulerOptions = {},3739  ) {3740    const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);3741    return new UniqueFTCollection(this.collectionId, scheduledHelper);3742  }37433744  getSudo<T extends UniqueHelper>() {3745    return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());3746  }3747}374837493750export class UniqueBaseToken {3751  collection: UniqueNFTCollection | UniqueRFTCollection;3752  collectionId: number;3753  tokenId: number;37543755  constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {3756    this.collection = collection;3757    this.collectionId = collection.collectionId;3758    this.tokenId = tokenId;3759  }37603761  async getNextSponsored(addressObj: ICrossAccountId) {3762    return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);3763  }37643765  async getProperties(propertyKeys?: string[] | null) {3766    return await this.collection.getTokenProperties(this.tokenId, propertyKeys);3767  }37683769  async getTokenPropertiesConsumedSpace() {3770    return await this.collection.getTokenPropertiesConsumedSpace(this.tokenId);3771  }37723773  async setProperties(signer: TSigner, properties: IProperty[]) {3774    return await this.collection.setTokenProperties(signer, this.tokenId, properties);3775  }37763777  async deleteProperties(signer: TSigner, propertyKeys: string[]) {3778    return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);3779  }37803781  async doesExist() {3782    return await this.collection.doesTokenExist(this.tokenId);3783  }37843785  nestingAccount() {3786    return this.collection.helper.util.getTokenAccount(this);3787  }37883789  scheduleAt<T extends UniqueHelper>(3790    executionBlockNumber: number,3791    options: ISchedulerOptions = {},3792  ) {3793    const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3794    return new UniqueBaseToken(this.tokenId, scheduledCollection);3795  }37963797  scheduleAfter<T extends UniqueHelper>(3798    blocksBeforeExecution: number,3799    options: ISchedulerOptions = {},3800  ) {3801    const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3802    return new UniqueBaseToken(this.tokenId, scheduledCollection);3803  }38043805  getSudo<T extends UniqueHelper>() {3806    return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());3807  }3808}380938103811export class UniqueNFToken extends UniqueBaseToken {3812  collection: UniqueNFTCollection;38133814  constructor(tokenId: number, collection: UniqueNFTCollection) {3815    super(tokenId, collection);3816    this.collection = collection;3817  }38183819  async getData(blockHashAt?: string) {3820    return await this.collection.getToken(this.tokenId, blockHashAt);3821  }38223823  async getOwner(blockHashAt?: string) {3824    return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3825  }38263827  async getTopmostOwner(blockHashAt?: string) {3828    return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3829  }38303831  async getChildren(blockHashAt?: string) {3832    return await this.collection.getTokenChildren(this.tokenId, blockHashAt);3833  }38343835  async nest(signer: TSigner, toTokenObj: IToken) {3836    return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3837  }38383839  async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3840    return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3841  }38423843  async transfer(signer: TSigner, addressObj: ICrossAccountId) {3844    return await this.collection.transferToken(signer, this.tokenId, addressObj);3845  }38463847  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {3848    return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);3849  }38503851  async approve(signer: TSigner, toAddressObj: ICrossAccountId) {3852    return await this.collection.approveToken(signer, this.tokenId, toAddressObj);3853  }38543855  async isApproved(toAddressObj: ICrossAccountId) {3856    return await this.collection.isTokenApproved(this.tokenId, toAddressObj);3857  }38583859  async burn(signer: TSigner) {3860    return await this.collection.burnToken(signer, this.tokenId);3861  }38623863  async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {3864    return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);3865  }38663867  scheduleAt<T extends UniqueHelper>(3868    executionBlockNumber: number,3869    options: ISchedulerOptions = {},3870  ) {3871    const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3872    return new UniqueNFToken(this.tokenId, scheduledCollection);3873  }38743875  scheduleAfter<T extends UniqueHelper>(3876    blocksBeforeExecution: number,3877    options: ISchedulerOptions = {},3878  ) {3879    const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3880    return new UniqueNFToken(this.tokenId, scheduledCollection);3881  }38823883  getSudo<T extends UniqueHelper>() {3884    return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());3885  }3886}38873888export class UniqueRFToken extends UniqueBaseToken {3889  collection: UniqueRFTCollection;38903891  constructor(tokenId: number, collection: UniqueRFTCollection) {3892    super(tokenId, collection);3893    this.collection = collection;3894  }38953896  async getData(blockHashAt?: string) {3897    return await this.collection.getToken(this.tokenId, blockHashAt);3898  }38993900  async getOwner(blockHashAt?: string) {3901    return await this.collection.getTokenOwner(this.tokenId, blockHashAt);3902  }39033904  async getTop10Owners() {3905    return await this.collection.getTop10TokenOwners(this.tokenId);3906  }39073908  async getTopmostOwner(blockHashAt?: string) {3909    return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);3910  }39113912  async nest(signer: TSigner, toTokenObj: IToken) {3913    return await this.collection.nestToken(signer, this.tokenId, toTokenObj);3914  }39153916  async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {3917    return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);3918  }39193920  async getBalance(addressObj: ICrossAccountId) {3921    return await this.collection.getTokenBalance(this.tokenId, addressObj);3922  }39233924  async getTotalPieces() {3925    return await this.collection.getTokenTotalPieces(this.tokenId);3926  }39273928  async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {3929    return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);3930  }39313932  async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {3933    return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);3934  }39353936  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {3937    return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);3938  }39393940  async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {3941    return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);3942  }39433944  async repartition(signer: TSigner, amount: bigint) {3945    return await this.collection.repartitionToken(signer, this.tokenId, amount);3946  }39473948  async burn(signer: TSigner, amount=1n) {3949    return await this.collection.burnToken(signer, this.tokenId, amount);3950  }39513952  async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {3953    return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);3954  }39553956  scheduleAt<T extends UniqueHelper>(3957    executionBlockNumber: number,3958    options: ISchedulerOptions = {},3959  ) {3960    const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);3961    return new UniqueRFToken(this.tokenId, scheduledCollection);3962  }39633964  scheduleAfter<T extends UniqueHelper>(3965    blocksBeforeExecution: number,3966    options: ISchedulerOptions = {},3967  ) {3968    const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);3969    return new UniqueRFToken(this.tokenId, scheduledCollection);3970  }39713972  getSudo<T extends UniqueHelper>() {3973    return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());3974  }3975}