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

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// SPDX-License-Identifier: Apache-2.034import {stringToU8a} from '@polkadot/util';5import {blake2AsHex, encodeAddress, mnemonicGenerate} from '@polkadot/util-crypto';6import {UniqueHelper, MoonbeamHelper, ChainHelperBase, AcalaHelper, RelayHelper, WestmintHelper, AstarHelper} from './unique';7import {ApiPromise, Keyring, WsProvider} from '@polkadot/api';8import * as defs from '../../interfaces/definitions';9import {IKeyringPair} from '@polkadot/types/types';10import {EventRecord} from '@polkadot/types/interfaces';11import {ICrossAccountId, IPovInfo, TSigner} from './types';12import {FrameSystemEventRecord, XcmV2TraitsError} from '@polkadot/types/lookup';13import {VoidFn} from '@polkadot/api/types';14import {Pallets} from '..';15import {spawnSync} from 'child_process';1617export class SilentLogger {18  log(_msg: any, _level: any): void { }19  level = {20    ERROR: 'ERROR' as const,21    WARNING: 'WARNING' as const,22    INFO: 'INFO' as const,23  };24}2526export class SilentConsole {27  // TODO: Remove, this is temporary: Filter unneeded API output28  // (Jaco promised it will be removed in the next version)29  consoleErr: any;30  consoleLog: any;31  consoleWarn: any;3233  constructor() {34    this.consoleErr = console.error;35    this.consoleLog = console.log;36    this.consoleWarn = console.warn;37  }3839  enable() {40    const outFn = (printer: any) => (...args: any[]) => {41      for (const arg of args) {42        if (typeof arg !== 'string')43          continue;44        if (arg.includes('1000:: Normal connection closure') || arg.includes('Not decorating unknown runtime apis:') || arg.includes('RPC methods not decorated:') || arg === 'Normal connection closure')45          return;46      }47      printer(...args);48    };4950    console.error = outFn(this.consoleErr.bind(console));51    console.log = outFn(this.consoleLog.bind(console));52    console.warn = outFn(this.consoleWarn.bind(console));53  }5455  disable() {56    console.error = this.consoleErr;57    console.log = this.consoleLog;58    console.warn = this.consoleWarn;59  }60}6162export interface IEventHelper {63  section(): string;6465  method(): string;6667  bindEventRecord(e: FrameSystemEventRecord): void;6869  raw(): FrameSystemEventRecord;70}7172// eslint-disable-next-line @typescript-eslint/naming-convention73function EventHelper(section: string, method: string) {74  return class implements IEventHelper {75    eventRecord: FrameSystemEventRecord | null;76    _section: string;77    _method: string;7879    constructor() {80      this.eventRecord = null;81      this._section = section;82      this._method = method;83    }8485    section(): string {86      return this._section;87    }8889    method(): string {90      return this._method;91    }9293    bindEventRecord(e: FrameSystemEventRecord) {94      this.eventRecord = e;95    }9697    raw() {98      return this.eventRecord!;99    }100101    eventJsonData<T = any>(index: number) {102      return this.raw().event.data[index].toJSON() as T;103    }104105    eventData<T>(index: number) {106      return this.raw().event.data[index] as T;107    }108  };109}110111// eslint-disable-next-line @typescript-eslint/naming-convention112function EventSection(section: string) {113  return class Section {114    static section = section;115116    static Method(name: string) {117      return EventHelper(Section.section, name);118    }119  };120}121122export class Event {123  static Democracy = class extends EventSection('democracy') {124    static Started = class extends this.Method('Started') {125      referendumIndex() {126        return this.eventJsonData<number>(0);127      }128129      threshold() {130        return this.eventJsonData(1);131      }132    };133134    static Voted = class extends this.Method('Voted') {135      voter() {136        return this.eventJsonData(0);137      }138139      referendumIndex() {140        return this.eventJsonData<number>(1);141      }142143      vote() {144        return this.eventJsonData(2);145      }146    };147148    static Passed = class extends this.Method('Passed') {149      referendumIndex() {150        return this.eventJsonData<number>(0);151      }152    };153  };154155  static Scheduler = class extends EventSection('scheduler') {156    static PriorityChanged = class extends this.Method('PriorityChanged') {157      task() {158        return this.eventJsonData(0);159      }160161      priority() {162        return this.eventJsonData(1);163      }164    };165  };166167  static XcmpQueue = class extends EventSection('xcmpQueue') {168    static XcmpMessageSent = class extends this.Method('XcmpMessageSent') {169      messageHash() {170        return this.eventJsonData(0);171      }172    };173174    static Fail = class extends this.Method('Fail') {175      messageHash() {176        return this.eventJsonData(0);177      }178179      outcome() {180        return this.eventData<XcmV2TraitsError>(1);181      }182    };183  };184}185186export class DevUniqueHelper extends UniqueHelper {187  /**188   * Arrange methods for tests189   */190  arrange: ArrangeGroup;191  wait: WaitGroup;192  admin: AdminGroup;193  session: SessionGroup;194  testUtils: TestUtilGroup;195196  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {197    options.helperBase = options.helperBase ?? DevUniqueHelper;198199    super(logger, options);200    this.arrange = new ArrangeGroup(this);201    this.wait = new WaitGroup(this);202    this.admin = new AdminGroup(this);203    this.testUtils = new TestUtilGroup(this);204    this.session = new SessionGroup(this);205  }206207  async connect(wsEndpoint: string, _listeners?: any): Promise<void> {208    const wsProvider = new WsProvider(wsEndpoint);209    this.api = new ApiPromise({210      provider: wsProvider,211      signedExtensions: {212        ContractHelpers: {213          extrinsic: {},214          payload: {},215        },216        CheckMaintenance: {217          extrinsic: {},218          payload: {},219        },220        DisableIdentityCalls: {221          extrinsic: {},222          payload: {},223        },224        FakeTransactionFinalizer: {225          extrinsic: {},226          payload: {},227        },228      },229      rpc: {230        unique: defs.unique.rpc,231        appPromotion: defs.appPromotion.rpc,232        povinfo: defs.povinfo.rpc,233        eth: {234          feeHistory: {235            description: 'Dummy',236            params: [],237            type: 'u8',238          },239          maxPriorityFeePerGas: {240            description: 'Dummy',241            params: [],242            type: 'u8',243          },244        },245      },246    });247    await this.api.isReadyOrError;248    this.network = await UniqueHelper.detectNetwork(this.api);249    this.wsEndpoint = wsEndpoint;250  }251}252253export class DevRelayHelper extends RelayHelper {254  wait: WaitGroup;255256  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {257    options.helperBase = options.helperBase ?? DevRelayHelper;258259    super(logger, options);260    this.wait = new WaitGroup(this);261  }262}263264export class DevWestmintHelper extends WestmintHelper {265  wait: WaitGroup;266267  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {268    options.helperBase = options.helperBase ?? DevWestmintHelper;269270    super(logger, options);271    this.wait = new WaitGroup(this);272  }273}274275export class DevStatemineHelper extends DevWestmintHelper {}276277export class DevStatemintHelper extends DevWestmintHelper {}278279export class DevMoonbeamHelper extends MoonbeamHelper {280  account: MoonbeamAccountGroup;281  wait: WaitGroup;282  fastDemocracy: MoonbeamFastDemocracyGroup;283284  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {285    options.helperBase = options.helperBase ?? DevMoonbeamHelper;286    options.notePreimagePallet = options.notePreimagePallet ?? 'preimage';287288    super(logger, options);289    this.account = new MoonbeamAccountGroup(this);290    this.wait = new WaitGroup(this);291    this.fastDemocracy = new MoonbeamFastDemocracyGroup(this);292  }293}294295export class DevMoonriverHelper extends DevMoonbeamHelper {296  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {297    options.notePreimagePallet = options.notePreimagePallet ?? 'preimage';298    super(logger, options);299  }300}301302export class DevAstarHelper extends AstarHelper {303  wait: WaitGroup;304305  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {306    options.helperBase = options.helperBase ?? DevAstarHelper;307308    super(logger, options);309    this.wait = new WaitGroup(this);310  }311}312313export class DevShidenHelper extends AstarHelper {314  wait: WaitGroup;315316  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {317    options.helperBase = options.helperBase ?? DevShidenHelper;318319    super(logger, options);320    this.wait = new WaitGroup(this);321  }322}323324export class DevAcalaHelper extends AcalaHelper {325  wait: WaitGroup;326327  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {328    options.helperBase = options.helperBase ?? DevAcalaHelper;329330    super(logger, options);331    this.wait = new WaitGroup(this);332  }333}334335export class DevKaruraHelper extends DevAcalaHelper {}336337export class ArrangeGroup {338  helper: DevUniqueHelper;339340  scheduledIdSlider = 0;341342  constructor(helper: DevUniqueHelper) {343    this.helper = helper;344  }345346  /**347   * Generates accounts with the specified UNQ token balance348   * @param balances balances for generated accounts. Each balance will be multiplied by the token nominal.349   * @param donor donor account for balances350   * @returns array of newly created accounts351   * @example const [acc1, acc2, acc3] = await createAccounts([0n, 10n, 20n], donor);352   */353  createAccounts = async (balances: bigint[], donor: IKeyringPair): Promise<IKeyringPair[]> => {354    let nonce = await this.helper.chain.getNonce(donor.address);355    const wait = new WaitGroup(this.helper);356    const ss58Format = this.helper.chain.getChainProperties().ss58Format;357    const tokenNominal = this.helper.balance.getOneTokenNominal();358    const transactions = [];359    const accounts: IKeyringPair[] = [];360    for (const balance of balances) {361      const recipient = this.helper.util.fromSeed(mnemonicGenerate(), ss58Format);362      accounts.push(recipient);363      if (balance !== 0n) {364        const tx = this.helper.constructApiCall('api.tx.balances.transfer', [{Id: recipient.address}, balance * tokenNominal]);365        transactions.push(this.helper.signTransaction(donor, tx, {nonce, era: 0}, 'account generation'));366        nonce++;367      }368    }369370    await Promise.all(transactions).catch(_e => {});371372    //#region TODO remove this region, when nonce problem will be solved373    const checkBalances = async () => {374      let isSuccess = true;375      for (let i = 0; i < balances.length; i++) {376        const balance = await this.helper.balance.getSubstrate(accounts[i].address);377        if (balance !== balances[i] * tokenNominal) {378          isSuccess = false;379          break;380        }381      }382      return isSuccess;383    };384385    let accountsCreated = false;386    const maxBlocksChecked = await this.helper.arrange.isDevNode() ? 50 : 5;387    // checkBalances retry up to 5-50 blocks388    for (let index = 0; index < maxBlocksChecked; index++) {389      accountsCreated = await checkBalances();390      if(accountsCreated) break;391      await wait.newBlocks(1);392    }393394    if (!accountsCreated) throw Error('Accounts generation failed');395    //#endregion396397    return accounts;398  };399400  // TODO combine this method and createAccounts into one401  createCrowd = async (accountsToCreate: number, withBalance: bigint, donor: IKeyringPair): Promise<IKeyringPair[]> => {402    const createAsManyAsCan = async () => {403      let transactions: any = [];404      const accounts: IKeyringPair[] = [];405      let nonce = await this.helper.chain.getNonce(donor.address);406      const tokenNominal = this.helper.balance.getOneTokenNominal();407      const ss58Format = this.helper.chain.getChainProperties().ss58Format;408      for (let i = 0; i < accountsToCreate; i++) {409        if (i === 500) { // if there are too many accounts to create410          await Promise.allSettled(transactions); // wait while first 500 (should be 100 for devnode) tx will be settled411          transactions = []; //412          nonce = await this.helper.chain.getNonce(donor.address); // update nonce413        }414        const recipient = this.helper.util.fromSeed(mnemonicGenerate(), ss58Format);415        accounts.push(recipient);416        if (withBalance !== 0n) {417          const tx = this.helper.constructApiCall('api.tx.balances.transfer', [{Id: recipient.address}, withBalance * tokenNominal]);418          transactions.push(this.helper.signTransaction(donor, tx, {nonce}, 'account generation'));419          nonce++;420        }421      }422423      const fullfilledAccounts = [];424      await Promise.allSettled(transactions);425      for (const account of accounts) {426        const accountBalance = await this.helper.balance.getSubstrate(account.address);427        if (accountBalance === withBalance * tokenNominal) {428          fullfilledAccounts.push(account);429        }430      }431      return fullfilledAccounts;432    };433434435    const crowd: IKeyringPair[] = [];436    // do up to 5 retries437    for (let index = 0; index < 5 && accountsToCreate !== 0; index++) {438      const asManyAsCan = await createAsManyAsCan();439      crowd.push(...asManyAsCan);440      accountsToCreate -= asManyAsCan.length;441    }442443    if (accountsToCreate !== 0) throw Error(`Crowd generation failed: ${accountsToCreate} accounts left`);444445    return crowd;446  };447448  isDevNode = async () => {449    let blockNumber = (await this.helper.callRpc('api.query.system.number')).toJSON();450    if (blockNumber == 0) {451      await this.helper.wait.newBlocks(1);452      blockNumber = (await this.helper.callRpc('api.query.system.number')).toJSON();453    }454    const block2 = await this.helper.callRpc('api.rpc.chain.getBlock', [await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])]);455    const block1 = await this.helper.callRpc('api.rpc.chain.getBlock', [await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber - 1])]);456    const findCreationDate = (block: any) => {457      const humanBlock = block.toHuman();458      let date;459      humanBlock.block.extrinsics.forEach((ext: any) => {460        if(ext.method.section === 'timestamp') {461          date = Number(ext.method.args.now.replaceAll(',', ''));462        }463      });464      return date;465    };466    const block1date = await findCreationDate(block1);467    const block2date = await findCreationDate(block2);468    if(block2date! - block1date! < 9000) return true;469  };470471  async calculcateFee(payer: ICrossAccountId, promise: () => Promise<any>): Promise<bigint> {472    const address = 'Substrate' in payer ? payer.Substrate : this.helper.address.ethToSubstrate(payer.Ethereum);473    let balance = await this.helper.balance.getSubstrate(address);474475    await promise();476477    balance -= await this.helper.balance.getSubstrate(address);478479    return balance;480  }481482  async calculatePoVInfo(txs: any[]): Promise<IPovInfo> {483    const rawPovInfo = await this.helper.callRpc('api.rpc.povinfo.estimateExtrinsicPoV', [txs]);484485    const kvJson: {[key: string]: string} = {};486487    for (const kv of rawPovInfo.keyValues) {488      kvJson[kv.key.toHex()] = kv.value.toHex();489    }490491    const kvStr = JSON.stringify(kvJson);492493    const chainql = spawnSync(494      'chainql',495      [496        `--tla-code=data=${kvStr}`,497        '-e', `function(data) cql.dump(cql.chain("${this.helper.getEndpoint()}").latest._meta, data, {omit_empty:true})`,498      ],499    );500501    if (!chainql.stdout) {502      throw Error('unable to get an output from the `chainql`');503    }504505    return {506      proofSize: rawPovInfo.proofSize.toNumber(),507      compactProofSize: rawPovInfo.compactProofSize.toNumber(),508      compressedProofSize: rawPovInfo.compressedProofSize.toNumber(),509      results: rawPovInfo.results,510      kv: JSON.parse(chainql.stdout.toString()),511    };512  }513514  calculatePalletAddress(palletId: any) {515    const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));516    return encodeAddress(address, this.helper.chain.getChainProperties().ss58Format);517  }518519  makeScheduledIds(num: number): string[] {520    function makeId(slider: number) {521      const scheduledIdSize = 64;522      const hexId = slider.toString(16);523      const prefixSize = scheduledIdSize - hexId.length;524525      const scheduledId = '0x' + '0'.repeat(prefixSize) + hexId;526527      return scheduledId;528    }529530    const ids = [];531    for (let i = 0; i < num; i++) {532      ids.push(makeId(this.scheduledIdSlider));533      this.scheduledIdSlider += 1;534    }535536    return ids;537  }538539  makeScheduledId(): string {540    return (this.makeScheduledIds(1))[0];541  }542543  async captureEvents(eventSection: string, eventMethod: string): Promise<EventCapture> {544    const capture = new EventCapture(this.helper, eventSection, eventMethod);545    await capture.startCapture();546547    return capture;548  }549550  makeXcmProgramWithdrawDeposit(beneficiary: Uint8Array, id: any, amount: bigint) {551    return {552      V2: [553        {554          WithdrawAsset: [555            {556              id,557              fun: {558                Fungible: amount,559              },560            },561          ],562        },563        {564          BuyExecution: {565            fees: {566              id,567              fun: {568                Fungible: amount,569              },570            },571            weightLimit: 'Unlimited',572          },573        },574        {575          DepositAsset: {576            assets: {577              Wild: 'All',578            },579            maxAssets: 1,580            beneficiary: {581              parents: 0,582              interior: {583                X1: {584                  AccountId32: {585                    network: 'Any',586                    id: beneficiary,587                  },588                },589              },590            },591          },592        },593      ],594    };595  }596597  makeXcmProgramReserveAssetDeposited(beneficiary: Uint8Array, id: any, amount: bigint) {598    return {599      V2: [600        {601          ReserveAssetDeposited: [602            {603              id,604              fun: {605                Fungible: amount,606              },607            },608          ],609        },610        {611          BuyExecution: {612            fees: {613              id,614              fun: {615                Fungible: amount,616              },617            },618            weightLimit: 'Unlimited',619          },620        },621        {622          DepositAsset: {623            assets: {624              Wild: 'All',625            },626            maxAssets: 1,627            beneficiary: {628              parents: 0,629              interior: {630                X1: {631                  AccountId32: {632                    network: 'Any',633                    id: beneficiary,634                  },635                },636              },637            },638          },639        },640      ],641    };642  }643}644645class MoonbeamAccountGroup {646  helper: MoonbeamHelper;647648  keyring: Keyring;649  _alithAccount: IKeyringPair;650  _baltatharAccount: IKeyringPair;651  _dorothyAccount: IKeyringPair;652653  constructor(helper: MoonbeamHelper) {654    this.helper = helper;655656    this.keyring = new Keyring({type: 'ethereum'});657    const alithPrivateKey = '0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133';658    const baltatharPrivateKey = '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b';659    const dorothyPrivateKey = '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68';660661    this._alithAccount = this.keyring.addFromUri(alithPrivateKey, undefined, 'ethereum');662    this._baltatharAccount = this.keyring.addFromUri(baltatharPrivateKey, undefined, 'ethereum');663    this._dorothyAccount = this.keyring.addFromUri(dorothyPrivateKey, undefined, 'ethereum');664  }665666  alithAccount() {667    return this._alithAccount;668  }669670  baltatharAccount() {671    return this._baltatharAccount;672  }673674  dorothyAccount() {675    return this._dorothyAccount;676  }677678  create() {679    return this.keyring.addFromUri(mnemonicGenerate());680  }681}682683class MoonbeamFastDemocracyGroup {684  helper: DevMoonbeamHelper;685686  constructor(helper: DevMoonbeamHelper) {687    this.helper = helper;688  }689690  async executeProposal(proposalDesciption: string, encodedProposal: string) {691    const proposalHash = blake2AsHex(encodedProposal);692693    const alithAccount = this.helper.account.alithAccount();694    const baltatharAccount = this.helper.account.baltatharAccount();695    const dorothyAccount = this.helper.account.dorothyAccount();696697    const councilVotingThreshold = 2;698    const technicalCommitteeThreshold = 2;699    const fastTrackVotingPeriod = 3;700    const fastTrackDelayPeriod = 0;701702    console.log(`[democracy] executing '${proposalDesciption}' proposal`);703704    // >>> Propose external motion through council >>>705    console.log('\t* Propose external motion through council.......');706    const externalMotion = this.helper.democracy.externalProposeMajority({Inline: encodedProposal});707    const encodedMotion = externalMotion?.method.toHex() || '';708    const motionHash = blake2AsHex(encodedMotion);709    console.log('\t* Motion hash is %s', motionHash);710711    await this.helper.collective.council.propose(712      baltatharAccount,713      councilVotingThreshold,714      externalMotion,715      externalMotion.encodedLength,716    );717718    const councilProposalIdx = await this.helper.collective.council.proposalCount() - 1;719    await this.helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);720    await this.helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);721722    await this.helper.collective.council.close(723      dorothyAccount,724      motionHash,725      councilProposalIdx,726      {727        refTime: 1_000_000_000,728        proofSize: 1_000_000,729      },730      externalMotion.encodedLength,731    );732    console.log('\t* Propose external motion through council.......DONE');733    // <<< Propose external motion through council <<<734735    // >>> Fast track proposal through technical committee >>>736    console.log('\t* Fast track proposal through technical committee.......');737    const fastTrack = this.helper.democracy.fastTrack(proposalHash, fastTrackVotingPeriod, fastTrackDelayPeriod);738    const encodedFastTrack = fastTrack?.method.toHex() || '';739    const fastTrackHash = blake2AsHex(encodedFastTrack);740    console.log('\t* FastTrack hash is %s', fastTrackHash);741742    await this.helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);743744    const techProposalIdx = await this.helper.collective.techCommittee.proposalCount() - 1;745    await this.helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);746    await this.helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);747748    await this.helper.collective.techCommittee.close(749      baltatharAccount,750      fastTrackHash,751      techProposalIdx,752      {753        refTime: 1_000_000_000,754        proofSize: 1_000_000,755      },756      fastTrack.encodedLength,757    );758    console.log('\t* Fast track proposal through technical committee.......DONE');759    // <<< Fast track proposal through technical committee <<<760761    const democracyStarted = await this.helper.wait.expectEvent(3, Event.Democracy.Started);762    const referendumIndex = democracyStarted.referendumIndex();763764    // >>> Referendum voting >>>765    console.log(`\t* Referendum #${referendumIndex} voting.......`);766    await this.helper.democracy.referendumVote(dorothyAccount, referendumIndex, {767      balance: 10_000_000_000_000_000_000n,768      vote: {aye: true, conviction: 1},769    });770    console.log(`\t* Referendum #${referendumIndex} voting.......DONE`);771    // <<< Referendum voting <<<772773    // Wait the proposal to pass774    await this.helper.wait.expectEvent(3, Event.Democracy.Passed, event => {775      return event.referendumIndex() == referendumIndex;776    });777778    await this.helper.wait.newBlocks(1);779780    console.log(`[democracy] executing '${proposalDesciption}' proposal.......DONE`);781  }782}783784class WaitGroup {785  helper: ChainHelperBase;786787  constructor(helper: ChainHelperBase) {788    this.helper = helper;789  }790791  sleep(milliseconds: number) {792    return new Promise((resolve) => setTimeout(resolve, milliseconds));793  }794795  private async waitWithTimeout(promise: Promise<any>, timeout: number) {796    let isBlock = false;797    promise.then(() => isBlock = true).catch(() => isBlock = true);798    let totalTime = 0;799    const step = 100;800    while(!isBlock) {801      await this.sleep(step);802      totalTime += step;803      if(totalTime >= timeout) throw Error('Blocks production failed');804    }805    return promise;806  }807808  /**809   * Launch some async operation, or throw an error after some time. Note that it will still continue executing after the timeout.810   * @param promise async operation to race against the timeout811   * @param timeoutMS time after which to time out812   * @param timeoutError error message to throw813   * @returns promise of the same type the operation had814   */815  withTimeout<T>(816    promise: Promise<T>,817    timeoutMS = 30000,818    timeoutError = 'The operation has timed out!',819  ): Promise<T> {820    const timeout = new Promise<never>((_, reject) => {821      setTimeout(() => {822        reject(new Error(timeoutError));823      }, timeoutMS);824    });825826    return Promise.race<T>([promise, timeout]).catch(e => {throw new Error(e);});827  }828829  /**830   * Wait for specified number of blocks831   * @param blocksCount number of blocks to wait832   * @returns833   */834  async newBlocks(blocksCount = 1, timeout?: number): Promise<void> {835    timeout = timeout ?? blocksCount * 60_000;836    // eslint-disable-next-line no-async-promise-executor837    const promise = new Promise<void>(async (resolve) => {838      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(() => {839        if (blocksCount > 0) {840          blocksCount--;841        } else {842          unsubscribe();843          resolve();844        }845      });846    });847    await this.waitWithTimeout(promise, timeout);848    return promise;849  }850851  /**852   * Wait for the specified number of sessions to pass.853   * Only applicable if the Session pallet is turned on.854   * @param sessionCount number of sessions to wait855   * @param blockTimeout time in ms until panicking that the chain has stopped producing blocks856   * @returns857   */858  async newSessions(sessionCount = 1, blockTimeout = 60000): Promise<void> {859    console.log(`Waiting for ${sessionCount} new session${sessionCount > 1 ? 's' : ''}.`860      + ' This might take a while -- check SessionPeriod in pallet_session::Config for session time.');861862    const expectedSessionIndex = await (this.helper as DevUniqueHelper).session.getIndex() + sessionCount;863    let currentSessionIndex = -1;864865    while (currentSessionIndex < expectedSessionIndex) {866      // eslint-disable-next-line no-async-promise-executor867      currentSessionIndex = await this.withTimeout(new Promise(async (resolve) => {868        await this.newBlocks(1);869        const res = await (this.helper as DevUniqueHelper).session.getIndex();870        resolve(res);871      }), blockTimeout, 'The chain has stopped producing blocks!');872    }873  }874875  async forParachainBlockNumber(blockNumber: bigint | number, timeout?: number) {876    timeout = timeout ?? 30 * 60 * 1000;877    // eslint-disable-next-line no-async-promise-executor878    const promise = new Promise<void>(async (resolve) => {879      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads((data: any) => {880        if (data.number.toNumber() >= blockNumber) {881          unsubscribe();882          resolve();883        }884      });885    });886    await this.waitWithTimeout(promise, timeout);887    return promise;888  }889890  async forRelayBlockNumber(blockNumber: bigint | number, timeout?: number) {891    timeout = timeout ?? 30 * 60 * 1000;892    // eslint-disable-next-line no-async-promise-executor893    const promise = new Promise<void>(async (resolve) => {894      const unsubscribe = await this.helper.getApi().query.parachainSystem.validationData((data: any) => {895        if (data.value.relayParentNumber.toNumber() >= blockNumber) {896          // @ts-ignore897          unsubscribe();898          resolve();899        }900      });901    });902    await this.waitWithTimeout(promise, timeout);903    return promise;904  }905906  noScheduledTasks() {907    const api = this.helper.getApi();908909    // eslint-disable-next-line no-async-promise-executor910    const promise = new Promise<void>(async resolve => {911      const unsubscribe = await api.rpc.chain.subscribeNewHeads(async () => {912        const areThereScheduledTasks = await api.query.scheduler.lookup.entries();913914        if(areThereScheduledTasks.length == 0) {915          unsubscribe();916          resolve();917        }918      });919    });920921    return promise;922  }923924  event<T extends IEventHelper>(925    maxBlocksToWait: number,926    eventHelperType: new () => T,927    filter: (_: T) => boolean = () => { return true; },928  ) {929    // eslint-disable-next-line no-async-promise-executor930    const promise = new Promise<T | null>(async (resolve) => {931      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(async header => {932        const eventHelper = new eventHelperType();933        const blockNumber = header.number.toHuman();934        const blockHash = header.hash;935        const eventIdStr = `${eventHelper.section()}.${eventHelper.method()}`;936        const waitLimitStr = `wait blocks remaining: ${maxBlocksToWait}`;937938        this.helper.logger.log(`[Block #${blockNumber}] Waiting for event \`${eventIdStr}\` (${waitLimitStr})`);939940        const apiAt = await this.helper.getApi().at(blockHash);941        const eventRecords = (await apiAt.query.system.events()) as any;942943        const neededEvent = eventRecords.toArray().find((r: FrameSystemEventRecord) => {944          if (945            r.event.section == eventHelper.section()946            && r.event.method == eventHelper.method()947          ) {948            eventHelper.bindEventRecord(r);949            return filter(eventHelper);950          } else {951            return false;952          }953        });954955        if (neededEvent) {956          unsubscribe();957          resolve(eventHelper);958        } else if (maxBlocksToWait > 0) {959          maxBlocksToWait--;960        } else {961          this.helper.logger.log(`Eligible event \`${eventIdStr}\` is NOT found`);962          unsubscribe();963          resolve(null);964        }965      });966    });967    return promise;968  }969970  async expectEvent<T extends IEventHelper>(971    maxBlocksToWait: number,972    eventHelperType: new () => T,973    filter: (e: T) => boolean = () => { return true; },974  ) {975    const e = await this.event(maxBlocksToWait, eventHelperType, filter);976    if (e == null) {977      const eventHelper = new eventHelperType();978      throw Error(`The event '${eventHelper.section()}.${eventHelper.method()}' is expected`);979    } else {980      return e;981    }982  }983}984985class SessionGroup {986  helper: ChainHelperBase;987988  constructor(helper: ChainHelperBase) {989    this.helper = helper;990  }991992  //todo:collator documentation993  async getIndex(): Promise<number> {994    return (await this.helper.callRpc('api.query.session.currentIndex', [])).toNumber();995  }996997  newSessions(sessionCount = 1, blockTimeout = 24000): Promise<void> {998    return (this.helper as DevUniqueHelper).wait.newSessions(sessionCount, blockTimeout);999  }10001001  setOwnKeys(signer: TSigner, key: string) {1002    return this.helper.executeExtrinsic(1003      signer,1004      'api.tx.session.setKeys',1005      [key, '0x0'],1006      true,1007    );1008  }10091010  setOwnKeysFromAddress(signer: TSigner) {1011    return this.setOwnKeys(signer, '0x' + Buffer.from(signer.addressRaw).toString('hex'));1012  }1013}10141015class TestUtilGroup {1016  helper: DevUniqueHelper;10171018  constructor(helper: DevUniqueHelper) {1019    this.helper = helper;1020  }10211022  async enable() {1023    if (this.helper.fetchMissingPalletNames([Pallets.TestUtils]).length != 0) {1024      return;1025    }10261027    const signer = this.helper.util.fromSeed('//Alice');1028    await this.helper.getSudo<DevUniqueHelper>().executeExtrinsic(signer, 'api.tx.testUtils.enable', [], true);1029  }10301031  async setTestValue(signer: TSigner, testVal: number) {1032    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.setTestValue', [testVal], true);1033  }10341035  async incTestValue(signer: TSigner) {1036    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.incTestValue', [], true);1037  }10381039  async setTestValueAndRollback(signer: TSigner, testVal: number) {1040    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.setTestValueAndRollback', [testVal], true);1041  }10421043  async testValue(blockIdx?: number) {1044    const api = blockIdx1045      ? await this.helper.getApi().at(await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockIdx]))1046      : this.helper.getApi();10471048    return (await api.query.testUtils.testValue()).toJSON();1049  }10501051  async justTakeFee(signer: TSigner) {1052    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.justTakeFee', [], true);1053  }10541055  async selfCancelingInc(signer: TSigner, scheduledId: string, maxTestVal: number) {1056    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.selfCancelingInc', [scheduledId, maxTestVal], true);1057  }1058}10591060class EventCapture {1061  helper: DevUniqueHelper;1062  eventSection: string;1063  eventMethod: string;1064  events: EventRecord[] = [];1065  unsubscribe: VoidFn | null = null;10661067  constructor(1068    helper: DevUniqueHelper,1069    eventSection: string,1070    eventMethod: string,1071  ) {1072    this.helper = helper;1073    this.eventSection = eventSection;1074    this.eventMethod = eventMethod;1075  }10761077  async startCapture() {1078    this.stopCapture();1079    this.unsubscribe = (await this.helper.getApi().query.system.events((eventRecords: FrameSystemEventRecord[]) => {1080      const newEvents = eventRecords.filter(r => {1081        return r.event.section == this.eventSection && r.event.method == this.eventMethod;1082      });10831084      this.events.push(...newEvents);1085    })) as any;1086  }10871088  stopCapture() {1089    if (this.unsubscribe !== null) {1090      this.unsubscribe();1091    }1092  }10931094  extractCapturedEvents() {1095    return this.events;1096  }1097}10981099class AdminGroup {1100  helper: UniqueHelper;11011102  constructor(helper: UniqueHelper) {1103    this.helper = helper;1104  }11051106  async payoutStakers(signer: IKeyringPair, stakersToPayout: number):  Promise<{staker: string, stake: bigint, payout: bigint}[]> {1107    const payoutResult = await this.helper.executeExtrinsic(signer, 'api.tx.appPromotion.payoutStakers', [stakersToPayout], true);1108    return payoutResult.result.events.filter(e => e.event.method === 'StakingRecalculation').map(e => {1109      return {1110        staker: e.event.data[0].toString(),1111        stake: e.event.data[1].toBigInt(),1112        payout: e.event.data[2].toBigInt(),1113      };1114    });1115  }1116}