git.delta.rocks / unique-network / refs/commits / 369a51ded768

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, ITransactionResult, TSigner} from './types';12import {FrameSystemEventRecord, XcmV2TraitsError, PalletSchedulerEvent} 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    }));177  };178179  static Council = class extends EventSection('council') {180    static Proposed = this.Method('Proposed', data => ({181      account: eventHumanData(data, 0),182      proposalIndex: eventJsonData<number>(data, 1),183      proposalHash: eventHumanData(data, 2),184      threshold: eventJsonData<number>(data, 3),185    }));186    static Closed = this.Method('Closed', data => ({187      proposalHash: eventHumanData(data, 0),188      yes: eventJsonData<number>(data, 1),189      no: eventJsonData<number>(data, 2),190    }));191  };192193  static TechnicalCommittee = class extends EventSection('technicalCommittee') {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  };206207  static FellowshipReferenda = class extends EventSection('fellowshipReferenda') {208    static Submitted = this.Method('Submitted', data => ({209      referendumIndex: eventJsonData<number>(data, 0),210      trackId: eventJsonData<number>(data, 1),211      proposal: eventJsonData(data, 2),212    }));213  };214215  static UniqueScheduler = schedulerSection('uniqueScheduler');216  static Scheduler = schedulerSection('scheduler');217218  static XcmpQueue = class extends EventSection('xcmpQueue') {219    static XcmpMessageSent = this.Method('XcmpMessageSent', data => ({220      messageHash: eventJsonData(data, 0),221    }));222223    static Fail = this.Method('Fail', data => ({224      messageHash: eventJsonData(data, 0),225      outcome: eventData<XcmV2TraitsError>(data, 1),226    }));227  };228}229230export class DevUniqueHelper extends UniqueHelper {231  /**232   * Arrange methods for tests233   */234  arrange: ArrangeGroup;235  wait: WaitGroup;236  admin: AdminGroup;237  session: SessionGroup;238  testUtils: TestUtilGroup;239240  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {241    options.helperBase = options.helperBase ?? DevUniqueHelper;242243    super(logger, options);244    this.arrange = new ArrangeGroup(this);245    this.wait = new WaitGroup(this);246    this.admin = new AdminGroup(this);247    this.testUtils = new TestUtilGroup(this);248    this.session = new SessionGroup(this);249  }250251  async connect(wsEndpoint: string, _listeners?: any): Promise<void> {252    const wsProvider = new WsProvider(wsEndpoint);253    this.api = new ApiPromise({254      provider: wsProvider,255      signedExtensions: {256        ContractHelpers: {257          extrinsic: {},258          payload: {},259        },260        CheckMaintenance: {261          extrinsic: {},262          payload: {},263        },264        DisableIdentityCalls: {265          extrinsic: {},266          payload: {},267        },268        FakeTransactionFinalizer: {269          extrinsic: {},270          payload: {},271        },272      },273      rpc: {274        unique: defs.unique.rpc,275        appPromotion: defs.appPromotion.rpc,276        povinfo: defs.povinfo.rpc,277        eth: {278          feeHistory: {279            description: 'Dummy',280            params: [],281            type: 'u8',282          },283          maxPriorityFeePerGas: {284            description: 'Dummy',285            params: [],286            type: 'u8',287          },288        },289      },290    });291    await this.api.isReadyOrError;292    this.network = await UniqueHelper.detectNetwork(this.api);293    this.wsEndpoint = wsEndpoint;294  }295}296297export class DevRelayHelper extends RelayHelper {298  wait: WaitGroup;299300  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {301    options.helperBase = options.helperBase ?? DevRelayHelper;302303    super(logger, options);304    this.wait = new WaitGroup(this);305  }306}307308export class DevWestmintHelper extends WestmintHelper {309  wait: WaitGroup;310311  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {312    options.helperBase = options.helperBase ?? DevWestmintHelper;313314    super(logger, options);315    this.wait = new WaitGroup(this);316  }317}318319export class DevStatemineHelper extends DevWestmintHelper {}320321export class DevStatemintHelper extends DevWestmintHelper {}322323export class DevMoonbeamHelper extends MoonbeamHelper {324  account: MoonbeamAccountGroup;325  wait: WaitGroup;326  fastDemocracy: MoonbeamFastDemocracyGroup;327328  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {329    options.helperBase = options.helperBase ?? DevMoonbeamHelper;330    options.notePreimagePallet = options.notePreimagePallet ?? 'preimage';331332    super(logger, options);333    this.account = new MoonbeamAccountGroup(this);334    this.wait = new WaitGroup(this);335    this.fastDemocracy = new MoonbeamFastDemocracyGroup(this);336  }337}338339export class DevMoonriverHelper extends DevMoonbeamHelper {340  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {341    options.notePreimagePallet = options.notePreimagePallet ?? 'preimage';342    super(logger, options);343  }344}345346export class DevAstarHelper extends AstarHelper {347  wait: WaitGroup;348349  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {350    options.helperBase = options.helperBase ?? DevAstarHelper;351352    super(logger, options);353    this.wait = new WaitGroup(this);354  }355}356357export class DevShidenHelper extends AstarHelper {358  wait: WaitGroup;359360  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {361    options.helperBase = options.helperBase ?? DevShidenHelper;362363    super(logger, options);364    this.wait = new WaitGroup(this);365  }366}367368export class DevAcalaHelper extends AcalaHelper {369  wait: WaitGroup;370371  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {372    options.helperBase = options.helperBase ?? DevAcalaHelper;373374    super(logger, options);375    this.wait = new WaitGroup(this);376  }377}378379export class DevKaruraHelper extends DevAcalaHelper {}380381export class ArrangeGroup {382  helper: DevUniqueHelper;383384  scheduledIdSlider = 0;385386  constructor(helper: DevUniqueHelper) {387    this.helper = helper;388  }389390  /**391   * Generates accounts with the specified UNQ token balance392   * @param balances balances for generated accounts. Each balance will be multiplied by the token nominal.393   * @param donor donor account for balances394   * @returns array of newly created accounts395   * @example const [acc1, acc2, acc3] = await createAccounts([0n, 10n, 20n], donor);396   */397  createAccounts = async (balances: bigint[], donor: IKeyringPair): Promise<IKeyringPair[]> => {398    let nonce = await this.helper.chain.getNonce(donor.address);399    const wait = new WaitGroup(this.helper);400    const ss58Format = this.helper.chain.getChainProperties().ss58Format;401    const tokenNominal = this.helper.balance.getOneTokenNominal();402    const transactions = [];403    const accounts: IKeyringPair[] = [];404    for(const balance of balances) {405      const recipient = this.helper.util.fromSeed(mnemonicGenerate(), ss58Format);406      accounts.push(recipient);407      if(balance !== 0n) {408        const tx = this.helper.constructApiCall('api.tx.balances.transfer', [{Id: recipient.address}, balance * tokenNominal]);409        transactions.push(this.helper.signTransaction(donor, tx, {nonce, era: 0}, 'account generation'));410        nonce++;411      }412    }413414    await Promise.all(transactions).catch(_e => {});415416    //#region TODO remove this region, when nonce problem will be solved417    const checkBalances = async () => {418      let isSuccess = true;419      for(let i = 0; i < balances.length; i++) {420        const balance = await this.helper.balance.getSubstrate(accounts[i].address);421        if(balance !== balances[i] * tokenNominal) {422          isSuccess = false;423          break;424        }425      }426      return isSuccess;427    };428429    let accountsCreated = false;430    const maxBlocksChecked = await this.helper.arrange.isDevNode() ? 50 : 5;431    // checkBalances retry up to 5-50 blocks432    for(let index = 0; index < maxBlocksChecked; index++) {433      accountsCreated = await checkBalances();434      if(accountsCreated) break;435      await wait.newBlocks(1);436    }437438    if(!accountsCreated) throw Error('Accounts generation failed');439    //#endregion440441    return accounts;442  };443444  // TODO combine this method and createAccounts into one445  createCrowd = async (accountsToCreate: number, withBalance: bigint, donor: IKeyringPair): Promise<IKeyringPair[]> => {446    const createAsManyAsCan = async () => {447      let transactions: any = [];448      const accounts: IKeyringPair[] = [];449      let nonce = await this.helper.chain.getNonce(donor.address);450      const tokenNominal = this.helper.balance.getOneTokenNominal();451      const ss58Format = this.helper.chain.getChainProperties().ss58Format;452      for(let i = 0; i < accountsToCreate; i++) {453        if(i === 500) { // if there are too many accounts to create454          await Promise.allSettled(transactions); // wait while first 500 (should be 100 for devnode) tx will be settled455          transactions = []; //456          nonce = await this.helper.chain.getNonce(donor.address); // update nonce457        }458        const recipient = this.helper.util.fromSeed(mnemonicGenerate(), ss58Format);459        accounts.push(recipient);460        if(withBalance !== 0n) {461          const tx = this.helper.constructApiCall('api.tx.balances.transfer', [{Id: recipient.address}, withBalance * tokenNominal]);462          transactions.push(this.helper.signTransaction(donor, tx, {nonce}, 'account generation'));463          nonce++;464        }465      }466467      const fullfilledAccounts = [];468      await Promise.allSettled(transactions);469      for(const account of accounts) {470        const accountBalance = await this.helper.balance.getSubstrate(account.address);471        if(accountBalance === withBalance * tokenNominal) {472          fullfilledAccounts.push(account);473        }474      }475      return fullfilledAccounts;476    };477478479    const crowd: IKeyringPair[] = [];480    // do up to 5 retries481    for(let index = 0; index < 5 && accountsToCreate !== 0; index++) {482      const asManyAsCan = await createAsManyAsCan();483      crowd.push(...asManyAsCan);484      accountsToCreate -= asManyAsCan.length;485    }486487    if(accountsToCreate !== 0) throw Error(`Crowd generation failed: ${accountsToCreate} accounts left`);488489    return crowd;490  };491492  /**493   * Generates one account with zero balance494   * @returns the newly generated account495   * @example const account = await helper.arrange.createEmptyAccount();496   */497  createEmptyAccount = (): IKeyringPair => {498    const ss58Format = this.helper.chain.getChainProperties().ss58Format;499    return this.helper.util.fromSeed(mnemonicGenerate(), ss58Format);500  };501502  isDevNode = async () => {503    let blockNumber = (await this.helper.callRpc('api.query.system.number')).toJSON();504    if(blockNumber == 0) {505      await this.helper.wait.newBlocks(1);506      blockNumber = (await this.helper.callRpc('api.query.system.number')).toJSON();507    }508    const block2 = await this.helper.callRpc('api.rpc.chain.getBlock', [await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])]);509    const block1 = await this.helper.callRpc('api.rpc.chain.getBlock', [await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber - 1])]);510    const findCreationDate = (block: any) => {511      const humanBlock = block.toHuman();512      let date;513      humanBlock.block.extrinsics.forEach((ext: any) => {514        if(ext.method.section === 'timestamp') {515          date = Number(ext.method.args.now.replaceAll(',', ''));516        }517      });518      return date;519    };520    const block1date = await findCreationDate(block1);521    const block2date = await findCreationDate(block2);522    if(block2date! - block1date! < 9000) return true;523  };524525  async calculcateFee(payer: ICrossAccountId, promise: () => Promise<any>): Promise<bigint> {526    const address = 'Substrate' in payer ? payer.Substrate : this.helper.address.ethToSubstrate(payer.Ethereum);527    let balance = await this.helper.balance.getSubstrate(address);528529    await promise();530531    balance -= await this.helper.balance.getSubstrate(address);532533    return balance;534  }535536  async calculatePoVInfo(txs: any[]): Promise<IPovInfo> {537    const rawPovInfo = await this.helper.callRpc('api.rpc.povinfo.estimateExtrinsicPoV', [txs]);538539    const kvJson: {[key: string]: string} = {};540541    for(const kv of rawPovInfo.keyValues) {542      kvJson[kv.key.toHex()] = kv.value.toHex();543    }544545    const kvStr = JSON.stringify(kvJson);546547    const chainql = spawnSync(548      'chainql',549      [550        `--tla-code=data=${kvStr}`,551        '-e', `function(data) cql.dump(cql.chain("${this.helper.getEndpoint()}").latest._meta, data, {omit_empty:true})`,552      ],553    );554555    if(!chainql.stdout) {556      throw Error('unable to get an output from the `chainql`');557    }558559    return {560      proofSize: rawPovInfo.proofSize.toNumber(),561      compactProofSize: rawPovInfo.compactProofSize.toNumber(),562      compressedProofSize: rawPovInfo.compressedProofSize.toNumber(),563      results: rawPovInfo.results,564      kv: JSON.parse(chainql.stdout.toString()),565    };566  }567568  calculatePalletAddress(palletId: any) {569    const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));570    return encodeAddress(address, this.helper.chain.getChainProperties().ss58Format);571  }572573  makeScheduledIds(num: number): string[] {574    function makeId(slider: number) {575      const scheduledIdSize = 64;576      const hexId = slider.toString(16);577      const prefixSize = scheduledIdSize - hexId.length;578579      const scheduledId = '0x' + '0'.repeat(prefixSize) + hexId;580581      return scheduledId;582    }583584    const ids = [];585    for(let i = 0; i < num; i++) {586      ids.push(makeId(this.scheduledIdSlider));587      this.scheduledIdSlider += 1;588    }589590    return ids;591  }592593  makeScheduledId(): string {594    return (this.makeScheduledIds(1))[0];595  }596597  async captureEvents(eventSection: string, eventMethod: string): Promise<EventCapture> {598    const capture = new EventCapture(this.helper, eventSection, eventMethod);599    await capture.startCapture();600601    return capture;602  }603604  makeXcmProgramWithdrawDeposit(beneficiary: Uint8Array, id: any, amount: bigint) {605    return {606      V2: [607        {608          WithdrawAsset: [609            {610              id,611              fun: {612                Fungible: amount,613              },614            },615          ],616        },617        {618          BuyExecution: {619            fees: {620              id,621              fun: {622                Fungible: amount,623              },624            },625            weightLimit: 'Unlimited',626          },627        },628        {629          DepositAsset: {630            assets: {631              Wild: 'All',632            },633            maxAssets: 1,634            beneficiary: {635              parents: 0,636              interior: {637                X1: {638                  AccountId32: {639                    network: 'Any',640                    id: beneficiary,641                  },642                },643              },644            },645          },646        },647      ],648    };649  }650651  makeXcmProgramReserveAssetDeposited(beneficiary: Uint8Array, id: any, amount: bigint) {652    return {653      V2: [654        {655          ReserveAssetDeposited: [656            {657              id,658              fun: {659                Fungible: amount,660              },661            },662          ],663        },664        {665          BuyExecution: {666            fees: {667              id,668              fun: {669                Fungible: amount,670              },671            },672            weightLimit: 'Unlimited',673          },674        },675        {676          DepositAsset: {677            assets: {678              Wild: 'All',679            },680            maxAssets: 1,681            beneficiary: {682              parents: 0,683              interior: {684                X1: {685                  AccountId32: {686                    network: 'Any',687                    id: beneficiary,688                  },689                },690              },691            },692          },693        },694      ],695    };696  }697}698699class MoonbeamAccountGroup {700  helper: MoonbeamHelper;701702  keyring: Keyring;703  _alithAccount: IKeyringPair;704  _baltatharAccount: IKeyringPair;705  _dorothyAccount: IKeyringPair;706707  constructor(helper: MoonbeamHelper) {708    this.helper = helper;709710    this.keyring = new Keyring({type: 'ethereum'});711    const alithPrivateKey = '0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133';712    const baltatharPrivateKey = '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b';713    const dorothyPrivateKey = '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68';714715    this._alithAccount = this.keyring.addFromUri(alithPrivateKey, undefined, 'ethereum');716    this._baltatharAccount = this.keyring.addFromUri(baltatharPrivateKey, undefined, 'ethereum');717    this._dorothyAccount = this.keyring.addFromUri(dorothyPrivateKey, undefined, 'ethereum');718  }719720  alithAccount() {721    return this._alithAccount;722  }723724  baltatharAccount() {725    return this._baltatharAccount;726  }727728  dorothyAccount() {729    return this._dorothyAccount;730  }731732  create() {733    return this.keyring.addFromUri(mnemonicGenerate());734  }735}736737class MoonbeamFastDemocracyGroup {738  helper: DevMoonbeamHelper;739740  constructor(helper: DevMoonbeamHelper) {741    this.helper = helper;742  }743744  async executeProposal(proposalDesciption: string, encodedProposal: string) {745    const proposalHash = blake2AsHex(encodedProposal);746747    const alithAccount = this.helper.account.alithAccount();748    const baltatharAccount = this.helper.account.baltatharAccount();749    const dorothyAccount = this.helper.account.dorothyAccount();750751    const councilVotingThreshold = 2;752    const technicalCommitteeThreshold = 2;753    const fastTrackVotingPeriod = 3;754    const fastTrackDelayPeriod = 0;755756    console.log(`[democracy] executing '${proposalDesciption}' proposal`);757758    // >>> Propose external motion through council >>>759    console.log('\t* Propose external motion through council.......');760    const externalMotion = this.helper.democracy.externalProposeMajority({Inline: encodedProposal});761    const encodedMotion = externalMotion?.method.toHex() || '';762    const motionHash = blake2AsHex(encodedMotion);763    console.log('\t* Motion hash is %s', motionHash);764765    await this.helper.collective.council.propose(766      baltatharAccount,767      councilVotingThreshold,768      externalMotion,769      externalMotion.encodedLength,770    );771772    const councilProposalIdx = await this.helper.collective.council.proposalCount() - 1;773    await this.helper.collective.council.vote(dorothyAccount, motionHash, councilProposalIdx, true);774    await this.helper.collective.council.vote(baltatharAccount, motionHash, councilProposalIdx, true);775776    await this.helper.collective.council.close(777      dorothyAccount,778      motionHash,779      councilProposalIdx,780      {781        refTime: 1_000_000_000,782        proofSize: 1_000_000,783      },784      externalMotion.encodedLength,785    );786    console.log('\t* Propose external motion through council.......DONE');787    // <<< Propose external motion through council <<<788789    // >>> Fast track proposal through technical committee >>>790    console.log('\t* Fast track proposal through technical committee.......');791    const fastTrack = this.helper.democracy.fastTrack(proposalHash, fastTrackVotingPeriod, fastTrackDelayPeriod);792    const encodedFastTrack = fastTrack?.method.toHex() || '';793    const fastTrackHash = blake2AsHex(encodedFastTrack);794    console.log('\t* FastTrack hash is %s', fastTrackHash);795796    await this.helper.collective.techCommittee.propose(alithAccount, technicalCommitteeThreshold, fastTrack, fastTrack.encodedLength);797798    const techProposalIdx = await this.helper.collective.techCommittee.proposalCount() - 1;799    await this.helper.collective.techCommittee.vote(baltatharAccount, fastTrackHash, techProposalIdx, true);800    await this.helper.collective.techCommittee.vote(alithAccount, fastTrackHash, techProposalIdx, true);801802    await this.helper.collective.techCommittee.close(803      baltatharAccount,804      fastTrackHash,805      techProposalIdx,806      {807        refTime: 1_000_000_000,808        proofSize: 1_000_000,809      },810      fastTrack.encodedLength,811    );812    console.log('\t* Fast track proposal through technical committee.......DONE');813    // <<< Fast track proposal through technical committee <<<814815    const democracyStarted = await this.helper.wait.expectEvent(3, Event.Democracy.Started);816    const referendumIndex = democracyStarted.referendumIndex;817818    // >>> Referendum voting >>>819    console.log(`\t* Referendum #${referendumIndex} voting.......`);820    await this.helper.democracy.referendumVote(dorothyAccount, referendumIndex, {821      balance: 10_000_000_000_000_000_000n,822      vote: {aye: true, conviction: 1},823    });824    console.log(`\t* Referendum #${referendumIndex} voting.......DONE`);825    // <<< Referendum voting <<<826827    // Wait the proposal to pass828    await this.helper.wait.expectEvent(3, Event.Democracy.Passed, event => event.referendumIndex == referendumIndex);829830    await this.helper.wait.newBlocks(1);831832    console.log(`[democracy] executing '${proposalDesciption}' proposal.......DONE`);833  }834}835836class WaitGroup {837  helper: ChainHelperBase;838839  constructor(helper: ChainHelperBase) {840    this.helper = helper;841  }842843  sleep(milliseconds: number) {844    return new Promise((resolve) => setTimeout(resolve, milliseconds));845  }846847  private async waitWithTimeout(promise: Promise<any>, timeout: number) {848    let isBlock = false;849    promise.then(() => isBlock = true).catch(() => isBlock = true);850    let totalTime = 0;851    const step = 100;852    while(!isBlock) {853      await this.sleep(step);854      totalTime += step;855      if(totalTime >= timeout) throw Error('Blocks production failed');856    }857    return promise;858  }859860  /**861   * Launch some async operation, or throw an error after some time. Note that it will still continue executing after the timeout.862   * @param promise async operation to race against the timeout863   * @param timeoutMS time after which to time out864   * @param timeoutError error message to throw865   * @returns promise of the same type the operation had866   */867  withTimeout<T>(868    promise: Promise<T>,869    timeoutMS = 30000,870    timeoutError = 'The operation has timed out!',871  ): Promise<T> {872    const timeout = new Promise<never>((_, reject) => {873      setTimeout(() => {874        reject(new Error(timeoutError));875      }, timeoutMS);876    });877878    return Promise.race<T>([promise, timeout]).catch(e => {throw new Error(e);});879  }880881  /**882   * Wait for specified number of blocks883   * @param blocksCount number of blocks to wait884   * @returns885   */886  async newBlocks(blocksCount = 1, timeout?: number): Promise<void> {887    timeout = timeout ?? blocksCount * 60_000;888    // eslint-disable-next-line no-async-promise-executor889    const promise = new Promise<void>(async (resolve) => {890      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(() => {891        if(blocksCount > 0) {892          blocksCount--;893        } else {894          unsubscribe();895          resolve();896        }897      });898    });899    await this.waitWithTimeout(promise, timeout);900    return promise;901  }902903  /**904   * Wait for the specified number of sessions to pass.905   * Only applicable if the Session pallet is turned on.906   * @param sessionCount number of sessions to wait907   * @param blockTimeout time in ms until panicking that the chain has stopped producing blocks908   * @returns909   */910  async newSessions(sessionCount = 1, blockTimeout = 60000): Promise<void> {911    console.log(`Waiting for ${sessionCount} new session${sessionCount > 1 ? 's' : ''}.`912      + ' This might take a while -- check SessionPeriod in pallet_session::Config for session time.');913914    const expectedSessionIndex = await (this.helper as DevUniqueHelper).session.getIndex() + sessionCount;915    let currentSessionIndex = -1;916917    while(currentSessionIndex < expectedSessionIndex) {918      // eslint-disable-next-line no-async-promise-executor919      currentSessionIndex = await this.withTimeout(new Promise(async (resolve) => {920        await this.newBlocks(1);921        const res = await (this.helper as DevUniqueHelper).session.getIndex();922        resolve(res);923      }), blockTimeout, 'The chain has stopped producing blocks!');924    }925  }926927  async forParachainBlockNumber(blockNumber: bigint | number, timeout?: number) {928    timeout = timeout ?? 30 * 60 * 1000;929    // eslint-disable-next-line no-async-promise-executor930    const promise = new Promise<void>(async (resolve) => {931      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads((data: any) => {932        if(data.number.toNumber() >= blockNumber) {933          unsubscribe();934          resolve();935        }936      });937    });938    await this.waitWithTimeout(promise, timeout);939    return promise;940  }941942  async forRelayBlockNumber(blockNumber: bigint | number, timeout?: number) {943    timeout = timeout ?? 30 * 60 * 1000;944    // eslint-disable-next-line no-async-promise-executor945    const promise = new Promise<void>(async (resolve) => {946      const unsubscribe = await this.helper.getApi().query.parachainSystem.validationData((data: any) => {947        if(data.value.relayParentNumber.toNumber() >= blockNumber) {948          // @ts-ignore949          unsubscribe();950          resolve();951        }952      });953    });954    await this.waitWithTimeout(promise, timeout);955    return promise;956  }957958  noScheduledTasks() {959    const api = this.helper.getApi();960961    // eslint-disable-next-line no-async-promise-executor962    const promise = new Promise<void>(async resolve => {963      const unsubscribe = await api.rpc.chain.subscribeNewHeads(async () => {964        const areThereScheduledTasks = await api.query.scheduler.lookup.entries();965966        if(areThereScheduledTasks.length == 0) {967          unsubscribe();968          resolve();969        }970      });971    });972973    return promise;974  }975976  parachainBlockMultiplesOf(val: bigint) {977    // eslint-disable-next-line no-async-promise-executor978    const promise = new Promise<void>(async resolve => {979      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads((data: any) => {980        if(data.number.toBigInt() % val == 0n) {981          console.log(`from waiter: ${data.number.toBigInt()}`);982          unsubscribe();983          resolve();984        }985      });986    });987    return promise;988  }989990  event<T extends IEventHelper>(991    maxBlocksToWait: number,992    eventHelper: T,993    filter: (_: any) => boolean = () => true,994  ): any {995    // eslint-disable-next-line no-async-promise-executor996    const promise = new Promise<T | null>(async (resolve) => {997      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(async header => {998        const blockNumber = header.number.toHuman();999        const blockHash = header.hash;1000        const eventIdStr = `${eventHelper.section()}.${eventHelper.method()}`;1001        const waitLimitStr = `wait blocks remaining: ${maxBlocksToWait}`;10021003        this.helper.logger.log(`[Block #${blockNumber}] Waiting for event \`${eventIdStr}\` (${waitLimitStr})`);10041005        const apiAt = await this.helper.getApi().at(blockHash);1006        const eventRecords = (await apiAt.query.system.events()) as any;10071008        const neededEvent = eventRecords.toArray()1009          .filter((r: FrameSystemEventRecord) => r.event.section == eventHelper.section() && r.event.method == eventHelper.method())1010          .map((r: FrameSystemEventRecord) => eventHelper.wrapEvent(r.event.data))1011          .find(filter);10121013        if(neededEvent) {1014          unsubscribe();1015          resolve(neededEvent);1016        } else if(maxBlocksToWait > 0) {1017          maxBlocksToWait--;1018        } else {1019          this.helper.logger.log(`Eligible event \`${eventIdStr}\` is NOT found`);1020          unsubscribe();1021          resolve(null);1022        }1023      });1024    });1025    return promise;1026  }10271028  async expectEvent<T extends IEventHelper>(1029    maxBlocksToWait: number,1030    eventHelper: T,1031    filter: (e: any) => boolean = () => true,1032  ) {1033    const e = await this.event(maxBlocksToWait, eventHelper, filter);1034    if(e == null) {1035      throw Error(`The event '${eventHelper.section()}.${eventHelper.method()}' is expected`);1036    } else {1037      return e;1038    }1039  }1040}10411042class SessionGroup {1043  helper: ChainHelperBase;10441045  constructor(helper: ChainHelperBase) {1046    this.helper = helper;1047  }10481049  //todo:collator documentation1050  async getIndex(): Promise<number> {1051    return (await this.helper.callRpc('api.query.session.currentIndex', [])).toNumber();1052  }10531054  newSessions(sessionCount = 1, blockTimeout = 24000): Promise<void> {1055    return (this.helper as DevUniqueHelper).wait.newSessions(sessionCount, blockTimeout);1056  }10571058  setOwnKeys(signer: TSigner, key: string) {1059    return this.helper.executeExtrinsic(1060      signer,1061      'api.tx.session.setKeys',1062      [key, '0x0'],1063      true,1064    );1065  }10661067  setOwnKeysFromAddress(signer: TSigner) {1068    return this.setOwnKeys(signer, '0x' + Buffer.from(signer.addressRaw).toString('hex'));1069  }1070}10711072class TestUtilGroup {1073  helper: DevUniqueHelper;10741075  constructor(helper: DevUniqueHelper) {1076    this.helper = helper;1077  }10781079  async enable() {1080    if(this.helper.fetchMissingPalletNames([Pallets.TestUtils]).length != 0) {1081      return;1082    }10831084    const signer = this.helper.util.fromSeed('//Alice');1085    await this.helper.getSudo<DevUniqueHelper>().executeExtrinsic(signer, 'api.tx.testUtils.enable', [], true);1086  }10871088  async setTestValue(signer: TSigner, testVal: number) {1089    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.setTestValue', [testVal], true);1090  }10911092  async incTestValue(signer: TSigner) {1093    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.incTestValue', [], true);1094  }10951096  async setTestValueAndRollback(signer: TSigner, testVal: number) {1097    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.setTestValueAndRollback', [testVal], true);1098  }10991100  async testValue(blockIdx?: number) {1101    const api = blockIdx1102      ? await this.helper.getApi().at(await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockIdx]))1103      : this.helper.getApi();11041105    return (await api.query.testUtils.testValue()).toJSON();1106  }11071108  async justTakeFee(signer: TSigner) {1109    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.justTakeFee', [], true);1110  }11111112  async selfCancelingInc(signer: TSigner, scheduledId: string, maxTestVal: number) {1113    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.selfCancelingInc', [scheduledId, maxTestVal], true);1114  }1115}11161117class EventCapture {1118  helper: DevUniqueHelper;1119  eventSection: string;1120  eventMethod: string;1121  events: EventRecord[] = [];1122  unsubscribe: VoidFn | null = null;11231124  constructor(1125    helper: DevUniqueHelper,1126    eventSection: string,1127    eventMethod: string,1128  ) {1129    this.helper = helper;1130    this.eventSection = eventSection;1131    this.eventMethod = eventMethod;1132  }11331134  async startCapture() {1135    this.stopCapture();1136    this.unsubscribe = (await this.helper.getApi().query.system.events((eventRecords: FrameSystemEventRecord[]) => {1137      const newEvents = eventRecords.filter(r => r.event.section == this.eventSection && r.event.method == this.eventMethod);11381139      this.events.push(...newEvents);1140    })) as any;1141  }11421143  stopCapture() {1144    if(this.unsubscribe !== null) {1145      this.unsubscribe();1146    }1147  }11481149  extractCapturedEvents() {1150    return this.events;1151  }1152}11531154class AdminGroup {1155  helper: UniqueHelper;11561157  constructor(helper: UniqueHelper) {1158    this.helper = helper;1159  }11601161  async payoutStakers(signer: IKeyringPair, stakersToPayout: number):  Promise<{staker: string, stake: bigint, payout: bigint}[]> {1162    const payoutResult = await this.helper.executeExtrinsic(signer, 'api.tx.appPromotion.payoutStakers', [stakersToPayout], true);1163    return payoutResult.result.events.filter(e => e.event.method === 'StakingRecalculation').map(e => ({1164      staker: e.event.data[0].toString(),1165      stake: e.event.data[1].toBigInt(),1166      payout: e.event.data[2].toBigInt(),1167    }));1168  }1169}