git.delta.rocks / unique-network / refs/commits / 12fbdbdcf4df

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) {24    return new CrossAccountId({Substrate: account.address});25  }2627  static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {28    return new CrossAccountId({Substrate: address.substrate, Ethereum: address.ethereum});29  }3031  static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {32    return encodeAddress(decodeAddress(address), ss58Format);33  }3435  static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {36    return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});37  }38  39  withNormalizedSubstrate(ss58Format = 42): CrossAccountId {40    if (this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);41    return this;42  }43  44  toLowerCase(): CrossAccountId {45    if (this.Substrate) this.Substrate = this.Substrate.toLowerCase();46    if (this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();47    return this;48  }49}5051const nesting = {52  toChecksumAddress(address: string): string {53    if (typeof address === 'undefined') return '';5455    if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);5657    address = address.toLowerCase().replace(/^0x/i,'');58    const addressHash = keccakAsHex(address).replace(/^0x/i,'');59    const checksumAddress = ['0x'];6061    for (let i = 0; i < address.length; i++) {62      // If ith character is 8 to f then make it uppercase63      if (parseInt(addressHash[i], 16) > 7) {64        checksumAddress.push(address[i].toUpperCase());65      } else {66        checksumAddress.push(address[i]);67      }68    }69    return checksumAddress.join('');70  },71  tokenIdToAddress(collectionId: number, tokenId: number) {72    return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8, '0')}${tokenId.toString(16).padStart(8, '0')}`);73  },74};7576class UniqueUtil {77  static transactionStatus = {78    NOT_READY: 'NotReady',79    FAIL: 'Fail',80    SUCCESS: 'Success',81  };8283  static chainLogType = {84    EXTRINSIC: 'extrinsic',85    RPC: 'rpc',86  };8788  static getTokenAccount(token: IToken): CrossAccountId {89    return new CrossAccountId({Ethereum: this.getTokenAddress(token)});90  }9192  static getTokenAddress(token: IToken): string {93    return nesting.tokenIdToAddress(token.collectionId, token.tokenId);94  }9596  static getDefaultLogger(): ILogger {97    return {98      log(msg: any, level = 'INFO') {99        console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));100      },101      level: {102        ERROR: 'ERROR',103        WARNING: 'WARNING',104        INFO: 'INFO',105      },106    };107  }108109  static vec2str(arr: string[] | number[]) {110    return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');111  }112113  static str2vec(string: string) {114    if (typeof string !== 'string') return string;115    return Array.from(string).map(x => x.charCodeAt(0));116  }117118  static fromSeed(seed: string, ss58Format = 42) {119    const keyring = new Keyring({type: 'sr25519', ss58Format});120    return keyring.addFromUri(seed);121  }122123  static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {124    if (creationResult.status !== this.transactionStatus.SUCCESS) {125      throw Error('Unable to create collection!');126    }127128    let collectionId = null;129    creationResult.result.events.forEach(({event: {data, method, section}}) => {130      if ((section === 'common') && (method === 'CollectionCreated')) {131        collectionId = parseInt(data[0].toString(), 10);132      }133    });134135    if (collectionId === null) {136      throw Error('No CollectionCreated event was found!');137    }138139    return collectionId;140  }141142  static extractTokensFromCreationResult(creationResult: ITransactionResult): {143    success: boolean, 144    tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],145  } {146    if (creationResult.status !== this.transactionStatus.SUCCESS) {147      throw Error('Unable to create tokens!');148    }149    let success = false;150    const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];151    creationResult.result.events.forEach(({event: {data, method, section}}) => {152      if (method === 'ExtrinsicSuccess') {153        success = true;154      } else if ((section === 'common') && (method === 'ItemCreated')) {155        tokens.push({156          collectionId: parseInt(data[0].toString(), 10),157          tokenId: parseInt(data[1].toString(), 10),158          owner: data[2].toHuman(),159          amount: data[3].toBigInt(),160        });161      }162    });163    return {success, tokens};164  }165166  static extractTokensFromBurnResult(burnResult: ITransactionResult): {167    success: boolean, 168    tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],169  } {170    if (burnResult.status !== this.transactionStatus.SUCCESS) {171      throw Error('Unable to burn tokens!');172    }173    let success = false;174    const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];175    burnResult.result.events.forEach(({event: {data, method, section}}) => {176      if (method === 'ExtrinsicSuccess') {177        success = true;178      } else if ((section === 'common') && (method === 'ItemDestroyed')) {179        tokens.push({180          collectionId: parseInt(data[0].toString(), 10),181          tokenId: parseInt(data[1].toString(), 10),182          owner: data[2].toHuman(),183          amount: data[3].toBigInt(),184        });185      }186    });187    return {success, tokens};188  }189190  static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {191    let eventId = null;192    events.forEach(({event: {data, method, section}}) => {193      if ((section === expectedSection) && (method === expectedMethod)) {194        eventId = parseInt(data[0].toString(), 10);195      }196    });197198    if (eventId === null) {199      throw Error(`No ${expectedMethod} event was found!`);200    }201    return eventId === collectionId;202  }203204  static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {205    const normalizeAddress = (address: string | ICrossAccountId) => {206      if(typeof address === 'string') return address;207      const obj = {} as any;208      Object.keys(address).forEach(k => {209        obj[k.toLocaleLowerCase()] = address[k as 'Substrate' | 'Ethereum'];210      });211      if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);212      if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();213      return address;214    };215    let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;216    events.forEach(({event: {data, method, section}}) => {217      if ((section === 'common') && (method === 'Transfer')) {218        const hData = (data as any).toJSON();219        transfer = {220          collectionId: hData[0],221          tokenId: hData[1],222          from: normalizeAddress(hData[2]),223          to: normalizeAddress(hData[3]),224          amount: BigInt(hData[4]),225        };226      }227    });228    let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;229    isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);230    isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);231    isSuccess = isSuccess && amount === transfer.amount;232    return isSuccess;233  }234}235236class UniqueEventHelper {237  private static extractIndex(index: any): [number, number] | string {238    if(index.toRawType() === '[u8;2]') return [index[0], index[1]];239    return index.toJSON();240  }241242  private static extractSub(data: any, subTypes: any): {[key: string]: any} {243    let obj: any = {};244    let index = 0;245246    if (data.entries) {247      for(const [key, value] of data.entries()) {248        obj[key] = this.extractData(value, subTypes[index]);249        index++;250      }251    } else obj = data.toJSON();252253    return obj;254  }255  256  private static extractData(data: any, type: any): any {257    if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();258    if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();259    if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);260    return data.toHuman();261  }262263  public static extractEvents(records: ITransactionResult): IEvent[] {264    const parsedEvents: IEvent[] = [];265266    records.result.events.forEach((record) => {267      const {event, phase} = record;268      const types = (event as any).typeDef;269270      const eventData: IEvent = {271        section: event.section.toString(),272        method: event.method.toString(),273        index: this.extractIndex(event.index),274        data: [],275        phase: phase.toJSON(),276      };277278      event.data.forEach((val: any, index: number) => {279        eventData.data.push(this.extractData(val, types[index]));280      });281282      parsedEvents.push(eventData);283    });284285    return parsedEvents;286  }287}288289class ChainHelperBase {290  transactionStatus = UniqueUtil.transactionStatus;291  chainLogType = UniqueUtil.chainLogType;292  util: typeof UniqueUtil;293  eventHelper: typeof UniqueEventHelper;294  logger: ILogger;295  api: ApiPromise | null;296  forcedNetwork: TUniqueNetworks | null;297  network: TUniqueNetworks | null;298  chainLog: IUniqueHelperLog[];299300  constructor(logger?: ILogger) {301    this.util = UniqueUtil;302    this.eventHelper = UniqueEventHelper;303    if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();304    this.logger = logger;305    this.api = null;306    this.forcedNetwork = null;307    this.network = null;308    this.chainLog = [];309  }310311  clearChainLog(): void {312    this.chainLog = [];313  }314315  forceNetwork(value: TUniqueNetworks): void {316    this.forcedNetwork = value;317  }318319  async connect(wsEndpoint: string, listeners?: IApiListeners) {320    if (this.api !== null) throw Error('Already connected');321    const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);322    this.api = api;323    this.network = network;324  }325326  async disconnect() {327    if (this.api === null) return;328    await this.api.disconnect();329    this.api = null;330    this.network = null;331  }332333  static async detectNetwork(api: ApiPromise): Promise<TUniqueNetworks> {334    const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;335    if(['quartz', 'unique'].indexOf(spec.specName) > -1) return spec.specName;336    return 'opal';337  }338339  static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TUniqueNetworks> {340    const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});341    await api.isReady;342343    const network = await this.detectNetwork(api);344345    await api.disconnect();346347    return network;348  }349350  static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TUniqueNetworks | null): Promise<{351    api: ApiPromise;352    network: TUniqueNetworks;353  }> {354    if(typeof network === 'undefined' || network === null) network = 'opal';355    const supportedRPC = {356      opal: {357        unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,358      },359      quartz: {360        unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,361      },362      unique: {363        unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,364      },365    };366    if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);367    const rpc = supportedRPC[network];368369    // TODO: investigate how to replace rpc in runtime370    // api._rpcCore.addUserInterfaces(rpc);371372    const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});373374    await api.isReadyOrError;375376    if (typeof listeners === 'undefined') listeners = {};377    for (const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {378      if (!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;379      api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);380    }381382    return {api, network};383  }384385  getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {386    const {events, status} = data;387    if (status.isReady) {388      return this.transactionStatus.NOT_READY;389    }390    if (status.isBroadcast) {391      return this.transactionStatus.NOT_READY;392    }393    if (status.isInBlock || status.isFinalized) {394      const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');395      if (errors.length > 0) {396        return this.transactionStatus.FAIL;397      }398      if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {399        return this.transactionStatus.SUCCESS;400      }401    }402403    return this.transactionStatus.FAIL;404  }405406  signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {407    const sign = (callback: any) => {408      if(options !== null) return transaction.signAndSend(sender, options, callback);409      return transaction.signAndSend(sender, callback);410    };411    // eslint-disable-next-line no-async-promise-executor412    return new Promise(async (resolve, reject) => {413      try {414        const unsub = await sign((result: any) => {415          const status = this.getTransactionStatus(result);416417          if (status === this.transactionStatus.SUCCESS) {418            this.logger.log(`${label} successful`);419            unsub();420            resolve({result, status});421          } else if (status === this.transactionStatus.FAIL) {422            let moduleError = null;423424            if (result.hasOwnProperty('dispatchError')) {425              const dispatchError = result['dispatchError'];426427              if (dispatchError) {428                if (dispatchError.isModule) {429                  const modErr = dispatchError.asModule;430                  const errorMeta = dispatchError.registry.findMetaError(modErr);431432                  moduleError = `${errorMeta.section}.${errorMeta.name}`;433                } else {434                  moduleError = dispatchError.toHuman();435                }436              } else {437                this.logger.log(result, this.logger.level.ERROR);438              }439            }440441            this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);442            unsub();443            reject({status, moduleError, result});444          }445        });446      } catch (e) {447        this.logger.log(e, this.logger.level.ERROR);448        reject(e);449      }450    });451  }452453  constructApiCall(apiCall: string, params: any[]) {454    if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);455    let call = this.api as any;456    for(const part of apiCall.slice(4).split('.')) {457      call = call[part];458    }459    return call(...params);460  }461462  async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true, options: Partial<SignerOptions>|null = null/*, failureMessage='expected success'*/) {463    if(this.api === null) throw Error('API not initialized');464    if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);465466    const startTime = (new Date()).getTime();467    let result: ITransactionResult;468    let events: IEvent[] = [];469    try {470      result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;471      events = this.eventHelper.extractEvents(result);472    }473    catch(e) {474      if(!(e as object).hasOwnProperty('status')) throw e;475      result = e as ITransactionResult;476    }477478    const endTime = (new Date()).getTime();479480    const log = {481      executedAt: endTime,482      executionTime: endTime - startTime,483      type: this.chainLogType.EXTRINSIC,484      status: result.status,485      call: extrinsic,486      signer: this.getSignerAddress(sender),487      params,488    } as IUniqueHelperLog;489490    if(result.status !== this.transactionStatus.SUCCESS && result.moduleError) log.moduleError = result.moduleError;491    if(events.length > 0) log.events = events;492493    this.chainLog.push(log);494495    if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) throw Error(`${result.moduleError}`);496    return result;497  }498499  async callRpc(rpc: string, params?: any[]) {500    if(typeof params === 'undefined') params = [];501    if(this.api === null) throw Error('API not initialized');502    if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);503504    const startTime = (new Date()).getTime();505    let result;506    let error = null;507    const log = {508      type: this.chainLogType.RPC,509      call: rpc,510      params,511    } as IUniqueHelperLog;512513    try {514      result = await this.constructApiCall(rpc, params);515    }516    catch(e) {517      error = e;518    }519520    const endTime = (new Date()).getTime();521522    log.executedAt = endTime;523    log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';524    log.executionTime = endTime - startTime;525526    this.chainLog.push(log);527528    if(error !== null) throw error;529530    return result;531  }532533  getSignerAddress(signer: IKeyringPair | string): string {534    if(typeof signer === 'string') return signer;535    return signer.address;536  }537538  fetchAllPalletNames(): string[] {539    if(this.api === null) throw Error('API not initialized');540    return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());541  }542543  fetchMissingPalletNames(requiredPallets: string[]): string[] {544    const palletNames = this.fetchAllPalletNames();545    return requiredPallets.filter(p => !palletNames.includes(p));546  }547}548549550class HelperGroup {551  helper: UniqueHelper;552553  constructor(uniqueHelper: UniqueHelper) {554    this.helper = uniqueHelper;555  }556}557558559class CollectionGroup extends HelperGroup {560  /**561 * Get number of blocks when sponsored transaction is available.562 *563 * @param collectionId ID of collection564 * @param tokenId ID of token565 * @param addressObj address for which the sponsorship is checked566 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});567 * @returns number of blocks or null if sponsorship hasn't been set568 */569  async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {570    return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();571  }572573  /**574   * Get the number of created collections.575   *576   * @returns number of created collections577   */578  async getTotalCount(): Promise<number> {579    return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();580  }581582  /**583   * Get information about the collection with additional data,584   * including the number of tokens it contains, its administrators,585   * the normalized address of the collection's owner, and decoded name and description.586   *587   * @param collectionId ID of collection588   * @example await getData(2)589   * @returns collection information object590   */591  async getData(collectionId: number): Promise<{592    id: number;593    name: string;594    description: string;595    tokensCount: number;596    admins: CrossAccountId[];597    normalizedOwner: TSubstrateAccount;598    raw: any599  } | null> {600    const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);601    const humanCollection = collection.toHuman(), collectionData = {602      id: collectionId, name: null, description: null, tokensCount: 0, admins: [],603      raw: humanCollection,604    } as any, jsonCollection = collection.toJSON();605    if (humanCollection === null) return null;606    collectionData.raw.limits = jsonCollection.limits;607    collectionData.raw.permissions = jsonCollection.permissions;608    collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);609    for (const key of ['name', 'description']) {610      collectionData[key] = this.helper.util.vec2str(humanCollection[key]);611    }612613    collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))614      ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)615      : 0;616    collectionData.admins = await this.getAdmins(collectionId);617618    return collectionData;619  }620621  /**622   * Get the addresses of the collection's administrators, optionally normalized.623   *624   * @param collectionId ID of collection625   * @param normalize whether to normalize the addresses to the default ss58 format626   * @example await getAdmins(1)627   * @returns array of administrators628   */629  async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {630    const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();631632    return normalize633      ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())634      : admins;635  }636637  /**638   * Get the addresses added to the collection allow-list, optionally normalized.639   * @param collectionId ID of collection640   * @param normalize whether to normalize the addresses to the default ss58 format641   * @example await getAllowList(1)642   * @returns array of allow-listed addresses643   */644  async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {645    const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();646    return normalize647      ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())648      : allowListed;649  }650651  /**652   * Get the effective limits of the collection instead of null for default values653   *654   * @param collectionId ID of collection655   * @example await getEffectiveLimits(2)656   * @returns object of collection limits657   */658  async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {659    return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();660  }661662  /**663   * Burns the collection if the signer has sufficient permissions and collection is empty.664   *665   * @param signer keyring of signer666   * @param collectionId ID of collection667   * @example await helper.collection.burn(aliceKeyring, 3);668   * @returns ```true``` if extrinsic success, otherwise ```false```669   */670  async burn(signer: TSigner, collectionId: number): Promise<boolean> {671    const result = await this.helper.executeExtrinsic(672      signer,673      'api.tx.unique.destroyCollection', [collectionId],674      true,675    );676677    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');678  }679680  /**681   * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.682   *683   * @param signer keyring of signer684   * @param collectionId ID of collection685   * @param sponsorAddress Sponsor substrate address686   * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")687   * @returns ```true``` if extrinsic success, otherwise ```false```688   */689  async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {690    const result = await this.helper.executeExtrinsic(691      signer,692      'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],693      true,694    );695696    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorSet');697  }698699  /**700   * Confirms consent to sponsor the collection on behalf of the signer.701   *702   * @param signer keyring of signer703   * @param collectionId ID of collection704   * @example confirmSponsorship(aliceKeyring, 10)705   * @returns ```true``` if extrinsic success, otherwise ```false```706   */707  async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {708    const result = await this.helper.executeExtrinsic(709      signer,710      'api.tx.unique.confirmSponsorship', [collectionId],711      true,712    );713714    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'SponsorshipConfirmed');715  }716717  /**718   * Removes the sponsor of a collection, regardless if it consented or not.719   *720   * @param signer keyring of signer721   * @param collectionId ID of collection722   * @example removeSponsor(aliceKeyring, 10)723   * @returns ```true``` if extrinsic success, otherwise ```false```724   */725  async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {726    const result = await this.helper.executeExtrinsic(727      signer,728      'api.tx.unique.removeCollectionSponsor', [collectionId],729      true,730    );731732    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionSponsorRemoved');733  }734735  /**736   * Sets the limits of the collection. At least one limit must be specified for a correct call.737   *738   * @param signer keyring of signer739   * @param collectionId ID of collection740   * @param limits collection limits object741   * @example742   * await setLimits(743   *   aliceKeyring,744   *   10,745   *   {746   *     sponsorTransferTimeout: 0,747   *     ownerCanDestroy: false748   *   }749   * )750   * @returns ```true``` if extrinsic success, otherwise ```false```751   */752  async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {753    const result = await this.helper.executeExtrinsic(754      signer,755      'api.tx.unique.setCollectionLimits', [collectionId, limits],756      true,757    );758759    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionLimitSet');760  }761762  /**763   * Changes the owner of the collection to the new Substrate address.764   *765   * @param signer keyring of signer766   * @param collectionId ID of collection767   * @param ownerAddress substrate address of new owner768   * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")769   * @returns ```true``` if extrinsic success, otherwise ```false```770   */771  async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {772    const result = await this.helper.executeExtrinsic(773      signer,774      'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],775      true,776    );777778    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionOwnedChanged');779  }780781  /**782   * Adds a collection administrator.783   *784   * @param signer keyring of signer785   * @param collectionId ID of collection786   * @param adminAddressObj Administrator address (substrate or ethereum)787   * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})788   * @returns ```true``` if extrinsic success, otherwise ```false```789   */790  async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {791    const result = await this.helper.executeExtrinsic(792      signer,793      'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],794      true,795    );796797    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminAdded');798  }799800  /**801   * Removes a collection administrator.802   *803   * @param signer keyring of signer804   * @param collectionId ID of collection805   * @param adminAddressObj Administrator address (substrate or ethereum)806   * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})807   * @returns ```true``` if extrinsic success, otherwise ```false```808   */809  async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {810    const result = await this.helper.executeExtrinsic(811      signer,812      'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],813      true,814    );815816    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionAdminRemoved');817  }818819  /**820   * Check if user is in allow list.821   * 822   * @param collectionId ID of collection823   * @param user Account to check824   * @example await getAdmins(1)825   * @returns is user in allow list826   */827  async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {828    return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();829  }830831  /**832   * Adds an address to allow list833   * @param signer keyring of signer834   * @param collectionId ID of collection835   * @param addressObj address to add to the allow list836   * @returns ```true``` if extrinsic success, otherwise ```false```837   */838  async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {839    const result = await this.helper.executeExtrinsic(840      signer,841      'api.tx.unique.addToAllowList', [collectionId, addressObj],842      true,843    );844845    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressAdded');846  }847848  /**849   * Removes an address from allow list850   *851   * @param signer keyring of signer852   * @param collectionId ID of collection853   * @param addressObj address to remove from the allow list854   * @returns ```true``` if extrinsic success, otherwise ```false```855   */856  async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {857    const result = await this.helper.executeExtrinsic(858      signer,859      'api.tx.unique.removeFromAllowList', [collectionId, addressObj],860      true,861    );862863    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'AllowListAddressRemoved');864  }865866  /**867   * Sets onchain permissions for selected collection.868   *869   * @param signer keyring of signer870   * @param collectionId ID of collection871   * @param permissions collection permissions object872   * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});873   * @returns ```true``` if extrinsic success, otherwise ```false```874   */875  async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {876    const result = await this.helper.executeExtrinsic(877      signer,878      'api.tx.unique.setCollectionPermissions', [collectionId, permissions],879      true,880    );881882    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'unique', 'CollectionPermissionSet');883  }884885  /**886   * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.887   *888   * @param signer keyring of signer889   * @param collectionId ID of collection890   * @param permissions nesting permissions object891   * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});892   * @returns ```true``` if extrinsic success, otherwise ```false```893   */894  async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {895    return await this.setPermissions(signer, collectionId, {nesting: permissions});896  }897898  /**899   * Disables nesting for selected collection.900   *901   * @param signer keyring of signer902   * @param collectionId ID of collection903   * @example disableNesting(aliceKeyring, 10);904   * @returns ```true``` if extrinsic success, otherwise ```false```905   */906  async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {907    return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});908  }909910  /**911   * Sets onchain properties to the collection.912   *913   * @param signer keyring of signer914   * @param collectionId ID of collection915   * @param properties array of property objects916   * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);917   * @returns ```true``` if extrinsic success, otherwise ```false```918   */919  async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {920    const result = await this.helper.executeExtrinsic(921      signer,922      'api.tx.unique.setCollectionProperties', [collectionId, properties],923      true,924    );925926    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');927  }928929  /**930   * Get collection properties.931   * 932   * @param collectionId ID of collection933   * @param propertyKeys optionally filter the returned properties to only these keys934   * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);935   * @returns array of key-value pairs936   */937  async getProperties(collectionId: number, propertyKeys: string[] | null = null): Promise<IProperty[]> {938    return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();939  }940941  /**942   * Deletes onchain properties from the collection.943   *944   * @param signer keyring of signer945   * @param collectionId ID of collection946   * @param propertyKeys array of property keys to delete947   * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);948   * @returns ```true``` if extrinsic success, otherwise ```false```949   */950  async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {951    const result = await this.helper.executeExtrinsic(952      signer,953      'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],954      true,955    );956957    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');958  }959960  /**961   * Changes the owner of the token.962   *963   * @param signer keyring of signer964   * @param collectionId ID of collection965   * @param tokenId ID of token966   * @param addressObj address of a new owner967   * @param amount amount of tokens to be transfered. For NFT must be set to 1n968   * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})969   * @returns true if the token success, otherwise false970   */971  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {972    const result = await this.helper.executeExtrinsic(973      signer,974      'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],975      true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,976    );977978    return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);979  }980981  /**982   *983   * Change ownership of a token(s) on behalf of the owner.984   *985   * @param signer keyring of signer986   * @param collectionId ID of collection987   * @param tokenId ID of token988   * @param fromAddressObj address on behalf of which the token will be sent989   * @param toAddressObj new token owner990   * @param amount amount of tokens to be transfered. For NFT must be set to 1n991   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})992   * @returns true if the token success, otherwise false993   */994  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {995    const result = await this.helper.executeExtrinsic(996      signer,997      'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],998      true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,999    );1000    return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1001  }10021003  /**1004   *1005   * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1006   *1007   * @param signer keyring of signer1008   * @param collectionId ID of collection1009   * @param tokenId ID of token1010   * @param amount amount of tokens to be burned. For NFT must be set to 1n1011   * @example burnToken(aliceKeyring, 10, 5);1012   * @returns ```true``` if the extrinsic is successful, otherwise ```false```1013   */1014  async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1015    const burnResult = await this.helper.executeExtrinsic(1016      signer,1017      'api.tx.unique.burnItem', [collectionId, tokenId, amount],1018      true, // `Unable to burn token for ${label}`,1019    );1020    const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1021    if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1022    return burnedTokens.success;1023  }10241025  /**1026   * Destroys a concrete instance of NFT on behalf of the owner1027   *1028   * @param signer keyring of signer1029   * @param collectionId ID of collection1030   * @param tokenId ID of token1031   * @param fromAddressObj address on behalf of which the token will be burnt1032   * @param amount amount of tokens to be burned. For NFT must be set to 1n1033   * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1034   * @returns ```true``` if extrinsic success, otherwise ```false```1035   */1036  async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1037    const burnResult = await this.helper.executeExtrinsic(1038      signer,1039      'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1040      true, // `Unable to burn token from for ${label}`,1041    );1042    const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1043    return burnedTokens.success && burnedTokens.tokens.length > 0;1044  }10451046  /**1047   * Set, change, or remove approved address to transfer the ownership of the NFT.1048   *1049   * @param signer keyring of signer1050   * @param collectionId ID of collection1051   * @param tokenId ID of token1052   * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1053   * @param amount amount of token to be approved. For NFT must be set to 1n1054   * @returns ```true``` if extrinsic success, otherwise ```false```1055   */1056  async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1057    const approveResult = await this.helper.executeExtrinsic(1058      signer,1059      'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1060      true, // `Unable to approve token for ${label}`,1061    );10621063    return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1064  }10651066  /**1067   * Get the amount of token pieces approved to transfer or burn. Normally 0.1068   *1069   * @param collectionId ID of collection1070   * @param tokenId ID of token1071   * @param toAccountObj address which is approved to use token pieces1072   * @param fromAccountObj address which may have allowed the use of its owned tokens1073   * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1074   * @returns number of approved to transfer pieces1075   */1076  async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1077    return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1078  }10791080  /**1081   * Get the last created token ID in a collection1082   *1083   * @param collectionId ID of collection1084   * @example getLastTokenId(10);1085   * @returns id of the last created token1086   */1087  async getLastTokenId(collectionId: number): Promise<number> {1088    return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1089  }10901091  /**1092   * Check if token exists1093   *1094   * @param collectionId ID of collection1095   * @param tokenId ID of token1096   * @example isTokenExists(10, 20);1097   * @returns true if the token exists, otherwise false1098   */1099  async isTokenExists(collectionId: number, tokenId: number): Promise<boolean> {1100    return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1101  }1102}11031104class NFTnRFT extends CollectionGroup {1105  /**1106   * Get tokens owned by account1107   *1108   * @param collectionId ID of collection1109   * @param addressObj tokens owner1110   * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1111   * @returns array of token ids owned by account1112   */1113  async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1114    return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1115  }11161117  /**1118   * Get token data1119   *1120   * @param collectionId ID of collection1121   * @param tokenId ID of token1122   * @param propertyKeys optionally filter the token properties to only these keys1123   * @param blockHashAt optionally query the data at some block with this hash1124   * @example getToken(10, 5);1125   * @returns human readable token data1126   */1127  async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1128    properties: IProperty[];1129    owner: CrossAccountId;1130    normalizedOwner: CrossAccountId;1131  }| null> {1132    let tokenData;1133    if(typeof blockHashAt === 'undefined') {1134      tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1135    }1136    else {1137      if(propertyKeys.length == 0) {1138        const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1139        if(!collection) return null;1140        propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1141      }1142      tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1143    }1144    tokenData = tokenData.toHuman();1145    if (tokenData === null || tokenData.owner === null) return null;1146    const owner = {} as any;1147    for (const key of Object.keys(tokenData.owner)) {1148      owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate' 1149        ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key]) 1150        : tokenData.owner[key];1151    }1152    tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1153    return tokenData;1154  }11551156  /**1157   * Set permissions to change token properties1158   *1159   * @param signer keyring of signer1160   * @param collectionId ID of collection1161   * @param permissions permissions to change a property by the collection admin or token owner1162   * @example setTokenPropertyPermissions(1163   *   aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1164   * )1165   * @returns true if extrinsic success otherwise false1166   */1167  async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1168    const result = await this.helper.executeExtrinsic(1169      signer,1170      'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1171      true,1172    );11731174    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1175  }11761177  /**1178   * Get token property permissions.1179   * 1180   * @param collectionId ID of collection1181   * @param propertyKeys optionally filter the returned property permissions to only these keys1182   * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1183   * @returns array of key-permission pairs1184   */1185  async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1186    return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1187  }11881189  /**1190   * Set token properties1191   *1192   * @param signer keyring of signer1193   * @param collectionId ID of collection1194   * @param tokenId ID of token1195   * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1196   * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1197   * @returns ```true``` if extrinsic success, otherwise ```false```1198   */1199  async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1200    const result = await this.helper.executeExtrinsic(1201      signer,1202      'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1203      true,1204    );12051206    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1207  }12081209  /**1210   * Get properties, metadata assigned to a token.1211   * 1212   * @param collectionId ID of collection1213   * @param tokenId ID of token1214   * @param propertyKeys optionally filter the returned properties to only these keys1215   * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1216   * @returns array of key-value pairs1217   */1218  async getTokenProperties(collectionId: number, tokenId: number, propertyKeys: string[] | null = null): Promise<IProperty[]> {1219    return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1220  }12211222  /**1223   * Delete the provided properties of a token1224   * @param signer keyring of signer1225   * @param collectionId ID of collection1226   * @param tokenId ID of token1227   * @param propertyKeys property keys to be deleted1228   * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1229   * @returns ```true``` if extrinsic success, otherwise ```false```1230   */1231  async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1232    const result = await this.helper.executeExtrinsic(1233      signer,1234      'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1235      true,1236    );12371238    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1239  }12401241  /**1242   * Mint new collection1243   *1244   * @param signer keyring of signer1245   * @param collectionOptions basic collection options and properties1246   * @param mode NFT or RFT type of a collection1247   * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1248   * @returns object of the created collection1249   */1250  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1251    collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1252    collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1253    for (const key of ['name', 'description', 'tokenPrefix']) {1254      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);1255    }1256    const creationResult = await this.helper.executeExtrinsic(1257      signer,1258      'api.tx.unique.createCollectionEx', [collectionOptions],1259      true, // errorLabel,1260    );1261    return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1262  }12631264  getCollectionObject(_collectionId: number): any {1265    return null;1266  }12671268  getTokenObject(_collectionId: number, _tokenId: number): any {1269    return null;1270  }1271}127212731274class NFTGroup extends NFTnRFT {1275  /**1276   * Get collection object1277   * @param collectionId ID of collection1278   * @example getCollectionObject(2);1279   * @returns instance of UniqueNFTCollection1280   */1281  getCollectionObject(collectionId: number): UniqueNFTCollection {1282    return new UniqueNFTCollection(collectionId, this.helper);1283  }12841285  /**1286   * Get token object1287   * @param collectionId ID of collection1288   * @param tokenId ID of token1289   * @example getTokenObject(10, 5);1290   * @returns instance of UniqueNFTToken1291   */1292  getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1293    return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1294  }12951296  /**1297   * Get token's owner1298   * @param collectionId ID of collection1299   * @param tokenId ID of token1300   * @param blockHashAt optionally query the data at the block with this hash1301   * @example getTokenOwner(10, 5);1302   * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1303   */1304  async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1305    let owner;1306    if (typeof blockHashAt === 'undefined') {1307      owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1308    } else {1309      owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1310    }1311    return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1312  }13131314  /**1315   * Is token approved to transfer1316   * @param collectionId ID of collection1317   * @param tokenId ID of token1318   * @param toAccountObj address to be approved1319   * @returns ```true``` if extrinsic success, otherwise ```false```1320   */1321  async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1322    return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1323  }13241325  /**1326   * Changes the owner of the token.1327   *1328   * @param signer keyring of signer1329   * @param collectionId ID of collection1330   * @param tokenId ID of token1331   * @param addressObj address of a new owner1332   * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1333   * @returns ```true``` if extrinsic success, otherwise ```false```1334   */1335  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1336    return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1337  }13381339  /**1340   *1341   * Change ownership of a NFT on behalf of the owner.1342   *1343   * @param signer keyring of signer1344   * @param collectionId ID of collection1345   * @param tokenId ID of token1346   * @param fromAddressObj address on behalf of which the token will be sent1347   * @param toAddressObj new token owner1348   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1349   * @returns ```true``` if extrinsic success, otherwise ```false```1350   */1351  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1352    return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1353  }13541355  /**1356   * Recursively find the address that owns the token1357   * @param collectionId ID of collection1358   * @param tokenId ID of token1359   * @param blockHashAt1360   * @example getTokenTopmostOwner(10, 5);1361   * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1362   */1363  async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1364    let owner;1365    if (typeof blockHashAt === 'undefined') {1366      owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1367    } else {1368      owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1369    }13701371    if (owner === null) return null;13721373    return owner.toHuman();1374  }13751376  /**1377   * Get tokens nested in the provided token1378   * @param collectionId ID of collection1379   * @param tokenId ID of token1380   * @param blockHashAt optionally query the data at the block with this hash1381   * @example getTokenChildren(10, 5);1382   * @returns tokens whose depth of nesting is <= 51383   */1384  async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1385    let children;1386    if(typeof blockHashAt === 'undefined') {1387      children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1388    } else {1389      children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1390    }13911392    return children.toJSON().map((x: any) => {1393      return {collectionId: x.collection, tokenId: x.token};1394    });1395  }13961397  /**1398   * Nest one token into another1399   * @param signer keyring of signer1400   * @param tokenObj token to be nested1401   * @param rootTokenObj token to be parent1402   * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});1403   * @returns ```true``` if extrinsic success, otherwise ```false```1404   */1405  async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1406    const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1407    const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1408    if(!result) {1409      throw Error('Unable to nest token!');1410    }1411    return result;1412  }14131414  /**1415   * Remove token from nested state1416   * @param signer keyring of signer1417   * @param tokenObj token to unnest1418   * @param rootTokenObj parent of a token1419   * @param toAddressObj address of a new token owner1420   * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});1421   * @returns ```true``` if extrinsic success, otherwise ```false```1422   */1423  async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1424    const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1425    const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1426    if(!result) {1427      throw Error('Unable to unnest token!');1428    }1429    return result;1430  }14311432  /**1433   * Mint new collection1434   * @param signer keyring of signer1435   * @param collectionOptions Collection options1436   * @example1437   * mintCollection(aliceKeyring, {1438   *   name: 'New',1439   *   description: 'New collection',1440   *   tokenPrefix: 'NEW',1441   * })1442   * @returns object of the created collection1443   */1444  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1445    return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1446  }14471448  /**1449   * Mint new token1450   * @param signer keyring of signer1451   * @param data token data1452   * @returns created token object1453   */1454  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1455    const creationResult = await this.helper.executeExtrinsic(1456      signer,1457      'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1458        nft: {1459          properties: data.properties,1460        },1461      }],1462      true,1463    );1464    const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1465    if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1466    if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1467    return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1468  }14691470  /**1471   * Mint multiple NFT tokens1472   * @param signer keyring of signer1473   * @param collectionId ID of collection1474   * @param tokens array of tokens with owner and properties1475   * @example1476   * mintMultipleTokens(aliceKeyring, 10, [{1477   *     owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1478   *     properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1479   *   },{1480   *     owner: {Ethereum: "0x9F0583DbB855d..."},1481   *     properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1482   * }]);1483   * @returns ```true``` if extrinsic success, otherwise ```false```1484   */1485  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1486    const creationResult = await this.helper.executeExtrinsic(1487      signer,1488      'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1489      true,1490    );1491    const collection = this.getCollectionObject(collectionId);1492    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1493  }14941495  /**1496   * Mint multiple NFT tokens with one owner1497   * @param signer keyring of signer1498   * @param collectionId ID of collection1499   * @param owner tokens owner1500   * @param tokens array of tokens with owner and properties1501   * @example1502   * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1503   *   properties: [{1504   *   key: "gender",1505   *   value: "female",1506   *  },{1507   *   key: "age",1508   *   value: "33",1509   *  }],1510   * }]);1511   * @returns array of newly created tokens1512   */1513  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {properties?: IProperty[]}[]): Promise<UniqueNFToken[]> {1514    const rawTokens = [];1515    for (const token of tokens) {1516      const raw = {NFT: {properties: token.properties}};1517      rawTokens.push(raw);1518    }1519    const creationResult = await this.helper.executeExtrinsic(1520      signer,1521      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1522      true,1523    );1524    const collection = this.getCollectionObject(collectionId);1525    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1526  }15271528  /**1529   * Set, change, or remove approved address to transfer the ownership of the NFT.1530   *1531   * @param signer keyring of signer1532   * @param collectionId ID of collection1533   * @param tokenId ID of token1534   * @param toAddressObj address to approve1535   * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1536   * @returns ```true``` if extrinsic success, otherwise ```false```1537   */1538  async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId) {1539    return super.approveToken(signer, collectionId, tokenId, toAddressObj, 1n);1540  }1541}154215431544class RFTGroup extends NFTnRFT {1545  /**1546   * Get collection object1547   * @param collectionId ID of collection1548   * @example getCollectionObject(2);1549   * @returns instance of UniqueRFTCollection1550   */1551  getCollectionObject(collectionId: number): UniqueRFTCollection {1552    return new UniqueRFTCollection(collectionId, this.helper);1553  }15541555  /**1556   * Get token object1557   * @param collectionId ID of collection1558   * @param tokenId ID of token1559   * @example getTokenObject(10, 5);1560   * @returns instance of UniqueNFTToken1561   */1562  getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1563    return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1564  }15651566  /**1567   * Get top 10 token owners with the largest number of pieces1568   * @param collectionId ID of collection1569   * @param tokenId ID of token1570   * @example getTokenTop10Owners(10, 5);1571   * @returns array of top 10 owners1572   */1573  async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1574    return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1575  }15761577  /**1578   * Get number of pieces owned by address1579   * @param collectionId ID of collection1580   * @param tokenId ID of token1581   * @param addressObj address token owner1582   * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1583   * @returns number of pieces ownerd by address1584   */1585  async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1586    return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1587  }15881589  /**1590   * Transfer pieces of token to another address1591   * @param signer keyring of signer1592   * @param collectionId ID of collection1593   * @param tokenId ID of token1594   * @param addressObj address of a new owner1595   * @param amount number of pieces to be transfered1596   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1597   * @returns ```true``` if extrinsic success, otherwise ```false```1598   */1599  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount=1n): Promise<boolean> {1600    return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1601  }16021603  /**1604   * Change ownership of some pieces of RFT on behalf of the owner.1605   * @param signer keyring of signer1606   * @param collectionId ID of collection1607   * @param tokenId ID of token1608   * @param fromAddressObj address on behalf of which the token will be sent1609   * @param toAddressObj new token owner1610   * @param amount number of pieces to be transfered1611   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1612   * @returns ```true``` if extrinsic success, otherwise ```false```1613   */1614  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1615    return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1616  }16171618  /**1619   * Mint new collection1620   * @param signer keyring of signer1621   * @param collectionOptions Collection options1622   * @example1623   * mintCollection(aliceKeyring, {1624   *   name: 'New',1625   *   description: 'New collection',1626   *   tokenPrefix: 'NEW',1627   * })1628   * @returns object of the created collection1629   */1630  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1631    return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1632  }16331634  /**1635   * Mint new token1636   * @param signer keyring of signer1637   * @param data token data1638   * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1639   * @returns created token object1640   */1641  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1642    const creationResult = await this.helper.executeExtrinsic(1643      signer,1644      'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1645        refungible: {1646          pieces: data.pieces,1647          properties: data.properties,1648        },1649      }],1650      true,1651    );1652    const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1653    if (createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1654    if (createdTokens.tokens.length < 1) throw Error('No tokens minted');1655    return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1656  }16571658  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: {owner: ICrossAccountId, pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1659    throw Error('Not implemented');1660    const creationResult = await this.helper.executeExtrinsic(1661      signer,1662      'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],1663      true, // `Unable to mint RFT tokens for ${label}`,1664    );1665    const collection = this.getCollectionObject(collectionId);1666    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1667  }16681669  /**1670   * Mint multiple RFT tokens with one owner1671   * @param signer keyring of signer1672   * @param collectionId ID of collection1673   * @param owner tokens owner1674   * @param tokens array of tokens with properties and pieces1675   * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);1676   * @returns array of newly created RFT tokens1677   */1678  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: {pieces: bigint, properties?: IProperty[]}[]): Promise<UniqueRFToken[]> {1679    const rawTokens = [];1680    for (const token of tokens) {1681      const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};1682      rawTokens.push(raw);1683    }1684    const creationResult = await this.helper.executeExtrinsic(1685      signer,1686      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1687      true,1688    );1689    const collection = this.getCollectionObject(collectionId);1690    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1691  }16921693  /**1694   * Destroys a concrete instance of RFT.1695   * @param signer keyring of signer1696   * @param collectionId ID of collection1697   * @param tokenId ID of token1698   * @param amount number of pieces to be burnt1699   * @example burnToken(aliceKeyring, 10, 5);1700   * @returns ```true``` if the extrinsic is successful, otherwise ```false```1701   */1702  async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {1703    return await super.burnToken(signer, collectionId, tokenId, amount);1704  }17051706  /**1707   * Destroys a concrete instance of RFT on behalf of the owner.1708   * @param signer keyring of signer1709   * @param collectionId ID of collection1710   * @param tokenId ID of token1711   * @param fromAddressObj address on behalf of which the token will be burnt1712   * @param amount number of pieces to be burnt1713   * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)1714   * @returns ```true``` if extrinsic success, otherwise ```false```1715   */1716  async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1717    return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);1718  }17191720  /**1721   * Set, change, or remove approved address to transfer the ownership of the RFT.1722   *1723   * @param signer keyring of signer1724   * @param collectionId ID of collection1725   * @param tokenId ID of token1726   * @param toAddressObj address to approve1727   * @param amount number of pieces to be approved1728   * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);1729   * @returns true if the token success, otherwise false1730   */1731  async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {1732    return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1733  }17341735  /**1736   * Get total number of pieces1737   * @param collectionId ID of collection1738   * @param tokenId ID of token1739   * @example getTokenTotalPieces(10, 5);1740   * @returns number of pieces1741   */1742  async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {1743    return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();1744  }17451746  /**1747   * Change number of token pieces. Signer must be the owner of all token pieces.1748   * @param signer keyring of signer1749   * @param collectionId ID of collection1750   * @param tokenId ID of token1751   * @param amount new number of pieces1752   * @example repartitionToken(aliceKeyring, 10, 5, 12345n);1753   * @returns true if the repartion was success, otherwise false1754   */1755  async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {1756    const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);1757    const repartitionResult = await this.helper.executeExtrinsic(1758      signer,1759      'api.tx.unique.repartition', [collectionId, tokenId, amount],1760      true,1761    );1762    if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');1763    return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');1764  }1765}176617671768class FTGroup extends CollectionGroup {1769  /**1770   * Get collection object1771   * @param collectionId ID of collection1772   * @example getCollectionObject(2);1773   * @returns instance of UniqueFTCollection1774   */1775  getCollectionObject(collectionId: number): UniqueFTCollection {1776    return new UniqueFTCollection(collectionId, this.helper);1777  }17781779  /**1780   * Mint new fungible collection1781   * @param signer keyring of signer1782   * @param collectionOptions Collection options1783   * @param decimalPoints number of token decimals1784   * @example1785   * mintCollection(aliceKeyring, {1786   *   name: 'New',1787   *   description: 'New collection',1788   *   tokenPrefix: 'NEW',1789   * }, 18)1790   * @returns newly created fungible collection1791   */1792  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {1793    collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1794    if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');1795    collectionOptions.mode = {fungible: decimalPoints};1796    for (const key of ['name', 'description', 'tokenPrefix']) {1797      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);1798    }1799    const creationResult = await this.helper.executeExtrinsic(1800      signer,1801      'api.tx.unique.createCollectionEx', [collectionOptions],1802      true,1803    );1804    return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1805  }18061807  /**1808   * Mint tokens1809   * @param signer keyring of signer1810   * @param collectionId ID of collection1811   * @param owner address owner of new tokens1812   * @param amount amount of tokens to be meanted1813   * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);1814   * @returns ```true``` if extrinsic success, otherwise ```false```1815   */1816  async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {1817    const creationResult = await this.helper.executeExtrinsic(1818      signer,1819      'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {1820        fungible: {1821          value: amount,1822        },1823      }],1824      true, // `Unable to mint fungible tokens for ${label}`,1825    );1826    return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1827  }18281829  /**1830   * Mint multiple Fungible tokens with one owner1831   * @param signer keyring of signer1832   * @param collectionId ID of collection1833   * @param owner tokens owner1834   * @param tokens array of tokens with properties and pieces1835   * @returns ```true``` if extrinsic success, otherwise ```false```1836   */1837  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: {value: bigint}[], owner: ICrossAccountId): Promise<boolean> {1838    const rawTokens = [];1839    for (const token of tokens) {1840      const raw = {Fungible: {Value: token.value}};1841      rawTokens.push(raw);1842    }1843    const creationResult = await this.helper.executeExtrinsic(1844      signer,1845      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1846      true,1847    );1848    return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');1849  }18501851  /**1852   * Get the top 10 owners with the largest balance for the Fungible collection1853   * @param collectionId ID of collection1854   * @example getTop10Owners(10);1855   * @returns array of ```ICrossAccountId```1856   */1857  async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {1858    return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1859  }18601861  /**1862   * Get account balance1863   * @param collectionId ID of collection1864   * @param addressObj address of owner1865   * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})1866   * @returns amount of fungible tokens owned by address1867   */1868  async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {1869    return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();1870  }18711872  /**1873   * Transfer tokens to address1874   * @param signer keyring of signer1875   * @param collectionId ID of collection1876   * @param toAddressObj address recipient1877   * @param amount amount of tokens to be sent1878   * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);1879   * @returns ```true``` if extrinsic success, otherwise ```false```1880   */1881  async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {1882    return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);1883  }18841885  /**1886   * Transfer some tokens on behalf of the owner.1887   * @param signer keyring of signer1888   * @param collectionId ID of collection1889   * @param fromAddressObj address on behalf of which tokens will be sent1890   * @param toAddressObj address where token to be sent1891   * @param amount number of tokens to be sent1892   * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);1893   * @returns ```true``` if extrinsic success, otherwise ```false```1894   */1895  async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {1896    return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);1897  }18981899  /**1900   * Destroy some amount of tokens1901   * @param signer keyring of signer1902   * @param collectionId ID of collection1903   * @param amount amount of tokens to be destroyed1904   * @example burnTokens(aliceKeyring, 10, 1000n);1905   * @returns ```true``` if extrinsic success, otherwise ```false```1906   */1907  async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {1908    return await super.burnToken(signer, collectionId, 0, amount);1909  }19101911  /**1912   * Burn some tokens on behalf of the owner.1913   * @param signer keyring of signer1914   * @param collectionId ID of collection1915   * @param fromAddressObj address on behalf of which tokens will be burnt1916   * @param amount amount of tokens to be burnt1917   * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);1918   * @returns ```true``` if extrinsic success, otherwise ```false```1919   */1920  async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount=1n): Promise<boolean> {1921    return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);1922  }19231924  /**1925   * Get total collection supply1926   * @param collectionId1927   * @returns1928   */1929  async getTotalPieces(collectionId: number): Promise<bigint> {1930    return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();1931  }19321933  /**1934   * Set, change, or remove approved address to transfer tokens.1935   *1936   * @param signer keyring of signer1937   * @param collectionId ID of collection1938   * @param toAddressObj address to be approved1939   * @param amount amount of tokens to be approved1940   * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)1941   * @returns ```true``` if extrinsic success, otherwise ```false```1942   */1943  async approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount=1n) {1944    return super.approveToken(signer, collectionId, 0, toAddressObj, amount);1945  }19461947  /**1948   * Get amount of fungible tokens approved to transfer1949   * @param collectionId ID of collection1950   * @param fromAddressObj owner of tokens1951   * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner1952   * @returns number of tokens approved for the transfer1953   */1954  async getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {1955    return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);1956  }1957}195819591960class ChainGroup extends HelperGroup {1961  /**1962   * Get system properties of a chain1963   * @example getChainProperties();1964   * @returns ss58Format, token decimals, and token symbol1965   */1966  getChainProperties(): IChainProperties {1967    const properties = (this.helper.api as any).registry.getChainProperties().toJSON();1968    return {1969      ss58Format: properties.ss58Format.toJSON(),1970      tokenDecimals: properties.tokenDecimals.toJSON(),1971      tokenSymbol: properties.tokenSymbol.toJSON(),1972    };1973  }19741975  /**1976   * Get chain header1977   * @example getLatestBlockNumber();1978   * @returns the number of the last block1979   */1980  async getLatestBlockNumber(): Promise<number> {1981    return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();1982  }19831984  /**1985   * Get block hash by block number1986   * @param blockNumber number of block1987   * @example getBlockHashByNumber(12345);1988   * @returns hash of a block1989   */1990  async getBlockHashByNumber(blockNumber: number): Promise<string | null> {1991    const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();1992    if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;1993    return blockHash;1994  }19951996  // TODO add docs1997  async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {1998    const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);1999    if (!blockHash) return null;2000    return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2001  }20022003  /**2004   * Get account nonce2005   * @param address substrate address2006   * @example getNonce("5GrwvaEF5zXb26Fz...");2007   * @returns number, account's nonce2008   */2009  async getNonce(address: TSubstrateAccount): Promise<number> {2010    return (await (this.helper.api as any).query.system.account(address)).nonce.toNumber();2011  }2012}201320142015class BalanceGroup extends HelperGroup {2016  /**2017   * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2018   * @example getOneTokenNominal()2019   * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2020   */2021  getOneTokenNominal(): bigint {2022    const chainProperties = this.helper.chain.getChainProperties();2023    return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2024  }20252026  /**2027   * Get substrate address balance2028   * @param address substrate address2029   * @example getSubstrate("5GrwvaEF5zXb26Fz...")2030   * @returns amount of tokens on address2031   */2032  async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2033    return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2034  }20352036  /**2037   * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2038   * @param address substrate address2039   * @returns2040   */2041  async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2042    const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2043    return {free: accountInfo.free.toBigInt(), miscFrozen: accountInfo.miscFrozen.toBigInt(), feeFrozen: accountInfo.feeFrozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2044  }20452046  /**2047   * Get ethereum address balance2048   * @param address ethereum address2049   * @example getEthereum("0x9F0583DbB855d...")2050   * @returns amount of tokens on address2051   */2052  async getEthereum(address: TEthereumAccount): Promise<bigint> {2053    return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2054  }20552056  /**2057   * Transfer tokens to substrate address2058   * @param signer keyring of signer2059   * @param address substrate address of a recipient2060   * @param amount amount of tokens to be transfered2061   * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2062   * @returns ```true``` if extrinsic success, otherwise ```false```2063   */2064  async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2065    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}`*/);20662067    let transfer = {from: null, to: null, amount: 0n} as any;2068    result.result.events.forEach(({event: {data, method, section}}) => {2069      if ((section === 'balances') && (method === 'Transfer')) {2070        transfer = {2071          from: this.helper.address.normalizeSubstrate(data[0]),2072          to: this.helper.address.normalizeSubstrate(data[1]),2073          amount: BigInt(data[2]),2074        };2075      }2076    });2077    const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from 2078      && this.helper.address.normalizeSubstrate(address) === transfer.to 2079      && BigInt(amount) === transfer.amount;2080    return isSuccess;2081  }2082}208320842085class AddressGroup extends HelperGroup {2086  /**2087   * Normalizes the address to the specified ss58 format, by default ```42```.2088   * @param address substrate address2089   * @param ss58Format format for address conversion, by default ```42```2090   * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2091   * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2092   */2093  normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2094    return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2095  }20962097  /**2098   * Get address in the connected chain format2099   * @param address substrate address2100   * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2101   * @returns address in chain format2102   */2103  async normalizeSubstrateToChainFormat(address: TSubstrateAccount): Promise<TSubstrateAccount> {2104    const info = this.helper.chain.getChainProperties();2105    return encodeAddress(decodeAddress(address), info.ss58Format);2106  }21072108  /**2109   * Get substrate mirror of an ethereum address2110   * @param ethAddress ethereum address2111   * @param toChainFormat false for normalized account2112   * @example ethToSubstrate('0x9F0583DbB855d...')2113   * @returns substrate mirror of a provided ethereum address2114   */2115  async ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat=false): Promise<TSubstrateAccount> {2116    if(!toChainFormat) return evmToAddress(ethAddress);2117    const info = this.helper.chain.getChainProperties();2118    return evmToAddress(ethAddress, info.ss58Format);2119  }21202121  /**2122   * Get ethereum mirror of a substrate address2123   * @param subAddress substrate account2124   * @example substrateToEth("5DnSF6RRjwteE3BrC...")2125   * @returns ethereum mirror of a provided substrate address2126   */2127  substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2128    return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(subAddress), i => i.toString(16).padStart(2, '0')).join(''));2129  }2130}21312132class StakingGroup extends HelperGroup {2133  /**2134   * Stake tokens for App Promotion2135   * @param signer keyring of signer2136   * @param amountToStake amount of tokens to stake2137   * @param label extra label for log2138   * @returns2139   */2140  async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2141    if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2142    const stakeResult = await this.helper.executeExtrinsic(2143      signer, 'api.tx.appPromotion.stake',2144      [amountToStake], true,2145    );2146    // TODO extract info from stakeResult2147    return true;2148  }21492150  /**2151   * Unstake tokens for App Promotion2152   * @param signer keyring of signer2153   * @param amountToUnstake amount of tokens to unstake2154   * @param label extra label for log2155   * @returns block number where balances will be unlocked2156   */2157  async unstake(signer: TSigner, label?: string): Promise<number> {2158    if(typeof label === 'undefined') label = `${signer.address}`;2159    const unstakeResult = await this.helper.executeExtrinsic(2160      signer, 'api.tx.appPromotion.unstake',2161      [], true,2162    );2163    // TODO extract block number fron events2164    return 1;2165  }21662167  /**2168   * Get total staked amount for address2169   * @param address substrate or ethereum address2170   * @returns total staked amount2171   */2172  async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2173    if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2174    return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2175  }21762177  /**2178   * Get total staked per block2179   * @param address substrate or ethereum address2180   * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2181   */2182  async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2183    const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2184    return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => {2185      return { 2186        block: block.toBigInt(),2187        amount: amount.toBigInt(),2188      };2189    });2190  }21912192  /**2193   * Get total pending unstake amount for address2194   * @param address substrate or ethereum address2195   * @returns total pending unstake amount2196   */2197  async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2198    return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2199  }22002201  /**2202   * Get pending unstake amount per block for address2203   * @param address substrate or ethereum address2204   * @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 block2205   */2206  async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2207    const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2208    const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => {2209      return {2210        block: block.toBigInt(),2211        amount: amount.toBigInt(),2212      };2213    });2214    return result;2215  }2216}22172218export class UniqueHelper extends ChainHelperBase {2219  chain: ChainGroup;2220  balance: BalanceGroup;2221  address: AddressGroup;2222  collection: CollectionGroup;2223  nft: NFTGroup;2224  rft: RFTGroup;2225  ft: FTGroup;2226  staking: StakingGroup;22272228  constructor(logger?: ILogger) {2229    super(logger);2230    this.chain = new ChainGroup(this);2231    this.balance = new BalanceGroup(this);2232    this.address = new AddressGroup(this);2233    this.collection = new CollectionGroup(this);2234    this.nft = new NFTGroup(this);2235    this.rft = new RFTGroup(this);2236    this.ft = new FTGroup(this);2237    this.staking = new StakingGroup(this);2238  }2239}224022412242export class UniqueBaseCollection {2243  helper: UniqueHelper;2244  collectionId: number;22452246  constructor(collectionId: number, uniqueHelper: UniqueHelper) {2247    this.collectionId = collectionId;2248    this.helper = uniqueHelper;2249  }22502251  async getData() {2252    return await this.helper.collection.getData(this.collectionId);2253  }22542255  async getLastTokenId() {2256    return await this.helper.collection.getLastTokenId(this.collectionId);2257  }22582259  async isTokenExists(tokenId: number) {2260    return await this.helper.collection.isTokenExists(this.collectionId, tokenId);2261  }22622263  async getAdmins() {2264    return await this.helper.collection.getAdmins(this.collectionId);2265  }22662267  async getAllowList() {2268    return await this.helper.collection.getAllowList(this.collectionId);2269  }22702271  async getEffectiveLimits() {2272    return await this.helper.collection.getEffectiveLimits(this.collectionId);2273  }22742275  async getProperties(propertyKeys: string[] | null = null) {2276    return await this.helper.collection.getProperties(this.collectionId, propertyKeys);2277  }22782279  async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {2280    return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);2281  }22822283  async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {2284    return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);2285  }22862287  async confirmSponsorship(signer: TSigner) {2288    return await this.helper.collection.confirmSponsorship(signer, this.collectionId);2289  }22902291  async removeSponsor(signer: TSigner) {2292    return await this.helper.collection.removeSponsor(signer, this.collectionId);2293  }22942295  async setLimits(signer: TSigner, limits: ICollectionLimits) {2296    return await this.helper.collection.setLimits(signer, this.collectionId, limits);2297  }22982299  async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {2300    return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);2301  }23022303  async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {2304    return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);2305  }23062307  async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {2308    return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);2309  }23102311  async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {2312    return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);2313  }23142315  async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {2316    return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);2317  }23182319  async setProperties(signer: TSigner, properties: IProperty[]) {2320    return await this.helper.collection.setProperties(signer, this.collectionId, properties);2321  }23222323  async deleteProperties(signer: TSigner, propertyKeys: string[]) {2324    return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);2325  }23262327  async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {2328    return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);2329  }23302331  async enableNesting(signer: TSigner, permissions: INestingPermissions) {2332    return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);2333  }23342335  async disableNesting(signer: TSigner) {2336    return await this.helper.collection.disableNesting(signer, this.collectionId);2337  }23382339  async burn(signer: TSigner) {2340    return await this.helper.collection.burn(signer, this.collectionId);2341  }2342}234323442345export class UniqueNFTCollection extends UniqueBaseCollection {2346  getTokenObject(tokenId: number) {2347    return new UniqueNFToken(tokenId, this);2348  }23492350  async getTokensByAddress(addressObj: ICrossAccountId) {2351    return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);2352  }23532354  async getToken(tokenId: number, blockHashAt?: string) {2355    return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);2356  }23572358  async getTokenOwner(tokenId: number, blockHashAt?: string) {2359    return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);2360  }23612362  async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {2363    return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);2364  }23652366  async getTokenChildren(tokenId: number, blockHashAt?: string) {2367    return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);2368  }23692370  async getPropertyPermissions(propertyKeys: string[] | null = null) {2371    return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);2372  }23732374  async getTokenProperties(tokenId: number, propertyKeys: string[] | null = null) {2375    return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);2376  }23772378  async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {2379    return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);2380  }23812382  async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2383    return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);2384  }23852386  async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {2387    return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);2388  }23892390  async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {2391    return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);2392  }23932394  async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {2395    return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});2396  }23972398  async mintMultipleTokens(signer: TSigner, tokens: {owner: ICrossAccountId, properties?: IProperty[]}[]) {2399    return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);2400  }24012402  async burnToken(signer: TSigner, tokenId: number) {2403    return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);2404  }24052406  async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {2407    return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);2408  }24092410  async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {2411    return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);2412  }24132414  async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {2415    return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);2416  }24172418  async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {2419    return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);2420  }24212422  async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {2423    return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);2424  }24252426  async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {2427    return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);2428  }2429}243024312432export class UniqueRFTCollection extends UniqueBaseCollection {2433  getTokenObject(tokenId: number) {2434    return new UniqueRFToken(tokenId, this);2435  }24362437  async getToken(tokenId: number, blockHashAt?: string) {2438    return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);2439  }24402441  async getTokensByAddress(addressObj: ICrossAccountId) {2442    return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);2443  }24442445  async getTop10TokenOwners(tokenId: number) {2446    return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);2447  }24482449  async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {2450    return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);2451  }24522453  async getTokenTotalPieces(tokenId: number) {2454    return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);2455  }24562457  async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2458    return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);2459  }24602461  async getPropertyPermissions(propertyKeys: string[] | null = null) {2462    return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);2463  }24642465  async getTokenProperties(tokenId: number, propertyKeys: string[] | null = null) {2466    return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);2467  }24682469  async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount=1n) {2470    return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);2471  }24722473  async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2474    return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);2475  }24762477  async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) {2478    return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);2479  }24802481  async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {2482    return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);2483  }24842485  async mintToken(signer: TSigner, pieces=1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {2486    return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});2487  }24882489  async mintMultipleTokens(signer: TSigner, tokens: {pieces: bigint, owner: ICrossAccountId, properties?: IProperty[]}[]) {2490    return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);2491  }24922493  async burnToken(signer: TSigner, tokenId: number, amount=1n) {2494    return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);2495  }24962497  async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId,  amount=1n) {2498    return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);2499  }25002501  async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {2502    return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);2503  }25042505  async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {2506    return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);2507  }25082509  async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {2510    return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);2511  }2512}251325142515export class UniqueFTCollection extends UniqueBaseCollection {2516  async getBalance(addressObj: ICrossAccountId) {2517    return await this.helper.ft.getBalance(this.collectionId, addressObj);2518  }25192520  async getTotalPieces() {2521    return await this.helper.ft.getTotalPieces(this.collectionId);2522  }25232524  async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2525    return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);2526  }25272528  async getTop10Owners() {2529    return await this.helper.ft.getTop10Owners(this.collectionId);2530  }25312532  async mint(signer: TSigner, amount=1n, owner: ICrossAccountId = {Substrate: signer.address}) {2533    return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);2534  }25352536  async mintWithOneOwner(signer: TSigner, tokens: {value: bigint}[], owner: ICrossAccountId = {Substrate: signer.address}) {2537    return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);2538  }25392540  async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {2541    return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);2542  }25432544  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2545    return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);2546  }25472548  async burnTokens(signer: TSigner, amount=1n) {2549    return await this.helper.ft.burnTokens(signer, this.collectionId, amount);2550  }25512552  async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {2553    return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);2554  }25552556  async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {2557    return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);2558  }2559}256025612562export class UniqueBaseToken {2563  collection: UniqueNFTCollection | UniqueRFTCollection;2564  collectionId: number;2565  tokenId: number;25662567  constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {2568    this.collection = collection;2569    this.collectionId = collection.collectionId;2570    this.tokenId = tokenId;2571  }25722573  async getNextSponsored(addressObj: ICrossAccountId) {2574    return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);2575  }25762577  async getProperties(propertyKeys: string[] | null = null) {2578    return await this.collection.getTokenProperties(this.tokenId, propertyKeys);2579  }25802581  async setProperties(signer: TSigner, properties: IProperty[]) {2582    return await this.collection.setTokenProperties(signer, this.tokenId, properties);2583  }25842585  async deleteProperties(signer: TSigner, propertyKeys: string[]) {2586    return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);2587  }25882589  nestingAccount() {2590    return this.collection.helper.util.getTokenAccount(this);2591  }2592}259325942595export class UniqueNFToken extends UniqueBaseToken {2596  collection: UniqueNFTCollection;25972598  constructor(tokenId: number, collection: UniqueNFTCollection) {2599    super(tokenId, collection);2600    this.collection = collection;2601  }26022603  async getData(blockHashAt?: string) {2604    return await this.collection.getToken(this.tokenId, blockHashAt);2605  }26062607  async getOwner(blockHashAt?: string) {2608    return await this.collection.getTokenOwner(this.tokenId, blockHashAt);2609  }26102611  async getTopmostOwner(blockHashAt?: string) {2612    return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);2613  }26142615  async getChildren(blockHashAt?: string) {2616    return await this.collection.getTokenChildren(this.tokenId, blockHashAt);2617  }26182619  async nest(signer: TSigner, toTokenObj: IToken) {2620    return await this.collection.nestToken(signer, this.tokenId, toTokenObj);2621  }26222623  async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {2624    return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);2625  }26262627  async transfer(signer: TSigner, addressObj: ICrossAccountId) {2628    return await this.collection.transferToken(signer, this.tokenId, addressObj);2629  }26302631  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2632    return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);2633  }26342635  async approve(signer: TSigner, toAddressObj: ICrossAccountId) {2636    return await this.collection.approveToken(signer, this.tokenId, toAddressObj);2637  }26382639  async isApproved(toAddressObj: ICrossAccountId) {2640    return await this.collection.isTokenApproved(this.tokenId, toAddressObj);2641  }26422643  async burn(signer: TSigner) {2644    return await this.collection.burnToken(signer, this.tokenId);2645  }26462647  async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {2648    return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);2649  }2650}26512652export class UniqueRFToken extends UniqueBaseToken {2653  collection: UniqueRFTCollection;26542655  constructor(tokenId: number, collection: UniqueRFTCollection) {2656    super(tokenId, collection);2657    this.collection = collection;2658  }26592660  async getData(blockHashAt?: string) {2661    return await this.collection.getToken(this.tokenId, blockHashAt);2662  }26632664  async getTop10Owners() {2665    return await this.collection.getTop10TokenOwners(this.tokenId);2666  }26672668  async getBalance(addressObj: ICrossAccountId) {2669    return await this.collection.getTokenBalance(this.tokenId, addressObj);2670  }26712672  async getTotalPieces() {2673    return await this.collection.getTokenTotalPieces(this.tokenId);2674  }26752676  async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {2677    return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);2678  }26792680  async transfer(signer: TSigner, addressObj: ICrossAccountId, amount=1n) {2681    return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);2682  }26832684  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {2685    return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);2686  }26872688  async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount=1n) {2689    return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);2690  }26912692  async repartition(signer: TSigner, amount: bigint) {2693    return await this.collection.repartitionToken(signer, this.tokenId, amount);2694  }26952696  async burn(signer: TSigner, amount=1n) {2697    return await this.collection.burnToken(signer, this.tokenId, amount);2698  }26992700  async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount=1n) {2701    return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);2702  }2703}