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

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, PolkadexHelper} 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, ITransactionResult, 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        const skippedWarnings = ['1000:: Normal connection closure', 'Not decorating unknown runtime apis:', 'RPC methods not decorated:', 'Not decorating runtime apis', 'Bad input data provided to validate_transaction', 'account balance too low', '1006:: Abnormal Closure'];45        const needToSkip = skippedWarnings.reduce((a,  b) => a || arg.includes(b), false);46        if(needToSkip || arg === 'Normal connection closure')47          return;48      }49      printer(...args);50    };5152    console.error = outFn(this.consoleErr.bind(console));53    console.log = outFn(this.consoleLog.bind(console));54    console.warn = outFn(this.consoleWarn.bind(console));55  }5657  disable() {58    console.error = this.consoleErr;59    console.log = this.consoleLog;60    console.warn = this.consoleWarn;61  }62}6364export interface IEventHelper {65  section(): string;6667  method(): string;6869  wrapEvent(data: any[]): any;70}7172// eslint-disable-next-line @typescript-eslint/naming-convention73function EventHelper(section: string, method: string, wrapEvent: (data: any[]) => any) {74  const helperClass = class implements IEventHelper {75    wrapEvent: (data: any[]) => any;76    _section: string;77    _method: string;7879    constructor() {80      this.wrapEvent = wrapEvent;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    filter(txres: ITransactionResult) {94      return txres.result.events.filter(e => e.event.section === section && e.event.method === method)95        .map(e => this.wrapEvent(e.event.data));96    }9798    find(txres: ITransactionResult) {99      const e = txres.result.events.find(e => e.event.section === section && e.event.method === method);100      return e ? this.wrapEvent(e.event.data) : null;101    }102103    expect(txres: ITransactionResult) {104      const e = this.find(txres);105      if(e) {106        return e;107      } else {108        throw Error(`Expected event ${section}.${method}`);109      }110    }111  };112113  return helperClass;114}115116function eventJsonData<T = any>(data: any[], index: number) {117  return data[index].toJSON() as T;118}119120function eventHumanData(data: any[], index: number) {121  return data[index].toHuman();122}123124function eventData<T = any>(data: any[], index: number) {125  return data[index] as T;126}127128// eslint-disable-next-line @typescript-eslint/naming-convention129function EventSection(section: string) {130  return class Section {131    static section = section;132133    static Method(name: string, wrapEvent: (data: any[]) => any = () => {}) {134      const helperClass = EventHelper(Section.section, name, wrapEvent);135      return new helperClass();136    }137  };138}139140function schedulerSection(schedulerInstance: string) {141  return class extends EventSection(schedulerInstance) {142    static Dispatched = this.Method('Dispatched', data => ({143      task: eventJsonData(data, 0),144      id: eventHumanData(data, 1),145      result: data[2],146    }));147148    static PriorityChanged = this.Method('PriorityChanged', data => ({149      task: eventJsonData(data, 0),150      priority: eventJsonData(data, 1),151    }));152  };153}154155export class Event {156  static Democracy = class extends EventSection('democracy') {157    static Proposed = this.Method('Proposed', data => ({158      proposalIndex: eventJsonData<number>(data, 0),159    }));160161    static ExternalTabled = this.Method('ExternalTabled');162163    static Started = this.Method('Started', data => ({164      referendumIndex: eventJsonData<number>(data, 0),165      threshold: eventHumanData(data, 1),166    }));167168    static Voted = this.Method('Voted', data => ({169      voter: eventJsonData(data, 0),170      referendumIndex: eventJsonData<number>(data, 1),171      vote: eventJsonData(data, 2),172    }));173174    static Passed = this.Method('Passed', data => ({175      referendumIndex: eventJsonData<number>(data, 0),176    }));177178    static ProposalCanceled = this.Method('ProposalCanceled', data => ({179      propIndex: eventJsonData<number>(data, 0),180    }));181182    static Cancelled = this.Method('Cancelled', data => ({183      propIndex: eventJsonData<number>(data, 0),184    }));185186    static Vetoed = this.Method('Vetoed', data => ({187      who: eventHumanData(data, 0),188      proposalHash: eventHumanData(data, 1),189      until: eventJsonData<number>(data, 1),190    }));191  };192193  static Council = class extends EventSection('council') {194    static Proposed = this.Method('Proposed', data => ({195      account: eventHumanData(data, 0),196      proposalIndex: eventJsonData<number>(data, 1),197      proposalHash: eventHumanData(data, 2),198      threshold: eventJsonData<number>(data, 3),199    }));200    static Closed = this.Method('Closed', data => ({201      proposalHash: eventHumanData(data, 0),202      yes: eventJsonData<number>(data, 1),203      no: eventJsonData<number>(data, 2),204    }));205    static Executed = this.Method('Executed', data => ({206      proposalHash: eventHumanData(data, 0),207    }));208  };209210  static TechnicalCommittee = class extends EventSection('technicalCommittee') {211    static Proposed = this.Method('Proposed', data => ({212      account: eventHumanData(data, 0),213      proposalIndex: eventJsonData<number>(data, 1),214      proposalHash: eventHumanData(data, 2),215      threshold: eventJsonData<number>(data, 3),216    }));217    static Closed = this.Method('Closed', data => ({218      proposalHash: eventHumanData(data, 0),219      yes: eventJsonData<number>(data, 1),220      no: eventJsonData<number>(data, 2),221    }));222    static Approved = this.Method('Approved', data => ({223      proposalHash: eventHumanData(data, 0),224    }));225    static Executed = this.Method('Executed', data => ({226      proposalHash: eventHumanData(data, 0),227      result: eventHumanData(data, 1),228    }));229  };230231  static FellowshipReferenda = class extends EventSection('fellowshipReferenda') {232    static Submitted = this.Method('Submitted', data => ({233      referendumIndex: eventJsonData<number>(data, 0),234      trackId: eventJsonData<number>(data, 1),235      proposal: eventJsonData(data, 2),236    }));237238    static Cancelled = this.Method('Cancelled', data => ({239      index: eventJsonData<number>(data, 0),240      tally: eventJsonData(data, 1),241    }));242  };243244  static UniqueScheduler = schedulerSection('uniqueScheduler');245  static Scheduler = schedulerSection('scheduler');246247  static XcmpQueue = class extends EventSection('xcmpQueue') {248    static XcmpMessageSent = this.Method('XcmpMessageSent', data => ({249      messageHash: eventJsonData(data, 0),250    }));251252    static Success = this.Method('Success', data => ({253      messageHash: eventJsonData(data, 0),254    }));255256    static Fail = this.Method('Fail', data => ({257      messageHash: eventJsonData(data, 0),258      outcome: eventData<XcmV2TraitsError>(data, 1),259    }));260  };261}262263export class DevUniqueHelper extends UniqueHelper {264  /**265   * Arrange methods for tests266   */267  arrange: ArrangeGroup;268  wait: WaitGroup;269  admin: AdminGroup;270  session: SessionGroup;271  testUtils: TestUtilGroup;272273  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {274    options.helperBase = options.helperBase ?? DevUniqueHelper;275276    super(logger, options);277    this.arrange = new ArrangeGroup(this);278    this.wait = new WaitGroup(this);279    this.admin = new AdminGroup(this);280    this.testUtils = new TestUtilGroup(this);281    this.session = new SessionGroup(this);282  }283284  async connect(wsEndpoint: string, _listeners?: any): Promise<void> {285    if(!wsEndpoint) throw new Error('wsEndpoint was not set');286    const wsProvider = new WsProvider(wsEndpoint);287    this.api = new ApiPromise({288      provider: wsProvider,289      signedExtensions: {290        ContractHelpers: {291          extrinsic: {},292          payload: {},293        },294        CheckMaintenance: {295          extrinsic: {},296          payload: {},297        },298        DisableIdentityCalls: {299          extrinsic: {},300          payload: {},301        },302        FakeTransactionFinalizer: {303          extrinsic: {},304          payload: {},305        },306      },307      rpc: {308        unique: defs.unique.rpc,309        appPromotion: defs.appPromotion.rpc,310        povinfo: defs.povinfo.rpc,311        eth: {312          feeHistory: {313            description: 'Dummy',314            params: [],315            type: 'u8',316          },317          maxPriorityFeePerGas: {318            description: 'Dummy',319            params: [],320            type: 'u8',321          },322        },323      },324    });325    await this.api.isReadyOrError;326    this.network = await UniqueHelper.detectNetwork(this.api);327    this.wsEndpoint = wsEndpoint;328  }329}330331export class DevRelayHelper extends RelayHelper {332  wait: WaitGroup;333334  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {335    options.helperBase = options.helperBase ?? DevRelayHelper;336337    super(logger, options);338    this.wait = new WaitGroup(this);339  }340}341342export class DevWestmintHelper extends WestmintHelper {343  wait: WaitGroup;344345  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {346    options.helperBase = options.helperBase ?? DevWestmintHelper;347348    super(logger, options);349    this.wait = new WaitGroup(this);350  }351}352353export class DevStatemineHelper extends DevWestmintHelper {}354355export class DevStatemintHelper extends DevWestmintHelper {}356357export class DevMoonbeamHelper extends MoonbeamHelper {358  account: MoonbeamAccountGroup;359  wait: WaitGroup;360  fastDemocracy: MoonbeamFastDemocracyGroup;361362  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {363    options.helperBase = options.helperBase ?? DevMoonbeamHelper;364    options.notePreimagePallet = options.notePreimagePallet ?? 'preimage';365366    super(logger, options);367    this.account = new MoonbeamAccountGroup(this);368    this.wait = new WaitGroup(this);369    this.fastDemocracy = new MoonbeamFastDemocracyGroup(this);370  }371}372373export class DevMoonriverHelper extends DevMoonbeamHelper {374  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {375    options.notePreimagePallet = options.notePreimagePallet ?? 'preimage';376    super(logger, options);377  }378}379380export class DevAstarHelper extends AstarHelper {381  wait: WaitGroup;382383  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {384    options.helperBase = options.helperBase ?? DevAstarHelper;385386    super(logger, options);387    this.wait = new WaitGroup(this);388  }389}390391export class DevShidenHelper extends AstarHelper {392  wait: WaitGroup;393394  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {395    options.helperBase = options.helperBase ?? DevShidenHelper;396397    super(logger, options);398    this.wait = new WaitGroup(this);399  }400}401402export class DevAcalaHelper extends AcalaHelper {403  wait: WaitGroup;404405  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {406    options.helperBase = options.helperBase ?? DevAcalaHelper;407408    super(logger, options);409    this.wait = new WaitGroup(this);410  }411}412413export class DevPolkadexHelper extends PolkadexHelper {414  wait: WaitGroup;415  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {416    options.helperBase = options.helperBase ?? PolkadexHelper;417418    super(logger, options);419    this.wait = new WaitGroup(this);420  }421}422423export class DevKaruraHelper extends DevAcalaHelper {}424425export class ArrangeGroup {426  helper: DevUniqueHelper;427428  scheduledIdSlider = 0;429430  constructor(helper: DevUniqueHelper) {431    this.helper = helper;432  }433434  /**435   * Generates accounts with the specified UNQ token balance436   * @param balances balances for generated accounts. Each balance will be multiplied by the token nominal.437   * @param donor donor account for balances438   * @returns array of newly created accounts439   * @example const [acc1, acc2, acc3] = await createAccounts([0n, 10n, 20n], donor);440   */441  createAccounts = async (balances: bigint[], donor: IKeyringPair): Promise<IKeyringPair[]> => {442    let nonce = await this.helper.chain.getNonce(donor.address);443    const wait = new WaitGroup(this.helper);444    const ss58Format = this.helper.chain.getChainProperties().ss58Format;445    const tokenNominal = this.helper.balance.getOneTokenNominal();446    const transactions = [];447    const accounts: IKeyringPair[] = [];448    for(const balance of balances) {449      const recipient = this.helper.util.fromSeed(mnemonicGenerate(), ss58Format);450      accounts.push(recipient);451      if(balance !== 0n) {452        const tx = this.helper.constructApiCall('api.tx.balances.transfer', [{Id: recipient.address}, balance * tokenNominal]);453        transactions.push(this.helper.signTransaction(donor, tx, {nonce, era: 0}, 'account generation'));454        nonce++;455      }456    }457458    await Promise.all(transactions).catch(_e => {});459460    //#region TODO remove this region, when nonce problem will be solved461    const checkBalances = async () => {462      let isSuccess = true;463      for(let i = 0; i < balances.length; i++) {464        const balance = await this.helper.balance.getSubstrate(accounts[i].address);465        if(balance !== balances[i] * tokenNominal) {466          isSuccess = false;467          break;468        }469      }470      return isSuccess;471    };472473    let accountsCreated = false;474    const maxBlocksChecked = await this.helper.arrange.isDevNode() ? 50 : 5;475    // checkBalances retry up to 5-50 blocks476    for(let index = 0; index < maxBlocksChecked; index++) {477      accountsCreated = await checkBalances();478      if(accountsCreated) break;479      await wait.newBlocks(1);480    }481482    if(!accountsCreated) throw Error('Accounts generation failed');483    //#endregion484485    return accounts;486  };487488  // TODO combine this method and createAccounts into one489  createCrowd = async (accountsToCreate: number, withBalance: bigint, donor: IKeyringPair): Promise<IKeyringPair[]> => {490    const createAsManyAsCan = async () => {491      let transactions: any = [];492      const accounts: IKeyringPair[] = [];493      let nonce = await this.helper.chain.getNonce(donor.address);494      const tokenNominal = this.helper.balance.getOneTokenNominal();495      const ss58Format = this.helper.chain.getChainProperties().ss58Format;496      for(let i = 0; i < accountsToCreate; i++) {497        if(i === 500) { // if there are too many accounts to create498          await Promise.allSettled(transactions); // wait while first 500 (should be 100 for devnode) tx will be settled499          transactions = []; //500          nonce = await this.helper.chain.getNonce(donor.address); // update nonce501        }502        const recipient = this.helper.util.fromSeed(mnemonicGenerate(), ss58Format);503        accounts.push(recipient);504        if(withBalance !== 0n) {505          const tx = this.helper.constructApiCall('api.tx.balances.transfer', [{Id: recipient.address}, withBalance * tokenNominal]);506          transactions.push(this.helper.signTransaction(donor, tx, {nonce}, 'account generation'));507          nonce++;508        }509      }510511      const fullfilledAccounts = [];512      await Promise.allSettled(transactions);513      for(const account of accounts) {514        const accountBalance = await this.helper.balance.getSubstrate(account.address);515        if(accountBalance === withBalance * tokenNominal) {516          fullfilledAccounts.push(account);517        }518      }519      return fullfilledAccounts;520    };521522523    const crowd: IKeyringPair[] = [];524    // do up to 5 retries525    for(let index = 0; index < 5 && accountsToCreate !== 0; index++) {526      const asManyAsCan = await createAsManyAsCan();527      crowd.push(...asManyAsCan);528      accountsToCreate -= asManyAsCan.length;529    }530531    if(accountsToCreate !== 0) throw Error(`Crowd generation failed: ${accountsToCreate} accounts left`);532533    return crowd;534  };535536  /**537   * Generates one account with zero balance538   * @returns the newly generated account539   * @example const account = await helper.arrange.createEmptyAccount();540   */541  createEmptyAccount = (): IKeyringPair => {542    const ss58Format = this.helper.chain.getChainProperties().ss58Format;543    return this.helper.util.fromSeed(mnemonicGenerate(), ss58Format);544  };545546  isDevNode = async () => {547    let blockNumber = (await this.helper.callRpc('api.query.system.number')).toJSON();548    if(blockNumber == 0) {549      await this.helper.wait.newBlocks(1);550      blockNumber = (await this.helper.callRpc('api.query.system.number')).toJSON();551    }552    const block2 = await this.helper.callRpc('api.rpc.chain.getBlock', [await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])]);553    const block1 = await this.helper.callRpc('api.rpc.chain.getBlock', [await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber - 1])]);554    const findCreationDate = (block: any) => {555      const humanBlock = block.toHuman();556      let date;557      humanBlock.block.extrinsics.forEach((ext: any) => {558        if(ext.method.section === 'timestamp') {559          date = Number(ext.method.args.now.replaceAll(',', ''));560        }561      });562      return date;563    };564    const block1date = await findCreationDate(block1);565    const block2date = await findCreationDate(block2);566    if(block2date! - block1date! < 9000) return true;567  };568569  async calculcateFee(payer: ICrossAccountId, promise: () => Promise<any>): Promise<bigint> {570    const address = 'Substrate' in payer ? payer.Substrate : this.helper.address.ethToSubstrate(payer.Ethereum);571    let balance = await this.helper.balance.getSubstrate(address);572573    await promise();574575    balance -= await this.helper.balance.getSubstrate(address);576577    return balance;578  }579580  async calculatePoVInfo(txs: any[]): Promise<IPovInfo> {581    const rawPovInfo = await this.helper.callRpc('api.rpc.povinfo.estimateExtrinsicPoV', [txs]);582583    const kvJson: {[key: string]: string} = {};584585    for(const kv of rawPovInfo.keyValues) {586      kvJson[kv.key.toHex()] = kv.value.toHex();587    }588589    const kvStr = JSON.stringify(kvJson);590591    const chainql = spawnSync(592      'chainql',593      [594        `--tla-code=data=${kvStr}`,595        '-e', `function(data) cql.dump(cql.chain("${this.helper.getEndpoint()}").latest._meta, data, {omit_empty:true})`,596      ],597    );598599    if(!chainql.stdout) {600      throw Error('unable to get an output from the `chainql`');601    }602603    return {604      proofSize: rawPovInfo.proofSize.toNumber(),605      compactProofSize: rawPovInfo.compactProofSize.toNumber(),606      compressedProofSize: rawPovInfo.compressedProofSize.toNumber(),607      results: rawPovInfo.results,608      kv: JSON.parse(chainql.stdout.toString()),609    };610  }611612  calculatePalletAddress(palletId: any) {613    const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));614    return encodeAddress(address, this.helper.chain.getChainProperties().ss58Format);615  }616617  makeScheduledIds(num: number): string[] {618    function makeId(slider: number) {619      const scheduledIdSize = 64;620      const hexId = slider.toString(16);621      const prefixSize = scheduledIdSize - hexId.length;622623      const scheduledId = '0x' + '0'.repeat(prefixSize) + hexId;624625      return scheduledId;626    }627628    const ids = [];629    for(let i = 0; i < num; i++) {630      ids.push(makeId(this.scheduledIdSlider));631      this.scheduledIdSlider += 1;632    }633634    return ids;635  }636637  makeScheduledId(): string {638    return (this.makeScheduledIds(1))[0];639  }640641  async captureEvents(eventSection: string, eventMethod: string): Promise<EventCapture> {642    const capture = new EventCapture(this.helper, eventSection, eventMethod);643    await capture.startCapture();644645    return capture;646  }647648  makeXcmProgramWithdrawDeposit(beneficiary: Uint8Array, id: any, amount: bigint) {649    return {650      V2: [651        {652          WithdrawAsset: [653            {654              id,655              fun: {656                Fungible: amount,657              },658            },659          ],660        },661        {662          BuyExecution: {663            fees: {664              id,665              fun: {666                Fungible: amount,667              },668            },669            weightLimit: 'Unlimited',670          },671        },672        {673          DepositAsset: {674            assets: {675              Wild: 'All',676            },677            maxAssets: 1,678            beneficiary: {679              parents: 0,680              interior: {681                X1: {682                  AccountId32: {683                    network: 'Any',684                    id: beneficiary,685                  },686                },687              },688            },689          },690        },691      ],692    };693  }694695  makeXcmProgramReserveAssetDeposited(beneficiary: Uint8Array, id: any, amount: bigint) {696    return {697      V2: [698        {699          ReserveAssetDeposited: [700            {701              id,702              fun: {703                Fungible: amount,704              },705            },706          ],707        },708        {709          BuyExecution: {710            fees: {711              id,712              fun: {713                Fungible: amount,714              },715            },716            weightLimit: 'Unlimited',717          },718        },719        {720          DepositAsset: {721            assets: {722              Wild: 'All',723            },724            maxAssets: 1,725            beneficiary: {726              parents: 0,727              interior: {728                X1: {729                  AccountId32: {730                    network: 'Any',731                    id: beneficiary,732                  },733                },734              },735            },736          },737        },738      ],739    };740  }741}742743class MoonbeamAccountGroup {744  helper: MoonbeamHelper;745746  keyring: Keyring;747  _alithAccount: IKeyringPair;748  _baltatharAccount: IKeyringPair;749  _dorothyAccount: IKeyringPair;750751  constructor(helper: MoonbeamHelper) {752    this.helper = helper;753754    this.keyring = new Keyring({type: 'ethereum'});755    const alithPrivateKey = '0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133';756    const baltatharPrivateKey = '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b';757    const dorothyPrivateKey = '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68';758759    this._alithAccount = this.keyring.addFromUri(alithPrivateKey, undefined, 'ethereum');760    this._baltatharAccount = this.keyring.addFromUri(baltatharPrivateKey, undefined, 'ethereum');761    this._dorothyAccount = this.keyring.addFromUri(dorothyPrivateKey, undefined, 'ethereum');762  }763764  alithAccount() {765    return this._alithAccount;766  }767768  baltatharAccount() {769    return this._baltatharAccount;770  }771772  dorothyAccount() {773    return this._dorothyAccount;774  }775776  create() {777    return this.keyring.addFromUri(mnemonicGenerate());778  }779}780781class MoonbeamFastDemocracyGroup {782  helper: DevMoonbeamHelper;783784  constructor(helper: DevMoonbeamHelper) {785    this.helper = helper;786  }787788  async executeProposal(proposalDesciption: string, encodedProposal: string) {789    const proposalHash = blake2AsHex(encodedProposal);790791    const alithAccount = this.helper.account.alithAccount();792    const baltatharAccount = this.helper.account.baltatharAccount();793    const dorothyAccount = this.helper.account.dorothyAccount();794795    const councilVotingThreshold = 2;796    const technicalCommitteeThreshold = 2;797    const fastTrackVotingPeriod = 3;798    const fastTrackDelayPeriod = 0;799800    console.log(`[democracy] executing '${proposalDesciption}' proposal`);801802    // >>> Propose external motion through council >>>803    console.log('\t* Propose external motion through council.......');804    const externalMotion = this.helper.democracy.externalProposeMajority({Inline: encodedProposal});805    const encodedMotion = externalMotion?.method.toHex() || '';806    const motionHash = blake2AsHex(encodedMotion);807    console.log('\t* Motion hash is %s', motionHash);808809    await this.helper.collective.council.propose(810      baltatharAccount,811      councilVotingThreshold,812      externalMotion,813      externalMotion.encodedLength,814    );815816    const councilProposalIdx = await this.helper.collective.council.proposalCount() - 1;817    await this.helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);818    await this.helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);819820    await this.helper.collective.council.close(821      dorothyAccount,822      motionHash,823      councilProposalIdx,824      {825        refTime: 1_000_000_000,826        proofSize: 1_000_000,827      },828      externalMotion.encodedLength,829    );830    console.log('\t* Propose external motion through council.......DONE');831    // <<< Propose external motion through council <<<832833    // >>> Fast track proposal through technical committee >>>834    console.log('\t* Fast track proposal through technical committee.......');835    const fastTrack = this.helper.democracy.fastTrack(proposalHash, fastTrackVotingPeriod, fastTrackDelayPeriod);836    const encodedFastTrack = fastTrack?.method.toHex() || '';837    const fastTrackHash = blake2AsHex(encodedFastTrack);838    console.log('\t* FastTrack hash is %s', fastTrackHash);839840    await this.helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);841842    const techProposalIdx = await this.helper.collective.techCommittee.proposalCount() - 1;843    await this.helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);844    await this.helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);845846    await this.helper.collective.techCommittee.close(847      baltatharAccount,848      fastTrackHash,849      techProposalIdx,850      {851        refTime: 1_000_000_000,852        proofSize: 1_000_000,853      },854      fastTrack.encodedLength,855    );856    console.log('\t* Fast track proposal through technical committee.......DONE');857    // <<< Fast track proposal through technical committee <<<858859    const democracyStarted = await this.helper.wait.expectEvent(3, Event.Democracy.Started);860    const referendumIndex = democracyStarted.referendumIndex;861862    // >>> Referendum voting >>>863    console.log(`\t* Referendum #${referendumIndex} voting.......`);864    await this.helper.democracy.referendumVote(dorothyAccount, referendumIndex, {865      balance: 10_000_000_000_000_000_000n,866      vote: {aye: true, conviction: 1},867    });868    console.log(`\t* Referendum #${referendumIndex} voting.......DONE`);869    // <<< Referendum voting <<<870871    // Wait the proposal to pass872    await this.helper.wait.expectEvent(3, Event.Democracy.Passed, event => event.referendumIndex == referendumIndex);873874    await this.helper.wait.newBlocks(1);875876    console.log(`[democracy] executing '${proposalDesciption}' proposal.......DONE`);877  }878}879880class WaitGroup {881  helper: ChainHelperBase;882883  constructor(helper: ChainHelperBase) {884    this.helper = helper;885  }886887  sleep(milliseconds: number) {888    return new Promise((resolve) => setTimeout(resolve, milliseconds));889  }890891  private async waitWithTimeout(promise: Promise<any>, timeout: number) {892    let isBlock = false;893    promise.then(() => isBlock = true).catch(() => isBlock = true);894    let totalTime = 0;895    const step = 100;896    while(!isBlock) {897      await this.sleep(step);898      totalTime += step;899      if(totalTime >= timeout) throw Error('Blocks production failed');900    }901    return promise;902  }903904  /**905   * Launch some async operation, or throw an error after some time. Note that it will still continue executing after the timeout.906   * @param promise async operation to race against the timeout907   * @param timeoutMS time after which to time out908   * @param timeoutError error message to throw909   * @returns promise of the same type the operation had910   */911  withTimeout<T>(912    promise: Promise<T>,913    timeoutMS = 30000,914    timeoutError = 'The operation has timed out!',915  ): Promise<T> {916    const timeout = new Promise<never>((_, reject) => {917      setTimeout(() => {918        reject(new Error(timeoutError));919      }, timeoutMS);920    });921922    return Promise.race<T>([promise, timeout]).catch(e => {throw new Error(e);});923  }924925  /**926   * Wait for specified number of blocks927   * @param blocksCount number of blocks to wait928   * @returns929   */930  async newBlocks(blocksCount = 1, timeout?: number): Promise<void> {931    timeout = timeout ?? blocksCount * 60_000;932    // eslint-disable-next-line no-async-promise-executor933    const promise = new Promise<void>(async (resolve) => {934      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(() => {935        if(blocksCount > 0) {936          blocksCount--;937        } else {938          unsubscribe();939          resolve();940        }941      });942    });943    await this.waitWithTimeout(promise, timeout);944    return promise;945  }946947  /**948   * Wait for the specified number of sessions to pass.949   * Only applicable if the Session pallet is turned on.950   * @param sessionCount number of sessions to wait951   * @param blockTimeout time in ms until panicking that the chain has stopped producing blocks952   * @returns953   */954  async newSessions(sessionCount = 1, blockTimeout = 60000): Promise<void> {955    console.log(`Waiting for ${sessionCount} new session${sessionCount > 1 ? 's' : ''}.`956      + ' This might take a while -- check SessionPeriod in pallet_session::Config for session time.');957958    const expectedSessionIndex = await (this.helper as DevUniqueHelper).session.getIndex() + sessionCount;959    let currentSessionIndex = -1;960961    while(currentSessionIndex < expectedSessionIndex) {962      // eslint-disable-next-line no-async-promise-executor963      currentSessionIndex = await this.withTimeout(new Promise(async (resolve) => {964        await this.newBlocks(1);965        const res = await (this.helper as DevUniqueHelper).session.getIndex();966        resolve(res);967      }), blockTimeout, 'The chain has stopped producing blocks!');968    }969  }970971  async forParachainBlockNumber(blockNumber: bigint | number, timeout?: number) {972    timeout = timeout ?? 30 * 60 * 1000;973    // eslint-disable-next-line no-async-promise-executor974    const promise = new Promise<void>(async (resolve) => {975      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads((data: any) => {976        if(data.number.toNumber() >= blockNumber) {977          unsubscribe();978          resolve();979        }980      });981    });982    await this.waitWithTimeout(promise, timeout);983    return promise;984  }985986  async forRelayBlockNumber(blockNumber: bigint | number, timeout?: number) {987    timeout = timeout ?? 30 * 60 * 1000;988    // eslint-disable-next-line no-async-promise-executor989    const promise = new Promise<void>(async (resolve) => {990      const unsubscribe = await this.helper.getApi().query.parachainSystem.validationData((data: any) => {991        if(data.value.relayParentNumber.toNumber() >= blockNumber) {992          // @ts-ignore993          unsubscribe();994          resolve();995        }996      });997    });998    await this.waitWithTimeout(promise, timeout);999    return promise;1000  }10011002  noScheduledTasks() {1003    const api = this.helper.getApi();10041005    // eslint-disable-next-line no-async-promise-executor1006    const promise = new Promise<void>(async resolve => {1007      const unsubscribe = await api.rpc.chain.subscribeNewHeads(async () => {1008        const areThereScheduledTasks = await api.query.scheduler.lookup.entries();10091010        if(areThereScheduledTasks.length == 0) {1011          unsubscribe();1012          resolve();1013        }1014      });1015    });10161017    return promise;1018  }10191020  parachainBlockMultiplesOf(val: bigint) {1021    // eslint-disable-next-line no-async-promise-executor1022    const promise = new Promise<void>(async resolve => {1023      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads((data: any) => {1024        if(data.number.toBigInt() % val == 0n) {1025          console.log(`from waiter: ${data.number.toBigInt()}`);1026          unsubscribe();1027          resolve();1028        }1029      });1030    });1031    return promise;1032  }10331034  event<T extends IEventHelper>(1035    maxBlocksToWait: number,1036    eventHelper: T,1037    filter: (_: any) => boolean = () => true,1038  ): any {1039    // eslint-disable-next-line no-async-promise-executor1040    const promise = new Promise<T | null>(async (resolve) => {1041      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(async header => {1042        const blockNumber = header.number.toHuman();1043        const blockHash = header.hash;1044        const eventIdStr = `${eventHelper.section()}.${eventHelper.method()}`;1045        const waitLimitStr = `wait blocks remaining: ${maxBlocksToWait}`;10461047        this.helper.logger.log(`[Block #${blockNumber}] Waiting for event \`${eventIdStr}\` (${waitLimitStr})`);10481049        const apiAt = await this.helper.getApi().at(blockHash);1050        const eventRecords = (await apiAt.query.system.events()) as any;10511052        const neededEvent = eventRecords.toArray()1053          .filter((r: FrameSystemEventRecord) => r.event.section == eventHelper.section() && r.event.method == eventHelper.method())1054          .map((r: FrameSystemEventRecord) => eventHelper.wrapEvent(r.event.data))1055          .find(filter);10561057        if(neededEvent) {1058          unsubscribe();1059          resolve(neededEvent);1060        } else if(maxBlocksToWait > 0) {1061          maxBlocksToWait--;1062        } else {1063          this.helper.logger.log(`Eligible event \`${eventIdStr}\` is NOT found`);1064          unsubscribe();1065          resolve(null);1066        }1067      });1068    });1069    return promise;1070  }10711072  async expectEvent<T extends IEventHelper>(1073    maxBlocksToWait: number,1074    eventHelper: T,1075    filter: (e: any) => boolean = () => true,1076  ) {1077    const e = await this.event(maxBlocksToWait, eventHelper, filter);1078    if(e == null) {1079      throw Error(`The event '${eventHelper.section()}.${eventHelper.method()}' is expected`);1080    } else {1081      return e;1082    }1083  }1084}10851086class SessionGroup {1087  helper: ChainHelperBase;10881089  constructor(helper: ChainHelperBase) {1090    this.helper = helper;1091  }10921093  //todo:collator documentation1094  async getIndex(): Promise<number> {1095    return (await this.helper.callRpc('api.query.session.currentIndex', [])).toNumber();1096  }10971098  newSessions(sessionCount = 1, blockTimeout = 24000): Promise<void> {1099    return (this.helper as DevUniqueHelper).wait.newSessions(sessionCount, blockTimeout);1100  }11011102  setOwnKeys(signer: TSigner, key: string) {1103    return this.helper.executeExtrinsic(1104      signer,1105      'api.tx.session.setKeys',1106      [key, '0x0'],1107      true,1108    );1109  }11101111  setOwnKeysFromAddress(signer: TSigner) {1112    return this.setOwnKeys(signer, '0x' + Buffer.from(signer.addressRaw).toString('hex'));1113  }1114}11151116class TestUtilGroup {1117  helper: DevUniqueHelper;11181119  constructor(helper: DevUniqueHelper) {1120    this.helper = helper;1121  }11221123  async enable() {1124    if(this.helper.fetchMissingPalletNames([Pallets.TestUtils]).length != 0) {1125      return;1126    }11271128    const signer = this.helper.util.fromSeed('//Alice');1129    await this.helper.getSudo<DevUniqueHelper>().executeExtrinsic(signer, 'api.tx.testUtils.enable', [], true);1130  }11311132  async setTestValue(signer: TSigner, testVal: number) {1133    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.setTestValue', [testVal], true);1134  }11351136  async incTestValue(signer: TSigner) {1137    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.incTestValue', [], true);1138  }11391140  async setTestValueAndRollback(signer: TSigner, testVal: number) {1141    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.setTestValueAndRollback', [testVal], true);1142  }11431144  async testValue(blockIdx?: number) {1145    const api = blockIdx1146      ? await this.helper.getApi().at(await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockIdx]))1147      : this.helper.getApi();11481149    return (await api.query.testUtils.testValue()).toJSON();1150  }11511152  async justTakeFee(signer: TSigner) {1153    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.justTakeFee', [], true);1154  }11551156  async selfCancelingInc(signer: TSigner, scheduledId: string, maxTestVal: number) {1157    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.selfCancelingInc', [scheduledId, maxTestVal], true);1158  }1159}11601161class EventCapture {1162  helper: DevUniqueHelper;1163  eventSection: string;1164  eventMethod: string;1165  events: EventRecord[] = [];1166  unsubscribe: VoidFn | null = null;11671168  constructor(1169    helper: DevUniqueHelper,1170    eventSection: string,1171    eventMethod: string,1172  ) {1173    this.helper = helper;1174    this.eventSection = eventSection;1175    this.eventMethod = eventMethod;1176  }11771178  async startCapture() {1179    this.stopCapture();1180    this.unsubscribe = (await this.helper.getApi().query.system.events((eventRecords: FrameSystemEventRecord[]) => {1181      const newEvents = eventRecords.filter(r => r.event.section == this.eventSection && r.event.method == this.eventMethod);11821183      this.events.push(...newEvents);1184    })) as any;1185  }11861187  stopCapture() {1188    if(this.unsubscribe !== null) {1189      this.unsubscribe();1190    }1191  }11921193  extractCapturedEvents() {1194    return this.events;1195  }1196}11971198class AdminGroup {1199  helper: UniqueHelper;12001201  constructor(helper: UniqueHelper) {1202    this.helper = helper;1203  }12041205  async payoutStakers(signer: IKeyringPair, stakersToPayout: number):  Promise<{staker: string, stake: bigint, payout: bigint}[]> {1206    const payoutResult = await this.helper.executeExtrinsic(signer, 'api.tx.appPromotion.payoutStakers', [stakersToPayout], true);1207    return payoutResult.result.events.filter(e => e.event.method === 'StakingRecalculation').map(e => ({1208      staker: e.event.data[0].toString(),1209      stake: e.event.data[1].toBigInt(),1210      payout: e.event.data[2].toBigInt(),1211    }));1212  }1213}