dappress 0.3.3 → 0.5.0

package/dist/metamask-pages.js

@@ -0,0 +1,143 @@
+"use strict";
+// Find MetaMask's pages in the browser Cypress launched: the full-screen home
+// page, and the surface where dapp requests show up. On Chrome that surface
+// is the side panel when it is open, and the "MetaMask Dialog" popup otherwise.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findExtensionId = findExtensionId;
+exports.getHomePage = getHomePage;
+exports.getRequestPages = getRequestPages;
+exports.getConfirmationPage = getConfirmationPage;
+exports.withUsableWindow = withUsableWindow;
+const page_helpers_1 = require("./page-helpers");
+const HOME_PATH = '/home.html';
+const CONFIRMATION_PATHS = ['/notification.html', '/sidepanel.html'];
+function extensionIdOf(url) {
+    const match = /^chrome-extension:\/\/([a-z]{32})\//.exec(url);
+    return match ? match[1] : null;
+}
+function isHomeRoute(url) {
+    return url.includes('/notification.html') && /notification\.html(#\/?)?$/.test(url);
+}
+function pagesOf(browser, extensionId, pathname) {
+    return browser.targets().filter((target) => target.type() === 'page' && target.url().startsWith(`chrome-extension://${extensionId}${pathname}`));
+}
+/**
+ * MetaMask's extension id. Cypress loads its own extension in headed
+ * Chromium browsers, so the id is the one whose home page is titled "MetaMask".
+ */
+async function findExtensionId(browser, timeout = 30000) {
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        const ids = new Set(browser
+            .targets()
+            .map((target) => extensionIdOf(target.url()))
+            .filter((id) => id !== null));
+        for (const id of ids) {
+            if (await isMetaMask(browser, id))
+                return id;
+        }
+        await (0, page_helpers_1.sleep)(500);
+    }
+    throw new Error('[dappress] MetaMask extension not found in the browser. Is it loaded in before:browser:launch?');
+}
+async function isMetaMask(browser, extensionId) {
+    const [target] = pagesOf(browser, extensionId, HOME_PATH);
+    if (target) {
+        // A page still loading or redirecting loses its execution context while its
+        // title is read; not MetaMask yet, findExtensionId looks again
+        try {
+            const page = await pageOf(target);
+            return (await page.title()).startsWith('MetaMask');
+        }
+        catch {
+            return false;
+        }
+    }
+    const page = await browser.newPage();
+    try {
+        const response = await page.goto(`chrome-extension://${extensionId}${HOME_PATH}`, { waitUntil: 'domcontentloaded' });
+        return Boolean(response && response.ok()) && (await page.title()).startsWith('MetaMask');
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await page.close();
+    }
+}
+// A target of type "page" has a page; Puppeteer types it as one that may not
+async function pageOf(target) {
+    const page = await target.page();
+    if (!page)
+        throw new Error(`[dappress] No page behind ${target.url()}`);
+    return page;
+}
+/** The full-screen MetaMask page, opened if it isn't already. */
+async function getHomePage(browser, extensionId) {
+    const [target] = pagesOf(browser, extensionId, HOME_PATH);
+    if (target)
+        return pageOf(target);
+    const page = await browser.newPage();
+    await page.goto(`chrome-extension://${extensionId}${HOME_PATH}`, { waitUntil: 'domcontentloaded' });
+    return page;
+}
+/** The pages open where dapp requests show up: the side panel, a popup. */
+async function getRequestPages(browser, extensionId) {
+    const pages = [];
+    for (const pathname of CONFIRMATION_PATHS) {
+        for (const target of pagesOf(browser, extensionId, pathname)) {
+            const page = await target.page();
+            if (page)
+                pages.push(pathname === '/notification.html' ? await withUsableWindow(page) : page);
+        }
+    }
+    return pages;
+}
+/**
+ * The page a dapp request is shown on. Waits for the popup to open, or takes
+ * the side panel. A popup still on its home route is one closing after the
+ * previous request, or one that hasn't routed to the request yet: skipped.
+ */
+async function getConfirmationPage(browser, extensionId, timeout) {
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        for (const pathname of CONFIRMATION_PATHS) {
+            const [target] = pagesOf(browser, extensionId, pathname).filter((candidate) => !isHomeRoute(candidate.url()));
+            if (target)
+                return pathname === '/notification.html' ? withUsableWindow(await pageOf(target)) : pageOf(target);
+        }
+        await (0, page_helpers_1.sleep)(250);
+    }
+    const seen = browser
+        .targets()
+        .filter((target) => extensionIdOf(target.url()) === extensionId)
+        .map((target) => `${target.type()} ${target.url()}`)
+        .join(', ');
+    throw new Error(`[dappress] MetaMask showed no confirmation within ${timeout}ms. Did the dapp send a request? MetaMask pages seen: ${seen || 'none'}`);
+}
+// MetaMask asks Chrome for a 400x620 popup. Under Xvfb on a GitHub runner the
+// window it gets is 1x1: nothing is laid out, the pane of a confirmation that
+// must be read to the end has no height, so it can never be scrolled there and
+// its Confirm button stays disabled. The popup is given its size back first.
+const POPUP = { width: 400, height: 620 };
+async function withUsableWindow(page) {
+    const session = await page.target().createCDPSession();
+    try {
+        const { windowId, bounds } = await session.send('Browser.getWindowForTarget');
+        if (bounds.windowState === 'normal' && (bounds.width ?? 0) >= 200 && (bounds.height ?? 0) >= 200)
+            return page;
+        console.log(`[dappress] MetaMask's popup is ${bounds.width}x${bounds.height} (${bounds.windowState}); resizing it to ${POPUP.width}x${POPUP.height}`);
+        if (bounds.windowState !== 'normal')
+            await session.send('Browser.setWindowBounds', { windowId, bounds: { windowState: 'normal' } });
+        await session.send('Browser.setWindowBounds', { windowId, bounds: { ...POPUP } });
+        // Let the page lay itself out at its new size before anything is looked for in it
+        await (0, page_helpers_1.sleep)(300);
+    }
+    catch (error) {
+        console.warn(`[dappress] Could not check the popup window's size: ${error.message}`);
+    }
+    finally {
+        await session.detach().catch(() => { });
+    }
+    return page;
+}

