git.delta.rocks / unique-network / refs/commits / 71ea0c3827eb

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// SPDX-License-Identifier: Apache-2.034import {stringToU8a} from '@polkadot/util';5import {encodeAddress, mnemonicGenerate} from '@polkadot/util-crypto';6import {UniqueHelper, MoonbeamHelper, ChainHelperBase, AcalaHelper, RelayHelper, WestmintHelper} 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, TSigner} from './types';12import {FrameSystemEventRecord} from '@polkadot/types/lookup';13import {VoidFn} from '@polkadot/api/types';1415export class SilentLogger {16  log(_msg: any, _level: any): void { }17  level = {18    ERROR: 'ERROR' as const,19    WARNING: 'WARNING' as const,20    INFO: 'INFO' as const,21  };22}2324export class SilentConsole {25  // TODO: Remove, this is temporary: Filter unneeded API output26  // (Jaco promised it will be removed in the next version)27  consoleErr: any;28  consoleLog: any;29  consoleWarn: any;3031  constructor() {32    this.consoleErr = console.error;33    this.consoleLog = console.log;34    this.consoleWarn = console.warn;35  }3637  enable() {  38    const outFn = (printer: any) => (...args: any[]) => {39      for (const arg of args) {40        if (typeof arg !== 'string')41          continue;42        if (arg.includes('1000:: Normal connection closure') || arg.includes('Not decorating unknown runtime apis:') || arg.includes('RPC methods not decorated:') || arg === 'Normal connection closure')43          return;44      }45      printer(...args);46    };47  48    console.error = outFn(this.consoleErr.bind(console));49    console.log = outFn(this.consoleLog.bind(console));50    console.warn = outFn(this.consoleWarn.bind(console));51  }5253  disable() {54    console.error = this.consoleErr;55    console.log = this.consoleLog;56    console.warn = this.consoleWarn;57  }58}5960export class DevUniqueHelper extends UniqueHelper {61  /**62   * Arrange methods for tests63   */64  arrange: ArrangeGroup;65  wait: WaitGroup;66  admin: AdminGroup;67  testUtils: TestUtilGroup;6869  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {70    options.helperBase = options.helperBase ?? DevUniqueHelper;7172    super(logger, options);73    this.arrange = new ArrangeGroup(this);74    this.wait = new WaitGroup(this);75    this.admin = new AdminGroup(this);76    this.testUtils = new TestUtilGroup(this);77  }7879  async connect(wsEndpoint: string, _listeners?: any): Promise<void> {80    const wsProvider = new WsProvider(wsEndpoint);81    this.api = new ApiPromise({82      provider: wsProvider,83      signedExtensions: {84        ContractHelpers: {85          extrinsic: {},86          payload: {},87        },88        FakeTransactionFinalizer: {89          extrinsic: {},90          payload: {},91        },92      },93      rpc: {94        unique: defs.unique.rpc,95        appPromotion: defs.appPromotion.rpc,96        rmrk: defs.rmrk.rpc,97        eth: {98          feeHistory: {99            description: 'Dummy',100            params: [],101            type: 'u8',102          },103          maxPriorityFeePerGas: {104            description: 'Dummy',105            params: [],106            type: 'u8',107          },108        },109      },110    });111    await this.api.isReadyOrError;112    this.network = await UniqueHelper.detectNetwork(this.api);113  }114}115116export class DevRelayHelper extends RelayHelper {}117118export class DevWestmintHelper extends WestmintHelper {119  wait: WaitGroup;120121  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {122    options.helperBase = options.helperBase ?? DevWestmintHelper;123124    super(logger, options);125    this.wait = new WaitGroup(this);126  }127}128129export class DevMoonbeamHelper extends MoonbeamHelper {130  account: MoonbeamAccountGroup;131  wait: WaitGroup;132133  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {134    options.helperBase = options.helperBase ?? DevMoonbeamHelper;135136    super(logger, options);137    this.account = new MoonbeamAccountGroup(this);138    this.wait = new WaitGroup(this);139  }140}141142export class DevMoonriverHelper extends DevMoonbeamHelper {}143144export class DevAcalaHelper extends AcalaHelper {145  wait: WaitGroup;146147  constructor(logger: { log: (msg: any, level: any) => void, level: any }, options: {[key: string]: any} = {}) {148    options.helperBase = options.helperBase ?? DevAcalaHelper;149150    super(logger, options);151    this.wait = new WaitGroup(this);152  }153}154155export class DevKaruraHelper extends DevAcalaHelper {}156157class ArrangeGroup {158  helper: DevUniqueHelper;159160  scheduledIdSlider = 0;161162  constructor(helper: DevUniqueHelper) {163    this.helper = helper;164  }165166  /**167   * Generates accounts with the specified UNQ token balance 168   * @param balances balances for generated accounts. Each balance will be multiplied by the token nominal.169   * @param donor donor account for balances170   * @returns array of newly created accounts171   * @example const [acc1, acc2, acc3] = await createAccounts([0n, 10n, 20n], donor); 172   */173  createAccounts = async (balances: bigint[], donor: IKeyringPair): Promise<IKeyringPair[]> => {174    let nonce = await this.helper.chain.getNonce(donor.address);175    const wait = new WaitGroup(this.helper);176    const ss58Format = this.helper.chain.getChainProperties().ss58Format;177    const tokenNominal = this.helper.balance.getOneTokenNominal();178    const transactions = [];179    const accounts: IKeyringPair[] = [];180    for (const balance of balances) {181      const recipient = this.helper.util.fromSeed(mnemonicGenerate(), ss58Format);182      accounts.push(recipient);183      if (balance !== 0n) {184        const tx = this.helper.constructApiCall('api.tx.balances.transfer', [{Id: recipient.address}, balance * tokenNominal]);185        transactions.push(this.helper.signTransaction(donor, tx, {nonce}, 'account generation'));186        nonce++;187      }188    }189190    await Promise.all(transactions).catch(_e => {});191    192    //#region TODO remove this region, when nonce problem will be solved193    const checkBalances = async () => {194      let isSuccess = true;195      for (let i = 0; i < balances.length; i++) {196        const balance = await this.helper.balance.getSubstrate(accounts[i].address);197        if (balance !== balances[i] * tokenNominal) {198          isSuccess = false;199          break;200        }201      }202      return isSuccess;203    };204205    let accountsCreated = false;206    const maxBlocksChecked = await this.helper.arrange.isDevNode() ? 50 : 5;207    // checkBalances retry up to 5-50 blocks208    for (let index = 0; index < maxBlocksChecked; index++) {209      accountsCreated = await checkBalances();210      if(accountsCreated) break;211      await wait.newBlocks(1);212    }213214    if (!accountsCreated) throw Error('Accounts generation failed');215    //#endregion216217    return accounts;218  };219220  // TODO combine this method and createAccounts into one221  createCrowd = async (accountsToCreate: number, withBalance: bigint, donor: IKeyringPair): Promise<IKeyringPair[]> => {  222    const createAsManyAsCan = async () => {223      let transactions: any = [];224      const accounts: IKeyringPair[] = [];225      let nonce = await this.helper.chain.getNonce(donor.address);226      const tokenNominal = this.helper.balance.getOneTokenNominal();227      for (let i = 0; i < accountsToCreate; i++) {228        if (i === 500) { // if there are too many accounts to create229          await Promise.allSettled(transactions); // wait while first 500 (should be 100 for devnode) tx will be settled 230          transactions = []; //231          nonce = await this.helper.chain.getNonce(donor.address); // update nonce 232        }233        const recepient = this.helper.util.fromSeed(mnemonicGenerate());234        accounts.push(recepient);235        if (withBalance !== 0n) {236          const tx = this.helper.constructApiCall('api.tx.balances.transfer', [{Id: recepient.address}, withBalance * tokenNominal]);237          transactions.push(this.helper.signTransaction(donor, tx, {nonce}, 'account generation'));238          nonce++;239        }240      }241      242      const fullfilledAccounts = [];243      await Promise.allSettled(transactions);244      for (const account of accounts) {245        const accountBalance = await this.helper.balance.getSubstrate(account.address);246        if (accountBalance === withBalance * tokenNominal) {247          fullfilledAccounts.push(account);248        }249      }250      return fullfilledAccounts;251    };252253    254    const crowd: IKeyringPair[] = [];255    // do up to 5 retries256    for (let index = 0; index < 5 && accountsToCreate !== 0; index++) {257      const asManyAsCan = await createAsManyAsCan();258      crowd.push(...asManyAsCan);259      accountsToCreate -= asManyAsCan.length;260    }261262    if (accountsToCreate !== 0) throw Error(`Crowd generation failed: ${accountsToCreate} accounts left`);263264    return crowd;265  };266267  isDevNode = async () => {268    let blockNumber = (await this.helper.callRpc('api.query.system.number')).toJSON();269    if (blockNumber == 0) {270      await this.helper.wait.newBlocks(1); 271      blockNumber = (await this.helper.callRpc('api.query.system.number')).toJSON();272    }273    const block2 = await this.helper.callRpc('api.rpc.chain.getBlock', [await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])]);274    const block1 = await this.helper.callRpc('api.rpc.chain.getBlock', [await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber - 1])]);275    const findCreationDate = async (block: any) => {276      const humanBlock = block.toHuman();277      let date;278      humanBlock.block.extrinsics.forEach((ext: any) => {279        if(ext.method.section === 'timestamp') {280          date = Number(ext.method.args.now.replaceAll(',', ''));281        }282      });283      return date;284    };285    const block1date = await findCreationDate(block1);286    const block2date = await findCreationDate(block2);287    if(block2date! - block1date! < 9000) return true;288  };289  290  async calculcateFee(payer: ICrossAccountId, promise: () => Promise<any>): Promise<bigint> {291    const address = payer.Substrate ? payer.Substrate : await this.helper.address.ethToSubstrate(payer.Ethereum!);292    let balance = await this.helper.balance.getSubstrate(address); 293    294    await promise();295    296    balance -= await this.helper.balance.getSubstrate(address);297    298    return balance;299  }300301  calculatePalletAddress(palletId: any) {302    const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));303    return encodeAddress(address);304  }305306  async makeScheduledIds(num: number): Promise<string[]> {307    await this.helper.wait.noScheduledTasks();308309    function makeId(slider: number) {310      const scheduledIdSize = 32;311      const hexId = slider.toString(16);312      const prefixSize = scheduledIdSize - hexId.length;313314      const scheduledId = '0x' + '0'.repeat(prefixSize) + hexId;315316      return scheduledId;  317    }318319    const ids = [];320    for (let i = 0; i < num; i++) {321      ids.push(makeId(this.scheduledIdSlider));322      this.scheduledIdSlider += 1;323    }324325    return ids;326  }327328  async makeScheduledId(): Promise<string> {329    return (await this.makeScheduledIds(1))[0];330  }331332  async captureEvents(eventSection: string, eventMethod: string): Promise<EventCapture> {333    const capture = new EventCapture(this.helper, eventSection, eventMethod);334    await capture.startCapture();335336    return capture;337  }338}339340class MoonbeamAccountGroup {341  helper: MoonbeamHelper;342343  keyring: Keyring;344  _alithAccount: IKeyringPair;345  _baltatharAccount: IKeyringPair;346  _dorothyAccount: IKeyringPair;347348  constructor(helper: MoonbeamHelper) {349    this.helper = helper;350351    this.keyring = new Keyring({type: 'ethereum'});352    const alithPrivateKey = '0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133';353    const baltatharPrivateKey = '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b';354    const dorothyPrivateKey = '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68';355356    this._alithAccount = this.keyring.addFromUri(alithPrivateKey, undefined, 'ethereum');357    this._baltatharAccount = this.keyring.addFromUri(baltatharPrivateKey, undefined, 'ethereum');358    this._dorothyAccount = this.keyring.addFromUri(dorothyPrivateKey, undefined, 'ethereum');359  }360361  alithAccount() {362    return this._alithAccount;363  }364365  baltatharAccount() {366    return this._baltatharAccount;367  }368369  dorothyAccount() {370    return this._dorothyAccount;371  }372373  create() {374    return this.keyring.addFromUri(mnemonicGenerate());375  }376}377378class WaitGroup {379  helper: ChainHelperBase;380381  constructor(helper: ChainHelperBase) {382    this.helper = helper;383  }384385  /**386   * Wait for specified number of blocks387   * @param blocksCount number of blocks to wait388   * @returns 389   */390  async newBlocks(blocksCount = 1): Promise<void> {391    // eslint-disable-next-line no-async-promise-executor392    const promise = new Promise<void>(async (resolve) => {393      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(() => {394        if (blocksCount > 0) {395          blocksCount--;396        } else {397          unsubscribe();398          resolve();399        }400      });401    });402    return promise;403  }404405  async forParachainBlockNumber(blockNumber: bigint) {406    // eslint-disable-next-line no-async-promise-executor407    return new Promise<void>(async (resolve) => {408      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(async (data: any) => {409        if (data.number.toNumber() >= blockNumber) {410          unsubscribe();411          resolve();412        }413      });414    });415  }416  417  async forRelayBlockNumber(blockNumber: bigint) {418    // eslint-disable-next-line no-async-promise-executor419    return new Promise<void>(async (resolve) => {420      const unsubscribe = await this.helper.getApi().query.parachainSystem.validationData(async (data: any) => {421        if (data.value.relayParentNumber.toNumber() >= blockNumber) {422          // @ts-ignore423          unsubscribe();424          resolve();425        }426      });427    });428  }429430  async noScheduledTasks() {431    const api = this.helper.getApi();432    433    // eslint-disable-next-line no-async-promise-executor434    const promise = new Promise<void>(async resolve => {435      const unsubscribe = await api.rpc.chain.subscribeNewHeads(async () => {436        const areThereScheduledTasks = await api.query.scheduler.lookup.entries();437438        if(areThereScheduledTasks.length == 0) {439          unsubscribe();440          resolve();441        }442      }); 443    });444445    return promise;446  }447448  async event(maxBlocksToWait: number, eventSection: string, eventMethod: string) {449    // eslint-disable-next-line no-async-promise-executor450    const promise = new Promise<EventRecord | null>(async (resolve) => {451      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(async header => {452        const blockNumber = header.number.toHuman();453        const blockHash = header.hash;454        const eventIdStr = `${eventSection}.${eventMethod}`;455        const waitLimitStr = `wait blocks remaining: ${maxBlocksToWait}`;456  457        this.helper.logger.log(`[Block #${blockNumber}] Waiting for event \`${eventIdStr}\` (${waitLimitStr})`);458  459        const apiAt = await this.helper.getApi().at(blockHash);460        const eventRecords = (await apiAt.query.system.events()) as any;461  462        const neededEvent = eventRecords.toArray().find((r: FrameSystemEventRecord) => {463          return r.event.section == eventSection && r.event.method == eventMethod;464        });465  466        if (neededEvent) {467          unsubscribe();468          resolve(neededEvent);469        } else if (maxBlocksToWait > 0) {470          maxBlocksToWait--;471        } else {472          this.helper.logger.log(`Event \`${eventIdStr}\` is NOT found`);473          unsubscribe();474          resolve(null);475        }476      });477    });478    return promise;479  }480}481482class TestUtilGroup {483  helper: DevUniqueHelper;484485  constructor(helper: DevUniqueHelper) {486    this.helper = helper;487  }488489  async setTestValue(signer: TSigner, testVal: number) {490    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.setTestValue', [testVal], true);491  }492493  async incTestValue(signer: TSigner) {494    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.incTestValue', [], true);495  }496497  async setTestValueAndRollback(signer: TSigner, testVal: number) {498    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.setTestValueAndRollback', [testVal], true);499  }500501  async testValue() {502    return (await this.helper.callRpc('api.query.testUtils.testValue', [])).toNumber();503  }504505  async justTakeFee(signer: TSigner) {506    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.justTakeFee', [], true);507  }508509  async selfCancelingInc(signer: TSigner, scheduledId: string, maxTestVal: number) {510    await this.helper.executeExtrinsic(signer, 'api.tx.testUtils.selfCancelingInc', [scheduledId, maxTestVal], true);511  }512}513514class EventCapture {515  helper: DevUniqueHelper;516  eventSection: string;517  eventMethod: string;518  events: EventRecord[] = [];519  unsubscribe: VoidFn | null = null;520521  constructor(522    helper: DevUniqueHelper,523    eventSection: string,524    eventMethod: string,525  ) {526    this.helper = helper;527    this.eventSection = eventSection;528    this.eventMethod = eventMethod;529  }530531  async startCapture() {532    this.stopCapture();533    this.unsubscribe = (await this.helper.getApi().query.system.events((eventRecords: FrameSystemEventRecord[]) => {534      const newEvents = eventRecords.filter(r => {535        return r.event.section == this.eventSection && r.event.method == this.eventMethod;536      });537538      this.events.push(...newEvents);539    })) as any;540  }541542  stopCapture() {543    if (this.unsubscribe !== null) {544      this.unsubscribe();545    }546  }547548  extractCapturedEvents() {549    return this.events;550  }551}552553class AdminGroup {554  helper: UniqueHelper;555556  constructor(helper: UniqueHelper) {557    this.helper = helper;558  }559560  async payoutStakers(signer: IKeyringPair, stakersToPayout: number) {561    const payoutResult = await this.helper.executeExtrinsic(signer, 'api.tx.appPromotion.payoutStakers', [stakersToPayout], true);562    return payoutResult.result.events.filter(e => e.event.method === 'StakingRecalculation').map(e => {563      return {564        staker: e.event.data[0].toString(),565        stake: e.event.data[1].toBigInt(),566        payout: e.event.data[2].toBigInt(),567      };568    });569  }570}