`8a54415cf31b`

2 files changed

modifiedtests/src/governance/init.test.tsdiff before after both

--- a/tests/src/governance/init.test.ts
+++ b/tests/src/governance/init.test.ts
@@ -1,13 +1,17 @@
 import {IKeyringPair} from '@polkadot/types/types';
 import {usingPlaygrounds, itSub, expect, Pallets, requirePalletsOrSkip, describeGov} from '../util';
 import {Event} from '../util/playgrounds/unique.dev';
-import {ICounselors, democracyLaunchPeriod, democracyVotingPeriod, ITechComms, democracyEnactmentPeriod, clearCouncil, clearTechComm} from './util';
+import {ICounselors, democracyLaunchPeriod, democracyVotingPeriod, ITechComms, democracyEnactmentPeriod, clearCouncil, clearTechComm, clearFellowship} from './util';
 
 describeGov('Governance: Initialization', () => {
   let donor: IKeyringPair;
   let sudoer: IKeyringPair;
   let counselors: ICounselors;
   let techcomms: ITechComms;
+  let coreDevs: any;
+
+  const expectedAlexFellowRank = 7;
+  const expectedFellowRank = 6;
 
   before(async function() {
     await usingPlaygrounds(async (helper, privateKey) => {
@@ -21,7 +25,24 @@
       donor = await privateKey({url: import.meta.url});
       sudoer = await privateKey('//Alice');
 
-      const [alex, ildar, charu, filip, irina] = await helper.arrange.createAccounts([10_000n, 10_000n, 10_000n, 10_000n, 10_000n], donor);
+      const counselorsNum = 5;
+      const techCommsNum = 3;
+      const coreDevsNum = 2;
+      const [
+        alex,
+        ildar,
+        charu,
+        filip,
+        irina,
+
+        greg,
+        andy,
+        constantine,
+
+        yaroslav,
+        daniel,
+    ] = await helper.arrange.createAccounts(new Array(counselorsNum + techCommsNum + coreDevsNum).fill(10_000n), donor);
+
       counselors = {
         alex,
         ildar,
@@ -30,26 +51,43 @@
         irina,
       };
 
-      const [greg, andy, constantine] = await helper.arrange.createAccounts([10_000n, 10_000n, 10_000n], donor);
       techcomms = {
         greg,
         andy,
         constantine,
       };
+
+      coreDevs = {
+        yaroslav: yaroslav,
+        daniel: daniel,
+      };
     });
   });
 
   itSub('Initialize Governance', async ({helper}) => {
+    const promoteFellow = (fellow: string, promotionsNum: number) => {
+        return new Array(promotionsNum).fill(helper.fellowship.collective.promoteCall(fellow));
+    };
+
+    const expectFellowRank = async (fellow: string, expectedRank: number) => {
+        expect(await helper.fellowship.collective.getMemberRank(fellow)).to.be.equal(expectedRank);
+    };
+
     console.log('\t- Setup the Prime of the Council via sudo');
     await helper.getSudo().utility.batchAll(sudoer, [
       helper.council.membership.addMemberCall(counselors.alex.address),
       helper.council.membership.setPrimeCall(counselors.alex.address),
+
+      helper.fellowship.collective.addMemberCall(counselors.alex.address),
+      ...promoteFellow(counselors.alex.address, expectedAlexFellowRank),
     ]);
 
     let councilMembers = await helper.council.membership.getMembers();
     const councilPrime = await helper.council.collective.getPrimeMember();
+    const alexFellowRank = await helper.fellowship.collective.getMemberRank(counselors.alex.address);
     expect(councilMembers).to.be.deep.equal([counselors.alex.address]);
     expect(councilPrime).to.be.equal(counselors.alex.address);
+    expect(alexFellowRank).to.be.equal(expectedAlexFellowRank);
 
     console.log('\t- The Council Prime initializes the Technical Commettee');
     const councilProposalThreshold = 1;
@@ -80,6 +118,26 @@
       helper.council.membership.addMemberCall(counselors.charu.address),
       helper.council.membership.addMemberCall(counselors.filip.address),
       helper.council.membership.addMemberCall(counselors.irina.address),
+
+      helper.fellowship.collective.addMemberCall(counselors.charu.address),
+      helper.fellowship.collective.addMemberCall(counselors.ildar.address),
+      helper.fellowship.collective.addMemberCall(counselors.irina.address),
+      helper.fellowship.collective.addMemberCall(counselors.filip.address),
+      helper.fellowship.collective.addMemberCall(techcomms.greg.address),
+      helper.fellowship.collective.addMemberCall(techcomms.andy.address),
+      helper.fellowship.collective.addMemberCall(techcomms.constantine.address),
+      helper.fellowship.collective.addMemberCall(coreDevs.yaroslav.address),
+      helper.fellowship.collective.addMemberCall(coreDevs.daniel.address),
+
+      ...promoteFellow(counselors.charu.address, expectedFellowRank),
+      ...promoteFellow(counselors.ildar.address, expectedFellowRank),
+      ...promoteFellow(counselors.irina.address, expectedFellowRank),
+      ...promoteFellow(counselors.filip.address, expectedFellowRank),
+      ...promoteFellow(techcomms.greg.address, expectedFellowRank),
+      ...promoteFellow(techcomms.andy.address, expectedFellowRank),
+      ...promoteFellow(techcomms.constantine.address, expectedFellowRank),
+      ...promoteFellow(coreDevs.yaroslav.address, expectedFellowRank),
+      ...promoteFellow(coreDevs.daniel.address, expectedFellowRank),
     ]), returnPreimageHash);
 
     await helper.council.collective.propose(
@@ -116,9 +174,20 @@
     ];
     expect(councilMembers.length).to.be.equal(expectedCounselors.length);
     expect(councilMembers).to.containSubset(expectedCounselors);
+
+    await expectFellowRank(counselors.ildar.address, expectedFellowRank);
+    await expectFellowRank(counselors.charu.address, expectedFellowRank);
+    await expectFellowRank(counselors.filip.address, expectedFellowRank);
+    await expectFellowRank(counselors.irina.address, expectedFellowRank);
+    await expectFellowRank(techcomms.greg.address, expectedFellowRank);
+    await expectFellowRank(techcomms.andy.address, expectedFellowRank);
+    await expectFellowRank(techcomms.constantine.address, expectedFellowRank);
+    await expectFellowRank(coreDevs.yaroslav.address, expectedFellowRank);
+    await expectFellowRank(coreDevs.daniel.address, expectedFellowRank);
   });
 
   after(async function() {
+    await clearFellowship(sudoer);
     await clearTechComm(sudoer);
     await clearCouncil(sudoer);
   });

