dappress 0.4.0 → 0.5.0

package/src/page-helpers.js

@@ -1,194 +0,0 @@
-// Small helpers on top of Puppeteer's Page API. They give every interaction
-// the same waiting and error reporting, and stay within what MetaMask's
-// sandbox (LavaMoat) allows: no script injected into the page.
-//
-// A "selector" is a CSS or XPath selector, or a list of them tried together:
-// the first one to show up wins.
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const DEFAULT_TIMEOUT = 15000;
-const SCREENSHOTS_DIR = path.join(os.tmpdir(), 'dappress');
-
-const candidates = (selector) => [].concat(selector);
-
-/** A readable name for a selector, for error messages. */
-function describe(selector) {
-  return candidates(selector)
-    .map((candidate) => candidate.replace(/^\[data-testid="(.+)"\]$/, '$1').replace(/^xpath\/.*="(.+)"\]$/, 'button "$1"'))
-    .join(' | ');
-}
-
-/** Wait for the first candidate to be visible and return its element handle. */
-async function waitFor(page, selector, { timeout = DEFAULT_TIMEOUT } = {}) {
-  const attempts = candidates(selector).map((candidate) => page.waitForSelector(candidate, { visible: true, timeout }));
-  try {
-    return await Promise.any(attempts);
-  } catch {
-    throw await failure(page, `Timed out waiting for "${describe(selector)}"`);
-  } finally {
-    // Let the losing attempts fail quietly when they time out
-    attempts.forEach((attempt) => attempt.catch(() => {}));
-  }
-}
-
-/** Returns true when `selector` is visible within `timeout` ms, false otherwise. */
-async function isVisible(page, selector, timeout = 1500) {
-  try {
-    await waitFor(page, selector, { timeout });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** Returns true once every candidate has left the page, or if the page itself closes. */
-async function isGone(page, selector, timeout = 1500) {
-  try {
-    await Promise.all(candidates(selector).map((candidate) => page.waitForSelector(candidate, { hidden: true, timeout })));
-    return true;
-  } catch {
-    return page.isClosed();
-  }
-}
-
-async function click(page, selector, options) {
-  await clickFresh(page, selector, options);
-}
-
-/**
- * Wait until the element is both visible and enabled, then click it. The
- * element is taken again at each turn: MetaMask re-renders its screens, and
- * a handle on a replaced element reads its last state forever.
- */
-async function clickWhenEnabled(page, selector, { timeout = DEFAULT_TIMEOUT, whileDisabled } = {}) {
-  const deadline = Date.now() + timeout;
-  let nudged = 0;
-  for (;;) {
-    const element = await waitFor(page, selector, { timeout });
-    if (!(await element.evaluate((el) => el.disabled))) break;
-    if (Date.now() > deadline) {
-      throw await failure(page, `"${describe(selector)}" stayed disabled for ${timeout}ms. ${await describeDisabled(page, element)}`);
-    }
-    // Something the page wants done before it enables the button, every half second
-    if (whileDisabled && Date.now() - nudged > 500) {
-      await whileDisabled();
-      nudged = Date.now();
-    }
-    await sleep(100);
-  }
-  await clickFresh(page, selector, { timeout });
-}
-
-// What may keep a button disabled: the button itself (a spinner, a class),
-// a pane left to scroll, the page not being the focused one
-async function describeDisabled(page, element) {
-  try {
-    const state = await page.evaluate((button) => {
-      const panes = [...document.querySelectorAll('[style*="overflow"]')]
-        .filter((pane) => pane.scrollHeight > pane.clientHeight)
-        .map((pane) => `${pane.scrollTop}+${pane.clientHeight}/${pane.scrollHeight}`);
-      return {
-        button: button.outerHTML.replace(/\s+/g, ' ').slice(0, 300),
-        panesToScroll: panes,
-        viewport: `${document.documentElement.clientWidth}x${document.documentElement.clientHeight}`,
-        focused: document.hasFocus(),
-        visibility: document.visibilityState,
-      };
-    }, element);
-    state.window = await windowBounds(page);
-    return `Button: ${JSON.stringify(state)}.`;
-  } catch {
-    return '';
-  }
-}
-
-// The size and state of the window the page is in, as "400x620 normal"
-async function windowBounds(page) {
-  const session = await page.target().createCDPSession();
-  try {
-    const { bounds } = await session.send('Browser.getWindowForTarget');
-    return `${bounds.width}x${bounds.height} ${bounds.windowState}`;
-  } catch {
-    return 'unknown';
-  } finally {
-    await session.detach().catch(() => {});
-  }
-}
-
-// Find the element and click it; once more if a re-render replaced it between the two
-async function clickFresh(page, selector, options) {
-  for (let attempt = 0; ; attempt++) {
-    const element = await waitFor(page, selector, options);
-    await waitForStill(element);
-    try {
-      return await element.click();
-    } catch (error) {
-      if (attempt > 0 || !/detached/.test(error.message)) throw error;
-    }
-  }
-}
-
-/** Click by dispatching the event on the element itself, for buttons something may cover. */
-async function dispatchClick(page, selector, options) {
-  const element = await waitFor(page, selector, options);
-  await element.evaluate((el) => el.click());
-}
-
-/** MetaMask animates its menus and confirmations in; a click during the animation lands elsewhere. */
-async function waitForStill(element, timeout = 2000) {
-  const deadline = Date.now() + timeout;
-  let previous = JSON.stringify(await element.boundingBox());
-  while (Date.now() < deadline) {
-    await sleep(100);
-    const current = JSON.stringify(await element.boundingBox());
-    if (current === previous) return;
-    previous = current;
-  }
-}
-
-/** Replace the content of a field with `text`. */
-async function fill(page, selector, text, options) {
-  const element = await waitFor(page, selector, options);
-  await element.click({ clickCount: 3 });
-  await element.type(text);
-}
-
-/**
- * The error for something that went wrong on `page`: what the page shows, in
- * words for the log and as a screenshot to look at.
- */
-async function failure(page, message) {
-  const prefix = `[dappress] ${message} on ${page.url()}`;
-  const shown = await pageText(page);
-  try {
-    fs.mkdirSync(SCREENSHOTS_DIR, { recursive: true });
-    const file = path.join(SCREENSHOTS_DIR, `${Date.now()}.png`);
-    await page.screenshot({ path: file });
-    return new Error(`${prefix}. ${shown}Screenshot: ${file}`);
-  } catch {
-    return new Error(`${prefix}. ${shown}`.trim());
-  }
-}
-
-// The visible text of the page, shortened: enough to tell which MetaMask
-// screen it is from the log alone, when the screenshot is out of reach
-async function pageText(page) {
-  try {
-    const text = await Promise.race([
-      page.evaluate(() => document.body.innerText.replace(/\s+/g, ' ').trim()),
-      sleep(2000).then(() => null),
-    ]);
-    return text ? `The page shows: "${text.length > 500 ? `${text.slice(0, 500)}…` : text}". ` : '';
-  } catch {
-    return '';
-  }
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-module.exports = { describe, waitFor, isVisible, isGone, click, clickWhenEnabled, dispatchClick, fill, failure, sleep };

package/src/profile.js

@@ -1,125 +0,0 @@
-// Onboard the wallet once, in a browser of our own, and keep the resulting
-// profile. Each Cypress run then starts from a copy of it, with the wallet
-// imported but nothing else: no connected site, no added network.
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const puppeteer = require('puppeteer-core');
-const metamask = require('./metamask');
-const { findExtensionId, getHomePage } = require('./metamask-pages');
-
-// One build at a time: Cypress calls before:browser:launch again when the
-// browser is slow to connect, and two builds on one profile would collide
-const builds = new Map();
-
-/** The cached profile for these options, built on first use. */
-function prepareProfile({ browserPath, extensionDir, options }) {
-  const key = crypto.createHash('sha256').update([options.metamaskVersion, options.seedPhrase, options.password, options.backupAndSync].join('|')).digest('hex').slice(0, 16);
-  if (!builds.has(key)) builds.set(key, buildProfile(path.join(options.cacheDir, 'profiles', key), { browserPath, extensionDir, options }));
-  return builds.get(key);
-}
-
-async function buildProfile(dir, { browserPath, extensionDir, options }) {
-  if (fs.existsSync(path.join(dir, 'ready'))) return dir;
-
-  console.log('[dappress] Importing the wallet once, into a cached profile…');
-  await fs.promises.rm(dir, { recursive: true, force: true });
-  const launch = () =>
-    puppeteer.launch({
-      executablePath: browserPath,
-      headless: false,
-      userDataDir: dir,
-      args: [
-        `--load-extension=${extensionDir}`,
-        `--disable-extensions-except=${extensionDir}`,
-        '--no-first-run',
-        // No sandbox on Linux: Ubuntu 23.10+ (GitHub's ubuntu-latest) blocks the
-        // user namespaces it needs, and this browser only imports a test wallet
-        ...(process.platform === 'linux' ? ['--no-sandbox'] : []),
-      ],
-    });
-
-  await withMetaMask(launch, (home) => metamask.onboard(home, options));
-  // Reopen the profile: the wallet must now be there, locked, with no onboarding left
-  await withMetaMask(launch, async (home) => {
-    const state = await metamask.walletState(home);
-    if (state !== 'locked') throw new Error(`[dappress] The cached profile did not keep the wallet: MetaMask is ${state} at ${home.url()}`);
-    await metamask.unlock(home, options);
-  });
-  fs.writeFileSync(path.join(dir, 'ready'), '');
-  return dir;
-}
-
-// MetaMask persists its state a moment after the last screen; leave it that moment before closing
-async function withMetaMask(launch, action) {
-  const browser = await launch();
-  try {
-    const home = await getHomePage(browser, await findExtensionId(browser));
-    await keepInFront(browser, home);
-    await action(home);
-    await new Promise((resolve) => setTimeout(resolve, 3000));
-  } finally {
-    await browser.close();
-  }
-}
-
-// Chrome stops rendering a tab that isn't the active one, and Puppeteer waits
-// on rendering to find an element or to click it: a hidden tab never answers.
-// So the home page is made the active tab, and again whenever MetaMask opens
-// a tab of its own, as it does for its onboarding right after the install.
-async function keepInFront(browser, home) {
-  const toFront = () => home.bringToFront().catch(() => {});
-  await toFront();
-  browser.on('targetcreated', (target) => {
-    if (target.type() !== 'page') return;
-    toFront();
-    setTimeout(toFront, 500);
-  });
-}
-
-// Where Cypress is about to create the browser profile:
-// <app data>/Cypress/cy/<env>/browsers/<name>-<channel>/run-<pid of the Cypress process>,
-// or .../interactive in open mode. The pid is our parent's: Cypress runs
-// setupNodeEvents in a child process. Returns null when it can't be found.
-function cypressProfileDir(browser, isTextTerminal) {
-  const appData = [
-    path.join(os.homedir(), 'Library', 'Application Support'),
-    process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'),
-    process.env.APPDATA,
-  ].filter(Boolean);
-  const cypressData = appData.map((dir) => path.join(dir, 'Cypress', 'cy')).find((dir) => fs.existsSync(dir));
-  if (!cypressData) return null;
-  const env = ['production', 'development'].find((name) => fs.existsSync(path.join(cypressData, name)));
-  if (!env) return null;
-  return path.join(cypressData, env, 'browsers', `${browser.name}-${browser.channel}`, isTextTerminal ? `run-${process.ppid}` : 'interactive');
-}
-
-/**
- * Copy MetaMask's data from the cached profile into the profile Cypress is
- * about to launch. Returns false when that profile can't be located; the
- * wallet is then imported during the run instead.
- */
-async function installProfile(profileDir, browser, isTextTerminal) {
-  const userDataDir = cypressProfileDir(browser, isTextTerminal);
-  if (!userDataDir) {
-    console.warn('[dappress] Could not locate the Cypress browser profile; importing the wallet in this run instead');
-    return false;
-  }
-  for (const entry of metamaskData(profileDir)) {
-    await fs.promises.cp(path.join(profileDir, entry), path.join(userDataDir, entry), { recursive: true });
-  }
-  return true;
-}
-
-// Where Chrome keeps an extension's storage: chrome.storage.local and IndexedDB
-function metamaskData(profileDir) {
-  const base = path.join(profileDir, 'Default');
-  const entries = ['Local Extension Settings', 'IndexedDB'];
-  return entries
-    .filter((entry) => fs.existsSync(path.join(base, entry)))
-    .flatMap((entry) => fs.readdirSync(path.join(base, entry)).map((name) => path.join('Default', entry, name)));
-}
-
-module.exports = { prepareProfile, installProfile };

package/src/support.js

@@ -1,102 +0,0 @@
-// Cypress commands. Import this file from your support file:
-//
-//   import 'dappress/support';
-//
-// Each command asks the Node side (src/actions.js) to drive MetaMask through
-// a Cypress task, then yields back to the test.
-
-const options = Cypress.expose('dappress') || {};
-
-// `shown` is what the command log displays for the argument, if anything
-function metamask(action, argument = null, shown = '') {
-  Cypress.log({ name: 'metamask', message: `${action} ${shown}`.trim() });
-  return cy.task(`dappress:${action}`, argument, { log: false });
-}
-
-function provider(method, params) {
-  return cy.window({ log: false }).then((win) => win.ethereum.request({ method, params }));
-}
-
-Cypress.Commands.add('setupMetaMask', () => metamask('setupWallet'));
-Cypress.Commands.add('rejectConnection', () => metamask('rejectConnection'));
-Cypress.Commands.add('approveNewNetwork', () => metamask('approveNewNetwork'));
-Cypress.Commands.add('rejectNewNetwork', () => metamask('rejectNewNetwork'));
-Cypress.Commands.add('approveSwitchNetwork', () => metamask('approveSwitchNetwork'));
-Cypress.Commands.add('rejectSwitchNetwork', () => metamask('rejectSwitchNetwork'));
-Cypress.Commands.add('confirmSignature', () => metamask('confirmSignature'));
-Cypress.Commands.add('rejectSignature', () => metamask('rejectSignature'));
-// Options are what to set on the confirmation before confirming it: { spendingCap, gas }
-Cypress.Commands.add('confirmTransaction', (options) => metamask('confirmTransaction', options, options ? JSON.stringify(options) : ''));
-Cypress.Commands.add('rejectTransaction', () => metamask('rejectTransaction'));
-Cypress.Commands.add('approveAddToken', () => metamask('approveAddToken'));
-Cypress.Commands.add('rejectAddToken', () => metamask('rejectAddToken'));
-
-// The wallet's own accounts. A new or imported account becomes the selected
-// one; the dapp sees it once it connects with it.
-Cypress.Commands.add('addAccount', () => metamask('addAccount'));
-Cypress.Commands.add('switchAccount', (name) => metamask('switchAccount', name, name));
-// The private key is kept out of the command log
-Cypress.Commands.add('importAccount', (privateKey) => metamask('importAccount', privateKey));
-
-// A locked wallet keeps the dapp's requests behind its unlock screen
-Cypress.Commands.add('lockWallet', () => metamask('lockWallet'));
-Cypress.Commands.add('unlockWallet', () => metamask('unlockWallet'));
-
-// The wallet's side of a disconnection: the site to remove from its
-// permissions is the dapp under test, known by the origin of its window.
-Cypress.Commands.add('disconnectFromDapp', () => {
-  cy.location('origin', { log: false }).then((origin) => metamask('disconnectFromDapp', origin, origin));
-});
-
-// Connect, then move the dapp onto the network from the wallet setup, if there is one.
-// `accounts` names the accounts to connect with, in place of the one MetaMask suggests.
-Cypress.Commands.add('connectToDapp', (connection) => {
-  metamask('connectToDapp', connection, connection?.accounts?.join(', '));
-  if (options.network) cy.useNetwork(options.network);
-});
-
-// Move the dapp onto `network` (a wallet_addEthereumChain parameter), adding
-// it to MetaMask if needed. A switch to a network the dapp is already allowed
-// on settles at once; anything else makes MetaMask ask, and we approve.
-Cypress.Commands.add('useNetwork', (network = options.network) => {
-  if (!network) throw new Error('[dappress] cy.useNetwork() needs a network, or one in cypress/wallet.setup.js');
-  Cypress.log({ name: 'metamask', message: `useNetwork ${network.chainName || network.chainId}` });
-  cy.window({ log: false }).then((win) => {
-    win.dappressNetwork = { settled: false };
-    win.dappressNetwork.request = win.ethereum
-      .request({ method: 'wallet_addEthereumChain', params: [network] })
-      .then((result) => ({ result }), (error) => ({ error }))
-      .finally(() => (win.dappressNetwork.settled = true));
-  });
-  cy.wait(1500, { log: false });
-  cy.window({ log: false }).then((win) => {
-    if (!win.dappressNetwork.settled) metamask('approveNetworkChange');
-  });
-  cy.window({ log: false }).then({ timeout: 60000 }, (win) => win.dappressNetwork.request).then(({ error }) => {
-    if (error) throw new Error(`[dappress] MetaMask refused the network: ${error.message}`);
-  });
-  waitForChainId(network.chainId);
-});
-
-// The address the dapp sees, asked to the injected provider rather than to the
-// MetaMask UI, so it keeps working across MetaMask versions.
-Cypress.Commands.add('getAccountAddress', () => {
-  Cypress.log({ name: 'metamask', message: 'getAccountAddress' });
-  return provider('eth_accounts').then(([address]) => address);
-});
-
-// MetaMask announces the new chain to the dapp shortly after the switch
-function waitForChainId(chainId, attempts = 20) {
-  return provider('eth_chainId').then((current) => {
-    if (current === chainId) return current;
-    if (attempts === 0) throw new Error(`[dappress] The dapp is on chain ${current}, not ${chainId}`);
-    return cy.wait(500, { log: false }).then(() => waitForChainId(chainId, attempts - 1));
-  });
-}
-
-// Onboard or unlock the wallet once per spec, before the dapp needs it.
-if (options.autoSetup !== false) {
-  before(() => {
-    cy.setupMetaMask();
-  });
-}

package/types/index.d.ts

@@ -1,55 +0,0 @@
-/// <reference types="cypress" />
-
-/** A network, as passed to MetaMask's wallet_addEthereumChain. */
-export interface Network {
-  chainId: string;
-  chainName: string;
-  rpcUrls: string[];
-  nativeCurrency: { name: string; symbol: string; decimals: number };
-  blockExplorerUrls?: string[];
-  iconUrls?: string[];
-}
-
-/** What cypress/wallet.setup.ts exports. */
-export interface WalletSetup {
-  /**
-   * The wallet to import. Without one, Dappress makes a new wallet for each run.
-   * Prefer DAPPRESS_SEED_PHRASE in cypress.env.json or the environment: this file is usually committed.
-   */
-  seedPhrase?: string;
-  /** The network the dapp is moved onto by cy.connectToDapp(). */
-  network?: Network;
-}
-
-export interface DappressOptions extends WalletSetup {
-  /** Password of the throwaway browser profile's wallet. Default: Tester@1234. */
-  password?: string;
-  /** MetaMask release to load, downloaded from GitHub on first run. */
-  metamaskVersion?: string;
-  /**
-   * Keep MetaMask's backup and sync on. It saves the accounts and contacts of a
-   * seed phrase and restores them on other installs. Default: false.
-   */
-  backupAndSync?: boolean;
-  /** Run cy.setupMetaMask() before the first test of each spec. Default: true. */
-  autoSetup?: boolean;
-  /** Import the wallet once and reuse the profile across runs. Keeps the vault under cacheDir. Headed runs only. Default: false. */
-  cache?: boolean;
-  /** Time allowed for MetaMask to display a request, in ms. Default: 20000. */
-  timeout?: number;
-  /** Where MetaMask builds are cached. Default: ~/.cache/dappress. */
-  cacheDir?: string;
-}
-
-/**
- * Wire Dappress into a Cypress project, from setupNodeEvents:
- *
- *   setupNodeEvents(on, config) {
- *     return configureDappress(on, config);
- *   }
- */
-export function configureDappress(
-  on: Cypress.PluginEvents,
-  config: Cypress.PluginConfigOptions,
-  options?: DappressOptions,
-): Cypress.PluginConfigOptions;

package/types/support.d.ts

@@ -1,88 +0,0 @@
-/// <reference types="cypress" />
-
-import type { Network } from './index';
-
-export type WalletState = 'onboarding' | 'locked' | 'unlocked';
-
-export type ConnectOptions = {
-  /**
-   * The accounts to connect the dapp with, by their names in MetaMask:
-   * `['Account 1', 'Account 2']`. These and no other are connected, in the
-   * order MetaMask gives them to the dapp, whatever their order here.
-   * Default: the account MetaMask suggests, the wallet's selected one.
-   */
-  accounts?: string[];
-};
-
-declare global {
-  namespace Cypress {
-    interface Chainable {
-      /** Imports or unlocks the wallet. Runs by itself before each spec unless autoSetup is false. */
-      setupMetaMask(): Chainable<WalletState>;
-      /** Accepts the connection request, with the accounts named in `accounts` if any, then moves the dapp onto the wallet setup's network if there is one. */
-      connectToDapp(options?: ConnectOptions): Chainable<void>;
-      rejectConnection(): Chainable<void>;
-      /** Disconnects the dapp from the wallet's permissions screen: the dapp gets an empty accountsChanged. */
-      disconnectFromDapp(): Chainable<void>;
-      /** Answers a signature request (personal_sign, eth_signTypedData_*). */
-      confirmSignature(): Chainable<void>;
-      rejectSignature(): Chainable<void>;
-      /** Answers a transaction, including ERC-20 approvals. Confirming takes what to set first: a spending cap, a network fee. */
-      confirmTransaction(options?: TransactionOptions): Chainable<void>;
-      rejectTransaction(): Chainable<void>;
-      /** Answers wallet_addEthereumChain. */
-      approveNewNetwork(): Chainable<void>;
-      rejectNewNetwork(): Chainable<void>;
-      /** Answers the permission asked before switching to a network the dapp isn't allowed on yet. */
-      approveSwitchNetwork(): Chainable<void>;
-      rejectSwitchNetwork(): Chainable<void>;
-      /** Answers wallet_watchAsset ("Add suggested tokens"). */
-      approveAddToken(): Chainable<void>;
-      rejectAddToken(): Chainable<void>;
-      /** Adds an account to the wallet and selects it. Yields its name, "Account N". */
-      addAccount(): Chainable<string>;
-      /** Selects an account of the wallet by its name. */
-      switchAccount(name: string): Chainable<void>;
-      /** Imports an account from its private key and selects it. Yields its name. */
-      importAccount(privateKey: string): Chainable<string>;
-      /** Locks the wallet from MetaMask's menu: requests wait behind its unlock screen until it is unlocked. */
-      lockWallet(): Chainable<void>;
-      /** Unlocks a locked wallet with the configured password. Yields how it was found: "unlocked" when there was nothing to do. */
-      unlockWallet(): Chainable<WalletState>;
-      /** Moves the dapp onto a network, adding it to MetaMask if needed. Defaults to the wallet setup's network. Yields the chain id. */
-      useNetwork(network?: Network): Chainable<string>;
-      /** The address the dapp is connected with. */
-      getAccountAddress(): Chainable<string>;
-    }
-  }
-}
-
-/** What cy.confirmTransaction() sets on the confirmation before confirming it. */
-export interface TransactionOptions {
-  /**
-   * On an ERC-20 approval, the amount the spender may use, in tokens, as a user types it: 5 or '2.5'.
-   * A string keeps an amount a number would round. Fails on a transaction that has no spending cap.
-   */
-  spendingCap?: number | string;
-  /**
-   * The network fee: one of the estimates MetaMask's fee editor offers for the network, or custom values.
-   * Fails when MetaMask doesn't offer that estimate.
-   */
-  gas?: GasEstimate | CustomGas;
-}
-
-/**
- * An estimate of MetaMask's fee editor, by the name it shows. Low, Market and Aggressive are offered on the
- * networks MetaMask has fee estimates for; Network suggested on those it only has a gas price for, such as a local node.
- */
-export type GasEstimate = 'low' | 'market' | 'aggressive' | 'networkSuggested';
-
-/** The fields of the fee editor's advanced form, on an EIP-1559 transaction. One left out keeps MetaMask's value. */
-export interface CustomGas {
-  /** "Max base fee", in GWEI: the transaction's maxFeePerGas. */
-  maxBaseFee?: number | string;
-  /** "Priority fee", in GWEI: the transaction's maxPriorityFeePerGas. At most the max base fee. */
-  priorityFee?: number | string;
-  /** "Gas limit", in units of gas: 21000 or more. */
-  gasLimit?: number | string;
-}