package/dist/metamask.d.ts

@@ -0,0 +1,53 @@
+import type { Page } from 'puppeteer-core';
+import type { ConnectOptions, ResolvedOptions, TransactionOptions, WalletState } from './types';
+export declare const decisions: {
+    connectToDapp: string[];
+    rejectConnection: string[];
+    approveNewNetwork: string[];
+    rejectNewNetwork: string[];
+    approveSwitchNetwork: string[];
+    rejectSwitchNetwork: string[];
+    approveAddToken: string[];
+    rejectAddToken: string[];
+    confirmSignature: string[];
+    rejectSignature: string[];
+    confirmTransaction: string[];
+    rejectTransaction: string[];
+};
+export type Decision = keyof typeof decisions;
+/** Which screen the extension home page shows, once MetaMask has started. */
+export declare function walletState(page: Page): Promise<WalletState | 'unknown'>;
+/** Import a wallet from its seed phrase on a fresh MetaMask install. */
+export declare function onboard(page: Page, { seedPhrase, password, backupAndSync }: Pick<ResolvedOptions, 'seedPhrase' | 'password' | 'backupAndSync'>): Promise<void>;
+export declare function unlock(page: Page, { password }: Pick<ResolvedOptions, 'password'>): Promise<void>;
+/**
+ * A page that was showing the unlock form when the wallet got unlocked from
+ * another one keeps showing it, and the dapp's requests wait behind it. The
+ * password is given there too, as a user would; what follows is the wallet
+ * or a request, so only the form is watched.
+ */
+export declare function leaveUnlockForm(page: Page, { password }: Pick<ResolvedOptions, 'password'>): Promise<void>;
+/**
+ * Add an account to the wallet and select it. Yields its name, "Account N".
+ * A click that lands while the list is still settling is lost, so the button
+ * is pressed again when no account shows up.
+ */
+export declare function addAccount(page: Page): Promise<string>;
+/** Make `name` the selected account of the wallet. */
+export declare function switchAccount(page: Page, name: string): Promise<void>;
+/** Import an account from its private key and select it. Yields its name. */
+export declare function importAccount(page: Page, privateKey: string): Promise<string>;
+/** Lock the wallet from the menu of its home page. Nothing to do on a wallet already locked. */
+export declare function lock(page: Page): Promise<void>;
+/**
+ * Disconnect the site at `origin` from the wallet, on its page of the
+ * "Permissions" screen. The dapp gets an empty accountsChanged.
+ */
+export declare function disconnectSite(page: Page, origin: string): Promise<void>;
+/** The options a command took from the test: those of the commands that take any. */
+type CommandOptions = ConnectOptions & TransactionOptions;
+/** Press the button of `decision` on the confirmation shown on `page`, once it is set as `options` ask. */
+export declare function decide(decision: Decision, page: Page, timeout: number, options?: CommandOptions): Promise<void>;
+/** wallet_addEthereumChain on a network MetaMask knows behaves like a switch: either prompt may show. */
+export declare function approveNetworkChange(page: Page, timeout: number): Promise<void>;
+export {};