modifiedtests/src/util/playgrounds/unique.tsdiff before after both

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 {SignerOptions} from '@polkadot/api/types/submittable';10import '../../interfaces/augment-api';11import {AugmentedSubmittables} from '@polkadot/api-base/types/submittable';12import {ApiInterfaceEvents} from '@polkadot/api/types';13import {encodeAddress, decodeAddress, keccakAsHex, evmToAddress, addressToEvm, base58Encode, blake2AsU8a, blake2AsHex} from '@polkadot/util-crypto';14import {IKeyringPair} from '@polkadot/types/types';15import {hexToU8a} from '@polkadot/util/hex';16import {u8aConcat} from '@polkadot/util/u8a';17import {18  IApiListeners,19  IBlock,20  IEvent,21  IChainProperties,22  ICollectionCreationOptions,23  ICollectionLimits,24  ICollectionPermissions,25  ICrossAccountId,26  ICrossAccountIdLower,27  ILogger,28  INestingPermissions,29  IProperty,30  IStakingInfo,31  ISchedulerOptions,32  ISubstrateBalance,33  IToken,34  ITokenPropertyPermission,35  ITransactionResult,36  IUniqueHelperLog,37  TApiAllowedListeners,38  TEthereumAccount,39  TSigner,40  TSubstrateAccount,41  TNetworks,42  IForeignAssetMetadata,43  AcalaAssetMetadata,44  MoonbeamAssetInfo,45  DemocracyStandardAccountVote,46  IEthCrossAccountId,47  IPhasicEvent,48} from './types';49import {RuntimeDispatchInfo} from '@polkadot/types/interfaces';50import type {Vec} from '@polkadot/types-codec';51import {FrameSystemEventRecord, PalletDemocracyConviction} from '@polkadot/types/lookup';5253export class CrossAccountId {54  Substrate!: TSubstrateAccount;55  Ethereum!: TEthereumAccount;5657  constructor(account: ICrossAccountId) {58    if('Substrate' in account) this.Substrate = account.Substrate;59    else this.Ethereum = account.Ethereum;60  }6162  static fromKeyring(account: IKeyringPair, domain: 'Substrate' | 'Ethereum' = 'Substrate') {63    switch (domain) {64      case 'Substrate': return new CrossAccountId({Substrate: account.address});65      case 'Ethereum': return new CrossAccountId({Substrate: account.address}).toEthereum();66    }67  }6869  static fromLowerCaseKeys(address: ICrossAccountIdLower): CrossAccountId {70    if('substrate' in address) return new CrossAccountId({Substrate: address.substrate});71    else return new CrossAccountId({Ethereum: address.ethereum});72  }7374  static normalizeSubstrateAddress(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {75    return encodeAddress(decodeAddress(address), ss58Format);76  }7778  static withNormalizedSubstrate(address: TSubstrateAccount, ss58Format = 42): CrossAccountId {79    return new CrossAccountId({Substrate: CrossAccountId.normalizeSubstrateAddress(address, ss58Format)});80  }8182  withNormalizedSubstrate(ss58Format = 42): CrossAccountId {83    if(this.Substrate) return CrossAccountId.withNormalizedSubstrate(this.Substrate, ss58Format);84    return this;85  }8687  static translateSubToEth(address: TSubstrateAccount): TEthereumAccount {88    return nesting.toChecksumAddress('0x' + Array.from(addressToEvm(address), i => i.toString(16).padStart(2, '0')).join(''));89  }9091  toEthereum(): CrossAccountId {92    if(this.Substrate) return new CrossAccountId({Ethereum: CrossAccountId.translateSubToEth(this.Substrate)});93    return this;94  }9596  static translateEthToSub(address: TEthereumAccount, ss58Format?: number): TSubstrateAccount {97    return evmToAddress(address, ss58Format);98  }99100  toSubstrate(ss58Format?: number): CrossAccountId {101    if(this.Ethereum) return new CrossAccountId({Substrate: CrossAccountId.translateEthToSub(this.Ethereum, ss58Format)});102    return this;103  }104105  toLowerCase(): CrossAccountId {106    if(this.Substrate) this.Substrate = this.Substrate.toLowerCase();107    if(this.Ethereum) this.Ethereum = this.Ethereum.toLowerCase();108    return this;109  }110}111112const nesting = {113  toChecksumAddress(address: string): string {114    if(typeof address === 'undefined') return '';115116    if(!/^(0x)?[0-9a-f]{40}$/i.test(address)) throw new Error(`Given address "${address}" is not a valid Ethereum address.`);117118    address = address.toLowerCase().replace(/^0x/i, '');119    const addressHash = keccakAsHex(address).replace(/^0x/i, '');120    const checksumAddress = ['0x'];121122    for(let i = 0; i < address.length; i++) {123      // If ith character is 8 to f then make it uppercase124      if(parseInt(addressHash[i], 16) > 7) {125        checksumAddress.push(address[i].toUpperCase());126      } else {127        checksumAddress.push(address[i]);128      }129    }130    return checksumAddress.join('');131  },132  tokenIdToAddress(collectionId: number, tokenId: number) {133    return this.toChecksumAddress(`0xf8238ccfff8ed887463fd5e0${collectionId.toString(16).padStart(8, '0')}${tokenId.toString(16).padStart(8, '0')}`);134  },135};136137class UniqueUtil {138  static transactionStatus = {139    NOT_READY: 'NotReady',140    FAIL: 'Fail',141    SUCCESS: 'Success',142  };143144  static chainLogType = {145    EXTRINSIC: 'extrinsic',146    RPC: 'rpc',147  };148149  static getTokenAccount(token: IToken): CrossAccountId {150    return new CrossAccountId({Ethereum: this.getTokenAddress(token)});151  }152153  static getTokenAddress(token: IToken): string {154    return nesting.tokenIdToAddress(token.collectionId, token.tokenId);155  }156157  static getDefaultLogger(): ILogger {158    return {159      log(msg: any, level = 'INFO') {160        console[level.toLocaleLowerCase() === 'error' ? 'error' : 'log'](...(Array.isArray(msg) ? msg : [msg]));161      },162      level: {163        ERROR: 'ERROR',164        WARNING: 'WARNING',165        INFO: 'INFO',166      },167    };168  }169170  static vec2str(arr: string[] | number[]) {171    return arr.map(x => String.fromCharCode(parseInt(x.toString()))).join('');172  }173174  static str2vec(string: string) {175    if(typeof string !== 'string') return string;176    return Array.from(string).map(x => x.charCodeAt(0));177  }178179  static fromSeed(seed: string, ss58Format = 42) {180    const keyring = new Keyring({type: 'sr25519', ss58Format});181    return keyring.addFromUri(seed);182  }183184  static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {185    if(creationResult.status !== this.transactionStatus.SUCCESS) {186      throw Error('Unable to create collection!');187    }188189    let collectionId = null;190    creationResult.result.events.forEach(({event: {data, method, section}}) => {191      if((section === 'common') && (method === 'CollectionCreated')) {192        collectionId = parseInt(data[0].toString(), 10);193      }194    });195196    if(collectionId === null) {197      throw Error('No CollectionCreated event was found!');198    }199200    return collectionId;201  }202203  static extractTokensFromCreationResult(creationResult: ITransactionResult): {204    success: boolean,205    tokens: { collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint }[],206  } {207    if(creationResult.status !== this.transactionStatus.SUCCESS) {208      throw Error('Unable to create tokens!');209    }210    let success = false;211    const tokens = [] as { collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint }[];212    creationResult.result.events.forEach(({event: {data, method, section}}) => {213      if(method === 'ExtrinsicSuccess') {214        success = true;215      } else if((section === 'common') && (method === 'ItemCreated')) {216        tokens.push({217          collectionId: parseInt(data[0].toString(), 10),218          tokenId: parseInt(data[1].toString(), 10),219          owner: data[2].toHuman(),220          amount: data[3].toBigInt(),221        });222      }223    });224    return {success, tokens};225  }226227  static extractTokensFromBurnResult(burnResult: ITransactionResult): {228    success: boolean,229    tokens: { collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint }[],230  } {231    if(burnResult.status !== this.transactionStatus.SUCCESS) {232      throw Error('Unable to burn tokens!');233    }234    let success = false;235    const tokens = [] as { collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint }[];236    burnResult.result.events.forEach(({event: {data, method, section}}) => {237      if(method === 'ExtrinsicSuccess') {238        success = true;239      } else if((section === 'common') && (method === 'ItemDestroyed')) {240        tokens.push({241          collectionId: parseInt(data[0].toString(), 10),242          tokenId: parseInt(data[1].toString(), 10),243          owner: data[2].toHuman(),244          amount: data[3].toBigInt(),245        });246      }247    });248    return {success, tokens};249  }250251  static findCollectionInEvents(events: { event: IEvent }[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {252    let eventId = null;253    events.forEach(({event: {data, method, section}}) => {254      if((section === expectedSection) && (method === expectedMethod)) {255        eventId = parseInt(data[0].toString(), 10);256      }257    });258259    if(eventId === null) {260      throw Error(`No ${expectedMethod} event was found!`);261    }262    return eventId === collectionId;263  }264265  static isTokenTransferSuccess(events: { event: IEvent }[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount = 1n) {266    const normalizeAddress = (address: string | ICrossAccountId) => {267      if(typeof address === 'string') return address;268      const obj = {} as any;269      Object.keys(address).forEach(k => {270        obj[k.toLocaleLowerCase()] = (address as any)[k];271      });272      if(obj.substrate) return CrossAccountId.withNormalizedSubstrate(obj.substrate);273      if(obj.ethereum) return CrossAccountId.fromLowerCaseKeys(obj).toLowerCase();274      return address;275    };276    let transfer = {collectionId: null, tokenId: null, from: null, to: null, amount: 1} as any;277    events.forEach(({event: {data, method, section}}) => {278      if((section === 'common') && (method === 'Transfer')) {279        const hData = (data as any).toJSON();280        transfer = {281          collectionId: hData[0],282          tokenId: hData[1],283          from: normalizeAddress(hData[2]),284          to: normalizeAddress(hData[3]),285          amount: BigInt(hData[4]),286        };287      }288    });289    let isSuccess = parseInt(collectionId.toString()) === transfer.collectionId && parseInt(tokenId.toString()) === transfer.tokenId;290    isSuccess = isSuccess && JSON.stringify(normalizeAddress(fromAddressObj)) === JSON.stringify(transfer.from);291    isSuccess = isSuccess && JSON.stringify(normalizeAddress(toAddressObj)) === JSON.stringify(transfer.to);292    isSuccess = isSuccess && amount === transfer.amount;293    return isSuccess;294  }295296  static bigIntToDecimals(number: bigint, decimals = 18) {297    const numberStr = number.toString();298    const dotPos = numberStr.length - decimals;299300    if(dotPos <= 0) {301      return '0.' + '0'.repeat(Math.abs(dotPos)) + numberStr;302    } else {303      const intPart = numberStr.substring(0, dotPos);304      const fractPart = numberStr.substring(dotPos);305      return intPart + '.' + fractPart;306    }307  }308}309310class UniqueEventHelper {311  private static extractIndex(index: any): [number, number] | string {312    if(index.toRawType() === '[u8;2]') return [index[0], index[1]];313    return index.toJSON();314  }315316  private static extractSub(data: any, subTypes: any): { [key: string]: any } {317    let obj: any = {};318    let index = 0;319320    if(data.entries) {321      for(const [key, value] of data.entries()) {322        obj[key] = this.extractData(value, subTypes[index]);323        index++;324      }325    } else obj = data.toJSON();326327    return obj;328  }329330  private static toHuman(data: any) {331    return data && data.toHuman ? data.toHuman() : `${data}`;332  }333334  private static extractData(data: any, type: any): any {335    if(!type) return this.toHuman(data);336    if(['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();337    if(['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();338    if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);339    return this.toHuman(data);340  }341342  public static extractEvents(events: { event: any, phase: any }[]): IEvent[] {343    const parsedEvents: IEvent[] = [];344345    events.forEach((record) => {346      const {event, phase} = record;347      const types = event.typeDef;348349      const eventData: IEvent = {350        section: event.section.toString(),351        method: event.method.toString(),352        index: this.extractIndex(event.index),353        data: [],354        phase: phase.toJSON(),355      };356357      event.data.forEach((val: any, index: number) => {358        eventData.data.push(this.extractData(val, types[index]));359      });360361      parsedEvents.push(eventData);362    });363364    return parsedEvents;365  }366}367const InvalidTypeSymbol = Symbol('Invalid type');368// eslint-disable-next-line @typescript-eslint/no-unused-vars369export type Invalid<ErrorMessage> =370  | ((371    invalidType: typeof InvalidTypeSymbol,372    ..._: typeof InvalidTypeSymbol[]373  ) => typeof InvalidTypeSymbol)374  | null375  | undefined;376// Has slightly better error messages than Get377type Get2<T, P extends string, E> =378  P extends `${infer Key}.${infer Key2}` ? Key extends keyof T ? Key2 extends keyof T[Key] ? T[Key][Key2] : E : E : E;379type ForceFunction<T> = T extends (...args: any) => any ? T : (...args: any) => Invalid<'not a function'>;380381export class ChainHelperBase {382  helperBase: any;383384  transactionStatus = UniqueUtil.transactionStatus;385  chainLogType = UniqueUtil.chainLogType;386  util: typeof UniqueUtil;387  eventHelper: typeof UniqueEventHelper;388  logger: ILogger;389  api: ApiPromise | null;390  forcedNetwork: TNetworks | null;391  network: TNetworks | null;392  wsEndpoint: string | null;393  chainLog: IUniqueHelperLog[];394  children: ChainHelperBase[];395  address: AddressGroup;396  chain: ChainGroup;397398  constructor(logger?: ILogger, helperBase?: any) {399    this.helperBase = helperBase;400401    this.util = UniqueUtil;402    this.eventHelper = UniqueEventHelper;403    if(typeof logger == 'undefined') logger = this.util.getDefaultLogger();404    this.logger = logger;405    this.api = null;406    this.forcedNetwork = null;407    this.network = null;408    this.wsEndpoint = null;409    this.chainLog = [];410    this.children = [];411    this.address = new AddressGroup(this);412    this.chain = new ChainGroup(this);413  }414415  clone(helperCls: ChainHelperBaseConstructor, options: { [key: string]: any } = {}) {416    Object.setPrototypeOf(helperCls.prototype, this);417    const newHelper = new helperCls(this.logger, options);418419    newHelper.api = this.api;420    newHelper.network = this.network;421    newHelper.forceNetwork = this.forceNetwork;422423    this.children.push(newHelper);424425    return newHelper;426  }427428  getEndpoint(): string {429    if(this.wsEndpoint === null) throw Error('No connection was established');430    return this.wsEndpoint;431  }432433  getApi(): ApiPromise {434    if(this.api === null) throw Error('API not initialized');435    return this.api;436  }437438  async subscribeEvents(expectedEvents: { section: string, names: string[] }[]) {439    const collectedEvents: IEvent[] = [];440    const unsubscribe = await this.getApi().query.system.events((events: Vec<FrameSystemEventRecord>) => {441      const ievents = this.eventHelper.extractEvents(events);442      ievents.forEach((event) => {443        expectedEvents.forEach((e => {444          if(event.section === e.section && e.names.includes(event.method)) {445            collectedEvents.push(event);446          }447        }));448      });449    });450    return {unsubscribe: unsubscribe as any, collectedEvents};451  }452453  clearChainLog(): void {454    this.chainLog = [];455  }456457  forceNetwork(value: TNetworks): void {458    this.forcedNetwork = value;459  }460461  async connect(wsEndpoint: string, listeners?: IApiListeners) {462    if(this.api !== null) throw Error('Already connected');463    const {api, network} = await ChainHelperBase.createConnection(wsEndpoint, listeners, this.forcedNetwork);464    this.wsEndpoint = wsEndpoint;465    this.api = api;466    this.network = network;467  }468469  async disconnect() {470    for(const child of this.children) {471      child.clearApi();472    }473474    if(this.api === null) return;475    await this.api.disconnect();476    this.clearApi();477  }478479  clearApi() {480    this.api = null;481    this.network = null;482  }483484  static async detectNetwork(api: ApiPromise): Promise<TNetworks> {485    const spec = (await api.query.system.lastRuntimeUpgrade()).toJSON() as any;486    const xcmChains = ['rococo', 'westend', 'westmint', 'acala', 'karura', 'moonbeam', 'moonriver'];487488    if(xcmChains.indexOf(spec.specName) > -1) return spec.specName;489490    if(['quartz', 'unique', 'sapphire'].indexOf(spec.specName) > -1) return spec.specName;491    return 'opal';492  }493494  static async detectNetworkByWsEndpoint(wsEndpoint: string): Promise<TNetworks> {495    if(!wsEndpoint) throw new Error('wsEndpoint was not set');496    const api = new ApiPromise({provider: new WsProvider(wsEndpoint)});497    await api.isReady;498499    const network = await this.detectNetwork(api);500501    await api.disconnect();502503    return network;504  }505506  static async createConnection(wsEndpoint: string, listeners?: IApiListeners, network?: TNetworks | null): Promise<{507    api: ApiPromise;508    network: TNetworks;509  }> {510    if(typeof network === 'undefined' || network === null) network = 'opal';511    if(!wsEndpoint) throw new Error('wsEndpoint was not set');512    const supportedRPC = {513      opal: {514        unique: require('@unique-nft/opal-testnet-types/definitions').unique.rpc,515      },516      quartz: {517        unique: require('@unique-nft/quartz-mainnet-types/definitions').unique.rpc,518      },519      unique: {520        unique: require('@unique-nft/unique-mainnet-types/definitions').unique.rpc,521      },522      rococo: {},523      westend: {},524      moonbeam: {},525      moonriver: {},526      acala: {},527      karura: {},528      westmint: {},529    };530    if(!supportedRPC.hasOwnProperty(network)) network = await this.detectNetworkByWsEndpoint(wsEndpoint);531    const rpc = supportedRPC[network];532533    // TODO: investigate how to replace rpc in runtime534    // api._rpcCore.addUserInterfaces(rpc);535536    const api = new ApiPromise({provider: new WsProvider(wsEndpoint), rpc});537538    await api.isReadyOrError;539540    if(typeof listeners === 'undefined') listeners = {};541    for(const event of ['connected', 'disconnected', 'error', 'ready', 'decorated']) {542      if(!listeners.hasOwnProperty(event) || typeof listeners[event as TApiAllowedListeners] === 'undefined') continue;543      api.on(event as ApiInterfaceEvents, listeners[event as TApiAllowedListeners] as (...args: any[]) => any);544    }545546    return {api, network};547  }548549  getTransactionStatus(data: { events: { event: IEvent }[], status: any }) {550    const {events, status} = data;551    if(status.isReady) {552      return this.transactionStatus.NOT_READY;553    }554    if(status.isBroadcast) {555      return this.transactionStatus.NOT_READY;556    }557    if(status.isInBlock || status.isFinalized) {558      const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');559      if(errors.length > 0) {560        return this.transactionStatus.FAIL;561      }562      if(events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {563        return this.transactionStatus.SUCCESS;564      }565    }566567    return this.transactionStatus.FAIL;568  }569570  signTransaction(sender: TSigner, transaction: any, options: Partial<SignerOptions> | null = null, label = 'transaction') {571    const sign = (callback: any) => {572      if(options !== null) return transaction.signAndSend(sender, options, callback);573      return transaction.signAndSend(sender, callback);574    };575    // eslint-disable-next-line no-async-promise-executor576    return new Promise(async (resolve, reject) => {577      try {578        const unsub = await sign((result: any) => {579          const status = this.getTransactionStatus(result);580581          if(status === this.transactionStatus.SUCCESS) {582            this.logger.log(`${label} successful`);583            unsub();584            resolve({result, status, blockHash: result.status.asInBlock.toHuman()});585          } else if(status === this.transactionStatus.FAIL) {586            let moduleError = null;587588            if(result.hasOwnProperty('dispatchError')) {589              const dispatchError = result['dispatchError'];590591              if(dispatchError) {592                if(dispatchError.isModule) {593                  const modErr = dispatchError.asModule;594                  const errorMeta = dispatchError.registry.findMetaError(modErr);595596                  moduleError = `${errorMeta.section}.${errorMeta.name}`;597                } else if(dispatchError.isToken) {598                  moduleError = `Token: ${dispatchError.asToken}`;599                } else {600                  // May be [object Object] in case of unhandled non-unit enum601                  moduleError = `Misc: ${dispatchError.toHuman()}`;602                }603              } else {604                this.logger.log(result, this.logger.level.ERROR);605              }606            }607608            this.logger.log(`Something went wrong with ${label}. Status: ${status}`, this.logger.level.ERROR);609            unsub();610            reject({status, moduleError, result});611          }612        });613      } catch (e) {614        this.logger.log(e, this.logger.level.ERROR);615        reject(e);616      }617    });618  }619620  async signTransactionWithoutSending(signer: TSigner, tx: any) {621    const api = this.getApi();622    const signingInfo = await api.derive.tx.signingInfo(signer.address);623624    tx.sign(signer, {625      blockHash: api.genesisHash,626      genesisHash: api.genesisHash,627      runtimeVersion: api.runtimeVersion,628      nonce: signingInfo.nonce,629    });630631    return tx.toHex();632  }633634  async getPaymentInfo(signer: TSigner, tx: any, len: number | null) {635    const api = this.getApi();636    const signingInfo = await api.derive.tx.signingInfo(signer.address);637638    // We need to sign the tx because639    // unsigned transactions does not have an inclusion fee640    tx.sign(signer, {641      blockHash: api.genesisHash,642      genesisHash: api.genesisHash,643      runtimeVersion: api.runtimeVersion,644      nonce: signingInfo.nonce,645    });646647    if(len === null) {648      return (await this.callRpc('api.rpc.payment.queryInfo', [tx.toHex()])) as RuntimeDispatchInfo;649    } else {650      return (await api.call.transactionPaymentApi.queryInfo(tx, len)) as RuntimeDispatchInfo;651    }652  }653654  constructApiCall(apiCall: string, params: any[]) {655    if(!apiCall.startsWith('api.')) throw Error(`Invalid api call: ${apiCall}`);656    let call = this.getApi() as any;657    for(const part of apiCall.slice(4).split('.')) {658      call = call[part];659      if(!call) {660        const advice = part.includes('_') ? ' Looks like it needs to be converted to camel case.' : '';661        throw Error(`Function ${part} of api call ${apiCall} not found.${advice}`);662      }663    }664    return call(...params);665  }666667  encodeApiCall(apiCall: string, params: any[]) {668    return this.constructApiCall(apiCall, params).method.toHex();669  }670671  async executeExtrinsic<672    E extends string,673    V extends (674      ...args: any) => any = ForceFunction<675        Get2<676          AugmentedSubmittables<'promise'>,677          E, (...args: any) => Invalid<'not found'>678        >679      >680  >(681    sender: TSigner,682    extrinsic: `api.tx.${E}`,683    params: Parameters<V>,684    expectSuccess = true,685    options: Partial<SignerOptions> | null = null,/*, failureMessage='expected success'*/686  ): Promise<ITransactionResult> {687    if(this.api === null) throw Error('API not initialized');688689    const startTime = (new Date()).getTime();690    let result: ITransactionResult;691    let events: IEvent[] = [];692    try {693      result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), options, extrinsic) as ITransactionResult;694      events = this.eventHelper.extractEvents(result.result.events);695      const errorEvent = events.find((event) => event.method == 'ExecutedFailed' || event.method == 'CreatedFailed');696      if(errorEvent)697        throw Error(errorEvent.method + ': ' + extrinsic);698    }699    catch (e) {700      if(!(e as object).hasOwnProperty('status')) throw e;701      result = e as ITransactionResult;702    }703704    const endTime = (new Date()).getTime();705706    const log = {707      executedAt: endTime,708      executionTime: endTime - startTime,709      type: this.chainLogType.EXTRINSIC,710      status: result.status,711      call: extrinsic,712      signer: this.getSignerAddress(sender),713      params,714    } as IUniqueHelperLog;715716    let errorMessage = '';717718    if(result.status !== this.transactionStatus.SUCCESS) {719      if(result.moduleError) {720        errorMessage = typeof result.moduleError === 'string'721          ? result.moduleError722          : `${Object.keys(result.moduleError)[0]}: ${Object.values(result.moduleError)[0]}`;723        log.moduleError = errorMessage;724      }725      else if(result.result.dispatchError) log.dispatchError = result.result.dispatchError;726    }727    if(events.length > 0) log.events = events;728729    this.chainLog.push(log);730731    if(expectSuccess && result.status !== this.transactionStatus.SUCCESS) {732      if(result.moduleError) throw Error(`${errorMessage}`);733      else if(result.result.dispatchError) throw Error(JSON.stringify(result.result.dispatchError));734    }735    return result as any;736  }737  executeExtrinsicUncheckedWeight<738      E extends string,739      V extends (740         ...args: any) => any = ForceFunction<741            Get2<742               AugmentedSubmittables<'promise'>,743               E, (...args: any) => Invalid<'not found'>744            >745         >746   >(747    sender: TSigner,748    extrinsic: `api.tx.${E}`,749    params: Parameters<V>,750    expectSuccess = true,751    options: Partial<SignerOptions> | null = null,/*, failureMessage='expected success'*/752  ): Promise<ITransactionResult> {753    throw new Error('executeExtrinsicUncheckedWeight only supported in sudo');754  }755756  async callRpc757  // TODO: make it strongly typed, or use api.query/api.rpc directly758  // <759  // K extends 'rpc' | 'query',760  // E extends string,761  // V extends (...args: any) => any = ForceFunction<762  //   Get2<763  //     K extends 'rpc' ? DecoratedRpc<'promise', RpcInterface> : QueryableStorage<'promise'>,764  //     E, (...args: any) => Invalid<'not found'>765  //   >766  // >,767  // P = Parameters<V>,768  // >769  (rpc: string, params?: any[]): Promise<any> {770771    if(typeof params === 'undefined') params = [] as any;772    if(this.api === null) throw Error('API not initialized');773    if(!rpc.startsWith('api.rpc.') && !rpc.startsWith('api.query.')) throw Error(`${rpc} is not RPC call`);774775    const startTime = (new Date()).getTime();776    let result;777    let error = null;778    const log = {779      type: this.chainLogType.RPC,780      call: rpc,781      params,782    } as any as IUniqueHelperLog;783784    try {785      result = await this.constructApiCall(rpc, params as any);786    }787    catch (e) {788      error = e;789    }790791    const endTime = (new Date()).getTime();792793    log.executedAt = endTime;794    log.status = (error === null ? this.transactionStatus.SUCCESS : this.transactionStatus.FAIL) as 'Fail' | 'Success';795    log.executionTime = endTime - startTime;796797    this.chainLog.push(log);798799    if(error !== null) throw error;800801    return result;802  }803804  getSignerAddress(signer: IKeyringPair | string): string {805    if(typeof signer === 'string') return signer;806    return signer.address;807  }808809  fetchAllPalletNames(): string[] {810    if(this.api === null) throw Error('API not initialized');811    return this.api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase()).sort();812  }813814  fetchMissingPalletNames(requiredPallets: readonly string[]): string[] {815    const palletNames = this.fetchAllPalletNames();816    return requiredPallets.filter(p => !palletNames.includes(p));817  }818}819820821class HelperGroup<T extends ChainHelperBase> {822  helper: T;823824  constructor(uniqueHelper: T) {825    this.helper = uniqueHelper;826  }827}828829830class CollectionGroup extends HelperGroup<UniqueHelper> {831  /**832 * Get number of blocks when sponsored transaction is available.833 *834 * @param collectionId ID of collection835 * @param tokenId ID of token836 * @param addressObj address for which the sponsorship is checked837 * @example await getTokenNextSponsored(1, 2, {Substrate: '5DfhbVfww7ThF8q6f3...'});838 * @returns number of blocks or null if sponsorship hasn't been set839 */840  async getTokenNextSponsored(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<number | null> {841    return (await this.helper.callRpc('api.rpc.unique.nextSponsored', [collectionId, addressObj, tokenId])).toJSON();842  }843844  /**845   * Get the number of created collections.846   *847   * @returns number of created collections848   */849  async getTotalCount(): Promise<number> {850    return (await this.helper.callRpc('api.rpc.unique.collectionStats')).created.toNumber();851  }852853  /**854   * Get information about the collection with additional data,855   * including the number of tokens it contains, its administrators,856   * the normalized address of the collection's owner, and decoded name and description.857   *858   * @param collectionId ID of collection859   * @example await getData(2)860   * @returns collection information object861   */862  async getData(collectionId: number): Promise<{863    id: number;864    name: string;865    description: string;866    tokensCount: number;867    admins: CrossAccountId[];868    normalizedOwner: TSubstrateAccount;869    raw: any870  } | null> {871    const collection = await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId]);872    const humanCollection = collection.toHuman(), collectionData = {873      id: collectionId, name: null, description: null, tokensCount: 0, admins: [],874      raw: humanCollection,875    } as any, jsonCollection = collection.toJSON();876    if(humanCollection === null) return null;877    collectionData.raw.limits = jsonCollection.limits;878    collectionData.raw.permissions = jsonCollection.permissions;879    collectionData.normalizedOwner = this.helper.address.normalizeSubstrate(collectionData.raw.owner);880    for(const key of ['name', 'description']) {881      collectionData[key] = this.helper.util.vec2str(humanCollection[key]);882    }883884    collectionData.tokensCount = (['RFT', 'NFT'].includes(humanCollection.mode))885      ? await this.helper[humanCollection.mode.toLocaleLowerCase() as 'nft' | 'rft'].getLastTokenId(collectionId)886      : 0;887    collectionData.admins = await this.getAdmins(collectionId);888889    return collectionData;890  }891892  /**893   * Get the addresses of the collection's administrators, optionally normalized.894   *895   * @param collectionId ID of collection896   * @param normalize whether to normalize the addresses to the default ss58 format897   * @example await getAdmins(1)898   * @returns array of administrators899   */900  async getAdmins(collectionId: number, normalize = false): Promise<CrossAccountId[]> {901    const admins = (await this.helper.callRpc('api.rpc.unique.adminlist', [collectionId])).toHuman();902903    return normalize904      ? admins.map((address: CrossAccountId) => address.withNormalizedSubstrate())905      : admins;906  }907908  /**909   * Get the addresses added to the collection allow-list, optionally normalized.910   * @param collectionId ID of collection911   * @param normalize whether to normalize the addresses to the default ss58 format912   * @example await getAllowList(1)913   * @returns array of allow-listed addresses914   */915  async getAllowList(collectionId: number, normalize = false): Promise<CrossAccountId[]> {916    const allowListed = (await this.helper.callRpc('api.rpc.unique.allowlist', [collectionId])).toHuman();917    return normalize918      ? allowListed.map((address: CrossAccountId) => address.withNormalizedSubstrate())919      : allowListed;920  }921922  /**923   * Get the effective limits of the collection instead of null for default values924   *925   * @param collectionId ID of collection926   * @example await getEffectiveLimits(2)927   * @returns object of collection limits928   */929  async getEffectiveLimits(collectionId: number): Promise<ICollectionLimits> {930    return (await this.helper.callRpc('api.rpc.unique.effectiveCollectionLimits', [collectionId])).toJSON();931  }932933  /**934   * Burns the collection if the signer has sufficient permissions and collection is empty.935   *936   * @param signer keyring of signer937   * @param collectionId ID of collection938   * @example await helper.collection.burn(aliceKeyring, 3);939   * @returns ```true``` if extrinsic success, otherwise ```false```940   */941  async burn(signer: TSigner, collectionId: number): Promise<boolean> {942    const result = await this.helper.executeExtrinsic(943      signer,944      'api.tx.unique.destroyCollection', [collectionId],945      true,946    );947948    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionDestroyed');949  }950951  /**952   * Sets the sponsor for the collection (Requires the Substrate address). Needs confirmation by the sponsor.953   *954   * @param signer keyring of signer955   * @param collectionId ID of collection956   * @param sponsorAddress Sponsor substrate address957   * @example setSponsor(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")958   * @returns ```true``` if extrinsic success, otherwise ```false```959   */960  async setSponsor(signer: TSigner, collectionId: number, sponsorAddress: TSubstrateAccount): Promise<boolean> {961    const result = await this.helper.executeExtrinsic(962      signer,963      'api.tx.unique.setCollectionSponsor', [collectionId, sponsorAddress],964      true,965    );966967    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorSet');968  }969970  /**971   * Confirms consent to sponsor the collection on behalf of the signer.972   *973   * @param signer keyring of signer974   * @param collectionId ID of collection975   * @example confirmSponsorship(aliceKeyring, 10)976   * @returns ```true``` if extrinsic success, otherwise ```false```977   */978  async confirmSponsorship(signer: TSigner, collectionId: number): Promise<boolean> {979    const result = await this.helper.executeExtrinsic(980      signer,981      'api.tx.unique.confirmSponsorship', [collectionId],982      true,983    );984985    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'SponsorshipConfirmed');986  }987988  /**989   * Removes the sponsor of a collection, regardless if it consented or not.990   *991   * @param signer keyring of signer992   * @param collectionId ID of collection993   * @example removeSponsor(aliceKeyring, 10)994   * @returns ```true``` if extrinsic success, otherwise ```false```995   */996  async removeSponsor(signer: TSigner, collectionId: number): Promise<boolean> {997    const result = await this.helper.executeExtrinsic(998      signer,999      'api.tx.unique.removeCollectionSponsor', [collectionId],1000      true,1001    );10021003    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionSponsorRemoved');1004  }10051006  /**1007   * Sets the limits of the collection. At least one limit must be specified for a correct call.1008   *1009   * @param signer keyring of signer1010   * @param collectionId ID of collection1011   * @param limits collection limits object1012   * @example1013   * await setLimits(1014   *   aliceKeyring,1015   *   10,1016   *   {1017   *     sponsorTransferTimeout: 0,1018   *     ownerCanDestroy: false1019   *   }1020   * )1021   * @returns ```true``` if extrinsic success, otherwise ```false```1022   */1023  async setLimits(signer: TSigner, collectionId: number, limits: ICollectionLimits): Promise<boolean> {1024    const result = await this.helper.executeExtrinsic(1025      signer,1026      'api.tx.unique.setCollectionLimits', [collectionId, limits],1027      true,1028    );10291030    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionLimitSet');1031  }10321033  /**1034   * Changes the owner of the collection to the new Substrate address.1035   *1036   * @param signer keyring of signer1037   * @param collectionId ID of collection1038   * @param ownerAddress substrate address of new owner1039   * @example changeOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...")1040   * @returns ```true``` if extrinsic success, otherwise ```false```1041   */1042  async changeOwner(signer: TSigner, collectionId: number, ownerAddress: TSubstrateAccount): Promise<boolean> {1043    const result = await this.helper.executeExtrinsic(1044      signer,1045      'api.tx.unique.changeCollectionOwner', [collectionId, ownerAddress],1046      true,1047    );10481049    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionOwnerChanged');1050  }10511052  /**1053   * Adds a collection administrator.1054   *1055   * @param signer keyring of signer1056   * @param collectionId ID of collection1057   * @param adminAddressObj Administrator address (substrate or ethereum)1058   * @example addAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})1059   * @returns ```true``` if extrinsic success, otherwise ```false```1060   */1061  async addAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {1062    const result = await this.helper.executeExtrinsic(1063      signer,1064      'api.tx.unique.addCollectionAdmin', [collectionId, adminAddressObj],1065      true,1066    );10671068    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminAdded');1069  }10701071  /**1072   * Removes a collection administrator.1073   *1074   * @param signer keyring of signer1075   * @param collectionId ID of collection1076   * @param adminAddressObj Administrator address (substrate or ethereum)1077   * @example removeAdmin(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."})1078   * @returns ```true``` if extrinsic success, otherwise ```false```1079   */1080  async removeAdmin(signer: TSigner, collectionId: number, adminAddressObj: ICrossAccountId): Promise<boolean> {1081    const result = await this.helper.executeExtrinsic(1082      signer,1083      'api.tx.unique.removeCollectionAdmin', [collectionId, adminAddressObj],1084      true,1085    );10861087    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionAdminRemoved');1088  }10891090  /**1091   * Check if user is in allow list.1092   *1093   * @param collectionId ID of collection1094   * @param user Account to check1095   * @example await getAdmins(1)1096   * @returns is user in allow list1097   */1098  async allowed(collectionId: number, user: ICrossAccountId): Promise<boolean> {1099    return (await this.helper.callRpc('api.rpc.unique.allowed', [collectionId, user])).toJSON();1100  }11011102  /**1103   * Adds an address to allow list1104   * @param signer keyring of signer1105   * @param collectionId ID of collection1106   * @param addressObj address to add to the allow list1107   * @returns ```true``` if extrinsic success, otherwise ```false```1108   */1109  async addToAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1110    const result = await this.helper.executeExtrinsic(1111      signer,1112      'api.tx.unique.addToAllowList', [collectionId, addressObj],1113      true,1114    );11151116    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressAdded');1117  }11181119  /**1120   * Removes an address from allow list1121   *1122   * @param signer keyring of signer1123   * @param collectionId ID of collection1124   * @param addressObj address to remove from the allow list1125   * @returns ```true``` if extrinsic success, otherwise ```false```1126   */1127  async removeFromAllowList(signer: TSigner, collectionId: number, addressObj: ICrossAccountId): Promise<boolean> {1128    const result = await this.helper.executeExtrinsic(1129      signer,1130      'api.tx.unique.removeFromAllowList', [collectionId, addressObj],1131      true,1132    );11331134    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'AllowListAddressRemoved');1135  }11361137  /**1138   * Sets onchain permissions for selected collection.1139   *1140   * @param signer keyring of signer1141   * @param collectionId ID of collection1142   * @param permissions collection permissions object1143   * @example setPermissions(aliceKeyring, 10, {access:'AllowList', mintMode: true, nesting: {collectionAdmin: true, tokenOwner: true}});1144   * @returns ```true``` if extrinsic success, otherwise ```false```1145   */1146  async setPermissions(signer: TSigner, collectionId: number, permissions: ICollectionPermissions): Promise<boolean> {1147    const result = await this.helper.executeExtrinsic(1148      signer,1149      'api.tx.unique.setCollectionPermissions', [collectionId, permissions],1150      true,1151    );11521153    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPermissionSet');1154  }11551156  /**1157   * Enables nesting for selected collection. If `restricted` set, you can nest only tokens from specified collections.1158   *1159   * @param signer keyring of signer1160   * @param collectionId ID of collection1161   * @param permissions nesting permissions object1162   * @example enableNesting(aliceKeyring, 10, {collectionAdmin: true, tokenOwner: true});1163   * @returns ```true``` if extrinsic success, otherwise ```false```1164   */1165  async enableNesting(signer: TSigner, collectionId: number, permissions: INestingPermissions): Promise<boolean> {1166    return await this.setPermissions(signer, collectionId, {nesting: permissions});1167  }11681169  /**1170   * Disables nesting for selected collection.1171   *1172   * @param signer keyring of signer1173   * @param collectionId ID of collection1174   * @example disableNesting(aliceKeyring, 10);1175   * @returns ```true``` if extrinsic success, otherwise ```false```1176   */1177  async disableNesting(signer: TSigner, collectionId: number): Promise<boolean> {1178    return await this.setPermissions(signer, collectionId, {nesting: {tokenOwner: false, collectionAdmin: false}});1179  }11801181  /**1182   * Sets onchain properties to the collection.1183   *1184   * @param signer keyring of signer1185   * @param collectionId ID of collection1186   * @param properties array of property objects1187   * @example setProperties(aliceKeyring, 10, [{key: "gender", value: "male"}]);1188   * @returns ```true``` if extrinsic success, otherwise ```false```1189   */1190  async setProperties(signer: TSigner, collectionId: number, properties: IProperty[]): Promise<boolean> {1191    const result = await this.helper.executeExtrinsic(1192      signer,1193      'api.tx.unique.setCollectionProperties', [collectionId, properties],1194      true,1195    );11961197    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertySet');1198  }11991200  /**1201   * Get collection properties.1202   *1203   * @param collectionId ID of collection1204   * @param propertyKeys optionally filter the returned properties to only these keys1205   * @example getProperties(1219, ['location', 'date', 'time', 'isParadise']);1206   * @returns array of key-value pairs1207   */1208  async getProperties(collectionId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1209    return (await this.helper.callRpc('api.rpc.unique.collectionProperties', [collectionId, propertyKeys])).toHuman();1210  }12111212  async getPropertiesConsumedSpace(collectionId: number): Promise<number> {1213    const api = this.helper.getApi();1214    const props = (await api.query.common.collectionProperties(collectionId)).toJSON();12151216    return (props! as any).consumedSpace;1217  }12181219  async getCollectionOptions(collectionId: number) {1220    return (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1221  }12221223  /**1224   * Deletes onchain properties from the collection.1225   *1226   * @param signer keyring of signer1227   * @param collectionId ID of collection1228   * @param propertyKeys array of property keys to delete1229   * @example deleteProperties(aliceKeyring, 10, ["gender", "age"]);1230   * @returns ```true``` if extrinsic success, otherwise ```false```1231   */1232  async deleteProperties(signer: TSigner, collectionId: number, propertyKeys: string[]): Promise<boolean> {1233    const result = await this.helper.executeExtrinsic(1234      signer,1235      'api.tx.unique.deleteCollectionProperties', [collectionId, propertyKeys],1236      true,1237    );12381239    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'CollectionPropertyDeleted');1240  }12411242  /**1243   * Changes the owner of the token.1244   *1245   * @param signer keyring of signer1246   * @param collectionId ID of collection1247   * @param tokenId ID of token1248   * @param addressObj address of a new owner1249   * @param amount amount of tokens to be transfered. For NFT must be set to 1n1250   * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1251   * @returns true if the token success, otherwise false1252   */1253  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount = 1n): Promise<boolean> {1254    const result = await this.helper.executeExtrinsic(1255      signer,1256      'api.tx.unique.transfer', [addressObj, collectionId, tokenId, amount],1257      true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1258    );12591260    return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, {Substrate: typeof signer === 'string' ? signer : signer.address}, addressObj, amount);1261  }12621263  /**1264   *1265   * Change ownership of a token(s) on behalf of the owner.1266   *1267   * @param signer keyring of signer1268   * @param collectionId ID of collection1269   * @param tokenId ID of token1270   * @param fromAddressObj address on behalf of which the token will be sent1271   * @param toAddressObj new token owner1272   * @param amount amount of tokens to be transfered. For NFT must be set to 1n1273   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg"}, {Ethereum: "0x9F0583DbB85..."})1274   * @returns true if the token success, otherwise false1275   */1276  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount = 1n): Promise<boolean> {1277    const result = await this.helper.executeExtrinsic(1278      signer,1279      'api.tx.unique.transferFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1280      true, // `Unable to transfer token #${tokenId} from collection #${collectionId}`,1281    );1282    return this.helper.util.isTokenTransferSuccess(result.result.events, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1283  }12841285  /**1286   *1287   * Destroys a concrete instance of NFT/RFT or burns a specified amount of fungible tokens.1288   *1289   * @param signer keyring of signer1290   * @param collectionId ID of collection1291   * @param tokenId ID of token1292   * @param amount amount of tokens to be burned. For NFT must be set to 1n1293   * @example burnToken(aliceKeyring, 10, 5);1294   * @returns ```true``` if the extrinsic is successful, otherwise ```false```1295   */1296  async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount = 1n): Promise<boolean> {1297    const burnResult = await this.helper.executeExtrinsic(1298      signer,1299      'api.tx.unique.burnItem', [collectionId, tokenId, amount],1300      true, // `Unable to burn token for ${label}`,1301    );1302    const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1303    if(burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');1304    return burnedTokens.success;1305  }13061307  /**1308   * Destroys a concrete instance of NFT on behalf of the owner1309   *1310   * @param signer keyring of signer1311   * @param collectionId ID of collection1312   * @param tokenId ID of token1313   * @param fromAddressObj address on behalf of which the token will be burnt1314   * @param amount amount of tokens to be burned. For NFT must be set to 1n1315   * @example burnTokenFrom(aliceKeyring, 10, {Substrate: "5DyN4Y92vZCjv38fg..."}, 5, {Ethereum: "0x9F0583DbB85..."})1316   * @returns ```true``` if extrinsic success, otherwise ```false```1317   */1318  async burnTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount = 1n): Promise<boolean> {1319    const burnResult = await this.helper.executeExtrinsic(1320      signer,1321      'api.tx.unique.burnFrom', [collectionId, fromAddressObj, tokenId, amount],1322      true, // `Unable to burn token from for ${label}`,1323    );1324    const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);1325    return burnedTokens.success && burnedTokens.tokens.length > 0;1326  }13271328  /**1329   * Set, change, or remove approved address to transfer the ownership of the NFT.1330   *1331   * @param signer keyring of signer1332   * @param collectionId ID of collection1333   * @param tokenId ID of token1334   * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1335   * @param amount amount of token to be approved. For NFT must be set to 1n1336   * @returns ```true``` if extrinsic success, otherwise ```false```1337   */1338  async approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount = 1n) {1339    const approveResult = await this.helper.executeExtrinsic(1340      signer,1341      'api.tx.unique.approve', [toAddressObj, collectionId, tokenId, amount],1342      true, // `Unable to approve token for ${label}`,1343    );13441345    return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1346  }13471348  /**1349   * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1350   *1351   * @param signer keyring of signer1352   * @param collectionId ID of collection1353   * @param tokenId ID of token1354   * @param fromAddressObj Signer's Ethereum address containing her tokens1355   * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1356   * @param amount amount of token to be approved. For NFT must be set to 1n1357   * @returns ```true``` if extrinsic success, otherwise ```false```1358   */1359  async approveTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount = 1n) {1360    const approveResult = await this.helper.executeExtrinsic(1361      signer,1362      'api.tx.unique.approveFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount],1363      true, // `Unable to approve token for ${label}`,1364    );13651366    return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved');1367  }13681369  /**1370   * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror.1371   *1372   * @param signer keyring of signer1373   * @param collectionId ID of collection1374   * @param tokenId ID of token1375   * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens1376   * @param amount amount of token to be approved. For NFT must be set to 1n1377   * @returns ```true``` if extrinsic success, otherwise ```false```1378   */1379  async approveTokenFromEth(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount = 1n) {1380    const ethMirror = CrossAccountId.fromKeyring(signer).toEthereum();1381    return await this.approveTokenFrom(signer, collectionId, tokenId, ethMirror, toAddressObj, amount);1382  }13831384  /**1385   * Get the amount of token pieces approved to transfer or burn. Normally 0.1386   *1387   * @param collectionId ID of collection1388   * @param tokenId ID of token1389   * @param toAccountObj address which is approved to use token pieces1390   * @param fromAccountObj address which may have allowed the use of its owned tokens1391   * @example getTokenApprovedPieces(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5ERZNF88Mm7UGfPP3mdG..."})1392   * @returns number of approved to transfer pieces1393   */1394  async getTokenApprovedPieces(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId, fromAccountObj: ICrossAccountId): Promise<bigint> {1395    return (await this.helper.callRpc('api.rpc.unique.allowance', [collectionId, fromAccountObj, toAccountObj, tokenId])).toBigInt();1396  }13971398  /**1399   * Get the last created token ID in a collection1400   *1401   * @param collectionId ID of collection1402   * @example getLastTokenId(10);1403   * @returns id of the last created token1404   */1405  async getLastTokenId(collectionId: number): Promise<number> {1406    return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1407  }14081409  /**1410   * Check if token exists1411   *1412   * @param collectionId ID of collection1413   * @param tokenId ID of token1414   * @example doesTokenExist(10, 20);1415   * @returns true if the token exists, otherwise false1416   */1417  async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {1418    return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1419  }1420}14211422class NFTnRFT extends CollectionGroup {1423  /**1424   * Get tokens owned by account1425   *1426   * @param collectionId ID of collection1427   * @param addressObj tokens owner1428   * @example getTokensByAddress(10, {Substrate: "5DyN4Y92vZCjv38fg..."})1429   * @returns array of token ids owned by account1430   */1431  async getTokensByAddress(collectionId: number, addressObj: ICrossAccountId): Promise<number[]> {1432    return (await this.helper.callRpc('api.rpc.unique.accountTokens', [collectionId, addressObj])).toJSON();1433  }14341435  /**1436   * Get token data1437   *1438   * @param collectionId ID of collection1439   * @param tokenId ID of token1440   * @param propertyKeys optionally filter the token properties to only these keys1441   * @param blockHashAt optionally query the data at some block with this hash1442   * @example getToken(10, 5);1443   * @returns human readable token data1444   */1445  async getToken(collectionId: number, tokenId: number, propertyKeys: string[] = [], blockHashAt?: string): Promise<{1446    properties: IProperty[];1447    owner: CrossAccountId;1448    normalizedOwner: CrossAccountId;1449  } | null> {1450    let tokenData;1451    if(typeof blockHashAt === 'undefined') {1452      tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId]);1453    }1454    else {1455      if(propertyKeys.length == 0) {1456        const collection = (await this.helper.callRpc('api.rpc.unique.collectionById', [collectionId])).toHuman();1457        if(!collection) return null;1458        propertyKeys = collection.tokenPropertyPermissions.map((x: ITokenPropertyPermission) => x.key);1459      }1460      tokenData = await this.helper.callRpc('api.rpc.unique.tokenData', [collectionId, tokenId, propertyKeys, blockHashAt]);1461    }1462    tokenData = tokenData.toHuman();1463    if(tokenData === null || tokenData.owner === null) return null;1464    const owner = {} as any;1465    for(const key of Object.keys(tokenData.owner)) {1466      owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate'1467        ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key])1468        : tokenData.owner[key];1469    }1470    tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);1471    return tokenData;1472  }14731474  /**1475   * Get token's owner1476   * @param collectionId ID of collection1477   * @param tokenId ID of token1478   * @param blockHashAt optionally query the data at the block with this hash1479   * @example getTokenOwner(10, 5);1480   * @returns Address in CrossAccountId format, e.g. {Substrate: "5DnSF6RRjwteE3BrCj..."}1481   */1482  async getTokenOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId> {1483    let owner;1484    if(typeof blockHashAt === 'undefined') {1485      owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId]);1486    } else {1487      owner = await this.helper.callRpc('api.rpc.unique.tokenOwner', [collectionId, tokenId, blockHashAt]);1488    }1489    return CrossAccountId.fromLowerCaseKeys(owner.toJSON());1490  }14911492  /**1493   * Recursively find the address that owns the token1494   * @param collectionId ID of collection1495   * @param tokenId ID of token1496   * @param blockHashAt1497   * @example getTokenTopmostOwner(10, 5);1498   * @returns address in CrossAccountId format, e.g. {Substrate: "5DyN4Y92vZCjv38fg..."}1499   */1500  async getTokenTopmostOwner(collectionId: number, tokenId: number, blockHashAt?: string): Promise<CrossAccountId | null> {1501    let owner;1502    if(typeof blockHashAt === 'undefined') {1503      owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId]);1504    } else {1505      owner = await this.helper.callRpc('api.rpc.unique.topmostTokenOwner', [collectionId, tokenId, blockHashAt]);1506    }15071508    if(owner === null) return null;15091510    return owner.toHuman();1511  }15121513  /**1514   * Nest one token into another1515   * @param signer keyring of signer1516   * @param tokenObj token to be nested1517   * @param rootTokenObj token to be parent1518   * @example nestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4});1519   * @returns ```true``` if extrinsic success, otherwise ```false```1520   */1521  async nestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken): Promise<boolean> {1522    const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1523    const result = await this.transferToken(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress);1524    if(!result) {1525      throw Error('Unable to nest token!');1526    }1527    return result;1528  }15291530  /**1531     * Remove token from nested state1532     * @param signer keyring of signer1533     * @param tokenObj token to unnest1534     * @param rootTokenObj parent of a token1535     * @param toAddressObj address of a new token owner1536     * @example unnestToken(aliceKeyring, {collectionId: 10, tokenId: 5}, {collectionId: 10, tokenId: 4}, {Substrate: "5DyN4Y92vZCjv38fg..."});1537     * @returns ```true``` if extrinsic success, otherwise ```false```1538     */1539  async unnestToken(signer: TSigner, tokenObj: IToken, rootTokenObj: IToken, toAddressObj: ICrossAccountId): Promise<boolean> {1540    const rootTokenAddress = this.helper.util.getTokenAccount(rootTokenObj);1541    const result = await this.transferTokenFrom(signer, tokenObj.collectionId, tokenObj.tokenId, rootTokenAddress, toAddressObj);1542    if(!result) {1543      throw Error('Unable to unnest token!');1544    }1545    return result;1546  }15471548  /**1549   * Set permissions to change token properties1550   *1551   * @param signer keyring of signer1552   * @param collectionId ID of collection1553   * @param permissions permissions to change a property by the collection admin or token owner1554   * @example setTokenPropertyPermissions(1555   *   aliceKeyring, 10, [{key: "gender", permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}]1556   * )1557   * @returns true if extrinsic success otherwise false1558   */1559  async setTokenPropertyPermissions(signer: TSigner, collectionId: number, permissions: ITokenPropertyPermission[]): Promise<boolean> {1560    const result = await this.helper.executeExtrinsic(1561      signer,1562      'api.tx.unique.setTokenPropertyPermissions', [collectionId, permissions],1563      true,1564    );15651566    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'PropertyPermissionSet');1567  }15681569  /**1570   * Get token property permissions.1571   *1572   * @param collectionId ID of collection1573   * @param propertyKeys optionally filter the returned property permissions to only these keys1574   * @example getPropertyPermissions(1219, ['location', 'date', 'time', 'isParadise']);1575   * @returns array of key-permission pairs1576   */1577  async getPropertyPermissions(collectionId: number, propertyKeys: string[] | null = null): Promise<ITokenPropertyPermission[]> {1578    return (await this.helper.callRpc('api.rpc.unique.propertyPermissions', [collectionId, ...(propertyKeys === null ? [] : [propertyKeys])])).toHuman();1579  }15801581  /**1582   * Set token properties1583   *1584   * @param signer keyring of signer1585   * @param collectionId ID of collection1586   * @param tokenId ID of token1587   * @param properties key-value pairs of metadata which to add to a token. Keys must be permitted in the collection1588   * @example setTokenProperties(aliceKeyring, 10, 5, [{key: "gender", value: "female"}, {key: "age", value: "23"}])1589   * @returns ```true``` if extrinsic success, otherwise ```false```1590   */1591  async setTokenProperties(signer: TSigner, collectionId: number, tokenId: number, properties: IProperty[]): Promise<boolean> {1592    const result = await this.helper.executeExtrinsic(1593      signer,1594      'api.tx.unique.setTokenProperties', [collectionId, tokenId, properties],1595      true,1596    );15971598    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertySet');1599  }16001601  /**1602   * Get properties, metadata assigned to a token.1603   *1604   * @param collectionId ID of collection1605   * @param tokenId ID of token1606   * @param propertyKeys optionally filter the returned properties to only these keys1607   * @example getTokenProperties(1219, ['location', 'date', 'time', 'isParadise']);1608   * @returns array of key-value pairs1609   */1610  async getTokenProperties(collectionId: number, tokenId: number, propertyKeys?: string[] | null): Promise<IProperty[]> {1611    return (await this.helper.callRpc('api.rpc.unique.tokenProperties', [collectionId, tokenId, propertyKeys])).toHuman();1612  }16131614  /**1615   * Delete the provided properties of a token1616   * @param signer keyring of signer1617   * @param collectionId ID of collection1618   * @param tokenId ID of token1619   * @param propertyKeys property keys to be deleted1620   * @example deleteTokenProperties(aliceKeyring, 10, 5, ["gender", "age"])1621   * @returns ```true``` if extrinsic success, otherwise ```false```1622   */1623  async deleteTokenProperties(signer: TSigner, collectionId: number, tokenId: number, propertyKeys: string[]): Promise<boolean> {1624    const result = await this.helper.executeExtrinsic(1625      signer,1626      'api.tx.unique.deleteTokenProperties', [collectionId, tokenId, propertyKeys],1627      true,1628    );16291630    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'TokenPropertyDeleted');1631  }16321633  /**1634   * Mint new collection1635   *1636   * @param signer keyring of signer1637   * @param collectionOptions basic collection options and properties1638   * @param mode NFT or RFT type of a collection1639   * @example mintCollection(aliceKeyring, {name: 'New', description: "New collection", tokenPrefix: "NEW"}, "NFT")1640   * @returns object of the created collection1641   */1642  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions, mode: 'NFT' | 'RFT'): Promise<UniqueBaseCollection> {1643    collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object1644    collectionOptions.mode = (mode === 'NFT') ? {nft: null} : {refungible: null};1645    for(const key of ['name', 'description', 'tokenPrefix']) {1646      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);1647    }16481649    let flags = 0;1650    // convert CollectionFlags to number and join them in one number1651    if(collectionOptions.flags) {1652      for(let i = 0; i < collectionOptions.flags.length; i++){1653        const flag = collectionOptions.flags[i];1654        flags = flags | flag;1655      }1656    }1657    collectionOptions.flags = [flags];16581659    const creationResult = await this.helper.executeExtrinsic(1660      signer,1661      'api.tx.unique.createCollectionEx', [collectionOptions],1662      true, // errorLabel,1663    );1664    return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));1665  }16661667  getCollectionObject(_collectionId: number): any {1668    return null;1669  }16701671  getTokenObject(_collectionId: number, _tokenId: number): any {1672    return null;1673  }16741675  /**1676   * Tells whether the given `owner` approves the `operator`.1677   * @param collectionId ID of collection1678   * @param owner owner address1679   * @param operator operator addrees1680   * @returns true if operator is enabled1681   */1682  async allowanceForAll(collectionId: number, owner: ICrossAccountId, operator: ICrossAccountId): Promise<boolean> {1683    return (await this.helper.callRpc('api.rpc.unique.allowanceForAll', [collectionId, owner, operator])).toJSON();1684  }16851686  /** Sets or unsets the approval of a given operator.1687   *  The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1688   *  @param operator Operator1689   *  @param approved Should operator status be granted or revoked?1690   *  @returns ```true``` if extrinsic success, otherwise ```false```1691   */1692  async setAllowanceForAll(signer: TSigner, collectionId: number, operator: ICrossAccountId, approved: boolean): Promise<boolean> {1693    const result = await this.helper.executeExtrinsic(1694      signer,1695      'api.tx.unique.setAllowanceForAll', [collectionId, operator, approved],1696      true,1697    );1698    return this.helper.util.findCollectionInEvents(result.result.events, collectionId, 'common', 'ApprovedForAll');1699  }1700}170117021703class NFTGroup extends NFTnRFT {1704  /**1705   * Get collection object1706   * @param collectionId ID of collection1707   * @example getCollectionObject(2);1708   * @returns instance of UniqueNFTCollection1709   */1710  getCollectionObject(collectionId: number): UniqueNFTCollection {1711    return new UniqueNFTCollection(collectionId, this.helper);1712  }17131714  /**1715   * Get token object1716   * @param collectionId ID of collection1717   * @param tokenId ID of token1718   * @example getTokenObject(10, 5);1719   * @returns instance of UniqueNFTToken1720   */1721  getTokenObject(collectionId: number, tokenId: number): UniqueNFToken {1722    return new UniqueNFToken(tokenId, this.getCollectionObject(collectionId));1723  }17241725  /**1726   * Is token approved to transfer1727   * @param collectionId ID of collection1728   * @param tokenId ID of token1729   * @param toAccountObj address to be approved1730   * @returns ```true``` if extrinsic success, otherwise ```false```1731   */1732  async isTokenApproved(collectionId: number, tokenId: number, toAccountObj: ICrossAccountId): Promise<boolean> {1733    return (await this.getTokenApprovedPieces(collectionId, tokenId, toAccountObj, await this.getTokenOwner(collectionId, tokenId))) === 1n;1734  }17351736  /**1737   * Changes the owner of the token.1738   *1739   * @param signer keyring of signer1740   * @param collectionId ID of collection1741   * @param tokenId ID of token1742   * @param addressObj address of a new owner1743   * @example transferToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1744   * @returns ```true``` if extrinsic success, otherwise ```false```1745   */1746  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<boolean> {1747    return await super.transferToken(signer, collectionId, tokenId, addressObj, 1n);1748  }17491750  /**1751   *1752   * Change ownership of a NFT on behalf of the owner.1753   *1754   * @param signer keyring of signer1755   * @param collectionId ID of collection1756   * @param tokenId ID of token1757   * @param fromAddressObj address on behalf of which the token will be sent1758   * @param toAddressObj new token owner1759   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Ethereum: "0x9F0583DbB85..."})1760   * @returns ```true``` if extrinsic success, otherwise ```false```1761   */1762  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId): Promise<boolean> {1763    return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, 1n);1764  }17651766  /**1767   * Get tokens nested in the provided token1768   * @param collectionId ID of collection1769   * @param tokenId ID of token1770   * @param blockHashAt optionally query the data at the block with this hash1771   * @example getTokenChildren(10, 5);1772   * @returns tokens whose depth of nesting is <= 51773   */1774  async getTokenChildren(collectionId: number, tokenId: number, blockHashAt?: string): Promise<IToken[]> {1775    let children;1776    if(typeof blockHashAt === 'undefined') {1777      children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId]);1778    } else {1779      children = await this.helper.callRpc('api.rpc.unique.tokenChildren', [collectionId, tokenId, blockHashAt]);1780    }17811782    return children.toJSON().map((x: any) => ({collectionId: x.collection, tokenId: x.token}));1783  }17841785  /**1786   * Mint new collection1787   * @param signer keyring of signer1788   * @param collectionOptions Collection options1789   * @example1790   * mintCollection(aliceKeyring, {1791   *   name: 'New',1792   *   description: 'New collection',1793   *   tokenPrefix: 'NEW',1794   * })1795   * @returns object of the created collection1796   */1797  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueNFTCollection> {1798    return await super.mintCollection(signer, collectionOptions, 'NFT') as UniqueNFTCollection;1799  }18001801  /**1802   * Mint new token1803   * @param signer keyring of signer1804   * @param data token data1805   * @returns created token object1806   */1807  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; properties?: IProperty[]; }): Promise<UniqueNFToken> {1808    const creationResult = await this.helper.executeExtrinsic(1809      signer,1810      'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1811        NFT: {1812          properties: data.properties,1813        },1814      }],1815      true,1816    );1817    const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);1818    if(createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');1819    if(createdTokens.tokens.length < 1) throw Error('No tokens minted');1820    return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);1821  }18221823  /**1824   * Mint multiple NFT tokens1825   * @param signer keyring of signer1826   * @param collectionId ID of collection1827   * @param tokens array of tokens with owner and properties1828   * @example1829   * mintMultipleTokens(aliceKeyring, 10, [{1830   *     owner: {Substrate: "5DyN4Y92vZCjv38fg..."},1831   *     properties: [{key: "gender", value: "male"},{key: "age", value: "45"}],1832   *   },{1833   *     owner: {Ethereum: "0x9F0583DbB855d..."},1834   *     properties: [{key: "gender", value: "female"},{key: "age", value: "22"}],1835   * }]);1836   * @returns ```true``` if extrinsic success, otherwise ```false```1837   */1838  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: { owner: ICrossAccountId, properties?: IProperty[] }[]): Promise<UniqueNFToken[]> {1839    const creationResult = await this.helper.executeExtrinsic(1840      signer,1841      'api.tx.unique.createMultipleItemsEx', [collectionId, {NFT: tokens}],1842      true,1843    );1844    const collection = this.getCollectionObject(collectionId);1845    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1846  }18471848  /**1849   * Mint multiple NFT tokens with one owner1850   * @param signer keyring of signer1851   * @param collectionId ID of collection1852   * @param owner tokens owner1853   * @param tokens array of tokens with owner and properties1854   * @example1855   * mintMultipleTokensWithOneOwner(aliceKeyring, 10, "5DyN4Y92vZCjv38fg...", [{1856   *   properties: [{1857   *   key: "gender",1858   *   value: "female",1859   *  },{1860   *   key: "age",1861   *   value: "33",1862   *  }],1863   * }]);1864   * @returns array of newly created tokens1865   */1866  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: { properties?: IProperty[] }[]): Promise<UniqueNFToken[]> {1867    const rawTokens = [];1868    for(const token of tokens) {1869      const raw = {NFT: {properties: token.properties}};1870      rawTokens.push(raw);1871    }1872    const creationResult = await this.helper.executeExtrinsic(1873      signer,1874      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],1875      true,1876    );1877    const collection = this.getCollectionObject(collectionId);1878    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));1879  }18801881  /**1882   * Set, change, or remove approved address to transfer the ownership of the NFT.1883   *1884   * @param signer keyring of signer1885   * @param collectionId ID of collection1886   * @param tokenId ID of token1887   * @param toAddressObj address to approve1888   * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."})1889   * @returns ```true``` if extrinsic success, otherwise ```false```1890   */1891  approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount = 1n) {1892    return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);1893  }1894}189518961897class RFTGroup extends NFTnRFT {1898  /**1899   * Get collection object1900   * @param collectionId ID of collection1901   * @example getCollectionObject(2);1902   * @returns instance of UniqueRFTCollection1903   */1904  getCollectionObject(collectionId: number): UniqueRFTCollection {1905    return new UniqueRFTCollection(collectionId, this.helper);1906  }19071908  /**1909   * Get token object1910   * @param collectionId ID of collection1911   * @param tokenId ID of token1912   * @example getTokenObject(10, 5);1913   * @returns instance of UniqueNFTToken1914   */1915  getTokenObject(collectionId: number, tokenId: number): UniqueRFToken {1916    return new UniqueRFToken(tokenId, this.getCollectionObject(collectionId));1917  }19181919  /**1920   * Get top 10 token owners with the largest number of pieces1921   * @param collectionId ID of collection1922   * @param tokenId ID of token1923   * @example getTokenTop10Owners(10, 5);1924   * @returns array of top 10 owners1925   */1926  async getTokenTop10Owners(collectionId: number, tokenId: number): Promise<CrossAccountId[]> {1927    return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, tokenId])).toJSON().map(CrossAccountId.fromLowerCaseKeys);1928  }19291930  /**1931   * Get number of pieces owned by address1932   * @param collectionId ID of collection1933   * @param tokenId ID of token1934   * @param addressObj address token owner1935   * @example getTokenBalance(10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."});1936   * @returns number of pieces ownerd by address1937   */1938  async getTokenBalance(collectionId: number, tokenId: number, addressObj: ICrossAccountId): Promise<bigint> {1939    return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, tokenId])).toBigInt();1940  }19411942  /**1943   * Transfer pieces of token to another address1944   * @param signer keyring of signer1945   * @param collectionId ID of collection1946   * @param tokenId ID of token1947   * @param addressObj address of a new owner1948   * @param amount number of pieces to be transfered1949   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2000n)1950   * @returns ```true``` if extrinsic success, otherwise ```false```1951   */1952  async transferToken(signer: TSigner, collectionId: number, tokenId: number, addressObj: ICrossAccountId, amount = 1n): Promise<boolean> {1953    return await super.transferToken(signer, collectionId, tokenId, addressObj, amount);1954  }19551956  /**1957   * Change ownership of some pieces of RFT on behalf of the owner.1958   * @param signer keyring of signer1959   * @param collectionId ID of collection1960   * @param tokenId ID of token1961   * @param fromAddressObj address on behalf of which the token will be sent1962   * @param toAddressObj new token owner1963   * @param amount number of pieces to be transfered1964   * @example transferTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, {Substrate: "5DfhbVfww7ThF8q6f3i..."}, 2000n)1965   * @returns ```true``` if extrinsic success, otherwise ```false```1966   */1967  async transferTokenFrom(signer: TSigner, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount = 1n): Promise<boolean> {1968    return await super.transferTokenFrom(signer, collectionId, tokenId, fromAddressObj, toAddressObj, amount);1969  }19701971  /**1972   * Mint new collection1973   * @param signer keyring of signer1974   * @param collectionOptions Collection options1975   * @example1976   * mintCollection(aliceKeyring, {1977   *   name: 'New',1978   *   description: 'New collection',1979   *   tokenPrefix: 'NEW',1980   * })1981   * @returns object of the created collection1982   */1983  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}): Promise<UniqueRFTCollection> {1984    return await super.mintCollection(signer, collectionOptions, 'RFT') as UniqueRFTCollection;1985  }19861987  /**1988   * Mint new token1989   * @param signer keyring of signer1990   * @param data token data1991   * @example mintToken(aliceKeyring, {collectionId: 10, owner: {Substrate: '5GHoZe9c73RYbVzq...'}, pieces: 10000n});1992   * @returns created token object1993   */1994  async mintToken(signer: TSigner, data: { collectionId: number; owner: ICrossAccountId | string; pieces: bigint; properties?: IProperty[]; }): Promise<UniqueRFToken> {1995    const creationResult = await this.helper.executeExtrinsic(1996      signer,1997      'api.tx.unique.createItem', [data.collectionId, (typeof data.owner === 'string') ? {Substrate: data.owner} : data.owner, {1998        ReFungible: {1999          pieces: data.pieces,2000          properties: data.properties,2001        },2002      }],2003      true,2004    );2005    const createdTokens = this.helper.util.extractTokensFromCreationResult(creationResult);2006    if(createdTokens.tokens.length > 1) throw Error('Minted multiple tokens');2007    if(createdTokens.tokens.length < 1) throw Error('No tokens minted');2008    return this.getTokenObject(data.collectionId, createdTokens.tokens[0].tokenId);2009  }20102011  async mintMultipleTokens(signer: TSigner, collectionId: number, tokens: { owner: ICrossAccountId, pieces: bigint, properties?: IProperty[] }[]): Promise<UniqueRFToken[]> {2012    throw Error('Not implemented');2013    const creationResult = await this.helper.executeExtrinsic(2014      signer,2015      'api.tx.unique.createMultipleItemsEx', [collectionId, {RefungibleMultipleOwners: tokens}],2016      true, // `Unable to mint RFT tokens for ${label}`,2017    );2018    const collection = this.getCollectionObject(collectionId);2019    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));2020  }20212022  /**2023   * Mint multiple RFT tokens with one owner2024   * @param signer keyring of signer2025   * @param collectionId ID of collection2026   * @param owner tokens owner2027   * @param tokens array of tokens with properties and pieces2028   * @example mintMultipleTokensWithOneOwner(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, [{pieces: 100000n, properties: [{key: "gender", value: "male"}]}]);2029   * @returns array of newly created RFT tokens2030   */2031  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, owner: ICrossAccountId, tokens: { pieces: bigint, properties?: IProperty[] }[]): Promise<UniqueRFToken[]> {2032    const rawTokens = [];2033    for(const token of tokens) {2034      const raw = {ReFungible: {pieces: token.pieces, properties: token.properties}};2035      rawTokens.push(raw);2036    }2037    const creationResult = await this.helper.executeExtrinsic(2038      signer,2039      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],2040      true,2041    );2042    const collection = this.getCollectionObject(collectionId);2043    return this.helper.util.extractTokensFromCreationResult(creationResult).tokens.map((x: IToken) => collection.getTokenObject(x.tokenId));2044  }20452046  /**2047   * Destroys a concrete instance of RFT.2048   * @param signer keyring of signer2049   * @param collectionId ID of collection2050   * @param tokenId ID of token2051   * @param amount number of pieces to be burnt2052   * @example burnToken(aliceKeyring, 10, 5);2053   * @returns ```true``` if the extrinsic is successful, otherwise ```false```2054   */2055  async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount = 1n): Promise<boolean> {2056    return await super.burnToken(signer, collectionId, tokenId, amount);2057  }20582059  /**2060   * Destroys a concrete instance of RFT on behalf of the owner.2061   * @param signer keyring of signer2062   * @param collectionId ID of collection2063   * @param tokenId ID of token2064   * @param fromAddressObj address on behalf of which the token will be burnt2065   * @param amount number of pieces to be burnt2066   * @example burnTokenFrom(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}, 2n)2067   * @returns ```true``` if extrinsic success, otherwise ```false```2068   */2069  async burnTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, amount = 1n): Promise<boolean> {2070    return await super.burnTokenFrom(signer, collectionId, tokenId, fromAddressObj, amount);2071  }20722073  /**2074   * Set, change, or remove approved address to transfer the ownership of the RFT.2075   *2076   * @param signer keyring of signer2077   * @param collectionId ID of collection2078   * @param tokenId ID of token2079   * @param toAddressObj address to approve2080   * @param amount number of pieces to be approved2081   * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5GHoZe9c73RYbVzq..."}, "", 10000n);2082   * @returns true if the token success, otherwise false2083   */2084  approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount = 1n) {2085    return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount);2086  }20872088  /**2089   * Get total number of pieces2090   * @param collectionId ID of collection2091   * @param tokenId ID of token2092   * @example getTokenTotalPieces(10, 5);2093   * @returns number of pieces2094   */2095  async getTokenTotalPieces(collectionId: number, tokenId: number): Promise<bigint> {2096    return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, tokenId])).unwrap().toBigInt();2097  }20982099  /**2100   * Change number of token pieces. Signer must be the owner of all token pieces.2101   * @param signer keyring of signer2102   * @param collectionId ID of collection2103   * @param tokenId ID of token2104   * @param amount new number of pieces2105   * @example repartitionToken(aliceKeyring, 10, 5, 12345n);2106   * @returns true if the repartion was success, otherwise false2107   */2108  async repartitionToken(signer: TSigner, collectionId: number, tokenId: number, amount: bigint): Promise<boolean> {2109    const currentAmount = await this.getTokenTotalPieces(collectionId, tokenId);2110    const repartitionResult = await this.helper.executeExtrinsic(2111      signer,2112      'api.tx.unique.repartition', [collectionId, tokenId, amount],2113      true,2114    );2115    if(currentAmount < amount) return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemCreated');2116    return this.helper.util.findCollectionInEvents(repartitionResult.result.events, collectionId, 'common', 'ItemDestroyed');2117  }2118}211921202121class FTGroup extends CollectionGroup {2122  /**2123   * Get collection object2124   * @param collectionId ID of collection2125   * @example getCollectionObject(2);2126   * @returns instance of UniqueFTCollection2127   */2128  getCollectionObject(collectionId: number): UniqueFTCollection {2129    return new UniqueFTCollection(collectionId, this.helper);2130  }21312132  /**2133   * Mint new fungible collection2134   * @param signer keyring of signer2135   * @param collectionOptions Collection options2136   * @param decimalPoints number of token decimals2137   * @example2138   * mintCollection(aliceKeyring, {2139   *   name: 'New',2140   *   description: 'New collection',2141   *   tokenPrefix: 'NEW',2142   * }, 18)2143   * @returns newly created fungible collection2144   */2145  async mintCollection(signer: TSigner, collectionOptions: ICollectionCreationOptions = {}, decimalPoints = 0): Promise<UniqueFTCollection> {2146    collectionOptions = JSON.parse(JSON.stringify(collectionOptions)) as ICollectionCreationOptions; // Clone object2147    if(collectionOptions.tokenPropertyPermissions) throw Error('Fungible collections has no tokenPropertyPermissions');2148    collectionOptions.mode = {fungible: decimalPoints};2149    for(const key of ['name', 'description', 'tokenPrefix']) {2150      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);2151    }2152    const creationResult = await this.helper.executeExtrinsic(2153      signer,2154      'api.tx.unique.createCollectionEx', [collectionOptions],2155      true,2156    );2157    return this.getCollectionObject(this.helper.util.extractCollectionIdFromCreationResult(creationResult));2158  }21592160  /**2161   * Mint tokens2162   * @param signer keyring of signer2163   * @param collectionId ID of collection2164   * @param owner address owner of new tokens2165   * @param amount amount of tokens to be meanted2166   * @example mintTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq"}, 1000n);2167   * @returns ```true``` if extrinsic success, otherwise ```false```2168   */2169  async mintTokens(signer: TSigner, collectionId: number, amount: bigint, owner: ICrossAccountId | string): Promise<boolean> {2170    const creationResult = await this.helper.executeExtrinsic(2171      signer,2172      'api.tx.unique.createItem', [collectionId, (typeof owner === 'string') ? {Substrate: owner} : owner, {2173        Fungible: {2174          value: amount,2175        },2176      }],2177      true, // `Unable to mint fungible tokens for ${label}`,2178    );2179    return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2180  }21812182  /**2183   * Mint multiple Fungible tokens with one owner2184   * @param signer keyring of signer2185   * @param collectionId ID of collection2186   * @param owner tokens owner2187   * @param tokens array of tokens with properties and pieces2188   * @returns ```true``` if extrinsic success, otherwise ```false```2189   */2190  async mintMultipleTokensWithOneOwner(signer: TSigner, collectionId: number, tokens: { value: bigint }[], owner: ICrossAccountId): Promise<boolean> {2191    const rawTokens = [];2192    for(const token of tokens) {2193      const raw = {Fungible: {Value: token.value}};2194      rawTokens.push(raw);2195    }2196    const creationResult = await this.helper.executeExtrinsic(2197      signer,2198      'api.tx.unique.createMultipleItems', [collectionId, owner, rawTokens],2199      true,2200    );2201    return this.helper.util.findCollectionInEvents(creationResult.result.events, collectionId, 'common', 'ItemCreated');2202  }22032204  /**2205   * Get the top 10 owners with the largest balance for the Fungible collection2206   * @param collectionId ID of collection2207   * @example getTop10Owners(10);2208   * @returns array of ```ICrossAccountId```2209   */2210  async getTop10Owners(collectionId: number): Promise<CrossAccountId[]> {2211    return (await this.helper.callRpc('api.rpc.unique.tokenOwners', [collectionId, 0])).toJSON().map(CrossAccountId.fromLowerCaseKeys);2212  }22132214  /**2215   * Get account balance2216   * @param collectionId ID of collection2217   * @param addressObj address of owner2218   * @example getBalance(10, {Substrate: "5GHoZe9c73RYbVzq..."})2219   * @returns amount of fungible tokens owned by address2220   */2221  async getBalance(collectionId: number, addressObj: ICrossAccountId): Promise<bigint> {2222    return (await this.helper.callRpc('api.rpc.unique.balance', [collectionId, addressObj, 0])).toBigInt();2223  }22242225  /**2226   * Transfer tokens to address2227   * @param signer keyring of signer2228   * @param collectionId ID of collection2229   * @param toAddressObj address recipient2230   * @param amount amount of tokens to be sent2231   * @example transfer(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2232   * @returns ```true``` if extrinsic success, otherwise ```false```2233   */2234  async transfer(signer: TSigner, collectionId: number, toAddressObj: ICrossAccountId, amount = 1n) {2235    return await super.transferToken(signer, collectionId, 0, toAddressObj, amount);2236  }22372238  /**2239   * Transfer some tokens on behalf of the owner.2240   * @param signer keyring of signer2241   * @param collectionId ID of collection2242   * @param fromAddressObj address on behalf of which tokens will be sent2243   * @param toAddressObj address where token to be sent2244   * @param amount number of tokens to be sent2245   * @example transferFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, {Substrate: "5DfhbVfww7ThF8q6f3ij..."}, 10000n);2246   * @returns ```true``` if extrinsic success, otherwise ```false```2247   */2248  async transferFrom(signer: TSigner, collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount = 1n) {2249    return await super.transferTokenFrom(signer, collectionId, 0, fromAddressObj, toAddressObj, amount);2250  }22512252  /**2253   * Destroy some amount of tokens2254   * @param signer keyring of signer2255   * @param collectionId ID of collection2256   * @param amount amount of tokens to be destroyed2257   * @example burnTokens(aliceKeyring, 10, 1000n);2258   * @returns ```true``` if extrinsic success, otherwise ```false```2259   */2260  async burnTokens(signer: IKeyringPair, collectionId: number, amount = 1n): Promise<boolean> {2261    return await super.burnToken(signer, collectionId, 0, amount);2262  }22632264  /**2265   * Burn some tokens on behalf of the owner.2266   * @param signer keyring of signer2267   * @param collectionId ID of collection2268   * @param fromAddressObj address on behalf of which tokens will be burnt2269   * @param amount amount of tokens to be burnt2270   * @example burnTokensFrom(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n);2271   * @returns ```true``` if extrinsic success, otherwise ```false```2272   */2273  async burnTokensFrom(signer: IKeyringPair, collectionId: number, fromAddressObj: ICrossAccountId, amount = 1n): Promise<boolean> {2274    return await super.burnTokenFrom(signer, collectionId, 0, fromAddressObj, amount);2275  }22762277  /**2278   * Get total collection supply2279   * @param collectionId2280   * @returns2281   */2282  async getTotalPieces(collectionId: number): Promise<bigint> {2283    return (await this.helper.callRpc('api.rpc.unique.totalPieces', [collectionId, 0])).unwrap().toBigInt();2284  }22852286  /**2287   * Set, change, or remove approved address to transfer tokens.2288   *2289   * @param signer keyring of signer2290   * @param collectionId ID of collection2291   * @param toAddressObj address to be approved2292   * @param amount amount of tokens to be approved2293   * @example approveTokens(aliceKeyring, 10, {Substrate: "5GHoZe9c73RYbVzq..."}, 1000n)2294   * @returns ```true``` if extrinsic success, otherwise ```false```2295   */2296  approveTokens(signer: IKeyringPair, collectionId: number, toAddressObj: ICrossAccountId, amount = 1n) {2297    return super.approveToken(signer, collectionId, 0, toAddressObj, amount);2298  }22992300  /**2301   * Get amount of fungible tokens approved to transfer2302   * @param collectionId ID of collection2303   * @param fromAddressObj owner of tokens2304   * @param toAddressObj the address approved for the transfer of tokens on behalf of the owner2305   * @returns number of tokens approved for the transfer2306   */2307  getApprovedTokens(collectionId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {2308    return super.getTokenApprovedPieces(collectionId, 0, toAddressObj, fromAddressObj);2309  }2310}231123122313class ChainGroup extends HelperGroup<ChainHelperBase> {2314  /**2315   * Get system properties of a chain2316   * @example getChainProperties();2317   * @returns ss58Format, token decimals, and token symbol2318   */2319  getChainProperties(): IChainProperties {2320    const properties = (this.helper.getApi() as any).registry.getChainProperties().toJSON();2321    return {2322      ss58Format: properties.ss58Format.toJSON(),2323      tokenDecimals: properties.tokenDecimals.toJSON(),2324      tokenSymbol: properties.tokenSymbol.toJSON(),2325    };2326  }23272328  /**2329   * Get chain header2330   * @example getLatestBlockNumber();2331   * @returns the number of the last block2332   */2333  async getLatestBlockNumber(): Promise<number> {2334    return (await this.helper.callRpc('api.rpc.chain.getHeader')).number.toNumber();2335  }23362337  /**2338   * Get block hash by block number2339   * @param blockNumber number of block2340   * @example getBlockHashByNumber(12345);2341   * @returns hash of a block2342   */2343  async getBlockHashByNumber(blockNumber: number): Promise<string | null> {2344    const blockHash = (await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])).toJSON();2345    if(blockHash === '0x0000000000000000000000000000000000000000000000000000000000000000') return null;2346    return blockHash;2347  }23482349  // TODO add docs2350  async getBlock(blockHashOrNumber: string | number): Promise<IBlock | null> {2351    const blockHash = typeof blockHashOrNumber === 'string' ? blockHashOrNumber : await this.getBlockHashByNumber(blockHashOrNumber);2352    if(!blockHash) return null;2353    return (await this.helper.callRpc('api.rpc.chain.getBlock', [blockHash])).toHuman().block;2354  }23552356  /**2357   * Get latest relay block2358   * @returns {number} relay block2359   */2360  async getRelayBlockNumber(): Promise<bigint> {2361    const blockNumber = (await this.helper.callRpc('api.query.parachainSystem.validationData')).toJSON().relayParentNumber;2362    return BigInt(blockNumber);2363  }23642365  /**2366   * Get account nonce2367   * @param address substrate address2368   * @example getNonce("5GrwvaEF5zXb26Fz...");2369   * @returns number, account's nonce2370   */2371  async getNonce(address: TSubstrateAccount): Promise<number> {2372    return (await this.helper.callRpc('api.query.system.account', [address])).nonce.toNumber();2373  }2374}23752376class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2377  /**2378 * Get substrate address balance2379 * @param address substrate address2380 * @example getSubstrate("5GrwvaEF5zXb26Fz...")2381 * @returns amount of tokens on address2382 */2383  async getSubstrate(address: TSubstrateAccount): Promise<bigint> {2384    return (await this.helper.callRpc('api.query.system.account', [address])).data.free.toBigInt();2385  }23862387  /**2388   * Transfer tokens to substrate address2389   * @param signer keyring of signer2390   * @param address substrate address of a recipient2391   * @param amount amount of tokens to be transfered2392   * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2393   * @returns ```true``` if extrinsic success, otherwise ```false```2394   */2395  async transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2396    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}`*/);23972398    let transfer = {from: null, to: null, amount: 0n} as any;2399    result.result.events.forEach(({event: {data, method, section}}) => {2400      if((section === 'balances') && (method === 'Transfer')) {2401        transfer = {2402          from: this.helper.address.normalizeSubstrate(data[0]),2403          to: this.helper.address.normalizeSubstrate(data[1]),2404          amount: BigInt(data[2]),2405        };2406      }2407    });2408    const isSuccess = this.helper.address.normalizeSubstrate(typeof signer === 'string' ? signer : signer.address) === transfer.from2409      && this.helper.address.normalizeSubstrate(address) === transfer.to2410      && BigInt(amount) === transfer.amount;2411    return isSuccess;2412  }24132414  /**2415   * Get full substrate balance including free, frozen, and reserved2416   * @param address substrate address2417   * @returns2418   */2419  async getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2420    const accountInfo = (await this.helper.callRpc('api.query.system.account', [address])).data;2421    return {free: accountInfo.free.toBigInt(), frozen: accountInfo.frozen.toBigInt(), reserved: accountInfo.reserved.toBigInt()};2422  }24232424  /**2425   * Get total issuance2426   * @returns2427   */2428  async getTotalIssuance(): Promise<bigint> {2429    const total = (await this.helper.callRpc('api.query.balances.totalIssuance', []));2430    return total.toBigInt();2431  }24322433  async getLocked(address: TSubstrateAccount): Promise<{ id: string, amount: bigint, reason: string }[]> {2434    const locks = (await this.helper.callRpc('api.query.balances.locks', [address])).toHuman();2435    return locks.map((lock: any) => ({id: lock.id, amount: BigInt(lock.amount.replace(/,/g, '')), reasons: lock.reasons}));2436  }2437  async getFrozen(address: TSubstrateAccount): Promise<{ id: string, amount: bigint }[]> {2438    const locks = (await this.helper.api!.query.balances.freezes(address)) as unknown as Array<any>;2439    return locks.map(lock => ({id: lock.id.toUtf8(), amount: lock.amount.toBigInt()}));2440  }2441}24422443class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2444  /**2445   * Get ethereum address balance2446   * @param address ethereum address2447   * @example getEthereum("0x9F0583DbB855d...")2448   * @returns amount of tokens on address2449   */2450  async getEthereum(address: TEthereumAccount): Promise<bigint> {2451    return (await this.helper.callRpc('api.rpc.eth.getBalance', [address])).toBigInt();2452  }24532454  /**2455   * Transfer tokens to address2456   * @param signer keyring of signer2457   * @param address Ethereum address of a recipient2458   * @param amount amount of tokens to be transfered2459   * @example transferToEthereum(alithKeyring, "0x9F0583DbB855d...", 100_000_000_000n);2460   * @returns ```true``` if extrinsic success, otherwise ```false```2461   */2462  async transferToEthereum(signer: TSigner, address: TEthereumAccount, amount: bigint | string): Promise<boolean> {2463    const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.transfer', [address, amount], true);24642465    let transfer = {from: null, to: null, amount: 0n} as any;2466    result.result.events.forEach(({event: {data, method, section}}) => {2467      if((section === 'balances') && (method === 'Transfer')) {2468        transfer = {2469          from: data[0].toString(),2470          to: data[1].toString(),2471          amount: BigInt(data[2]),2472        };2473      }2474    });2475    const isSuccess = (typeof signer === 'string' ? signer : signer.address) === transfer.from2476      && address === transfer.to2477      && BigInt(amount) === transfer.amount;2478    return isSuccess;2479  }2480}24812482class BalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2483  subBalanceGroup: SubstrateBalanceGroup<T>;2484  ethBalanceGroup: EthereumBalanceGroup<T>;24852486  constructor(helper: T) {2487    super(helper);2488    this.subBalanceGroup = new SubstrateBalanceGroup(helper);2489    this.ethBalanceGroup = new EthereumBalanceGroup(helper);2490  }24912492  getCollectionCreationPrice(): bigint {2493    return 2n * this.getOneTokenNominal();2494  }2495  /**2496   * Representation of the native token in the smallest unit - one OPAL (OPL), QUARTZ (QTZ), or UNIQUE (UNQ).2497   * @example getOneTokenNominal()2498   * @returns ```BigInt``` representation of the native token in the smallest unit, e.g. ```1_000_000_000_000_000_000n``` for QTZ.2499   */2500  getOneTokenNominal(): bigint {2501    const chainProperties = this.helper.chain.getChainProperties();2502    return 10n ** BigInt((chainProperties.tokenDecimals || [18])[0]);2503  }25042505  /**2506   * Get substrate address balance2507   * @param address substrate address2508   * @example getSubstrate("5GrwvaEF5zXb26Fz...")2509   * @returns amount of tokens on address2510   */2511  getSubstrate(address: TSubstrateAccount): Promise<bigint> {2512    return this.subBalanceGroup.getSubstrate(address);2513  }25142515  /**2516   * Get full substrate balance including free, miscFrozen, feeFrozen, and reserved2517   * @param address substrate address2518   * @returns2519   */2520  getSubstrateFull(address: TSubstrateAccount): Promise<ISubstrateBalance> {2521    return this.subBalanceGroup.getSubstrateFull(address);2522  }25232524  /**2525   * Get total issuance2526   * @returns2527   */2528  getTotalIssuance(): Promise<bigint> {2529    return this.subBalanceGroup.getTotalIssuance();2530  }25312532  /**2533   * Get locked balances2534   * @param address substrate address2535   * @returns locked balances with reason via api.query.balances.locks2536   * @deprecated all the methods should switch to getFrozen2537   */2538  getLocked(address: TSubstrateAccount) {2539    return this.subBalanceGroup.getLocked(address);2540  }25412542  /**2543   * Get frozen balances2544   * @param address substrate address2545   * @returns frozen balances with id via api.query.balances.freezes2546   */2547  getFrozen(address: TSubstrateAccount) {2548    return this.subBalanceGroup.getFrozen(address);2549  }25502551  /**2552   * Get ethereum address balance2553   * @param address ethereum address2554   * @example getEthereum("0x9F0583DbB855d...")2555   * @returns amount of tokens on address2556   */2557  getEthereum(address: TEthereumAccount): Promise<bigint> {2558    return this.ethBalanceGroup.getEthereum(address);2559  }25602561  async setBalanceSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint) {2562    await this.helper.executeExtrinsic(signer, 'api.tx.balances.forceSetBalance', [address, amount], true);2563  }25642565  /**2566   * Transfer tokens to substrate address2567   * @param signer keyring of signer2568   * @param address substrate address of a recipient2569   * @param amount amount of tokens to be transfered2570   * @example transferToSubstrate(aliceKeyring, "5GrwvaEF5zXb26Fz...", 100_000_000_000n);2571   * @returns ```true``` if extrinsic success, otherwise ```false```2572   */2573  transferToSubstrate(signer: TSigner, address: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2574    return this.subBalanceGroup.transferToSubstrate(signer, address, amount);2575  }25762577  async forceTransferToSubstrate(signer: TSigner, from: TSubstrateAccount, to: TSubstrateAccount, amount: bigint | string): Promise<boolean> {2578    const result = await this.helper.executeExtrinsic(signer, 'api.tx.balances.forceTransfer', [from, to, amount], true);25792580    let transfer = {from: null, to: null, amount: 0n} as any;2581    result.result.events.forEach(({event: {data, method, section}}) => {2582      if((section === 'balances') && (method === 'Transfer')) {2583        transfer = {2584          from: this.helper.address.normalizeSubstrate(data[0]),2585          to: this.helper.address.normalizeSubstrate(data[1]),2586          amount: BigInt(data[2]),2587        };2588      }2589    });2590    let isSuccess = this.helper.address.normalizeSubstrate(from) === transfer.from;2591    isSuccess = isSuccess && this.helper.address.normalizeSubstrate(to) === transfer.to;2592    isSuccess = isSuccess && BigInt(amount) === transfer.amount;2593    return isSuccess;2594  }25952596  /**2597   * Transfer tokens with the unlock period2598   * @param signer signers Keyring2599   * @param address Substrate address of recipient2600   * @param schedule Schedule params2601   * @example vestedTransfer(signer, recepient.address, 20000, 100, 10, 50 * nominal); // total amount of vested tokens will be 100 * 50 = 50002602   */2603  async vestedTransfer(signer: TSigner, address: TSubstrateAccount, schedule: { start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint }): Promise<void> {2604    const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.vestedTransfer', [address, schedule]);2605    const event = result.result.events2606      .find(e => e.event.section === 'vesting' &&2607        e.event.method === 'VestingScheduleAdded' &&2608        e.event.data[0].toHuman() === signer.address);2609    if(!event) throw Error('Cannot find transfer in events');2610  }26112612  /**2613   * Get schedule for recepient of vested transfer2614   * @param address Substrate address of recipient2615   * @returns2616   */2617  async getVestingSchedules(address: TSubstrateAccount): Promise<{ start: bigint, period: bigint, periodCount: bigint, perPeriod: bigint }[]> {2618    const schedule = (await this.helper.callRpc('api.query.vesting.vestingSchedules', [address])).toJSON();2619    return schedule.map((schedule: any) => ({2620      start: BigInt(schedule.start),2621      period: BigInt(schedule.period),2622      periodCount: BigInt(schedule.periodCount),2623      perPeriod: BigInt(schedule.perPeriod),2624    }));2625  }26262627  /**2628   * Claim vested tokens2629   * @param signer signers Keyring2630   */2631  async claim(signer: TSigner) {2632    const result = await this.helper.executeExtrinsic(signer, 'api.tx.vesting.claim', []);2633    const event = result.result.events2634      .find(e => e.event.section === 'vesting' &&2635        e.event.method === 'Claimed' &&2636        e.event.data[0].toHuman() === signer.address);2637    if(!event) throw Error('Cannot find claim in events');2638  }2639}26402641class AddressGroup extends HelperGroup<ChainHelperBase> {2642  /**2643   * Normalizes the address to the specified ss58 format, by default ```42```.2644   * @param address substrate address2645   * @param ss58Format format for address conversion, by default ```42```2646   * @example normalizeSubstrate("unjKJQJrRd238pkUZZvzDQrfKuM39zBSnQ5zjAGAGcdRhaJTx") // returns 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY2647   * @returns substrate address converted to normalized (i.e., starting with 5) or specified explicitly representation2648   */2649  normalizeSubstrate(address: TSubstrateAccount, ss58Format = 42): TSubstrateAccount {2650    return CrossAccountId.normalizeSubstrateAddress(address, ss58Format);2651  }26522653  /**2654   * Get address in the connected chain format2655   * @param address substrate address2656   * @example normalizeSubstrateToChainFormat("5GrwvaEF5zXb26Fz...") // returns unjKJQJrRd238pkUZZ... for Unique Network2657   * @returns address in chain format2658   */2659  normalizeSubstrateToChainFormat(address: TSubstrateAccount): TSubstrateAccount {2660    return this.normalizeSubstrate(address, this.helper.chain.getChainProperties().ss58Format);2661  }26622663  /**2664   * Get substrate mirror of an ethereum address2665   * @param ethAddress ethereum address2666   * @param toChainFormat false for normalized account2667   * @example ethToSubstrate('0x9F0583DbB855d...')2668   * @returns substrate mirror of a provided ethereum address2669   */2670  ethToSubstrate(ethAddress: TEthereumAccount, toChainFormat = false): TSubstrateAccount {2671    return CrossAccountId.translateEthToSub(ethAddress, toChainFormat ? this.helper.chain.getChainProperties().ss58Format : undefined);2672  }26732674  /**2675   * Get ethereum mirror of a substrate address2676   * @param subAddress substrate account2677   * @example substrateToEth("5DnSF6RRjwteE3BrC...")2678   * @returns ethereum mirror of a provided substrate address2679   */2680  substrateToEth(subAddress: TSubstrateAccount): TEthereumAccount {2681    return CrossAccountId.translateSubToEth(subAddress);2682  }26832684  /**2685   * Encode key to substrate address2686   * @param key key for encoding address2687   * @param ss58Format prefix for encoding to the address of the corresponding network2688   * @returns encoded substrate address2689   */2690  encodeSubstrateAddress(key: Uint8Array | string | bigint, ss58Format = 42): string {2691    const u8a: Uint8Array = typeof key === 'string'2692      ? hexToU8a(key)2693      : typeof key === 'bigint'2694        ? hexToU8a(key.toString(16))2695        : key;26962697    if(ss58Format < 0 || ss58Format > 16383 || [46, 47].includes(ss58Format)) {2698      throw new Error(`ss58Format is not valid, received ${typeof ss58Format} "${ss58Format}"`);2699    }27002701    const allowedDecodedLengths = [1, 2, 4, 8, 32, 33];2702    if(!allowedDecodedLengths.includes(u8a.length)) {2703      throw new Error(`key length is not valid, received ${u8a.length}, valid values are ${allowedDecodedLengths.join(', ')}`);2704    }27052706    const u8aPrefix = ss58Format < 642707      ? new Uint8Array([ss58Format])2708      : new Uint8Array([2709        ((ss58Format & 0xfc) >> 2) | 0x40,2710        (ss58Format >> 8) | ((ss58Format & 0x03) << 6),2711      ]);27122713    const input = u8aConcat(u8aPrefix, u8a);27142715    return base58Encode(u8aConcat(2716      input,2717      blake2AsU8a(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1),2718    ));2719  }27202721  /**2722   * Restore substrate address from bigint representation2723   * @param number decimal representation of substrate address2724   * @returns substrate address2725   */2726  restoreCrossAccountFromBigInt(number: bigint): TSubstrateAccount {2727    if(this.helper.api === null) {2728      throw 'Not connected';2729    }2730    const res = this.helper.api.registry.createType('AccountId', '0x' + number.toString(16).padStart(64, '0')).toJSON();2731    if(res === undefined || res === null) {2732      throw 'Restore address error';2733    }2734    return res.toString();2735  }27362737  /**2738   * Convert etherium cross account id to substrate cross account id2739   * @param ethCrossAccount etherium cross account2740   * @returns substrate cross account id2741   */2742  convertCrossAccountFromEthCrossAccount(ethCrossAccount: IEthCrossAccountId): ICrossAccountId {2743    if(ethCrossAccount.sub === '0') {2744      return {Ethereum: ethCrossAccount.eth.toLocaleLowerCase()};2745    }27462747    const ss58 = this.restoreCrossAccountFromBigInt(BigInt(ethCrossAccount.sub));2748    return {Substrate: ss58};2749  }27502751  paraSiblingSovereignAccount(paraid: number) {2752    // We are getting a *sibling* parachain sovereign account,2753    // so we need a sibling prefix: encoded(b"sibl") == 0x7369626c2754    const siblingPrefix = '0x7369626c';27552756    const encodedParaId = this.helper.getApi().createType('u32', paraid).toHex(true).substring(2);2757    const suffix = '000000000000000000000000000000000000000000000000';27582759    return siblingPrefix + encodedParaId + suffix;2760  }2761}27622763class StakingGroup extends HelperGroup<UniqueHelper> {2764  /**2765   * Stake tokens for App Promotion2766   * @param signer keyring of signer2767   * @param amountToStake amount of tokens to stake2768   * @param label extra label for log2769   * @returns2770   */2771  async stake(signer: TSigner, amountToStake: bigint, label?: string): Promise<boolean> {2772    if(typeof label === 'undefined') label = `${signer.address} amount: ${amountToStake}`;2773    const _stakeResult = await this.helper.executeExtrinsic(2774      signer, 'api.tx.appPromotion.stake',2775      [amountToStake], true,2776    );2777    // TODO extract info from stakeResult2778    return true;2779  }27802781  /**2782   * Unstake all staked tokens2783   * @param signer keyring of signer2784   * @param amountToUnstake amount of tokens to unstake2785   * @param label extra label for log2786   * @returns block hash where unstake happened2787   */2788  async unstakeAll(signer: TSigner, label?: string): Promise<string> {2789    if(typeof label === 'undefined') label = `${signer.address}`;2790    const unstakeResult = await this.helper.executeExtrinsic(2791      signer, 'api.tx.appPromotion.unstakeAll',2792      [], true,2793    );2794    return unstakeResult.blockHash;2795  }27962797  /**2798   * Unstake the part of a staked tokens2799   * @param signer keyring of signer2800   * @param amount amount of tokens to unstake2801   * @param label extra label for log2802   * @returns block hash where unstake happened2803   */2804  async unstakePartial(signer: TSigner, amount: bigint, label?: string): Promise<string> {2805    if(typeof label === 'undefined') label = `${signer.address}`;2806    const unstakeResult = await this.helper.executeExtrinsic(2807      signer, 'api.tx.appPromotion.unstakePartial',2808      [amount], true,2809    );2810    return unstakeResult.blockHash;2811  }28122813  /**2814   * Get total number of active stakes2815   * @param address substrate address2816   * @returns {number}2817   */2818  async getStakesNumber(address: ICrossAccountId): Promise<number> {2819    if('Ethereum' in address) throw Error('only substrate address');2820    return (await this.helper.callRpc('api.query.appPromotion.stakesPerAccount', [address.Substrate])).toNumber();2821  }28222823  /**2824   * Get total staked amount for address2825   * @param address substrate or ethereum address2826   * @returns total staked amount2827   */2828  async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {2829    if(address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt();2830    return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();2831  }28322833  /**2834   * Get total staked per block2835   * @param address substrate or ethereum address2836   * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block2837   */2838  async getTotalStakedPerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2839    const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]);2840    return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => ({2841      block: block.toBigInt(),2842      amount: amount.toBigInt(),2843    }));2844  }28452846  /**2847   * Get total pending unstake amount for address2848   * @param address substrate or ethereum address2849   * @returns total pending unstake amount2850   */2851  async getPendingUnstake(address: ICrossAccountId): Promise<bigint> {2852    return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt();2853  }28542855  /**2856   * Get pending unstake amount per block for address2857   * @param address substrate or ethereum address2858   * @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 block2859   */2860  async getPendingUnstakePerBlock(address: ICrossAccountId): Promise<IStakingInfo[]> {2861    const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]);2862    const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => ({2863      block: block.toBigInt(),2864      amount: amount.toBigInt(),2865    }));2866    return result;2867  }2868}28692870class SchedulerGroup extends HelperGroup<UniqueHelper> {2871  constructor(helper: UniqueHelper) {2872    super(helper);2873  }28742875  cancelScheduled(signer: TSigner, scheduledId: string) {2876    return this.helper.executeExtrinsic(2877      signer,2878      'api.tx.scheduler.cancelNamed',2879      [scheduledId],2880      true,2881    );2882  }28832884  changePriority(signer: TSigner, scheduledId: string, priority: number) {2885    return this.helper.executeExtrinsic(2886      signer,2887      'api.tx.scheduler.changeNamedPriority',2888      [scheduledId, priority],2889      true,2890    );2891  }28922893  scheduleAt<T extends UniqueHelper>(2894    executionBlockNumber: number,2895    options: ISchedulerOptions = {},2896  ) {2897    return this.schedule<T>('schedule', executionBlockNumber, options);2898  }28992900  scheduleAfter<T extends UniqueHelper>(2901    blocksBeforeExecution: number,2902    options: ISchedulerOptions = {},2903  ) {2904    return this.schedule<T>('scheduleAfter', blocksBeforeExecution, options);2905  }29062907  schedule<T extends UniqueHelper>(2908    scheduleFn: 'schedule' | 'scheduleAfter',2909    blocksNum: number,2910    options: ISchedulerOptions = {},2911  ) {2912    // eslint-disable-next-line @typescript-eslint/naming-convention2913    const ScheduledHelperType = ScheduledUniqueHelper(this.helper.helperBase);2914    return this.helper.clone(ScheduledHelperType, {2915      scheduleFn,2916      blocksNum,2917      options,2918    }) as T;2919  }2920}29212922class CollatorSelectionGroup extends HelperGroup<UniqueHelper> {2923  //todo:collator documentation2924  addInvulnerable(signer: TSigner, address: string) {2925    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.addInvulnerable', [address]);2926  }29272928  removeInvulnerable(signer: TSigner, address: string) {2929    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.removeInvulnerable', [address]);2930  }29312932  async getInvulnerables(): Promise<string[]> {2933    return (await this.helper.callRpc('api.query.collatorSelection.invulnerables')).map((x: any) => x.toHuman());2934  }29352936  /** and also total max invulnerables */2937  maxCollators(): number {2938    return (this.helper.getApi().consts.configuration.defaultCollatorSelectionMaxCollators.toJSON() as number);2939  }29402941  async getDesiredCollators(): Promise<number> {2942    return (await this.helper.callRpc('api.query.configuration.collatorSelectionDesiredCollatorsOverride')).toNumber();2943  }29442945  setLicenseBond(signer: TSigner, amount: bigint) {2946    return this.helper.executeExtrinsic(signer, 'api.tx.configuration.setCollatorSelectionLicenseBond', [amount]);2947  }29482949  async getLicenseBond(): Promise<bigint> {2950    return (await this.helper.callRpc('api.query.configuration.collatorSelectionLicenseBondOverride')).toBigInt();2951  }29522953  obtainLicense(signer: TSigner) {2954    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.getLicense', []);2955  }29562957  releaseLicense(signer: TSigner) {2958    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.releaseLicense', []);2959  }29602961  forceReleaseLicense(signer: TSigner, released: string) {2962    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.forceReleaseLicense', [released]);2963  }29642965  async hasLicense(address: string): Promise<bigint> {2966    return (await this.helper.callRpc('api.query.collatorSelection.licenseDepositOf', [address])).toBigInt();2967  }29682969  onboard(signer: TSigner) {2970    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.onboard', []);2971  }29722973  offboard(signer: TSigner) {2974    return this.helper.executeExtrinsic(signer, 'api.tx.collatorSelection.offboard', []);2975  }29762977  async getCandidates(): Promise<string[]> {2978    return (await this.helper.callRpc('api.query.collatorSelection.candidates')).map((x: any) => x.toHuman());2979  }2980}29812982class CollectiveGroup extends HelperGroup<UniqueHelper> {2983  /**2984   * Pallet name to make an API call to. Examples: 'council', 'technicalCommittee'2985   */2986  private collective: string;29872988  constructor(helper: UniqueHelper, collective: string) {2989    super(helper);2990    this.collective = collective;2991  }29922993  /**2994   * Check the result of a proposal execution for the success of the underlying proposed extrinsic.2995   * @param events events of the proposal execution2996   * @returns proposal hash2997   */2998  private checkExecutedEvent(events: IPhasicEvent[]): string {2999    const executionEvents = events.filter(x =>3000      x.event.section === this.collective && (x.event.method === 'Executed' || x.event.method === 'MemberExecuted'));30013002    if(executionEvents.length != 1) {3003      if(events.filter(x => x.event.section === this.collective && x.event.method === 'Disapproved').length > 0)3004        throw new Error(`Disapproved by ${this.collective}`);3005      else3006        throw new Error(`Expected one 'Executed' or 'MemberExecuted' event for ${this.collective}`);3007    }30083009    const result = (executionEvents[0].event.data as any).result;30103011    if(result.isErr) {3012      if(result.asErr.isModule) {3013        const error = result.asErr.asModule;3014        const metaError = this.helper.getApi()?.registry.findMetaError(error);3015        throw new Error(`Proposal execution failed with ${metaError.section}.${metaError.name}`);3016      } else {3017        throw new Error('Proposal execution failed with ' + result.asErr.toHuman());3018      }3019    }30203021    return (executionEvents[0].event.data as any).proposalHash;3022  }30233024  /**3025   * Returns an array of members' addresses.3026   */3027  async getMembers() {3028    return (await this.helper.callRpc(`api.query.${this.collective}.members`, [])).toHuman();3029  }30303031  /**3032   * Returns the optional address of the prime member of the collective.3033   */3034  async getPrimeMember() {3035    return (await this.helper.callRpc(`api.query.${this.collective}.prime`, [])).toHuman();3036  }30373038  /**3039   * Returns an array of proposal hashes that are currently active for this collective.3040   */3041  async getProposals() {3042    return (await this.helper.callRpc(`api.query.${this.collective}.proposals`, [])).toHuman();3043  }30443045  /**3046   * Returns the call originally encoded under the specified hash.3047   * @param hash h256-encoded proposal3048   * @returns the optional call that the proposal hash stands for.3049   */3050  async getProposalCallOf(hash: string) {3051    return (await this.helper.callRpc(`api.query.${this.collective}.proposalOf`, [hash])).toHuman();3052  }30533054  /**3055   * Returns the total number of proposals so far.3056   */3057  async getTotalProposalsCount() {3058    return (await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, [])).toNumber();3059  }30603061  /**3062   * Creates a new proposal up for voting. If the threshold is set to 1, the proposal will be executed immediately.3063   * @param signer keyring of the proposer3064   * @param proposal constructed call to be executed if the proposal is successful3065   * @param voteThreshold minimal number of votes for the proposal to be verified and executed3066   * @param lengthBound byte length of the encoded call3067   * @returns promise of extrinsic execution and its result3068   */3069  async propose(signer: TSigner, proposal: any, voteThreshold: number, lengthBound = 10000) {3070    return await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [voteThreshold, proposal, lengthBound]);3071  }30723073  /**3074   * Casts a vote to either approve or reject a proposal.3075   * @param signer keyring of the voter3076   * @param proposalHash hash of the proposal to be voted for3077   * @param proposalIndex absolute index of the proposal used for absolutely nothing but throwing pointless errors3078   * @param approve aye or nay3079   * @returns promise of extrinsic execution and its result3080   */3081  vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {3082    return this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve]);3083  }30843085  /**3086   * Executes a call immediately as a member of the collective. Needed for the Member origin.3087   * @param signer keyring of the executor member3088   * @param proposal constructed call to be executed by the member3089   * @param lengthBound byte length of the encoded call3090   * @returns promise of extrinsic execution3091   */3092  async execute(signer: TSigner, proposal: any, lengthBound = 10000) {3093    const result = await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.execute`, [proposal, lengthBound]);3094    this.checkExecutedEvent(result.result.events);3095    return result;3096  }30973098  /**3099   * Attempt to close and execute a proposal. Note that there must already be enough votes to meet the threshold set when proposing.3100   * @param signer keyring of the executor. Can be absolutely anyone.3101   * @param proposalHash hash of the proposal to close3102   * @param proposalIndex index of the proposal generated on its creation3103   * @param weightBound weight of the proposed call. Can be obtained by calling `paymentInfo()` on the call.3104   * @param lengthBound byte length of the encoded call3105   * @returns promise of extrinsic execution and its result3106   */3107  async close(3108    signer: TSigner,3109    proposalHash: string,3110    proposalIndex: number,3111    weightBound: [number, number] | any = [20_000_000_000, 1000_000],3112    lengthBound = 10_000,3113  ) {3114    const result = await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [3115      proposalHash,3116      proposalIndex,3117      weightBound,3118      lengthBound,3119    ]);3120    this.checkExecutedEvent(result.result.events);3121    return result;3122  }31233124  /**3125   * Shut down a proposal, regardless of its current state.3126   * @param signer keyring of the disapprover. Must be root3127   * @param proposalHash hash of the proposal to close3128   * @returns promise of extrinsic execution and its result3129   */3130  disapproveProposal(signer: TSigner, proposalHash: string) {3131    return this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.disapproveProposal`, [proposalHash]);3132  }3133}31343135class CollectiveMembershipGroup extends HelperGroup<UniqueHelper> {3136  /**3137   * Pallet name to make an API call to. Examples: 'councilMembership', 'technicalCommitteeMembership'3138   */3139  private membership: string;31403141  constructor(helper: UniqueHelper, membership: string) {3142    super(helper);3143    this.membership = membership;3144  }31453146  /**3147   * Returns an array of members' addresses according to the membership pallet's perception.3148   * Note that it does not recognize the original pallet's members set with `setMembers()`.3149   */3150  async getMembers() {3151    return (await this.helper.callRpc(`api.query.${this.membership}.members`, [])).toHuman();3152  }31533154  /**3155   * Returns the optional address of the prime member of the collective.3156   */3157  async getPrimeMember() {3158    return (await this.helper.callRpc(`api.query.${this.membership}.prime`, [])).toHuman();3159  }31603161  /**3162   * Add a member to the collective.3163   * @param signer keyring of the setter. Must be root3164   * @param member address of the member to add3165   * @returns promise of extrinsic execution and its result3166   */3167  addMember(signer: TSigner, member: string) {3168    return this.helper.executeExtrinsic(signer, `api.tx.${this.membership}.addMember`, [member]);3169  }31703171  addMemberCall(member: string) {3172    return this.helper.constructApiCall(`api.tx.${this.membership}.addMember`, [member]);3173  }31743175  /**3176   * Remove a member from the collective.3177   * @param signer keyring of the setter. Must be root3178   * @param member address of the member to remove3179   * @returns promise of extrinsic execution and its result3180   */3181  removeMember(signer: TSigner, member: string) {3182    return this.helper.executeExtrinsic(signer, `api.tx.${this.membership}.removeMember`, [member]);3183  }31843185  removeMemberCall(member: string) {3186    return this.helper.constructApiCall(`api.tx.${this.membership}.removeMember`, [member]);3187  }31883189  /**3190   * Set members of the collective to the given list of addresses.3191   * @param signer keyring of the setter. Must be root (for the direct call, bypassing a public motion)3192   * @param members addresses of the members to set3193   * @returns promise of extrinsic execution and its result3194   */3195  resetMembers(signer: TSigner, members: string[]) {3196    return this.helper.executeExtrinsic(signer, `api.tx.${this.membership}.resetMembers`, [members]);3197  }31983199  /**3200   * Set the collective's prime member to the given address.3201   * @param signer keyring of the setter. Must be root (for the direct call, bypassing a public motion)3202   * @param prime address of the prime member of the collective3203   * @returns promise of extrinsic execution and its result3204   */3205  setPrime(signer: TSigner, prime: string) {3206    return this.helper.executeExtrinsic(signer, `api.tx.${this.membership}.setPrime`, [prime]);3207  }32083209  setPrimeCall(member: string) {3210    return this.helper.constructApiCall(`api.tx.${this.membership}.setPrime`, [member]);3211  }32123213  /**3214   * Remove the collective's prime member.3215   * @param signer keyring of the setter. Must be root (for the direct call, bypassing a public motion)3216   * @returns promise of extrinsic execution and its result3217   */3218  clearPrime(signer: TSigner) {3219    return this.helper.executeExtrinsic(signer, `api.tx.${this.membership}.clearPrime`, []);3220  }32213222  clearPrimeCall() {3223    return this.helper.constructApiCall(`api.tx.${this.membership}.clearPrime`, []);3224  }3225}32263227class RankedCollectiveGroup extends HelperGroup<UniqueHelper> {3228  /**3229   * Pallet name to make an API call to. Examples: 'FellowshipCollective'3230   */3231  private collective: string;32323233  constructor(helper: UniqueHelper, collective: string) {3234    super(helper);3235    this.collective = collective;3236  }32373238  addMember(signer: TSigner, newMember: string) {3239    return this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.addMember`, [newMember]);3240  }32413242  addMemberCall(newMember: string) {3243    return this.helper.constructApiCall(`api.tx.${this.collective}.addMember`, [newMember]);3244  }32453246  removeMember(signer: TSigner, member: string, minRank: number) {3247    return this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.removeMember`, [member, minRank]);3248  }32493250  removeMemberCall(newMember: string, minRank: number) {3251    return this.helper.constructApiCall(`api.tx.${this.collective}.removeMember`, [newMember, minRank]);3252  }32533254  promote(signer: TSigner, member: string) {3255    return this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.promoteMember`, [member]);3256  }32573258  promoteCall(newMember: string) {3259    return this.helper.constructApiCall(`api.tx.${this.collective}.promoteMember`, [newMember]);3260  }32613262  demote(signer: TSigner, member: string) {3263    return this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.demoteMember`, [member]);3264  }32653266  demoteCall(newMember: string) {3267    return this.helper.constructApiCall(`api.tx.${this.collective}.demoteMember`, [newMember]);3268  }32693270  vote(signer: TSigner, pollIndex: number, aye: boolean) {3271    return this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [pollIndex, aye]);3272  }32733274  async getMembers() {3275    return (await this.helper.getApi().query.fellowshipCollective.members.keys())3276      .map((key) => key.args[0].toString());3277  }3278}32793280class ReferendaGroup extends HelperGroup<UniqueHelper> {3281  /**3282   * Pallet name to make an API call to. Examples: 'FellowshipReferenda'3283   */3284  private referenda: string;32853286  constructor(helper: UniqueHelper, referenda: string) {3287    super(helper);3288    this.referenda = referenda;3289  }32903291  submit(3292    signer: TSigner,3293    proposalOrigin: string,3294    proposal: any,3295    enactmentMoment: any,3296  ) {3297    return this.helper.executeExtrinsic(signer, `api.tx.${this.referenda}.submit`, [3298      {Origins: proposalOrigin},3299      proposal,3300      enactmentMoment,3301    ]);3302  }33033304  placeDecisionDeposit(signer: TSigner, referendumIndex: number) {3305    return this.helper.executeExtrinsic(signer, `api.tx.${this.referenda}.placeDecisionDeposit`, [referendumIndex]);3306  }33073308  cancel(signer: TSigner, referendumIndex: number) {3309    return this.helper.executeExtrinsic(signer, `api.tx.${this.referenda}.cancel`, [referendumIndex]);3310  }33113312  cancelCall(referendumIndex: number) {3313    return this.helper.constructApiCall(`api.tx.${this.referenda}.cancel`, [referendumIndex]);3314  }33153316  async referendumInfo(referendumIndex: number) {3317    return (await this.helper.callRpc(`api.query.${this.referenda}.referendumInfoFor`, [referendumIndex])).toJSON();3318  }33193320  async enactmentEventId(referendumIndex: number) {3321    const api = await this.helper.getApi();33223323    const bytes = api.createType('([u8;8], Text, u32)', ['assembly', 'enactment', referendumIndex]).toU8a();3324    return blake2AsHex(bytes, 256);3325  }3326}33273328export interface IFellowshipGroup {3329  collective: RankedCollectiveGroup;3330  referenda: ReferendaGroup;3331}33323333export interface ICollectiveGroup {3334  collective: CollectiveGroup;3335  membership: CollectiveMembershipGroup;3336}33373338class DemocracyGroup extends HelperGroup<UniqueHelper> {3339  // todo displace proposal into types?3340  propose(signer: TSigner, call: any, deposit: bigint) {3341    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.propose', [{Inline: call.method.toHex()}, deposit]);3342  }33433344  proposeWithPreimage(signer: TSigner, preimage: string, deposit: bigint) {3345    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.propose', [{Legacy: preimage}, deposit]);3346  }33473348  proposeCall(call: any, deposit: bigint) {3349    return this.helper.constructApiCall('api.tx.democracy.propose', [{Inline: call.method.toHex()}, deposit]);3350  }33513352  second(signer: TSigner, proposalIndex: number) {3353    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.second', [proposalIndex]);3354  }33553356  externalPropose(signer: TSigner, proposalCall: any) {3357    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.externalPropose', [{Inline: proposalCall.method.toHex()}]);3358  }33593360  externalProposeMajority(signer: TSigner, proposalCall: any) {3361    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.externalProposeMajority', [{Inline: proposalCall.method.toHex()}]);3362  }33633364  externalProposeDefault(signer: TSigner, proposalCall: any) {3365    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.externalProposeDefault', [{Inline: proposalCall.method.toHex()}]);3366  }33673368  externalProposeDefaultWithPreimage(signer: TSigner, preimage: string) {3369    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.externalProposeDefault', [{Legacy: preimage}]);3370  }33713372  externalProposeCall(proposalCall: any) {3373    return this.helper.constructApiCall('api.tx.democracy.externalPropose', [{Inline: proposalCall.method.toHex()}]);3374  }33753376  externalProposeMajorityCall(proposalCall: any) {3377    return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [{Inline: proposalCall.method.toHex()}]);3378  }33793380  externalProposeDefaultCall(proposalCall: any) {3381    return this.helper.constructApiCall('api.tx.democracy.externalProposeDefault', [{Inline: proposalCall.method.toHex()}]);3382  }33833384  externalProposeDefaultWithPreimageCall(preimage: string) {3385    return this.helper.constructApiCall('api.tx.democracy.externalProposeDefault', [{Legacy: preimage}]);3386  }33873388  // ... and blacklist external proposal hash.3389  vetoExternal(signer: TSigner, proposalHash: string) {3390    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.vetoExternal', [proposalHash]);3391  }33923393  vetoExternalCall(proposalHash: string) {3394    return this.helper.constructApiCall('api.tx.democracy.vetoExternal', [proposalHash]);3395  }33963397  blacklist(signer: TSigner, proposalHash: string, referendumIndex: number | null = null) {3398    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.blacklist', [proposalHash, referendumIndex]);3399  }34003401  blacklistCall(proposalHash: string, referendumIndex: number | null = null) {3402    return this.helper.constructApiCall('api.tx.democracy.blacklist', [proposalHash, referendumIndex]);3403  }34043405  // proposal. CancelProposalOrigin (root or all techcom)3406  cancelProposal(signer: TSigner, proposalIndex: number) {3407    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.cancelProposal', [proposalIndex]);3408  }34093410  cancelProposalCall(proposalIndex: number) {3411    return this.helper.constructApiCall('api.tx.democracy.cancelProposal', [proposalIndex]);3412  }34133414  clearPublicProposals(signer: TSigner) {3415    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.clearPublicProposals', []);3416  }34173418  fastTrack(signer: TSigner, proposalHash: string, votingPeriod: number, delayPeriod: number) {3419    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);3420  }34213422  fastTrackCall(proposalHash: string, votingPeriod: number, delayPeriod: number) {3423    return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);3424  }34253426  // referendum. CancellationOrigin (TechCom member)3427  emergencyCancel(signer: TSigner, referendumIndex: number) {3428    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.emergencyCancel', [referendumIndex]);3429  }34303431  emergencyCancelCall(referendumIndex: number) {3432    return this.helper.constructApiCall('api.tx.democracy.emergencyCancel', [referendumIndex]);3433  }34343435  vote(signer: TSigner, referendumIndex: number, vote: any) {3436    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, vote]);3437  }34383439  removeVote(signer: TSigner, referendumIndex: number, targetAccount?: string) {3440    if(targetAccount) {3441      return this.helper.executeExtrinsic(signer, 'api.tx.democracy.removeOtherVote', [targetAccount, referendumIndex]);3442    } else {3443      return this.helper.executeExtrinsic(signer, 'api.tx.democracy.removeVote', [referendumIndex]);3444    }3445  }34463447  unlock(signer: TSigner, targetAccount: string) {3448    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.unlock', [targetAccount]);3449  }34503451  delegate(signer: TSigner, toAccount: string, conviction: PalletDemocracyConviction, balance: bigint) {3452    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.delegate', [toAccount, conviction, balance]);3453  }34543455  undelegate(signer: TSigner) {3456    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.undelegate', []);3457  }34583459  async referendumInfo(referendumIndex: number) {3460    return (await this.helper.callRpc('api.query.democracy.referendumInfoOf', [referendumIndex])).toJSON();3461  }34623463  async publicProposals() {3464    return (await this.helper.callRpc('api.query.democracy.publicProps', [])).toJSON();3465  }34663467  async findPublicProposal(proposalIndex: number) {3468    const proposalInfo = (await this.publicProposals()).find((proposalInfo: any[]) => proposalInfo[0] == proposalIndex);34693470    return proposalInfo ? proposalInfo[1] : null;3471  }34723473  async expectPublicProposal(proposalIndex: number) {3474    const proposal = await this.findPublicProposal(proposalIndex);34753476    if(proposal) {3477      return proposal;3478    } else {3479      throw Error(`Proposal #${proposalIndex} is expected to exist`);3480    }3481  }34823483  async getExternalProposal() {3484    return (await this.helper.callRpc('api.query.democracy.nextExternal', []));3485  }34863487  async expectExternalProposal() {3488    const proposal = await this.getExternalProposal();34893490    if(proposal) {3491      return proposal;3492    } else {3493      throw Error('An external proposal is expected to exist');3494    }3495  }34963497  /* setMetadata? */34983499  /* todo?3500  referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {3501    return this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);3502  }*/3503}35043505class PreimageGroup extends HelperGroup<UniqueHelper> {3506  async getPreimageInfo(h256: string) {3507    return (await this.helper.callRpc('api.query.preimage.statusFor', [h256])).toJSON();3508  }35093510  /**3511   * Create a preimage from an API call.3512   * @param signer keyring of the signer.3513   * @param call an extrinsic call3514   * @example await notePreimageFromCall(preimageMaker,3515   *   helper.constructApiCall('api.tx.identity.forceInsertIdentities', [identitiesToAdd])3516   * );3517   * @returns promise of extrinsic execution.3518   */3519  notePreimageFromCall(signer: TSigner, call: any, returnPreimageHash = false) {3520    return this.notePreimage(signer, call.method.toHex(), returnPreimageHash);3521  }35223523  /**3524   * Create a preimage with a hex or a byte array.3525   * @param signer keyring of the signer.3526   * @param bytes preimage encoded in hex or a byte array, e.g. an extrinsic call.3527   * @example await notePreimage(preimageMaker,3528   *   helper.constructApiCall('api.tx.identity.forceInsertIdentities', [identitiesToAdd]).method.toHex()3529   * );3530   * @returns promise of extrinsic execution.3531   */3532  async notePreimage(signer: TSigner, bytes: string | Uint8Array, returnPreimageHash = false) {3533    const promise = this.helper.executeExtrinsic(signer, 'api.tx.preimage.notePreimage', [bytes]);3534    if(returnPreimageHash) {3535      const result = await promise;3536      const events = result.result.events.filter(x => x.event.method === 'Noted' && x.event.section === 'preimage');3537      const preimageHash = events[0].event.data[0].toHuman();3538      return preimageHash;3539    }3540    return promise;3541  }35423543  /**3544   * Delete an existing preimage and return the deposit.3545   * @param signer keyring of the signer - either the owner or the preimage manager (sudo).3546   * @param h256 hash of the preimage.3547   * @returns promise of extrinsic execution.3548   */3549  unnotePreimage(signer: TSigner, h256: string) {3550    return this.helper.executeExtrinsic(signer, 'api.tx.preimage.unnotePreimage', [h256]);3551  }35523553  /**3554   * Request a preimage be uploaded to the chain without paying any fees or deposits.3555   * @param signer keyring of the signer - either the owner or the preimage manager (sudo).3556   * @param h256 hash of the preimage.3557   * @returns promise of extrinsic execution.3558   */3559  requestPreimage(signer: TSigner, h256: string) {3560    return this.helper.executeExtrinsic(signer, 'api.tx.preimage.requestPreimage', [h256]);3561  }35623563  /**3564   * Clear a previously made request for a preimage.3565   * @param signer keyring of the signer - either the owner or the preimage manager (sudo).3566   * @param h256 hash of the preimage.3567   * @returns promise of extrinsic execution.3568   */3569  unrequestPreimage(signer: TSigner, h256: string) {3570    return this.helper.executeExtrinsic(signer, 'api.tx.preimage.unrequestPreimage', [h256]);3571  }3572}35733574class ForeignAssetsGroup extends HelperGroup<UniqueHelper> {3575  async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {3576    await this.helper.executeExtrinsic(3577      signer,3578      'api.tx.foreignAssets.registerForeignAsset',3579      [ownerAddress, location, metadata],3580      true,3581    );3582  }35833584  async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {3585    await this.helper.executeExtrinsic(3586      signer,3587      'api.tx.foreignAssets.updateForeignAsset',3588      [foreignAssetId, location, metadata],3589      true,3590    );3591  }3592}35933594class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {3595  palletName: string;35963597  constructor(helper: T, palletName: string) {3598    super(helper);35993600    this.palletName = palletName;3601  }36023603  async limitedReserveTransferAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number, weightLimit: any) {3604    await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.limitedReserveTransferAssets`, [destination, beneficiary, assets, feeAssetItem, weightLimit], true);3605  }36063607  async setSafeXcmVersion(signer: TSigner, version: number) {3608    await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.forceDefaultXcmVersion`, [version], true);3609  }36103611  async teleportAssets(signer: TSigner, destination: any, beneficiary: any, assets: any, feeAssetItem: number) {3612    await this.helper.executeExtrinsic(signer, `api.tx.${this.palletName}.teleportAssets`, [destination, beneficiary, assets, feeAssetItem], true);3613  }36143615  async teleportNativeAsset(signer: TSigner, destinationParaId: number, targetAccount: Uint8Array, amount: bigint, xcmVersion = 3) {3616    const destinationContent = {3617      parents: 0,3618      interior: {3619        X1: {3620          Parachain: destinationParaId,3621        },3622      },3623    };36243625    const beneficiaryContent = {3626      parents: 0,3627      interior: {3628        X1: {3629          AccountId32: {3630            network: 'Any',3631            id: targetAccount,3632          },3633        },3634      },3635    };36363637    const assetsContent = [3638      {3639        id: {3640          Concrete: {3641            parents: 0,3642            interior: 'Here',3643          },3644        },3645        fun: {3646          Fungible: amount,3647        },3648      },3649    ];36503651    let destination;3652    let beneficiary;3653    let assets;36543655    if(xcmVersion == 2) {3656      destination = {V1: destinationContent};3657      beneficiary = {V1: beneficiaryContent};3658      assets = {V1: assetsContent};36593660    } else if(xcmVersion == 3) {3661      destination = {V2: destinationContent};3662      beneficiary = {V2: beneficiaryContent};3663      assets = {V2: assetsContent};36643665    } else {3666      throw Error('Unknown XCM version: ' + xcmVersion);3667    }36683669    const feeAssetItem = 0;36703671    await this.teleportAssets(signer, destination, beneficiary, assets, feeAssetItem);3672  }36733674  async send(signer: IKeyringPair, destination: any, message: any) {3675    await this.helper.executeExtrinsic(3676      signer,3677      `api.tx.${this.palletName}.send`,3678      [3679        destination,3680        message,3681      ],3682      true,3683    );3684  }3685}36863687class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {3688  async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: any) {3689    await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);3690  }36913692  async transferMultiasset(signer: TSigner, asset: any, destination: any, destWeight: any) {3693    await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMultiasset', [asset, destination, destWeight], true);3694  }36953696  async transferMulticurrencies(signer: TSigner, currencies: any[], feeItem: number, destLocation: any, destWeight: any) {3697    await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transferMulticurrencies', [currencies, feeItem, destLocation, destWeight], true);3698  }3699}37003701class PolkadexXcmHelperGroup<T extends ChainHelperBase> extends HelperGroup<T> {3702  async whitelistToken(signer: TSigner, assetId: any) {3703    await this.helper.executeExtrinsic(signer, 'api.tx.xcmHelper.whitelistToken', [assetId], true);3704  }3705}37063707class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {3708  async accounts(address: string, currencyId: any) {3709    const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;3710    return BigInt(free);3711  }3712}37133714class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {3715  async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {3716    await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);3717  }37183719  async setMetadata(signer: TSigner, assetId: number, name: string, symbol: string, decimals: number) {3720    await this.helper.executeExtrinsic(signer, 'api.tx.assets.setMetadata', [assetId, name, symbol, decimals], true);3721  }37223723  async mint(signer: TSigner, assetId: number, beneficiary: string, amount: bigint) {3724    await this.helper.executeExtrinsic(signer, 'api.tx.assets.mint', [assetId, beneficiary, amount], true);3725  }37263727  async account(assetId: string | number, address: string) {3728    const accountAsset = (3729      await this.helper.callRpc('api.query.assets.account', [assetId, address])3730    ).toJSON()! as any;37313732    if(accountAsset !== null) {3733      return BigInt(accountAsset['balance']);3734    } else {3735      return null;3736    }3737  }3738}37393740class UtilityGroup<T extends ChainHelperBase> extends HelperGroup<T> {3741  async batch(signer: TSigner, txs: any[]) {3742    return await this.helper.executeExtrinsic(signer, 'api.tx.utility.batch', [txs]);3743  }37443745  async batchAll(signer: TSigner, txs: any[]) {3746    return await this.helper.executeExtrinsic(signer, 'api.tx.utility.batchAll', [txs]);3747  }37483749  batchAllCall(txs: any[]) {3750    return this.helper.constructApiCall('api.tx.utility.batchAll', [txs]);3751  }3752}37533754class AcalaAssetRegistryGroup extends HelperGroup<AcalaHelper> {3755  async registerForeignAsset(signer: TSigner, destination: any, metadata: AcalaAssetMetadata) {3756    await this.helper.executeExtrinsic(signer, 'api.tx.assetRegistry.registerForeignAsset', [destination, metadata], true);3757  }3758}37593760class MoonbeamAssetManagerGroup extends HelperGroup<MoonbeamHelper> {3761  makeRegisterForeignAssetProposal(assetInfo: MoonbeamAssetInfo) {3762    const apiPrefix = 'api.tx.assetManager.';37633764    const registerTx = this.helper.constructApiCall(3765      apiPrefix + 'registerForeignAsset',3766      [assetInfo.location, assetInfo.metadata, assetInfo.existentialDeposit, assetInfo.isSufficient],3767    );37683769    const setUnitsTx = this.helper.constructApiCall(3770      apiPrefix + 'setAssetUnitsPerSecond',3771      [assetInfo.location, assetInfo.unitsPerSecond, assetInfo.numAssetsWeightHint],3772    );37733774    const batchCall = this.helper.getApi().tx.utility.batchAll([registerTx, setUnitsTx]);3775    const encodedProposal = batchCall?.method.toHex() || '';3776    return encodedProposal;3777  }37783779  async assetTypeId(location: any) {3780    return await this.helper.callRpc('api.query.assetManager.assetTypeId', [location]);3781  }3782}37833784class MoonbeamDemocracyGroup extends HelperGroup<MoonbeamHelper> {3785  notePreimagePallet: string;37863787  constructor(helper: MoonbeamHelper, options: { [key: string]: any } = {}) {3788    super(helper);3789    this.notePreimagePallet = options.notePreimagePallet;3790  }37913792  async notePreimage(signer: TSigner, encodedProposal: string) {3793    await this.helper.executeExtrinsic(signer, `api.tx.${this.notePreimagePallet}.notePreimage`, [encodedProposal], true);3794  }37953796  externalProposeMajority(proposal: any) {3797    return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposal]);3798  }37993800  fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {3801    return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);3802  }38033804  async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {3805    await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);3806  }3807}38083809class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {3810  collective: string;38113812  constructor(helper: MoonbeamHelper, collective: string) {3813    super(helper);38143815    this.collective = collective;3816  }38173818  async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {3819    await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);3820  }38213822  async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {3823    await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);3824  }38253826  async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: any, lengthBound: number) {3827    await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);3828  }38293830  async proposalCount() {3831    return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));3832  }3833}38343835export type ChainHelperBaseConstructor = new (...args: any[]) => ChainHelperBase;3836export type UniqueHelperConstructor = new (...args: any[]) => UniqueHelper;38373838export class UniqueHelper extends ChainHelperBase {3839  balance: BalanceGroup<UniqueHelper>;3840  collection: CollectionGroup;3841  nft: NFTGroup;3842  rft: RFTGroup;3843  ft: FTGroup;3844  staking: StakingGroup;3845  scheduler: SchedulerGroup;3846  collatorSelection: CollatorSelectionGroup;3847  council: ICollectiveGroup;3848  technicalCommittee: ICollectiveGroup;3849  fellowship: IFellowshipGroup;3850  democracy: DemocracyGroup;3851  preimage: PreimageGroup;3852  foreignAssets: ForeignAssetsGroup;3853  xcm: XcmGroup<UniqueHelper>;3854  xTokens: XTokensGroup<UniqueHelper>;3855  tokens: TokensGroup<UniqueHelper>;3856  utility: UtilityGroup<UniqueHelper>;38573858  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {3859    super(logger, options.helperBase ?? UniqueHelper);38603861    this.balance = new BalanceGroup(this);3862    this.collection = new CollectionGroup(this);3863    this.nft = new NFTGroup(this);3864    this.rft = new RFTGroup(this);3865    this.ft = new FTGroup(this);3866    this.staking = new StakingGroup(this);3867    this.scheduler = new SchedulerGroup(this);3868    this.collatorSelection = new CollatorSelectionGroup(this);3869    this.council = {3870      collective: new CollectiveGroup(this, 'council'),3871      membership: new CollectiveMembershipGroup(this, 'councilMembership'),3872    };3873    this.technicalCommittee = {3874      collective: new CollectiveGroup(this, 'technicalCommittee'),3875      membership: new CollectiveMembershipGroup(this, 'technicalCommitteeMembership'),3876    };3877    this.fellowship = {3878      collective: new RankedCollectiveGroup(this, 'fellowshipCollective'),3879      referenda: new ReferendaGroup(this, 'fellowshipReferenda'),3880    };3881    this.democracy = new DemocracyGroup(this);3882    this.preimage = new PreimageGroup(this);3883    this.foreignAssets = new ForeignAssetsGroup(this);3884    this.xcm = new XcmGroup(this, 'polkadotXcm');3885    this.xTokens = new XTokensGroup(this);3886    this.tokens = new TokensGroup(this);3887    this.utility = new UtilityGroup(this);3888  }38893890  getSudo<T extends UniqueHelper>() {3891    // eslint-disable-next-line @typescript-eslint/naming-convention3892    const SudoHelperType = SudoHelper(this.helperBase);3893    return this.clone(SudoHelperType) as T;3894  }3895}38963897export class XcmChainHelper extends ChainHelperBase {3898  async connect(wsEndpoint: string, _listeners?: any): Promise<void> {3899    const wsProvider = new WsProvider(wsEndpoint);3900    this.api = new ApiPromise({3901      provider: wsProvider,3902    });3903    await this.api.isReadyOrError;3904    this.network = await UniqueHelper.detectNetwork(this.api);3905  }3906}39073908export class RelayHelper extends XcmChainHelper {3909  balance: SubstrateBalanceGroup<RelayHelper>;3910  xcm: XcmGroup<RelayHelper>;39113912  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {3913    super(logger, options.helperBase ?? RelayHelper);39143915    this.balance = new SubstrateBalanceGroup(this);3916    this.xcm = new XcmGroup(this, 'xcmPallet');3917  }3918}39193920export class WestmintHelper extends XcmChainHelper {3921  balance: SubstrateBalanceGroup<WestmintHelper>;3922  xcm: XcmGroup<WestmintHelper>;3923  assets: AssetsGroup<WestmintHelper>;3924  xTokens: XTokensGroup<WestmintHelper>;39253926  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {3927    super(logger, options.helperBase ?? WestmintHelper);39283929    this.balance = new SubstrateBalanceGroup(this);3930    this.xcm = new XcmGroup(this, 'polkadotXcm');3931    this.assets = new AssetsGroup(this);3932    this.xTokens = new XTokensGroup(this);3933  }3934}39353936export class MoonbeamHelper extends XcmChainHelper {3937  balance: EthereumBalanceGroup<MoonbeamHelper>;3938  assetManager: MoonbeamAssetManagerGroup;3939  assets: AssetsGroup<MoonbeamHelper>;3940  xTokens: XTokensGroup<MoonbeamHelper>;3941  democracy: MoonbeamDemocracyGroup;3942  collective: {3943    council: MoonbeamCollectiveGroup,3944    techCommittee: MoonbeamCollectiveGroup,3945  };39463947  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {3948    super(logger, options.helperBase ?? MoonbeamHelper);39493950    this.balance = new EthereumBalanceGroup(this);3951    this.assetManager = new MoonbeamAssetManagerGroup(this);3952    this.assets = new AssetsGroup(this);3953    this.xTokens = new XTokensGroup(this);3954    this.democracy = new MoonbeamDemocracyGroup(this, options);3955    this.collective = {3956      council: new MoonbeamCollectiveGroup(this, 'councilCollective'),3957      techCommittee: new MoonbeamCollectiveGroup(this, 'techCommitteeCollective'),3958    };3959  }3960}39613962export class AstarHelper extends XcmChainHelper {3963  balance: SubstrateBalanceGroup<AstarHelper>;3964  assets: AssetsGroup<AstarHelper>;3965  xcm: XcmGroup<AstarHelper>;39663967  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {3968    super(logger, options.helperBase ?? AstarHelper);39693970    this.balance = new SubstrateBalanceGroup(this);3971    this.assets = new AssetsGroup(this);3972    this.xcm = new XcmGroup(this, 'polkadotXcm');3973  }39743975  getSudo<T extends UniqueHelper>() {3976    // eslint-disable-next-line @typescript-eslint/naming-convention3977    const SudoHelperType = SudoHelper(this.helperBase);3978    return this.clone(SudoHelperType) as T;3979  }3980}39813982export class AcalaHelper extends XcmChainHelper {3983  balance: SubstrateBalanceGroup<AcalaHelper>;3984  assetRegistry: AcalaAssetRegistryGroup;3985  xTokens: XTokensGroup<AcalaHelper>;3986  tokens: TokensGroup<AcalaHelper>;3987  xcm: XcmGroup<AcalaHelper>;39883989  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {3990    super(logger, options.helperBase ?? AcalaHelper);39913992    this.balance = new SubstrateBalanceGroup(this);3993    this.assetRegistry = new AcalaAssetRegistryGroup(this);3994    this.xTokens = new XTokensGroup(this);3995    this.tokens = new TokensGroup(this);3996    this.xcm = new XcmGroup(this, 'polkadotXcm');3997  }39983999  getSudo<T extends AcalaHelper>() {4000    // eslint-disable-next-line @typescript-eslint/naming-convention4001    const SudoHelperType = SudoHelper(this.helperBase);4002    return this.clone(SudoHelperType) as T;4003  }4004}40054006export class PolkadexHelper extends XcmChainHelper {4007  assets: AssetsGroup<PolkadexHelper>;4008  balance: SubstrateBalanceGroup<PolkadexHelper>;4009  xTokens: XTokensGroup<PolkadexHelper>;4010  xcm: XcmGroup<PolkadexHelper>;4011  xcmHelper: PolkadexXcmHelperGroup<PolkadexHelper>;40124013  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {4014    super(logger, options.helperBase ?? PolkadexHelper);40154016    this.assets = new AssetsGroup(this);4017    this.balance = new SubstrateBalanceGroup(this);4018    this.xTokens = new XTokensGroup(this);4019    this.xcm = new XcmGroup(this, 'polkadotXcm');4020    this.xcmHelper = new PolkadexXcmHelperGroup(this);4021  }40224023  getSudo<T extends PolkadexHelper>() {4024    // eslint-disable-next-line @typescript-eslint/naming-convention4025    const SudoHelperType = SudoHelper(this.helperBase);4026    return this.clone(SudoHelperType) as T;4027  }4028}40294030// eslint-disable-next-line @typescript-eslint/naming-convention4031function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {4032  return class extends Base {4033    scheduleFn: 'schedule' | 'scheduleAfter';4034    blocksNum: number;4035    options: ISchedulerOptions;40364037    constructor(...args: any[]) {4038      const logger = args[0] as ILogger;4039      const options = args[1] as {4040        scheduleFn: 'schedule' | 'scheduleAfter',4041        blocksNum: number,4042        options: ISchedulerOptions4043      };40444045      super(logger);40464047      this.scheduleFn = options.scheduleFn;4048      this.blocksNum = options.blocksNum;4049      this.options = options.options;4050    }40514052    executeExtrinsic(sender: IKeyringPair, scheduledExtrinsic: string, scheduledParams: any[], expectSuccess?: boolean): Promise<ITransactionResult> {4053      const scheduledTx = this.constructApiCall(scheduledExtrinsic, scheduledParams);40544055      const mandatorySchedArgs = [4056        this.blocksNum,4057        this.options.periodic ? [this.options.periodic.period, this.options.periodic.repetitions] : null,4058        this.options.priority ?? null,4059        scheduledTx,4060      ];40614062      let schedArgs;4063      let scheduleFn;40644065      if(this.options.scheduledId) {4066        schedArgs = [this.options.scheduledId!, ...mandatorySchedArgs];40674068        if(this.scheduleFn == 'schedule') {4069          scheduleFn = 'scheduleNamed';4070        } else if(this.scheduleFn == 'scheduleAfter') {4071          scheduleFn = 'scheduleNamedAfter';4072        }4073      } else {4074        schedArgs = mandatorySchedArgs;4075        scheduleFn = this.scheduleFn;4076      }40774078      const extrinsic = 'api.tx.scheduler.' + scheduleFn;40794080      return super.executeExtrinsic(4081        sender,4082        extrinsic as any,4083        schedArgs,4084        expectSuccess,4085      );4086    }4087  };4088}40894090// eslint-disable-next-line @typescript-eslint/naming-convention4091function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {4092  return class extends Base {4093    constructor(...args: any[]) {4094      super(...args);4095    }40964097    async executeExtrinsic(4098      sender: IKeyringPair,4099      extrinsic: string,4100      params: any[],4101      expectSuccess?: boolean,4102      options: Partial<SignerOptions> | null = null,4103    ): Promise<ITransactionResult> {4104      const call = this.constructApiCall(extrinsic, params);4105      const result = await super.executeExtrinsic(4106        sender,4107        'api.tx.sudo.sudo',4108        [call],4109        expectSuccess,4110        options,4111      );41124113      if(result.status === 'Fail') return result;41144115      const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;4116      if(data.isErr) {4117        if(data.asErr.isModule) {4118          const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;4119          const metaError = super.getApi()?.registry.findMetaError(error);4120          throw new Error(`${metaError.section}.${metaError.name}`);4121        } else if(data.asErr.isToken) {4122          throw new Error(`Token: ${data.asErr.asToken}`);4123        }4124        // May be [object Object] in case of unhandled non-unit enum4125        throw new Error(`Misc: ${data.asErr.toHuman()}`);4126      }4127      return result;4128    }4129    async executeExtrinsicUncheckedWeight(4130      sender: IKeyringPair,4131      extrinsic: string,4132      params: any[],4133      expectSuccess?: boolean,4134      options: Partial<SignerOptions> | null = null,4135    ): Promise<ITransactionResult> {4136      const call = this.constructApiCall(extrinsic, params);4137      const result = await super.executeExtrinsic(4138        sender,4139        'api.tx.sudo.sudoUncheckedWeight',4140        [call, {refTime: 0, proofSize: 0}],4141        expectSuccess,4142        options,4143      );41444145      if(result.status === 'Fail') return result;41464147      const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;4148      if(data.isErr) {4149        if(data.asErr.isModule) {4150          const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;4151          const metaError = super.getApi()?.registry.findMetaError(error);4152          throw new Error(`${metaError.section}.${metaError.name}`);4153        } else if(data.asErr.isToken) {4154          throw new Error(`Token: ${data.asErr.asToken}`);4155        }4156        // May be [object Object] in case of unhandled non-unit enum4157        throw new Error(`Misc: ${data.asErr.toHuman()}`);4158      }4159      return result;4160    }4161  };4162}41634164export class UniqueBaseCollection {4165  helper: UniqueHelper;4166  collectionId: number;41674168  constructor(collectionId: number, uniqueHelper: UniqueHelper) {4169    this.collectionId = collectionId;4170    this.helper = uniqueHelper;4171  }41724173  async getData() {4174    return await this.helper.collection.getData(this.collectionId);4175  }41764177  async getLastTokenId() {4178    return await this.helper.collection.getLastTokenId(this.collectionId);4179  }41804181  async doesTokenExist(tokenId: number) {4182    return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);4183  }41844185  async getAdmins() {4186    return await this.helper.collection.getAdmins(this.collectionId);4187  }41884189  async getAllowList() {4190    return await this.helper.collection.getAllowList(this.collectionId);4191  }41924193  async getEffectiveLimits() {4194    return await this.helper.collection.getEffectiveLimits(this.collectionId);4195  }41964197  async getProperties(propertyKeys?: string[] | null) {4198    return await this.helper.collection.getProperties(this.collectionId, propertyKeys);4199  }42004201  async getPropertiesConsumedSpace() {4202    return await this.helper.collection.getPropertiesConsumedSpace(this.collectionId);4203  }42044205  async getTokenNextSponsored(tokenId: number, addressObj: ICrossAccountId) {4206    return await this.helper.collection.getTokenNextSponsored(this.collectionId, tokenId, addressObj);4207  }42084209  async getOptions() {4210    return await this.helper.collection.getCollectionOptions(this.collectionId);4211  }42124213  async setSponsor(signer: TSigner, sponsorAddress: TSubstrateAccount) {4214    return await this.helper.collection.setSponsor(signer, this.collectionId, sponsorAddress);4215  }42164217  async confirmSponsorship(signer: TSigner) {4218    return await this.helper.collection.confirmSponsorship(signer, this.collectionId);4219  }42204221  async removeSponsor(signer: TSigner) {4222    return await this.helper.collection.removeSponsor(signer, this.collectionId);4223  }42244225  async setLimits(signer: TSigner, limits: ICollectionLimits) {4226    return await this.helper.collection.setLimits(signer, this.collectionId, limits);4227  }42284229  async changeOwner(signer: TSigner, ownerAddress: TSubstrateAccount) {4230    return await this.helper.collection.changeOwner(signer, this.collectionId, ownerAddress);4231  }42324233  async addAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {4234    return await this.helper.collection.addAdmin(signer, this.collectionId, adminAddressObj);4235  }42364237  async addToAllowList(signer: TSigner, addressObj: ICrossAccountId) {4238    return await this.helper.collection.addToAllowList(signer, this.collectionId, addressObj);4239  }42404241  async removeFromAllowList(signer: TSigner, addressObj: ICrossAccountId) {4242    return await this.helper.collection.removeFromAllowList(signer, this.collectionId, addressObj);4243  }42444245  async removeAdmin(signer: TSigner, adminAddressObj: ICrossAccountId) {4246    return await this.helper.collection.removeAdmin(signer, this.collectionId, adminAddressObj);4247  }42484249  async setProperties(signer: TSigner, properties: IProperty[]) {4250    return await this.helper.collection.setProperties(signer, this.collectionId, properties);4251  }42524253  async deleteProperties(signer: TSigner, propertyKeys: string[]) {4254    return await this.helper.collection.deleteProperties(signer, this.collectionId, propertyKeys);4255  }42564257  async setPermissions(signer: TSigner, permissions: ICollectionPermissions) {4258    return await this.helper.collection.setPermissions(signer, this.collectionId, permissions);4259  }42604261  async enableNesting(signer: TSigner, permissions: INestingPermissions) {4262    return await this.helper.collection.enableNesting(signer, this.collectionId, permissions);4263  }42644265  async disableNesting(signer: TSigner) {4266    return await this.helper.collection.disableNesting(signer, this.collectionId);4267  }42684269  async burn(signer: TSigner) {4270    return await this.helper.collection.burn(signer, this.collectionId);4271  }42724273  scheduleAt<T extends UniqueHelper>(4274    executionBlockNumber: number,4275    options: ISchedulerOptions = {},4276  ) {4277    const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);4278    return new UniqueBaseCollection(this.collectionId, scheduledHelper);4279  }42804281  scheduleAfter<T extends UniqueHelper>(4282    blocksBeforeExecution: number,4283    options: ISchedulerOptions = {},4284  ) {4285    const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);4286    return new UniqueBaseCollection(this.collectionId, scheduledHelper);4287  }42884289  getSudo<T extends UniqueHelper>() {4290    return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());4291  }4292}429342944295export class UniqueNFTCollection extends UniqueBaseCollection {4296  getTokenObject(tokenId: number) {4297    return new UniqueNFToken(tokenId, this);4298  }42994300  async getTokensByAddress(addressObj: ICrossAccountId) {4301    return await this.helper.nft.getTokensByAddress(this.collectionId, addressObj);4302  }43034304  async getToken(tokenId: number, blockHashAt?: string) {4305    return await this.helper.nft.getToken(this.collectionId, tokenId, [], blockHashAt);4306  }43074308  async getTokenOwner(tokenId: number, blockHashAt?: string) {4309    return await this.helper.nft.getTokenOwner(this.collectionId, tokenId, blockHashAt);4310  }43114312  async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {4313    return await this.helper.nft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);4314  }43154316  async getTokenChildren(tokenId: number, blockHashAt?: string) {4317    return await this.helper.nft.getTokenChildren(this.collectionId, tokenId, blockHashAt);4318  }43194320  async getPropertyPermissions(propertyKeys: string[] | null = null) {4321    return await this.helper.nft.getPropertyPermissions(this.collectionId, propertyKeys);4322  }43234324  async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {4325    return await this.helper.nft.getTokenProperties(this.collectionId, tokenId, propertyKeys);4326  }43274328  async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {4329    const api = this.helper.getApi();4330    const props = (await api.query.nonfungible.tokenProperties(this.collectionId, tokenId)).toJSON();43314332    return (props! as any).consumedSpace;4333  }43344335  async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {4336    return await this.helper.nft.transferToken(signer, this.collectionId, tokenId, addressObj);4337  }43384339  async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {4340    return await this.helper.nft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj);4341  }43424343  async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId) {4344    return await this.helper.nft.approveToken(signer, this.collectionId, tokenId, toAddressObj);4345  }43464347  async isTokenApproved(tokenId: number, toAddressObj: ICrossAccountId) {4348    return await this.helper.nft.isTokenApproved(this.collectionId, tokenId, toAddressObj);4349  }43504351  async mintToken(signer: TSigner, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {4352    return await this.helper.nft.mintToken(signer, {collectionId: this.collectionId, owner, properties});4353  }43544355  async mintMultipleTokens(signer: TSigner, tokens: { owner: ICrossAccountId, properties?: IProperty[] }[]) {4356    return await this.helper.nft.mintMultipleTokens(signer, this.collectionId, tokens);4357  }43584359  async burnToken(signer: TSigner, tokenId: number) {4360    return await this.helper.nft.burnToken(signer, this.collectionId, tokenId);4361  }43624363  async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId) {4364    return await this.helper.nft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj);4365  }43664367  async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {4368    return await this.helper.nft.setTokenProperties(signer, this.collectionId, tokenId, properties);4369  }43704371  async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {4372    return await this.helper.nft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);4373  }43744375  async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {4376    return await this.helper.nft.setTokenPropertyPermissions(signer, this.collectionId, permissions);4377  }43784379  async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {4380    return await this.helper.nft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);4381  }43824383  async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {4384    return await this.helper.nft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);4385  }43864387  scheduleAt<T extends UniqueHelper>(4388    executionBlockNumber: number,4389    options: ISchedulerOptions = {},4390  ) {4391    const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);4392    return new UniqueNFTCollection(this.collectionId, scheduledHelper);4393  }43944395  scheduleAfter<T extends UniqueHelper>(4396    blocksBeforeExecution: number,4397    options: ISchedulerOptions = {},4398  ) {4399    const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);4400    return new UniqueNFTCollection(this.collectionId, scheduledHelper);4401  }44024403  getSudo<T extends UniqueHelper>() {4404    return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());4405  }4406}440744084409export class UniqueRFTCollection extends UniqueBaseCollection {4410  getTokenObject(tokenId: number) {4411    return new UniqueRFToken(tokenId, this);4412  }44134414  async getToken(tokenId: number, blockHashAt?: string) {4415    return await this.helper.rft.getToken(this.collectionId, tokenId, [], blockHashAt);4416  }44174418  async getTokenOwner(tokenId: number, blockHashAt?: string) {4419    return await this.helper.rft.getTokenOwner(this.collectionId, tokenId, blockHashAt);4420  }44214422  async getTokensByAddress(addressObj: ICrossAccountId) {4423    return await this.helper.rft.getTokensByAddress(this.collectionId, addressObj);4424  }44254426  async getTop10TokenOwners(tokenId: number) {4427    return await this.helper.rft.getTokenTop10Owners(this.collectionId, tokenId);4428  }44294430  async getTokenTopmostOwner(tokenId: number, blockHashAt?: string) {4431    return await this.helper.rft.getTokenTopmostOwner(this.collectionId, tokenId, blockHashAt);4432  }44334434  async getTokenBalance(tokenId: number, addressObj: ICrossAccountId) {4435    return await this.helper.rft.getTokenBalance(this.collectionId, tokenId, addressObj);4436  }44374438  async getTokenTotalPieces(tokenId: number) {4439    return await this.helper.rft.getTokenTotalPieces(this.collectionId, tokenId);4440  }44414442  async getTokenApprovedPieces(tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {4443    return await this.helper.rft.getTokenApprovedPieces(this.collectionId, tokenId, toAddressObj, fromAddressObj);4444  }44454446  async getPropertyPermissions(propertyKeys: string[] | null = null) {4447    return await this.helper.rft.getPropertyPermissions(this.collectionId, propertyKeys);4448  }44494450  async getTokenProperties(tokenId: number, propertyKeys?: string[] | null) {4451    return await this.helper.rft.getTokenProperties(this.collectionId, tokenId, propertyKeys);4452  }44534454  async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {4455    const api = this.helper.getApi();4456    const props = (await api.query.refungible.tokenProperties(this.collectionId, tokenId)).toJSON();44574458    return (props! as any).consumedSpace;4459  }44604461  async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount = 1n) {4462    return await this.helper.rft.transferToken(signer, this.collectionId, tokenId, addressObj, amount);4463  }44644465  async transferTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount = 1n) {4466    return await this.helper.rft.transferTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, toAddressObj, amount);4467  }44684469  async approveToken(signer: TSigner, tokenId: number, toAddressObj: ICrossAccountId, amount = 1n) {4470    return await this.helper.rft.approveToken(signer, this.collectionId, tokenId, toAddressObj, amount);4471  }44724473  async repartitionToken(signer: TSigner, tokenId: number, amount: bigint) {4474    return await this.helper.rft.repartitionToken(signer, this.collectionId, tokenId, amount);4475  }44764477  async mintToken(signer: TSigner, pieces = 1n, owner: ICrossAccountId = {Substrate: signer.address}, properties?: IProperty[]) {4478    return await this.helper.rft.mintToken(signer, {collectionId: this.collectionId, owner, pieces, properties});4479  }44804481  async mintMultipleTokens(signer: TSigner, tokens: { pieces: bigint, owner: ICrossAccountId, properties?: IProperty[] }[]) {4482    return await this.helper.rft.mintMultipleTokens(signer, this.collectionId, tokens);4483  }44844485  async burnToken(signer: TSigner, tokenId: number, amount = 1n) {4486    return await this.helper.rft.burnToken(signer, this.collectionId, tokenId, amount);4487  }44884489  async burnTokenFrom(signer: TSigner, tokenId: number, fromAddressObj: ICrossAccountId, amount = 1n) {4490    return await this.helper.rft.burnTokenFrom(signer, this.collectionId, tokenId, fromAddressObj, amount);4491  }44924493  async setTokenProperties(signer: TSigner, tokenId: number, properties: IProperty[]) {4494    return await this.helper.rft.setTokenProperties(signer, this.collectionId, tokenId, properties);4495  }44964497  async deleteTokenProperties(signer: TSigner, tokenId: number, propertyKeys: string[]) {4498    return await this.helper.rft.deleteTokenProperties(signer, this.collectionId, tokenId, propertyKeys);4499  }45004501  async setTokenPropertyPermissions(signer: TSigner, permissions: ITokenPropertyPermission[]) {4502    return await this.helper.rft.setTokenPropertyPermissions(signer, this.collectionId, permissions);4503  }45044505  async nestToken(signer: TSigner, tokenId: number, toTokenObj: IToken) {4506    return await this.helper.rft.nestToken(signer, {collectionId: this.collectionId, tokenId}, toTokenObj);4507  }45084509  async unnestToken(signer: TSigner, tokenId: number, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {4510    return await this.helper.rft.unnestToken(signer, {collectionId: this.collectionId, tokenId}, fromTokenObj, toAddressObj);4511  }45124513  scheduleAt<T extends UniqueHelper>(4514    executionBlockNumber: number,4515    options: ISchedulerOptions = {},4516  ) {4517    const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);4518    return new UniqueRFTCollection(this.collectionId, scheduledHelper);4519  }45204521  scheduleAfter<T extends UniqueHelper>(4522    blocksBeforeExecution: number,4523    options: ISchedulerOptions = {},4524  ) {4525    const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);4526    return new UniqueRFTCollection(this.collectionId, scheduledHelper);4527  }45284529  getSudo<T extends UniqueHelper>() {4530    return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());4531  }4532}453345344535export class UniqueFTCollection extends UniqueBaseCollection {4536  async getBalance(addressObj: ICrossAccountId) {4537    return await this.helper.ft.getBalance(this.collectionId, addressObj);4538  }45394540  async getTotalPieces() {4541    return await this.helper.ft.getTotalPieces(this.collectionId);4542  }45434544  async getApprovedTokens(fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {4545    return await this.helper.ft.getApprovedTokens(this.collectionId, fromAddressObj, toAddressObj);4546  }45474548  async getTop10Owners() {4549    return await this.helper.ft.getTop10Owners(this.collectionId);4550  }45514552  async mint(signer: TSigner, amount = 1n, owner: ICrossAccountId = {Substrate: signer.address}) {4553    return await this.helper.ft.mintTokens(signer, this.collectionId, amount, owner);4554  }45554556  async mintWithOneOwner(signer: TSigner, tokens: { value: bigint }[], owner: ICrossAccountId = {Substrate: signer.address}) {4557    return await this.helper.ft.mintMultipleTokensWithOneOwner(signer, this.collectionId, tokens, owner);4558  }45594560  async transfer(signer: TSigner, toAddressObj: ICrossAccountId, amount = 1n) {4561    return await this.helper.ft.transfer(signer, this.collectionId, toAddressObj, amount);4562  }45634564  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount = 1n) {4565    return await this.helper.ft.transferFrom(signer, this.collectionId, fromAddressObj, toAddressObj, amount);4566  }45674568  async burnTokens(signer: TSigner, amount = 1n) {4569    return await this.helper.ft.burnTokens(signer, this.collectionId, amount);4570  }45714572  async burnTokensFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount = 1n) {4573    return await this.helper.ft.burnTokensFrom(signer, this.collectionId, fromAddressObj, amount);4574  }45754576  async approveTokens(signer: TSigner, toAddressObj: ICrossAccountId, amount = 1n) {4577    return await this.helper.ft.approveTokens(signer, this.collectionId, toAddressObj, amount);4578  }45794580  scheduleAt<T extends UniqueHelper>(4581    executionBlockNumber: number,4582    options: ISchedulerOptions = {},4583  ) {4584    const scheduledHelper = this.helper.scheduler.scheduleAt<T>(executionBlockNumber, options);4585    return new UniqueFTCollection(this.collectionId, scheduledHelper);4586  }45874588  scheduleAfter<T extends UniqueHelper>(4589    blocksBeforeExecution: number,4590    options: ISchedulerOptions = {},4591  ) {4592    const scheduledHelper = this.helper.scheduler.scheduleAfter<T>(blocksBeforeExecution, options);4593    return new UniqueFTCollection(this.collectionId, scheduledHelper);4594  }45954596  getSudo<T extends UniqueHelper>() {4597    return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());4598  }4599}460046014602export class UniqueBaseToken {4603  collection: UniqueNFTCollection | UniqueRFTCollection;4604  collectionId: number;4605  tokenId: number;46064607  constructor(tokenId: number, collection: UniqueNFTCollection | UniqueRFTCollection) {4608    this.collection = collection;4609    this.collectionId = collection.collectionId;4610    this.tokenId = tokenId;4611  }46124613  async getNextSponsored(addressObj: ICrossAccountId) {4614    return await this.collection.getTokenNextSponsored(this.tokenId, addressObj);4615  }46164617  async getProperties(propertyKeys?: string[] | null) {4618    return await this.collection.getTokenProperties(this.tokenId, propertyKeys);4619  }46204621  async getTokenPropertiesConsumedSpace() {4622    return await this.collection.getTokenPropertiesConsumedSpace(this.tokenId);4623  }46244625  async setProperties(signer: TSigner, properties: IProperty[]) {4626    return await this.collection.setTokenProperties(signer, this.tokenId, properties);4627  }46284629  async deleteProperties(signer: TSigner, propertyKeys: string[]) {4630    return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);4631  }46324633  async doesExist() {4634    return await this.collection.doesTokenExist(this.tokenId);4635  }46364637  nestingAccount() {4638    return this.collection.helper.util.getTokenAccount(this);4639  }46404641  scheduleAt<T extends UniqueHelper>(4642    executionBlockNumber: number,4643    options: ISchedulerOptions = {},4644  ) {4645    const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);4646    return new UniqueBaseToken(this.tokenId, scheduledCollection);4647  }46484649  scheduleAfter<T extends UniqueHelper>(4650    blocksBeforeExecution: number,4651    options: ISchedulerOptions = {},4652  ) {4653    const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);4654    return new UniqueBaseToken(this.tokenId, scheduledCollection);4655  }46564657  getSudo<T extends UniqueHelper>() {4658    return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());4659  }4660}466146624663export class UniqueNFToken extends UniqueBaseToken {4664  collection: UniqueNFTCollection;46654666  constructor(tokenId: number, collection: UniqueNFTCollection) {4667    super(tokenId, collection);4668    this.collection = collection;4669  }46704671  async getData(blockHashAt?: string) {4672    return await this.collection.getToken(this.tokenId, blockHashAt);4673  }46744675  async getOwner(blockHashAt?: string) {4676    return await this.collection.getTokenOwner(this.tokenId, blockHashAt);4677  }46784679  async getTopmostOwner(blockHashAt?: string) {4680    return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);4681  }46824683  async getChildren(blockHashAt?: string) {4684    return await this.collection.getTokenChildren(this.tokenId, blockHashAt);4685  }46864687  async nest(signer: TSigner, toTokenObj: IToken) {4688    return await this.collection.nestToken(signer, this.tokenId, toTokenObj);4689  }46904691  async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {4692    return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);4693  }46944695  async transfer(signer: TSigner, addressObj: ICrossAccountId) {4696    return await this.collection.transferToken(signer, this.tokenId, addressObj);4697  }46984699  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId) {4700    return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj);4701  }47024703  async approve(signer: TSigner, toAddressObj: ICrossAccountId) {4704    return await this.collection.approveToken(signer, this.tokenId, toAddressObj);4705  }47064707  async isApproved(toAddressObj: ICrossAccountId) {4708    return await this.collection.isTokenApproved(this.tokenId, toAddressObj);4709  }47104711  async burn(signer: TSigner) {4712    return await this.collection.burnToken(signer, this.tokenId);4713  }47144715  async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId) {4716    return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj);4717  }47184719  scheduleAt<T extends UniqueHelper>(4720    executionBlockNumber: number,4721    options: ISchedulerOptions = {},4722  ) {4723    const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);4724    return new UniqueNFToken(this.tokenId, scheduledCollection);4725  }47264727  scheduleAfter<T extends UniqueHelper>(4728    blocksBeforeExecution: number,4729    options: ISchedulerOptions = {},4730  ) {4731    const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);4732    return new UniqueNFToken(this.tokenId, scheduledCollection);4733  }47344735  getSudo<T extends UniqueHelper>() {4736    return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());4737  }4738}47394740export class UniqueRFToken extends UniqueBaseToken {4741  collection: UniqueRFTCollection;47424743  constructor(tokenId: number, collection: UniqueRFTCollection) {4744    super(tokenId, collection);4745    this.collection = collection;4746  }47474748  async getData(blockHashAt?: string) {4749    return await this.collection.getToken(this.tokenId, blockHashAt);4750  }47514752  async getOwner(blockHashAt?: string) {4753    return await this.collection.getTokenOwner(this.tokenId, blockHashAt);4754  }47554756  async getTop10Owners() {4757    return await this.collection.getTop10TokenOwners(this.tokenId);4758  }47594760  async getTopmostOwner(blockHashAt?: string) {4761    return await this.collection.getTokenTopmostOwner(this.tokenId, blockHashAt);4762  }47634764  async nest(signer: TSigner, toTokenObj: IToken) {4765    return await this.collection.nestToken(signer, this.tokenId, toTokenObj);4766  }47674768  async unnest(signer: TSigner, fromTokenObj: IToken, toAddressObj: ICrossAccountId) {4769    return await this.collection.unnestToken(signer, this.tokenId, fromTokenObj, toAddressObj);4770  }47714772  async getBalance(addressObj: ICrossAccountId) {4773    return await this.collection.getTokenBalance(this.tokenId, addressObj);4774  }47754776  async getTotalPieces() {4777    return await this.collection.getTokenTotalPieces(this.tokenId);4778  }47794780  async getApprovedPieces(fromAddressObj: ICrossAccountId, toAccountObj: ICrossAccountId) {4781    return await this.collection.getTokenApprovedPieces(this.tokenId, fromAddressObj, toAccountObj);4782  }47834784  async transfer(signer: TSigner, addressObj: ICrossAccountId, amount = 1n) {4785    return await this.collection.transferToken(signer, this.tokenId, addressObj, amount);4786  }47874788  async transferFrom(signer: TSigner, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount = 1n) {4789    return await this.collection.transferTokenFrom(signer, this.tokenId, fromAddressObj, toAddressObj, amount);4790  }47914792  async approve(signer: TSigner, toAddressObj: ICrossAccountId, amount = 1n) {4793    return await this.collection.approveToken(signer, this.tokenId, toAddressObj, amount);4794  }47954796  async repartition(signer: TSigner, amount: bigint) {4797    return await this.collection.repartitionToken(signer, this.tokenId, amount);4798  }47994800  async burn(signer: TSigner, amount = 1n) {4801    return await this.collection.burnToken(signer, this.tokenId, amount);4802  }48034804  async burnFrom(signer: TSigner, fromAddressObj: ICrossAccountId, amount = 1n) {4805    return await this.collection.burnTokenFrom(signer, this.tokenId, fromAddressObj, amount);4806  }48074808  scheduleAt<T extends UniqueHelper>(4809    executionBlockNumber: number,4810    options: ISchedulerOptions = {},4811  ) {4812    const scheduledCollection = this.collection.scheduleAt<T>(executionBlockNumber, options);4813    return new UniqueRFToken(this.tokenId, scheduledCollection);4814  }48154816  scheduleAfter<T extends UniqueHelper>(4817    blocksBeforeExecution: number,4818    options: ISchedulerOptions = {},4819  ) {4820    const scheduledCollection = this.collection.scheduleAfter<T>(blocksBeforeExecution, options);4821    return new UniqueRFToken(this.tokenId, scheduledCollection);4822  }48234824  getSudo<T extends UniqueHelper>() {4825    return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());4826  }4827}