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

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} from '@polkadot/util-crypto';11import {IKeyringPair} from '@polkadot/types/types';12import {IApiListeners, IBlock, IEvent, IChainProperties, ICollectionCreationOptions, ICollectionLimits, ICollectionPermissions, ICrossAccountId, ICrossAccountIdLower, ILogger, INestingPermissions, IProperty, IStakingInfo, ISubstrateBalance, IToken, ITokenPropertyPermission, ITransactionResult, IUniqueHelperLog, TApiAllowedListeners, TEthereumAccount, TSigner, TSubstrateAccount, TUniqueNetworks} from './types';1314export class CrossAccountId implements ICrossAccountId {15  Substrate?: TSubstrateAccount;16  Ethereum?: TEthereumAccount;1718  constructor(account: ICrossAccountId) {19    if (account.Substrate) this.Substrate = account.Substrate;20    if (account.Ethereum) this.Ethereum = account.Ethereum;21  }2223  static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {24    switch (domain) {25      case 'Substrate': return new CrossAccountId({Substrate: account.address});26      case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();27    }28  }2930  static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {31    return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});32  }3334  static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {35    return encodeAddress(decodeAddress(address), ss58Format);36  }3738  static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {39    return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});40  }41  42  withNormalizedSubstrate(ss58Format = 42): CrossAccountId {43    if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);44    return this;45  }4647  static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {48    return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));49  }5051  toEthereum(): CrossAccountId {52    if (this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});53    return this;54  }5556  static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {57    return evmToAddress(address, ss58Format);58  }5960  toSubstrate(ss58Format?: number): CrossAccountId {61    if (this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});62    return this;63  }64  65  toLowerCase(): CrossAccountId {66    if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();67    if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();68    return this;69  }70}7172const nesting = {73  toChecksumAddress(address: string): string {74    if (typeof address === 'undefined') return '';7576    if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);7778    address = address.toLowerCase().replace(/^0x/i,'');79    const addressHash = keccakAsHex(address).replace(/^0x/i,'');80    const checksumAddress = ['0x'];8182    for (let i = 0; i < address.length; i++) {83      // If ith character is 8 to f then make it uppercase84      if (parseInt(addressHash[i], 16) > 7) {85        checksumAddress.push(address[i].toUpperCase());86      } else {87        checksumAddress.push(address[i]);88      }89    }90    return checksumAddress.join('');91  },92  tokenIdToAddress(collectionId: number, tokenId: number) {93    return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8, '0')}${tokenId.toString(16).padStart(8, '0')}`);94  },95};9697class UniqueUtil {98  static transactionStatus = {99    NOT_READY: 'NotReady',100    FAIL: 'Fail',101    SUCCESS: 'Success',102  };103104  static chainLogType = {105    EXTRINSIC: 'extrinsic',106    RPC: 'rpc',107  };108109  static getTokenAccount(token: IToken): CrossAccountId {110    return new CrossAccountId({Ethereum: this.getTokenAddress(token)});111  }112113  static getTokenAddress(token: IToken): string {114    return nesting.tokenIdToAddress(token.collectionId, token.tokenId);115  }116117  static getDefaultLogger(): ILogger {118    return {119      log(msg: any, level = 'INFO') {120        console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));121      },122      level: {123        ERROR: 'ERROR',124        WARNING: 'WARNING',125        INFO: 'INFO',126      },127    };128  }129130  static vec2str(arr: string[] | number[]) {131    return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');132  }133134  static str2vec(string: string) {135    if (typeof string !== 'string') return string;136    return Array.from(string).map(x => x.charCodeAt(0));137  }138139  static fromSeed(seed: string, ss58Format = 42) {140    const keyring = new Keyring({type: 'sr25519', ss58Format});141    return keyring.addFromUri(seed);142  }143144  static extractCollectionIdFromCreationResult(creationResult: ITransactionResult) {145    if (creationResult.status !== this.transactionStatus.SUCCESS) {146      throw Error('Unable to create collection!');147    }148149    let collectionId = null;150    creationResult.result.events.forEach(({event: {data, method, section}}) => {151      if ((section === 'common') && (method === 'CollectionCreated')) {152        collectionId = parseInt(data[0].toString(), 10);153      }154    });155156    if (collectionId === null) {157      throw Error('No CollectionCreated event was found!');158    }159160    return collectionId;161  }162163  static extractTokensFromCreationResult(creationResult: ITransactionResult) {164    if (creationResult.status !== this.transactionStatus.SUCCESS) {165      throw Error('Unable to create tokens!');166    }167    let success = false;168    const tokens = [] as any;169    creationResult.result.events.forEach(({event: {data, method, section}}) => {170      if (method === 'ExtrinsicSuccess') {171        success = true;172      } else if ((section === 'common') && (method === 'ItemCreated')) {173        tokens.push({174          collectionId: parseInt(data[0].toString(), 10),175          tokenId: parseInt(data[1].toString(), 10),176          owner: data[2].toJSON(),177        });178      }179    });180    return {success, tokens};181  }182183  static extractTokensFromBurnResult(burnResult: ITransactionResult) {184    if (burnResult.status !== this.transactionStatus.SUCCESS) {185      throw Error('Unable to burn tokens!');186    }187    let success = false;188    const tokens = [] as any;189    burnResult.result.events.forEach(({event: {data, method, section}}) => {190      if (method === 'ExtrinsicSuccess') {191        success = true;192      } else if ((section === 'common') && (method === 'ItemDestroyed')) {193        tokens.push({194          collectionId: parseInt(data[0].toString(), 10),195          tokenId: parseInt(data[1].toString(), 10),196          owner: data[2].toJSON(),197        });198      }199    });200    return {success, tokens};201  }202203  static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string) {204    let eventId = null;205    events.forEach(({event: {data, method, section}}) => {206      if ((section === expectedSection) && (method === expectedMethod)) {207        eventId = parseInt(data[0].toString(), 10);208      }209    });210211    if (eventId === null) {212      throw Error(`No ${expectedMethod} event was found!`);213    }214    return eventId === collectionId;215  }216217  static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {218    const normalizeAddress = (address: string | ICrossAccountId) => {219      if(typeof address === 'string') return address;220      const obj = {} as any;221      Object.keys(address).forEach(k => {222        obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];223      });224      if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);225      if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();226      return address;227    };228    let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;229    events.forEach(({event: {data, method, section}}) => {230      if ((section === 'common') && (method === 'Transfer')) {231        const hData = (data as any).toJSON();232        transfer = {233          collectionId: hData[0],234          tokenId: hData[1],235          from: normalizeAddress(hData[2]),236          to: normalizeAddress(hData[3]),237          amount: BigInt(hData[4]),238        };239      }240    });241    let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;242    isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);243    isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);244    isSuccess = isSuccess && amount === transfer.amount;245    return isSuccess;246  }247}248249class UniqueEventHelper {250  private static extractIndex(index: any): [number, number] | string {251    if(index.toRawType() === '[u8;2]') return [index[0], index[1]];252    return index.toJSON();253  }254255  private static extractSub(data: any, subTypes: any): {[key: string]: any} {256    let obj: any = {};257    let index = 0;258259    if (data.entries) {260      for(const [key, value] of data.entries()) {261        obj[key] = this.extractData(value, subTypes[index]);262        index++;263      }264    } else obj = data.toJSON();265266    return obj;267  }268  269  private static extractData(data: any, type: any): any {270    if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();271    if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();272    if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);273    return data.toHuman();274  }275276  public static extractEvents(records: ITransactionResult): IEvent[] {277    const parsedEvents: IEvent[] = [];278279    records.result.events.forEach((record) => {280      const {event, phase} = record;281      const types = (event as any).typeDef;282283      const eventData: IEvent = {284        section: event.section.toString(),285        method: event.method.toString(),286        index: this.extractIndex(event.index),287        data: [],288        phase: phase.toJSON(),289      };290291      event.data.forEach((val: any, index: number) => {292        eventData.data.push(this.extractData(val, types[index]));293      });294295      parsedEvents.push(eventData);296    });297298    return parsedEvents;299  }300}301302class ChainHelperBase {303  transactionStatus = UniqueUtil.transactionStatus;304  chainLogType = UniqueUtil.chainLogType;305  util: typeof UniqueUtil;306  eventHelper: typeof UniqueEventHelper;307  logger: ILogger;308  api: ApiPromise | null;309  forcedNetwork: TUniqueNetworks | null;310  network: TUniqueNetworks | null;311  chainLog: IUniqueHelperLog[];312313  constructor(logger?: ILogger) {314    this.util = UniqueUtil;315    this.eventHelper = UniqueEventHelper;316    if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();317    this.logger = logger;318    this.api = null;319    this.forcedNetwork = null;320    this.network = null;321    this.chainLog = [];322  }323324  clearChainLog(): void {325    this.chainLog = [];326  }327328  forceNetwork(value: TUniqueNetworks): void {329    this.forcedNetwork = value;330  }331332  async connect(wsEndpoint: string, listeners?: IApiListeners) {333    if (this.api !== null) throw Error('Already connected');334    const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);335    this.api = api;336    this.network = network;337  }338339  async disconnect() {340    if (this.api === null) return;341    await this.api.disconnect();342    this.api = null;343    this.network = null;344  }345346  static async detectNetwork(api: ApiPromise): Promise<TUniqueNetworks> {347    const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;348    if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;349    return 'opal';350  }351352  static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TUniqueNetworks> {353    const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});354    await api.isReady;355356    const network = await this.detectNetwork(api);357358    await api.disconnect();359360    return network;361  }362363  static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TUniqueNetworks | null): Promise<{364    api: ApiPromise;365    network: TUniqueNetworks;366  }> {367    if(typeof network === 'undefined' || network === null) network = 'opal';368    const supportedRPC = {369      opal: {370        unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,371      },372      quartz: {373        unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,374      },375      unique: {376        unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,377      },378    };379    if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);380    const rpc = supportedRPC[network];381382    // TODO: investigate how to replace rpc in runtime383    // api._rpcCore.addUserInterfaces(rpc);384385    const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});386387    await api.isReadyOrError;388389    if (typeof listeners === 'undefined') listeners = {};390    for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {391      if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;392      api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);393    }394395    return {api, network};396  }397398  getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {399    const {events, status} = data;400    if (status.isReady) {401      return this.transactionStatus.NOT_READY;402    }403    if (status.isBroadcast) {404      return this.transactionStatus.NOT_READY;405    }406    if (status.isInBlock || status.isFinalized) {407      const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');408      if (errors.length > 0) {409        return this.transactionStatus.FAIL;410      }411      if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {412        return this.transactionStatus.SUCCESS;413      }414    }415416    return this.transactionStatus.FAIL;417  }418419  signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {420    const sign = (callback: any) => {421      if(options !== null) return transaction.signAndSend(sender, options, callback);422      return transaction.signAndSend(sender, callback);423    };424    // eslint-disable-next-line no-async-promise-executor425    return new Promise(async (resolve, reject) => {426      try {427        const unsub = await sign((result: any) => {428          const status = this.getTransactionStatus(result);429430          if (status === this.transactionStatus.SUCCESS) {431            this.logger.log(`${label} successful`);432            unsub();433            resolve({result, status});434          } else if (status === this.transactionStatus.FAIL) {435            let moduleError = null;436437            if (result.hasOwnProperty('dispatchError')) {438              const dispatchError = result['dispatchError'];439440              if (dispatchError) {441                if (dispatchError.isModule) {442                  const modErr = dispatchError.asModule;443                  const errorMeta = dispatchError.registry.findMetaError(modErr);444445                  moduleError = `${errorMeta.section}.${errorMeta.name}`;446                } else {447                  moduleError = dispatchError.toHuman();448                }449              } else {450                this.logger.log(result, this.logger.level.ERROR);451              }452            }453454            this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);455            unsub();456            reject({status, moduleError, result});457          }458        });459      } catch (e) {460        this.logger.log(e, this.logger.level.ERROR);461        reject(e);462      }463    });464  }465466  constructApiCall(apiCall: string, params: any[]) {467    if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);468    let call = this.api as any;469    for(const part of apiCall.slice(4).split('.')) {470      call = call[part];471    }472    return call(...params);473  }474475  async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null/*, failureMessage='expected success'*/) {476    if(this.api === null) throw Error('API not initialized');477    if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);478479    const startTime = (new Date()).getTime();480    let result: ITransactionResult;481    let events: IEvent[] = [];482    try {483      result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;484      events = this.eventHelper.extractEvents(result);485    }486    catch(e) {487      if(!(e as object).hasOwnProperty('status')) throw e;488      result = e as ITransactionResult;489    }490491    const endTime = (new Date()).getTime();492493    const log = {494      executedAt: endTime,495      executionTime: endTime - startTime,496      type: this.chainLogType.EXTRINSIC,497      status: result.status,498      call: extrinsic,499      signer: this.getSignerAddress(sender),500      params,501    } as IUniqueHelperLog;502503    if(result.status !== this.transactionStatus.SUCCESS && result.moduleError) log.moduleError = result.moduleError;504    if(events.length > 0) log.events = events;505506    this.chainLog.push(log);507508    if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) throw Error(`${result.moduleError}`);509    return result;510  }511512  async callRpc(rpc: string, params?: any[]) {513    if(typeof params === 'undefined') params = [];514    if(this.api === null) throw Error('API not initialized');515    if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);516517    const startTime = (new Date()).getTime();518    let result;519    let error = null;520    const log = {521      type: this.chainLogType.RPC,522      call: rpc,523      params,524    } as IUniqueHelperLog;525526    try {527      result = await this.constructApiCall(rpc, params);528    }529    catch(e) {530      error = e;531    }532533    const endTime = (new Date()).getTime();534535    log.executedAt = endTime;536    log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';537    log.executionTime = endTime - startTime;538539    this.chainLog.push(log);540541    if(error !== null) throw error;542543    return result;544  }545546  getSignerAddress(signer: IKeyringPair | string): string {547    if(typeof signer === 'string') return signer;548    return signer.address;549  }550551  fetchAllPalletNames(): string[] {552    if(this.api === null) throw Error('API not initialized');553    return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());554  }555556  fetchMissingPalletNames(requiredPallets: string[]): string[] {557    const palletNames = this.fetchAllPalletNames();558    return requiredPallets.filter(p => !palletNames.includes(p));559  }560}561562563class HelperGroup {564  helper: UniqueHelper;565566  constructor(uniqueHelper: UniqueHelper) {567    this.helper = uniqueHelper;568  }569}570571572class CollectionGroup extends HelperGroup {573  /**574 * Get number of blocks when sponsored transaction is available.575 *576 * @param collectionId ID of collection577 * @param tokenId ID of token578 * @param addressObj address for which the sponsorship is checked579 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});580 * @returns number of blocks or null if sponsorship hasn't been set581 */582  async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {583    return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();584  }585586  /**587   * Get the number of created collections.588   *589   * @returns number of created collections590   */591  async getTotalCount(): Promise<number> {592    return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();593  }594595  /**596   * Get information about the collection with additional data,597   * including the number of tokens it contains, its administrators,598   * the normalized address of the collection's owner, and decoded name and description.599   *600   * @param collectionId ID of collection601   * @example await getData(2)602   * @returns collection information object603   */604  async getData(collectionId: number): Promise<{605    id: number;606    name: string;607    description: string;608    tokensCount: number;609    admins: CrossAccountId[];610    normalizedOwner: TSubstrateAccount;611    raw: any612  } | null> {613    const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);614    const humanCollection = collection.toHuman(), collectionData = {615      id: collectionId, name: null, description: null, tokensCount: 0, admins: [],616      raw: humanCollection,617    } as any, jsonCollection = collection.toJSON();618    if (humanCollection === null) return null;619    collectionData.raw.limits = jsonCollection.limits;620    collectionData.raw.permissions = jsonCollection.permissions;621    collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);622    for (const key of ['name', 'description']) {623      collectionData[key] = this.helper.util.vec2str(humanCollection[key]);624    }625626    collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))627      ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)628      : 0;629    collectionData.admins = await this.getAdmins(collectionId);630631    return collectionData;632  }633634  /**635   * Get the addresses of the collection's administrators, optionally normalized.636   *637   * @param collectionId ID of collection638   * @param normalize whether to normalize the addresses to the default ss58 format639   * @example await getAdmins(1)640   * @returns array of administrators641   */642  async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {643    const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();644645    return normalize646      ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())647      : admins;648  }649650  /**651   * Get the addresses added to the collection allow-list, optionally normalized.652   * @param collectionId ID of collection653   * @param normalize whether to normalize the addresses to the default ss58 format654   * @example await getAllowList(1)655   * @returns array of allow-listed addresses656   */657  async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {658    const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();659    return normalize660      ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())661      : allowListed;662  }663664  /**665   * Get the effective limits of the collection instead of null for default values666   *667   * @param collectionId ID of collection668   * @example await getEffectiveLimits(2)669   * @returns object of collection limits670   */671  async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {672    return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();673  }674675  /**676   * Burns the collection if the signer has sufficient permissions and collection is empty.677   *678   * @param signer keyring of signer679   * @param collectionId ID of collection680   * @example await helper.collection.burn(aliceKeyring, 3);681   * @returns ```true``` if extrinsic success, otherwise ```false```682   */683  async burn(signer: TSigner, collectionId: number): Promise<boolean> {684    const result = await this.helper.executeExtrinsic(685      signer,686      'api.tx.unique.destroyCollection', [collectionId],687      true,688    );689690    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');691  }692693  /**694   * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.695   *696   * @param signer keyring of signer697   * @param collectionId ID of collection698   * @param sponsorAddress Sponsor substrate address699   * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")700   * @returns ```true``` if extrinsic success, otherwise ```false```701   */702  async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {703    const result = await this.helper.executeExtrinsic(704      signer,705      'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],706      true,707    );708709    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorSet');710  }711712  /**713   * Confirms consent to sponsor the collection on behalf of the signer.714   *715   * @param signer keyring of signer716   * @param collectionId ID of collection717   * @example confirmSponsorship(aliceKeyring, 10)718   * @returns ```true``` if extrinsic success, otherwise ```false```719   */720  async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {721    const result = await this.helper.executeExtrinsic(722      signer,723      'api.tx.unique.confirmSponsorship', [collectionId],724      true,725    );726727    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'SponsorshipConfirmed');728  }729730  /**731   * Removes the sponsor of a collection, regardless if it consented or not.732   *733   * @param signer keyring of signer734   * @param collectionId ID of collection735   * @example removeSponsor(aliceKeyring, 10)736   * @returns ```true``` if extrinsic success, otherwise ```false```737   */738  async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {739    const result = await this.helper.executeExtrinsic(740      signer,741      'api.tx.unique.removeCollectionSponsor', [collectionId],742      true,743    );744745    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorRemoved');746  }747748  /**749   * Sets the limits of the collection. At least one limit must be specified for a correct call.750   *751   * @param signer keyring of signer752   * @param collectionId ID of collection753   * @param limits collection limits object754   * @example755   * await setLimits(756   *   aliceKeyring,757   *   10,758   *   {759   *     sponsorTransferTimeout: 0,760   *     ownerCanDestroy: false761   *   }762   * )763   * @returns ```true``` if extrinsic success, otherwise ```false```764   */765  async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {766    const result = await this.helper.executeExtrinsic(767      signer,768      'api.tx.unique.setCollectionLimits', [collectionId, limits],769      true,770    );771772    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionLimitSet');773  }774775  /**776   * Changes the owner of the collection to the new Substrate address.777   *778   * @param signer keyring of signer779   * @param collectionId ID of collection780   * @param ownerAddress substrate address of new owner781   * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")782   * @returns ```true``` if extrinsic success, otherwise ```false```783   */784  async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {785    const result = await this.helper.executeExtrinsic(786      signer,787      'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],788      true,789    );790791    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionOwnedChanged');792  }793794  /**795   * Adds a collection administrator.796   *797   * @param signer keyring of signer798   * @param collectionId ID of collection799   * @param adminAddressObj Administrator address (substrate or ethereum)800   * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})801   * @returns ```true``` if extrinsic success, otherwise ```false```802   */803  async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {804    const result = await this.helper.executeExtrinsic(805      signer,806      'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],807      true,808    );809810    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminAdded');811  }812813  /**814   * Removes a collection administrator.815   *816   * @param signer keyring of signer817   * @param collectionId ID of collection818   * @param adminAddressObj Administrator address (substrate or ethereum)819   * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})820   * @returns ```true``` if extrinsic success, otherwise ```false```821   */822  async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {823    const result = await this.helper.executeExtrinsic(824      signer,825      'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],826      true,827    );828829    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminRemoved');830  }831832  /**833   * Check if user is in allow list.834   * 835   * @param collectionId ID of collection836   * @param user Account to check837   * @example await getAdmins(1)838   * @returns is user in allow list839   */840  async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {841    return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();842  }843844  /**845   * Adds an address to allow list846   * @param signer keyring of signer847   * @param collectionId ID of collection848   * @param addressObj address to add to the allow list849   * @returns ```true``` if extrinsic success, otherwise ```false```850   */851  async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {852    const result = await this.helper.executeExtrinsic(853      signer,854      'api.tx.unique.addToAllowList', [collectionId, addressObj],855      true,856    );857858    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressAdded');859  }860861  /**862   * Removes an address from allow list863   *864   * @param signer keyring of signer865   * @param collectionId ID of collection866   * @param addressObj address to remove from the allow list867   * @returns ```true``` if extrinsic success, otherwise ```false```868   */869  async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {870    const result = await this.helper.executeExtrinsic(871      signer,872      'api.tx.unique.removeFromAllowList', [collectionId, addressObj],873      true,874    );875876    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressRemoved');877  }878879  /**880   * Sets onchain permissions for selected collection.881   *882   * @param signer keyring of signer883   * @param collectionId ID of collection884   * @param permissions collection permissions object885   * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});886   * @returns ```true``` if extrinsic success, otherwise ```false```887   */888  async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {889    const result = await this.helper.executeExtrinsic(890      signer,891      'api.tx.unique.setCollectionPermissions', [collectionId, permissions],892      true,893    );894895    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionPermissionSet');896  }897898  /**899   * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.900   *901   * @param signer keyring of signer902   * @param collectionId ID of collection903   * @param permissions nesting permissions object904   * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});905   * @returns ```true``` if extrinsic success, otherwise ```false```906   */907  async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {908    return await this.setPermissions(signer, collectionId, {nesting: permissions});909  }910911  /**912   * Disables nesting for selected collection.913   *914   * @param signer keyring of signer915   * @param collectionId ID of collection916   * @example disableNesting(aliceKeyring, 10);917   * @returns ```true``` if extrinsic success, otherwise ```false```918   */919  async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {920    return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});921  }922923  /**924   * Sets onchain properties to the collection.925   *926   * @param signer keyring of signer927   * @param collectionId ID of collection928   * @param properties array of property objects929   * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);930   * @returns ```true``` if extrinsic success, otherwise ```false```931   */932  async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {933    const result = await this.helper.executeExtrinsic(934      signer,935      'api.tx.unique.setCollectionProperties', [collectionId, properties],936      true,937    );938939    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');940  }941942  /**943   * Get collection properties.944   * 945   * @param collectionId ID of collection946   * @param propertyKeys optionally filter the returned properties to only these keys947   * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);948   * @returns array of key-value pairs949   */950  async getProperties(collectionId: number, propertyKeys: string[] | null = null): Promise<IProperty[]> {951    return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();952  }953954  /**955   * Deletes onchain properties from the collection.956   *957   * @param signer keyring of signer958   * @param collectionId ID of collection959   * @param propertyKeys array of property keys to delete960   * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);961   * @returns ```true``` if extrinsic success, otherwise ```false```962   */963  async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {964    const result = await this.helper.executeExtrinsic(965      signer,966      'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],967      true,968    );969970    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');971  }972973  /**974   * Changes the owner of the token.975   *976   * @param signer keyring of signer977   * @param collectionId ID of collection978   * @param tokenId ID of token979   * @param addressObj address of a new owner980   * @param amount amount of tokens to be transfered. For NFT must be set to 1n981   * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})982   * @returns true if the token success, otherwise false983   */984  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {985    const result = await this.helper.executeExtrinsic(986      signer,987      'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],988      true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,989    );990991    return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);992  }993994  /**995   *996   * Change ownership of a token(s) on behalf of the owner.997   *998   * @param signer keyring of signer999   * @param collectionId ID of collection1000   * @param tokenId ID of token1001   * @param fromAddressObj address on behalf of which the token will be sent1002   * @param toAddressObj new token owner1003   * @param amount amount of tokens to be transfered. For NFT must be set to 1n1004   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})1005   * @returns true if the token success, otherwise false1006   */1007  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1008    const result = await this.helper.executeExtrinsic(1009      signer,1010      'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1011      true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1012    );1013    return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1014  }10151016  /**1017   *1018   * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1019   *1020   * @param signer keyring of signer1021   * @param collectionId ID of collection1022   * @param tokenId ID of token1023   * @param amount amount of tokens to be burned. For NFT must be set to 1n1024   * @example burnToken(aliceKeyring, 10, 5);1025   * @returns ```true``` and burnt token number is extrinsic success. Otherwise ```false``` and ```null```1026   */1027  async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<{1028    success: boolean,1029    token: number | null1030  }> {1031    const burnResult = await this.helper.executeExtrinsic(1032      signer,1033      'api.tx.unique.burnItem', [collectionId, tokenId, amount],1034      true, // `Unable to burn token for ${label}`,1035    );1036    const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1037    if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1038    return {success: burnedTokens.success, token: burnedTokens.tokens.length > 0 ? burnedTokens.tokens[0] : null};1039  }10401041  /**1042   * Destroys a concrete instance of NFT on behalf of the owner1043   *1044   * @param signer keyring of signer1045   * @param collectionId ID of collection1046   * @param tokenId ID of token1047   * @param fromAddressObj address on behalf of which the token will be burnt1048   * @param amount amount of tokens to be burned. For NFT must be set to 1n1049   * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1050   * @returns ```true``` if extrinsic success, otherwise ```false```1051   */1052  async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1053    const burnResult = await this.helper.executeExtrinsic(1054      signer,1055      'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1056      true, // `Unable to burn token from for ${label}`,1057    );1058    const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1059    return burnedTokens.success && burnedTokens.tokens.length > 0;1060  }10611062  /**1063   * Set, change, or remove approved address to transfer the ownership of the NFT.1064   *1065   * @param signer keyring of signer1066   * @param collectionId ID of collection1067   * @param tokenId ID of token1068   * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1069   * @param amount amount of token to be approved. For NFT must be set to 1n1070   * @returns ```true``` if extrinsic success, otherwise ```false```1071   */1072  async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1073    const approveResult = await this.helper.executeExtrinsic(1074      signer,1075      'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1076      true, // `Unable to approve token for ${label}`,1077    );10781079    return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1080  }10811082  /**1083   * Get the amount of token pieces approved to transfer or burn. Normally 0.1084   *1085   * @param collectionId ID of collection1086   * @param tokenId ID of token1087   * @param toAccountObj address which is approved to use token pieces1088   * @param fromAccountObj address which may have allowed the use of its owned tokens1089   * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1090   * @returns number of approved to transfer pieces1091   */1092  async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1093    return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1094  }10951096  /**1097   * Get the last created token ID in a collection1098   *1099   * @param collectionId ID of collection1100   * @example getLastTokenId(10);1101   * @returns id of the last created token1102   */1103  async getLastTokenId(collectionId: number): Promise<number> {1104    return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1105  }11061107  /**1108   * Check if token exists1109   *1110   * @param collectionId ID of collection1111   * @param tokenId ID of token1112   * @example isTokenExists(10, 20);1113   * @returns true if the token exists, otherwise false1114   */1115  async isTokenExists(collectionId: number, tokenId: number): Promise<boolean> {1116    return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1117  }1118}11191120class NFTnRFT extends CollectionGroup {1121  /**1122   * Get tokens owned by account1123   *1124   * @param collectionId ID of collection1125   * @param addressObj tokens owner1126   * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1127   * @returns array of token ids owned by account1128   */1129  async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1130    return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1131  }11321133  /**1134   * Get token data1135   *1136   * @param collectionId ID of collection1137   * @param tokenId ID of token1138   * @param propertyKeys optionally filter the token properties to only these keys1139   * @param blockHashAt optionally query the data at some block with this hash1140   * @example getToken(10, 5);1141   * @returns human readable token data1142   */1143  async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1144    properties: IProperty[];1145    owner: CrossAccountId;1146    normalizedOwner: CrossAccountId;1147  }| null> {1148    let tokenData;1149    if(typeof blockHashAt === 'undefined') {1150      tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1151    }1152    else {1153      if(propertyKeys.length == 0) {1154        const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1155        if(!collection) return null;1156        propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1157      }1158      tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1159    }1160    tokenData = tokenData.toHuman();1161    if (tokenData === null || tokenData.owner === null) return null;1162    const owner = {} as any;1163    for (const key of Object.keys(tokenData.owner)) {1164      owner[key.toLocaleLowerCase()] = new CrossAccountId(tokenData.owner[key]).withNormalizedSubstrate();1165    }1166    tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1167    return tokenData;1168  }11691170  /**1171   * Set permissions to change token properties1172   *1173   * @param signer keyring of signer1174   * @param collectionId ID of collection1175   * @param permissions permissions to change a property by the collection admin or token owner1176   * @example setTokenPropertyPermissions(1177   *   aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1178   * )1179   * @returns true if extrinsic success otherwise false1180   */1181  async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1182    const result = await this.helper.executeExtrinsic(1183      signer,1184      'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1185      true,1186    );11871188    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1189  }11901191  /**1192   * Get token property permissions.1193   * 1194   * @param collectionId ID of collection1195   * @param propertyKeys optionally filter the returned property permissions to only these keys1196   * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1197   * @returns array of key-permission pairs1198   */1199  async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1200    return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1201  }12021203  /**1204   * Set token properties1205   *1206   * @param signer keyring of signer1207   * @param collectionId ID of collection1208   * @param tokenId ID of token1209   * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1210   * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1211   * @returns ```true``` if extrinsic success, otherwise ```false```1212   */1213  async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1214    const result = await this.helper.executeExtrinsic(1215      signer,1216      'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1217      true,1218    );12191220    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1221  }12221223  /**1224   * Get properties, metadata assigned to a token.1225   * 1226   * @param collectionId ID of collection1227   * @param tokenId ID of token1228   * @param propertyKeys optionally filter the returned properties to only these keys1229   * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1230   * @returns array of key-value pairs1231   */1232  async getTokenProperties(collectionId: number, tokenId: number, propertyKeys: string[] | null = null): Promise<IProperty[]> {1233    return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1234  }12351236  /**1237   * Delete the provided properties of a token1238   * @param signer keyring of signer1239   * @param collectionId ID of collection1240   * @param tokenId ID of token1241   * @param propertyKeys property keys to be deleted1242   * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1243   * @returns ```true``` if extrinsic success, otherwise ```false```1244   */1245  async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1246    const result = await this.helper.executeExtrinsic(1247      signer,1248      'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1249      true,1250    );12511252    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1253  }12541255  /**1256   * Mint new collection1257   *1258   * @param signer keyring of signer1259   * @param collectionOptions basic collection options and properties1260   * @param mode NFT or RFT type of a collection1261   * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1262   * @returns object of the created collection1263   */1264  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1265    collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1266    collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1267    for (const key of ['name', 'description', 'tokenPrefix']) {1268      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);1269    }1270    const creationResult = await this.helper.executeExtrinsic(1271      signer,1272      'api.tx.unique.createCollectionEx', [collectionOptions],1273      true, // errorLabel,1274    );1275    return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1276  }12771278  getCollectionObject(_collectionId: number): any {1279    return null;1280  }12811282  getTokenObject(_collectionId: number, _tokenId: number): any {1283    return null;1284  }1285}128612871288class NFTGroup extends NFTnRFT {1289  /**1290   * Get collection object1291   * @param collectionId ID of collection1292   * @example getCollectionObject(2);1293   * @returns instance of UniqueNFTCollection1294   */1295  getCollectionObject(collectionId: number): UniqueNFTCollection {1296    return new UniqueNFTCollection(collectionId, this.helper);1297  }12981299  /**1300   * Get token object1301   * @param collectionId ID of collection1302   * @param tokenId ID of token1303   * @example getTokenObject(10, 5);1304   * @returns instance of UniqueNFTToken1305   */1306  getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1307    return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1308  }13091310  /**1311   * Get token's owner1312   * @param collectionId ID of collection1313   * @param tokenId ID of token1314   * @param blockHashAt optionally query the data at the block with this hash1315   * @example getTokenOwner(10, 5);1316   * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1317   */1318  async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1319    let owner;1320    if (typeof blockHashAt === 'undefined') {1321      owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1322    } else {1323      owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1324    }1325    return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1326  }13271328  /**1329   * Is token approved to transfer1330   * @param collectionId ID of collection1331   * @param tokenId ID of token1332   * @param toAccountObj address to be approved1333   * @returns ```true``` if extrinsic success, otherwise ```false```1334   */1335  async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1336    return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1337  }13381339  /**1340   * Changes the owner of the token.1341   *1342   * @param signer keyring of signer1343   * @param collectionId ID of collection1344   * @param tokenId ID of token1345   * @param addressObj address of a new owner1346   * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1347   * @returns ```true``` if extrinsic success, otherwise ```false```1348   */1349  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1350    return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1351  }13521353  /**1354   *1355   * Change ownership of a NFT on behalf of the owner.1356   *1357   * @param signer keyring of signer1358   * @param collectionId ID of collection1359   * @param tokenId ID of token1360   * @param fromAddressObj address on behalf of which the token will be sent1361   * @param toAddressObj new token owner1362   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1363   * @returns ```true``` if extrinsic success, otherwise ```false```1364   */1365  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1366    return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1367  }13681369  /**1370   * Recursively find the address that owns the token1371   * @param collectionId ID of collection1372   * @param tokenId ID of token1373   * @param blockHashAt1374   * @example getTokenTopmostOwner(10, 5);1375   * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1376   */1377  async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1378    let owner;1379    if (typeof blockHashAt === 'undefined') {1380      owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1381    } else {1382      owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1383    }13841385    if (owner === null) return null;13861387    return owner.toHuman();1388  }13891390  /**1391   * Get tokens nested in the provided token1392   * @param collectionId ID of collection1393   * @param tokenId ID of token1394   * @param blockHashAt optionally query the data at the block with this hash1395   * @example getTokenChildren(10, 5);1396   * @returns tokens whose depth of nesting is <= 51397   */1398  async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1399    let children;1400    if(typeof blockHashAt === 'undefined') {1401      children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1402    } else {1403      children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1404    }14051406    return children.toJSON().map((x: any) => {1407      return {collectionId: x.collection, tokenId: x.token};1408    });1409  }14101411  /**1412   * Nest one token into another1413   * @param signer keyring of signer1414   * @param tokenObj token to be nested1415   * @param rootTokenObj token to be parent1416   * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});1417   * @returns ```true``` if extrinsic success, otherwise ```false```1418   */1419  async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1420    const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1421    const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1422    if(!result) {1423      throw Error('Unable to nest token!');1424    }1425    return result;1426  }14271428  /**1429   * Remove token from nested state1430   * @param signer keyring of signer1431   * @param tokenObj token to unnest1432   * @param rootTokenObj parent of a token1433   * @param toAddressObj address of a new token owner1434   * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});1435   * @returns ```true``` if extrinsic success, otherwise ```false```1436   */1437  async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1438    const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1439    const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1440    if(!result) {1441      throw Error('Unable to unnest token!');1442    }1443    return result;1444  }14451446  /**1447   * Mint new collection1448   * @param signer keyring of signer1449   * @param collectionOptions Collection options1450   * @example1451   * mintCollection(aliceKeyring, {1452   *   name: 'New',1453   *   description: 'New collection',1454   *   tokenPrefix: 'NEW',1455   * })1456   * @returns object of the created collection1457   */1458  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1459    return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1460  }14611462  /**1463   * Mint new token1464   * @param signer keyring of signer1465   * @param data token data1466   * @returns created token object1467   */1468  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1469    const creationResult = await this.helper.executeExtrinsic(1470      signer,1471      'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1472        nft: {1473          properties: data.properties,1474        },1475      }],1476      true,1477    );1478    const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1479    if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1480    if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1481    return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1482  }14831484  /**1485   * Mint multiple NFT tokens1486   * @param signer keyring of signer1487   * @param collectionId ID of collection1488   * @param tokens array of tokens with owner and properties1489   * @example1490   * mintMultipleTokens(aliceKeyring, 10, [{1491   *     owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1492   *     properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1493   *   },{1494   *     owner: {Ethereum: "0x9F0583DbB855d..."},1495   *     properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1496   * }]);1497   * @returns ```true``` if extrinsic success, otherwise ```false```1498   */1499  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1500    const creationResult = await this.helper.executeExtrinsic(1501      signer,1502      'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1503      true,1504    );1505    const collection = this.getCollectionObject(collectionId);1506    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1507  }15081509  /**1510   * Mint multiple NFT tokens with one owner1511   * @param signer keyring of signer1512   * @param collectionId ID of collection1513   * @param owner tokens owner1514   * @param tokens array of tokens with owner and properties1515   * @example1516   * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1517   *   properties: [{1518   *   key: "gender",1519   *   value: "female",1520   *  },{1521   *   key: "age",1522   *   value: "33",1523   *  }],1524   * }]);1525   * @returns array of newly created tokens1526   */1527  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1528    const rawTokens = [];1529    for (const token of tokens) {1530      const raw = {NFT: {properties: token.properties}};1531      rawTokens.push(raw);1532    }1533    const creationResult = await this.helper.executeExtrinsic(1534      signer,1535      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1536      true,1537    );1538    const collection = this.getCollectionObject(collectionId);1539    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1540  }15411542  /**1543   * Set, change, or remove approved address to transfer the ownership of the NFT.1544   *1545   * @param signer keyring of signer1546   * @param collectionId ID of collection1547   * @param tokenId ID of token1548   * @param toAddressObj address to approve1549   * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1550   * @returns ```true``` if extrinsic success, otherwise ```false```1551   */1552  async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId) {1553    return super.approveToken(signer, collectionId, tokenId, toAddressObj, 1n);1554  }1555}155615571558class RFTGroup extends NFTnRFT {1559  /**1560   * Get collection object1561   * @param collectionId ID of collection1562   * @example getCollectionObject(2);1563   * @returns instance of UniqueRFTCollection1564   */1565  getCollectionObject(collectionId: number): UniqueRFTCollection {1566    return new UniqueRFTCollection(collectionId, this.helper);1567  }15681569  /**1570   * Get token object1571   * @param collectionId ID of collection1572   * @param tokenId ID of token1573   * @example getTokenObject(10, 5);1574   * @returns instance of UniqueNFTToken1575   */1576  getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1577    return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1578  }15791580  /**1581   * Get top 10 token owners with the largest number of pieces1582   * @param collectionId ID of collection1583   * @param tokenId ID of token1584   * @example getTokenTop10Owners(10, 5);1585   * @returns array of top 10 owners1586   */1587  async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1588    return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1589  }15901591  /**1592   * Get number of pieces owned by address1593   * @param collectionId ID of collection1594   * @param tokenId ID of token1595   * @param addressObj address token owner1596   * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1597   * @returns number of pieces ownerd by address1598   */1599  async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1600    return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1601  }16021603  /**1604   * Transfer pieces of token to another address1605   * @param signer keyring of signer1606   * @param collectionId ID of collection1607   * @param tokenId ID of token1608   * @param addressObj address of a new owner1609   * @param amount number of pieces to be transfered1610   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1611   * @returns ```true``` if extrinsic success, otherwise ```false```1612   */1613  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1614    return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1615  }16161617  /**1618   * Change ownership of some pieces of RFT on behalf of the owner.1619   * @param signer keyring of signer1620   * @param collectionId ID of collection1621   * @param tokenId ID of token1622   * @param fromAddressObj address on behalf of which the token will be sent1623   * @param toAddressObj new token owner1624   * @param amount number of pieces to be transfered1625   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1626   * @returns ```true``` if extrinsic success, otherwise ```false```1627   */1628  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1629    return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1630  }16311632  /**1633   * Mint new collection1634   * @param signer keyring of signer1635   * @param collectionOptions Collection options1636   * @example1637   * mintCollection(aliceKeyring, {1638   *   name: 'New',1639   *   description: 'New collection',1640   *   tokenPrefix: 'NEW',1641   * })1642   * @returns object of the created collection1643   */1644  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1645    return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1646  }16471648  /**1649   * Mint new token1650   * @param signer keyring of signer1651   * @param data token data1652   * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1653   * @returns created token object1654   */1655  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1656    const creationResult = await this.helper.executeExtrinsic(1657      signer,1658      'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1659        refungible: {1660          pieces: data.pieces,1661          properties: data.properties,1662        },1663      }],1664      true,1665    );1666    const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1667    if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1668    if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1669    return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1670  }16711672  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1673    throw Error('Not implemented');1674    const creationResult = await this.helper.executeExtrinsic(1675      signer,1676      'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1677      true, // `Unable to mint RFT tokens for ${label}`,1678    );1679    const collection = this.getCollectionObject(collectionId);1680    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1681  }16821683  /**1684   * Mint multiple RFT tokens with one owner1685   * @param signer keyring of signer1686   * @param collectionId ID of collection1687   * @param owner tokens owner1688   * @param tokens array of tokens with properties and pieces1689   * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);1690   * @returns array of newly created RFT tokens1691   */1692  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1693    const rawTokens = [];1694    for (const token of tokens) {1695      const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1696      rawTokens.push(raw);1697    }1698    const creationResult = await this.helper.executeExtrinsic(1699      signer,1700      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1701      true,1702    );1703    const collection = this.getCollectionObject(collectionId);1704    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1705  }17061707  /**1708   * Destroys a concrete instance of RFT.1709   * @param signer keyring of signer1710   * @param collectionId ID of collection1711   * @param tokenId ID of token1712   * @param amount number of pieces to be burnt1713   * @example burnToken(aliceKeyring, 10, 5);1714   * @returns ```true``` and burnt token number, if extrinsic is successful. Otherwise ```false``` and ```null```1715   */1716  async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<{ success: boolean; token: number | null; }> {1717    return await super.burnToken(signer, collectionId, tokenId, amount);1718  }17191720  /**1721   * Destroys a concrete instance of RFT on behalf of the owner.1722   * @param signer keyring of signer1723   * @param collectionId ID of collection1724   * @param tokenId ID of token1725   * @param fromAddressObj address on behalf of which the token will be burnt1726   * @param amount number of pieces to be burnt1727   * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)1728   * @returns ```true``` if extrinsic success, otherwise ```false```1729   */1730  async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1731    return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1732  }17331734  /**1735   * Set, change, or remove approved address to transfer the ownership of the RFT.1736   *1737   * @param signer keyring of signer1738   * @param collectionId ID of collection1739   * @param tokenId ID of token1740   * @param toAddressObj address to approve1741   * @param amount number of pieces to be approved1742   * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);1743   * @returns true if the token success, otherwise false1744   */1745  async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1746    return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1747  }17481749  /**1750   * Get total number of pieces1751   * @param collectionId ID of collection1752   * @param tokenId ID of token1753   * @example getTokenTotalPieces(10, 5);1754   * @returns number of pieces1755   */1756  async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {1757    return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();1758  }17591760  /**1761   * Change number of token pieces. Signer must be the owner of all token pieces.1762   * @param signer keyring of signer1763   * @param collectionId ID of collection1764   * @param tokenId ID of token1765   * @param amount new number of pieces1766   * @example repartitionToken(aliceKeyring, 10, 5, 12345n);1767   * @returns true if the repartion was success, otherwise false1768   */1769  async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {1770    const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);1771    const repartitionResult = await this.helper.executeExtrinsic(1772      signer,1773      'api.tx.unique.repartition', [collectionId, tokenId, amount],1774      true,1775    );1776    if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');1777    return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');1778  }1779}178017811782class FTGroup extends CollectionGroup {1783  /**1784   * Get collection object1785   * @param collectionId ID of collection1786   * @example getCollectionObject(2);1787   * @returns instance of UniqueFTCollection1788   */1789  getCollectionObject(collectionId: number): UniqueFTCollection {1790    return new UniqueFTCollection(collectionId, this.helper);1791  }17921793  /**1794   * Mint new fungible collection1795   * @param signer keyring of signer1796   * @param collectionOptions Collection options1797   * @param decimalPoints number of token decimals1798   * @example1799   * mintCollection(aliceKeyring, {1800   *   name: 'New',1801   *   description: 'New collection',1802   *   tokenPrefix: 'NEW',1803   * }, 18)1804   * @returns newly created fungible collection1805   */1806  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {1807    collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1808    if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');1809    collectionOptions.mode = {fungible: decimalPoints};1810    for (const key of ['name', 'description', 'tokenPrefix']) {1811      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);1812    }1813    const creationResult = await this.helper.executeExtrinsic(1814      signer,1815      'api.tx.unique.createCollectionEx', [collectionOptions],1816      true,1817    );1818    return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1819  }18201821  /**1822   * Mint tokens1823   * @param signer keyring of signer1824   * @param collectionId ID of collection1825   * @param owner address owner of new tokens1826   * @param amount amount of tokens to be meanted1827   * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);1828   * @returns ```true``` if extrinsic success, otherwise ```false```1829   */1830  async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {1831    const creationResult = await this.helper.executeExtrinsic(1832      signer,1833      'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {1834        fungible: {1835          value: amount,1836        },1837      }],1838      true, // `Unable to mint fungible tokens for ${label}`,1839    );1840    return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1841  }18421843  /**1844   * Mint multiple Fungible tokens with one owner1845   * @param signer keyring of signer1846   * @param collectionId ID of collection1847   * @param owner tokens owner1848   * @param tokens array of tokens with properties and pieces1849   * @returns ```true``` if extrinsic success, otherwise ```false```1850   */1851  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {1852    const rawTokens = [];1853    for (const token of tokens) {1854      const raw = {Fungible: {Value: token.value}};1855      rawTokens.push(raw);1856    }1857    const creationResult = await this.helper.executeExtrinsic(1858      signer,1859      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1860      true,1861    );1862    return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1863  }18641865  /**1866   * Get the top 10 owners with the largest balance for the Fungible collection1867   * @param collectionId ID of collection1868   * @example getTop10Owners(10);1869   * @returns array of ```ICrossAccountId```1870   */1871  async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {1872    return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1873  }18741875  /**1876   * Get account balance1877   * @param collectionId ID of collection1878   * @param addressObj address of owner1879   * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})1880   * @returns amount of fungible tokens owned by address1881   */1882  async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {1883    return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();1884  }18851886  /**1887   * Transfer tokens to address1888   * @param signer keyring of signer1889   * @param collectionId ID of collection1890   * @param toAddressObj address recipient1891   * @param amount amount of tokens to be sent1892   * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);1893   * @returns ```true``` if extrinsic success, otherwise ```false```1894   */1895  async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {1896    return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);1897  }18981899  /**1900   * Transfer some tokens on behalf of the owner.1901   * @param signer keyring of signer1902   * @param collectionId ID of collection1903   * @param fromAddressObj address on behalf of which tokens will be sent1904   * @param toAddressObj address where token to be sent1905   * @param amount number of tokens to be sent1906   * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);1907   * @returns ```true``` if extrinsic success, otherwise ```false```1908   */1909  async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {1910    return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);1911  }19121913  /**1914   * Destroy some amount of tokens1915   * @param signer keyring of signer1916   * @param collectionId ID of collection1917   * @param amount amount of tokens to be destroyed1918   * @example burnTokens(aliceKeyring, 10, 1000n);1919   * @returns ```true``` if extrinsic success, otherwise ```false```1920   */1921  async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {1922    return (await super.burnToken(signer, collectionId, 0, amount)).success;1923  }19241925  /**1926   * Burn some tokens on behalf of the owner.1927   * @param signer keyring of signer1928   * @param collectionId ID of collection1929   * @param fromAddressObj address on behalf of which tokens will be burnt1930   * @param amount amount of tokens to be burnt1931   * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);1932   * @returns ```true``` if extrinsic success, otherwise ```false```1933   */1934  async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1935    return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);1936  }19371938  /**1939   * Get total collection supply1940   * @param collectionId1941   * @returns1942   */1943  async getTotalPieces(collectionId: number): Promise<bigint> {1944    return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();1945  }19461947  /**1948   * Set, change, or remove approved address to transfer tokens.1949   *1950   * @param signer keyring of signer1951   * @param collectionId ID of collection1952   * @param toAddressObj address to be approved1953   * @param amount amount of tokens to be approved1954   * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)1955   * @returns ```true``` if extrinsic success, otherwise ```false```1956   */1957  async approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {1958    return super.approveToken(signer, collectionId, 0, toAddressObj, amount);1959  }19601961  /**1962   * Get amount of fungible tokens approved to transfer1963   * @param collectionId ID of collection1964   * @param fromAddressObj owner of tokens1965   * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner1966   * @returns number of tokens approved for the transfer1967   */1968  async getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {1969    return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);1970  }1971}197219731974class ChainGroup extends HelperGroup {1975  /**1976   * Get system properties of a chain1977   * @example getChainProperties();1978   * @returns ss58Format, token decimals, and token symbol1979   */1980  getChainProperties(): IChainProperties {1981    const properties = (this.helper.api as any).registry.getChainProperties().toJSON();1982    return {1983      ss58Format: properties.ss58Format.toJSON(),1984      tokenDecimals: properties.tokenDecimals.toJSON(),1985      tokenSymbol: properties.tokenSymbol.toJSON(),1986    };1987  }19881989  /**1990   * Get chain header1991   * @example getLatestBlockNumber();1992   * @returns the number of the last block1993   */1994  async getLatestBlockNumber(): Promise<number> {1995    return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();1996  }19971998  /**1999   * Get block hash by block number2000   * @param blockNumber number of block2001   * @example getBlockHashByNumber(12345);2002   * @returns hash of a block2003   */2004  async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2005    const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2006    if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2007    return blockHash;2008  }20092010  // TODO add docs2011  async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2012    const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2013    if (!blockHash) return null;2014    return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2015  }20162017  /**2018   * Get account nonce2019   * @param address substrate address2020   * @example getNonce("5GrwvaEF5zXb26Fz...");2021   * @returns number, account's nonce2022   */2023  async getNonce(address: TSubstrateAccount): Promise<number> {2024    return (await (this.helper.api as any).query.system.account(address)).nonce.toNumber();2025  }2026}202720282029class BalanceGroup extends HelperGroup {2030  /**2031   * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2032   * @example getOneTokenNominal()2033   * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2034   */2035  getOneTokenNominal(): bigint {2036    const chainProperties = this.helper.chain.getChainProperties();2037    return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2038  }20392040  /**2041   * Get substrate address balance2042   * @param address substrate address2043   * @example getSubstrate("5GrwvaEF5zXb26Fz...")2044   * @returns amount of tokens on address2045   */2046  async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2047    return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2048  }20492050  /**2051   * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2052   * @param address substrate address2053   * @returns2054   */2055  async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2056    const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2057    return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2058  }20592060  /**2061   * Get ethereum address balance2062   * @param address ethereum address2063   * @example getEthereum("0x9F0583DbB855d...")2064   * @returns amount of tokens on address2065   */2066  async getEthereum(address: TEthereumAccount): Promise<bigint> {2067    return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2068  }20692070  /**2071   * Transfer tokens to substrate address2072   * @param signer keyring of signer2073   * @param address substrate address of a recipient2074   * @param amount amount of tokens to be transfered2075   * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2076   * @returns ```true``` if extrinsic success, otherwise ```false```2077   */2078  async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2079    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}`*/);20802081    let transfer = {from: null, to: null, amount: 0n} as any;2082    result.result.events.forEach(({event: {data, method, section}}) => {2083      if ((section === 'balances') && (method === 'Transfer')) {2084        transfer = {2085          from: this.helper.address.normalizeSubstrate(data[0]),2086          to: this.helper.address.normalizeSubstrate(data[1]),2087          amount: BigInt(data[2]),2088        };2089      }2090    });2091    const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from 2092      && this.helper.address.normalizeSubstrate(address) === transfer.to 2093      && BigInt(amount) === transfer.amount;2094    return isSuccess;2095  }2096}209720982099class AddressGroup extends HelperGroup {2100  /**2101   * Normalizes the address to the specified ss58 format, by default ```42```.2102   * @param address substrate address2103   * @param ss58Format format for address conversion, by default ```42```2104   * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2105   * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2106   */2107  normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2108    return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2109  }21102111  /**2112   * Get address in the connected chain format2113   * @param address substrate address2114   * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2115   * @returns address in chain format2116   */2117  normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2118    return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2119  }21202121  /**2122   * Get substrate mirror of an ethereum address2123   * @param ethAddress ethereum address2124   * @param toChainFormat false for normalized account2125   * @example ethToSubstrate('0x9F0583DbB855d...')2126   * @returns substrate mirror of a provided ethereum address2127   */2128  ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): TSubstrateAccount {2129    return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2130  }21312132  /**2133   * Get ethereum mirror of a substrate address2134   * @param subAddress substrate account2135   * @example substrateToEth("5DnSF6RRjwteE3BrC...")2136   * @returns ethereum mirror of a provided substrate address2137   */2138  substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2139    return CrossAccountId.translateSubToEth(subAddress);2140  }2141}21422143class StakingGroup extends HelperGroup {2144  /**2145   * Stake tokens for App Promotion2146   * @param signer keyring of signer2147   * @param amountToStake amount of tokens to stake2148   * @param label extra label for log2149   * @returns2150   */2151  async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2152    if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2153    const stakeResult = await this.helper.executeExtrinsic(2154      signer, 'api.tx.appPromotion.stake',2155      [amountToStake], true,2156    );2157    // TODO extract info from stakeResult2158    return true;2159  }21602161  /**2162   * Unstake tokens for App Promotion2163   * @param signer keyring of signer2164   * @param amountToUnstake amount of tokens to unstake2165   * @param label extra label for log2166   * @returns block number where balances will be unlocked2167   */2168  async unstake(signer: TSigner, label?: string): Promise<number> {2169    if(typeof label === 'undefined') label = `${signer.address}`;2170    const unstakeResult = await this.helper.executeExtrinsic(2171      signer, 'api.tx.appPromotion.unstake',2172      [], true,2173    );2174    // TODO extract block number fron events2175    return 1;2176  }21772178  /**2179   * Get total staked amount for address2180   * @param address substrate or ethereum address2181   * @returns total staked amount2182   */2183  async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2184    if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2185    return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2186  }21872188  /**2189   * Get total staked per block2190   * @param address substrate or ethereum address2191   * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2192   */2193  async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2194    const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2195    return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2196      return { 2197        block: block.toBigInt(),2198        amount: amount.toBigInt(),2199      };2200    });2201  }22022203  /**2204   * Get total pending unstake amount for address2205   * @param address substrate or ethereum address2206   * @returns total pending unstake amount2207   */2208  async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2209    return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2210  }22112212  /**2213   * Get pending unstake amount per block for address2214   * @param address substrate or ethereum address2215   * @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 block2216   */2217  async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2218    const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2219    const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2220      return {2221        block: block.toBigInt(),2222        amount: amount.toBigInt(),2223      };2224    });2225    return result;2226  }2227}22282229export class UniqueHelper extends ChainHelperBase {2230  chain: ChainGroup;2231  balance: BalanceGroup;2232  address: AddressGroup;2233  collection: CollectionGroup;2234  nft: NFTGroup;2235  rft: RFTGroup;2236  ft: FTGroup;2237  staking: StakingGroup;22382239  constructor(logger?: ILogger) {2240    super(logger);2241    this.chain = new ChainGroup(this);2242    this.balance = new BalanceGroup(this);2243    this.address = new AddressGroup(this);2244    this.collection = new CollectionGroup(this);2245    this.nft = new NFTGroup(this);2246    this.rft = new RFTGroup(this);2247    this.ft = new FTGroup(this);2248    this.staking = new StakingGroup(this);2249  }2250}225122522253export class UniqueBaseCollection {2254  helper: UniqueHelper;2255  collectionId: number;22562257  constructor(collectionId: number, uniqueHelper: UniqueHelper) {2258    this.collectionId = collectionId;2259    this.helper = uniqueHelper;2260  }22612262  async getData() {2263    return await this.helper.collection.getData(this.collectionId);2264  }22652266  async getLastTokenId() {2267    return await this.helper.collection.getLastTokenId(this.collectionId);2268  }22692270  async isTokenExists(tokenId: number) {2271    return await this.helper.collection.isTokenExists(this.collectionId, tokenId);2272  }22732274  async getAdmins() {2275    return await this.helper.collection.getAdmins(this.collectionId);2276  }22772278  async getAllowList() {2279    return await this.helper.collection.getAllowList(this.collectionId);2280  }22812282  async getEffectiveLimits() {2283    return await this.helper.collection.getEffectiveLimits(this.collectionId);2284  }22852286  async getProperties(propertyKeys: string[] | null = null) {2287    return await this.helper.collection.getProperties(this.collectionId, propertyKeys);2288  }22892290  async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {2291    return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);2292  }22932294  async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {2295    return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);2296  }22972298  async confirmSponsorship(signer: TSigner) {2299    return await this.helper.collection.confirmSponsorship(signer, this.collectionId);2300  }23012302  async removeSponsor(signer: TSigner) {2303    return await this.helper.collection.removeSponsor(signer, this.collectionId);2304  }23052306  async setLimits(signer: TSigner, limits: ICollectionLimits) {2307    return await this.helper.collection.setLimits(signer, this.collectionId, limits);2308  }23092310  async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {2311    return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);2312  }23132314  async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {2315    return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);2316  }23172318  async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {2319    return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);2320  }23212322  async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {2323    return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);2324  }23252326  async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {2327    return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);2328  }23292330  async setProperties(signer: TSigner, properties: IProperty[]) {2331    return await this.helper.collection.setProperties(signer, this.collectionId, properties);2332  }23332334  async deleteProperties(signer: TSigner, propertyKeys: string[]) {2335    return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);2336  }23372338  async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {2339    return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);2340  }23412342  async enableNesting(signer: TSigner, permissions: INestingPermissions) {2343    return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);2344  }23452346  async disableNesting(signer: TSigner) {2347    return await this.helper.collection.disableNesting(signer, this.collectionId);2348  }23492350  async burn(signer: TSigner) {2351    return await this.helper.collection.burn(signer, this.collectionId);2352  }2353}235423552356export class UniqueNFTCollection extends UniqueBaseCollection {2357  getTokenObject(tokenId: number) {2358    return new UniqueNFToken(tokenId, this);2359  }23602361  async getTokensByAddress(addressObj: ICrossAccountId) {2362    return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);2363  }23642365  async getToken(tokenId: number, blockHashAt?: string) {2366    return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);2367  }23682369  async getTokenOwner(tokenId: number, blockHashAt?: string) {2370    return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);2371  }23722373  async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {2374    return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);2375  }23762377  async getTokenChildren(tokenId: number, blockHashAt?: string) {2378    return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);2379  }23802381  async getPropertyPermissions(propertyKeys: string[] | null = null) {2382    return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);2383  }23842385  async getTokenProperties(tokenId: number, propertyKeys: string[] | null = null) {2386    return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);2387  }23882389  async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {2390    return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);2391  }23922393  async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2394    return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);2395  }23962397  async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {2398    return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);2399  }24002401  async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {2402    return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);2403  }24042405  async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {2406    return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});2407  }24082409  async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {2410    return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);2411  }24122413  async burnToken(signer: TSigner, tokenId: number) {2414    return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);2415  }24162417  async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {2418    return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);2419  }24202421  async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {2422    return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);2423  }24242425  async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {2426    return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);2427  }24282429  async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {2430    return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);2431  }24322433  async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {2434    return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);2435  }24362437  async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {2438    return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);2439  }2440}244124422443export class UniqueRFTCollection extends UniqueBaseCollection {2444  getTokenObject(tokenId: number) {2445    return new UniqueRFToken(tokenId, this);2446  }24472448  async getToken(tokenId: number, blockHashAt?: string) {2449    return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);2450  }24512452  async getTokensByAddress(addressObj: ICrossAccountId) {2453    return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);2454  }24552456  async getTop10TokenOwners(tokenId: number) {2457    return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);2458  }24592460  async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {2461    return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);2462  }24632464  async getTokenTotalPieces(tokenId: number) {2465    return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);2466  }24672468  async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2469    return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);2470  }24712472  async getPropertyPermissions(propertyKeys: string[] | null = null) {2473    return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);2474  }24752476  async getTokenProperties(tokenId: number, propertyKeys: string[] | null = null) {2477    return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);2478  }24792480  async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {2481    return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);2482  }24832484  async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2485    return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);2486  }24872488  async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {2489    return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);2490  }24912492  async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {2493    return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);2494  }24952496  async mintToken(signer: TSigner, pieces=1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {2497    return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});2498  }24992500  async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {2501    return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);2502  }25032504  async burnToken(signer: TSigner, tokenId: number, amount=1n) {2505    return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);2506  }25072508  async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId,  amount=1n) {2509    return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);2510  }25112512  async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {2513    return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);2514  }25152516  async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {2517    return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);2518  }25192520  async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {2521    return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);2522  }2523}252425252526export class UniqueFTCollection extends UniqueBaseCollection {2527  async getBalance(addressObj: ICrossAccountId) {2528    return await this.helper.ft.getBalance(this.collectionId, addressObj);2529  }25302531  async getTotalPieces() {2532    return await this.helper.ft.getTotalPieces(this.collectionId);2533  }25342535  async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2536    return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);2537  }25382539  async getTop10Owners() {2540    return await this.helper.ft.getTop10Owners(this.collectionId);2541  }25422543  async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {2544    return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);2545  }25462547  async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {2548    return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);2549  }25502551  async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {2552    return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);2553  }25542555  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2556    return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);2557  }25582559  async burnTokens(signer: TSigner, amount=1n) {2560    return await this.helper.ft.burnTokens(signer, this.collectionId, amount);2561  }25622563  async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {2564    return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);2565  }25662567  async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {2568    return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);2569  }2570}257125722573export class UniqueBaseToken {2574  collection: UniqueNFTCollection | UniqueRFTCollection;2575  collectionId: number;2576  tokenId: number;25772578  constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {2579    this.collection = collection;2580    this.collectionId = collection.collectionId;2581    this.tokenId = tokenId;2582  }25832584  async getNextSponsored(addressObj: ICrossAccountId) {2585    return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);2586  }25872588  async getProperties(propertyKeys: string[] | null = null) {2589    return await this.collection.getTokenProperties(this.tokenId, propertyKeys);2590  }25912592  async setProperties(signer: TSigner, properties: IProperty[]) {2593    return await this.collection.setTokenProperties(signer, this.tokenId, properties);2594  }25952596  async deleteProperties(signer: TSigner, propertyKeys: string[]) {2597    return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);2598  }25992600  nestingAccount() {2601    return this.collection.helper.util.getTokenAccount(this);2602  }2603}260426052606export class UniqueNFToken extends UniqueBaseToken {2607  collection: UniqueNFTCollection;26082609  constructor(tokenId: number, collection: UniqueNFTCollection) {2610    super(tokenId, collection);2611    this.collection = collection;2612  }26132614  async getData(blockHashAt?: string) {2615    return await this.collection.getToken(this.tokenId, blockHashAt);2616  }26172618  async getOwner(blockHashAt?: string) {2619    return await this.collection.getTokenOwner(this.tokenId, blockHashAt);2620  }26212622  async getTopmostOwner(blockHashAt?: string) {2623    return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);2624  }26252626  async getChildren(blockHashAt?: string) {2627    return await this.collection.getTokenChildren(this.tokenId, blockHashAt);2628  }26292630  async nest(signer: TSigner, toTokenObj: IToken) {2631    return await this.collection.nestToken(signer, this.tokenId, toTokenObj);2632  }26332634  async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {2635    return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);2636  }26372638  async transfer(signer: TSigner, addressObj: ICrossAccountId) {2639    return await this.collection.transferToken(signer, this.tokenId, addressObj);2640  }26412642  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2643    return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);2644  }26452646  async approve(signer: TSigner, toAddressObj: ICrossAccountId) {2647    return await this.collection.approveToken(signer, this.tokenId, toAddressObj);2648  }26492650  async isApproved(toAddressObj: ICrossAccountId) {2651    return await this.collection.isTokenApproved(this.tokenId, toAddressObj);2652  }26532654  async burn(signer: TSigner) {2655    return await this.collection.burnToken(signer, this.tokenId);2656  }26572658  async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {2659    return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);2660  }2661}26622663export class UniqueRFToken extends UniqueBaseToken {2664  collection: UniqueRFTCollection;26652666  constructor(tokenId: number, collection: UniqueRFTCollection) {2667    super(tokenId, collection);2668    this.collection = collection;2669  }26702671  async getData(blockHashAt?: string) {2672    return await this.collection.getToken(this.tokenId, blockHashAt);2673  }26742675  async getTop10Owners() {2676    return await this.collection.getTop10TokenOwners(this.tokenId);2677  }26782679  async getBalance(addressObj: ICrossAccountId) {2680    return await this.collection.getTokenBalance(this.tokenId, addressObj);2681  }26822683  async getTotalPieces() {2684    return await this.collection.getTokenTotalPieces(this.tokenId);2685  }26862687  async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {2688    return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);2689  }26902691  async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {2692    return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);2693  }26942695  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2696    return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);2697  }26982699  async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {2700    return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);2701  }27022703  async repartition(signer: TSigner, amount: bigint) {2704    return await this.collection.repartitionToken(signer, this.tokenId, amount);2705  }27062707  async burn(signer: TSigner, amount=1n) {2708    return await this.collection.burnToken(signer, this.tokenId, amount);2709  }27102711  async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {2712    return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);2713  }2714}