@walletwright/core 0.2.0

package/dist/cache-Bqz3Mchl.mjs

@@ -0,0 +1,972 @@
+import { mkdir, readdir, rm } from "node:fs/promises";
+import path from "node:path";
+import { chromium } from "@playwright/test";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import AdmZip from "adm-zip";
+import { ClassicLevel } from "classic-level";
+
+//#region src/internal/download.ts
+const ZIP_SIGNATURE = Buffer.from([
+	80,
+	75,
+	3,
+	4
+]);
+/**
+* Download an extension archive and extract it to `<cacheDir>/<name>`, returning that path. A `.crx`
+* is a ZIP with a binary header, we slice from the ZIP signature before unzipping. Reuses an
+* existing extraction (so you can pre-place the extension to skip the download).
+*/
+const downloadAndExtractExtension = async (options) => {
+	const { cacheDir, kind, name, sha256, url } = options;
+	const cacheRoot = path.resolve(cacheDir);
+	const outDir = path.resolve(cacheDir, name);
+	if (outDir === cacheRoot || !outDir.startsWith(cacheRoot + path.sep)) throw new Error(`[walletwright] invalid extension name: ${name}`);
+	if (existsSync(path.join(outDir, "manifest.json"))) return outDir;
+	await mkdir(cacheDir, { recursive: true });
+	const response = await fetch(url, { redirect: "follow" });
+	if (!response.ok) throw new Error(`[walletwright] failed to download ${url}: ${response.status} ${response.statusText}`);
+	const bytes = Buffer.from(await response.arrayBuffer());
+	if (sha256 !== void 0) {
+		const actual = createHash("sha256").update(bytes).digest("hex");
+		if (actual !== sha256.toLowerCase()) throw new Error(`[walletwright] ${name} failed integrity check: expected ${sha256}, got ${actual}`);
+	}
+	let zipBytes = bytes;
+	if (kind === "crx") {
+		const start = bytes.indexOf(ZIP_SIGNATURE);
+		if (start === -1) throw new Error(`[walletwright] ${url} is not a valid CRX (no ZIP header found)`);
+		zipBytes = bytes.subarray(start);
+	}
+	await rm(outDir, {
+		force: true,
+		recursive: true
+	});
+	const zip = new AdmZip(zipBytes);
+	const root = path.resolve(outDir);
+	for (const entry of zip.getEntries()) {
+		const target = path.resolve(root, entry.entryName);
+		if (target !== root && !target.startsWith(root + path.sep)) throw new Error(`[walletwright] refusing to extract ${entry.entryName}: escapes ${outDir}`);
+	}
+	zip.extractAllTo(outDir, true);
+	if (!existsSync(path.join(outDir, "manifest.json"))) throw new Error(`[walletwright] extracted ${name} but no manifest.json found in ${outDir}`);
+	return outDir;
+};
+/** Build the Chrome Web Store CRX download URL for an extension id. */
+const chromeWebStoreCrxUrl = (extensionId) => `https://clients2.google.com/service/update2/crx?response=redirect&prodversion=130.0&acceptformat=crx2,crx3&x=id%3D${extensionId}%26uc`;
+/** Download and extract a Chrome Web Store extension (latest) into `<cacheDir>/<name>`. */
+const prepareWebStoreExtension = (options) => downloadAndExtractExtension({
+	cacheDir: options.cacheDir,
+	kind: "crx",
+	name: options.name,
+	sha256: void 0,
+	url: chromeWebStoreCrxUrl(options.extensionId)
+});
+
+//#endregion
+//#region src/wallets/metamask/actions/accounts.ts
+const openAccountMenu = async (home) => {
+	await home.getByTestId("account-menu-icon").click();
+	await home.getByTestId("add-multichain-account-button").waitFor({ state: "visible" });
+};
+/** The menu is a popover with no close affordance; going home is the reliable way out. */
+const closeAccountMenu = async (home) => {
+	await home.goto(`${home.url().split("#")[0]}#/`);
+	await home.getByTestId("account-menu-icon").waitFor({ state: "visible" });
+};
+const add$1 = async ({ home }) => {
+	await openAccountMenu(home);
+	const cells = home.getByTestId("account-cell-avatar");
+	const before = await cells.count();
+	await home.getByTestId("add-multichain-account-button").click();
+	await cells.nth(before).waitFor({
+		state: "visible",
+		timeout: 15e3
+	});
+	await closeAccountMenu(home);
+};
+const importPrivateKey = async ({ home }, privateKey) => {
+	await openAccountMenu(home);
+	await home.getByTestId("account-list-add-wallet-button").click();
+	const chooseImport = home.getByTestId("choose-wallet-type-import-account");
+	await chooseImport.waitFor({ state: "visible" });
+	await chooseImport.click();
+	const confirm = home.getByTestId("import-account-confirm-button");
+	await confirm.waitFor({ state: "visible" });
+	await home.locator("input").first().fill(privateKey);
+	await confirm.click();
+	await confirm.waitFor({
+		state: "hidden",
+		timeout: 15e3
+	});
+	await closeAccountMenu(home);
+};
+const rename = async ({ home }, options) => {
+	await openAccountMenu(home);
+	await home.getByTestId("multichain-account-cell-end-accessory").nth(options.index).click();
+	await home.getByTestId("multichain-account-menu-item-rename").click();
+	await home.getByTestId("account-name-input").locator("input").fill(options.name);
+	await home.getByRole("button", { name: "Confirm" }).click();
+	await closeAccountMenu(home);
+};
+const switchTo = async ({ home }, index) => {
+	await openAccountMenu(home);
+	await home.getByTestId("account-cell-avatar").nth(index).click();
+	if (!await home.getByTestId("add-multichain-account-button").waitFor({
+		state: "hidden",
+		timeout: 1e4
+	}).then(() => true).catch(() => false)) throw new Error(`[walletwright] accounts.switch(${index}) did not switch (menu stayed open)`);
+};
+const accounts = {
+	add: add$1,
+	importPrivateKey,
+	rename,
+	switch: switchTo
+};
+
+//#endregion
+//#region src/wallets/metamask/actions/network.ts
+const closeButton = (home) => home.getByTestId("modal-header-close-button").filter({ visible: true }).first();
+const openNetworkManager = async (home) => {
+	await home.getByTestId("sort-by-networks").click();
+	await closeButton(home).waitFor({ state: "visible" });
+};
+const add = async ({ home }, config) => {
+	await openNetworkManager(home);
+	await home.getByText("Custom", { exact: true }).first().click();
+	await home.getByRole("button", { name: "Add custom network" }).first().click();
+	await home.getByTestId("network-form-network-name").fill(config.name);
+	await home.getByTestId("network-form-chain-id").fill(String(config.chainId));
+	await home.getByTestId("network-form-ticker-input").fill(config.symbol);
+	await home.getByTestId("test-add-rpc-drop-down").click();
+	await home.getByText("Add RPC URL", { exact: true }).first().click();
+	await home.getByTestId("rpc-url-input-test").fill(config.rpcUrl);
+	await home.getByTestId("page-container-footer-next").click();
+	await home.getByTestId("network-form-network-name").waitFor();
+	await home.getByTestId("page-container-footer-next").click();
+	await closeButton(home).click();
+	await closeButton(home).waitFor({ state: "hidden" });
+};
+const network = { add };
+
+//#endregion
+//#region src/internal/wait.ts
+const DEFAULT_INTERVAL_MS = 200;
+const DEFAULT_NAVIGATION_INTERVAL_MS = 1e3;
+const sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+/** Render a timeout for an error message, so what a failure claims matches what it waited. */
+const formatTimeout = (ms) => `${Math.round(ms / 100) / 10}s`;
+/**
+* Poll `check` until it yields anything other than `undefined`/`false`, then hand that value back.
+* Returns `undefined` when the budget elapses, so only a caller that can genuinely continue without
+* the condition (an optional approval popup, say) branches on the result; everything else uses
+* `waitUntilOrThrow` and gets a named failure instead of a wallet that looks ready and isn't.
+*/
+const waitUntil = async (check, { intervalMs = DEFAULT_INTERVAL_MS, timeoutMs }) => {
+	const deadline = Date.now() + timeoutMs;
+	for (;;) {
+		const result = await check();
+		if (result !== void 0 && result !== false) return result;
+		if (Date.now() >= deadline) return;
+		await sleep(intervalMs);
+	}
+};
+const waitUntilOrThrow = async (check, options) => {
+	const result = await waitUntil(check, options);
+	if (result === void 0) throw new Error(`[walletwright] ${options.message} (gave up after ${formatTimeout(options.timeoutMs)})`);
+	return result;
+};
+/**
+* A `chrome-extension://` URL fails with `ERR_BLOCKED_BY_CLIENT` until the extension registers,
+* which takes seconds after launch, so reaching an extension page is a poll rather than a one-shot.
+*/
+const gotoWithRetry = async (page, url, { intervalMs = DEFAULT_NAVIGATION_INTERVAL_MS, label, timeoutMs }) => {
+	await waitUntilOrThrow(() => page.goto(url, { waitUntil: "domcontentloaded" }).then(() => true).catch(() => void 0), {
+		intervalMs,
+		message: `${label} never loaded (${url})`,
+		timeoutMs
+	});
+};
+
+//#endregion
+//#region src/internal/unlock-screen.ts
+const PASSWORD_FIELD = "input[type=\"password\"]";
+const NAVIGATION_TIMEOUT_MS$1 = 15e3;
+const FIRST_SETTLE_TIMEOUT_MS = 2e4;
+const RELOAD_ATTEMPTS = 5;
+const RELOAD_SETTLE_TIMEOUT_MS = 5e3;
+const PROBE_INTERVAL_MS = 500;
+const PASSWORD_CLEARED_TIMEOUT_MS = 15e3;
+/**
+* The shared unlock flow: open the wallet's own page, wait for it to settle into a state we can
+* name, and type the password. Every wallet differs only in its entry page, how it submits, and
+* whether it can come back already unlocked.
+*/
+const createUnlockScreen = ({ entry, isUnlocked, submit, wallet }) => {
+	const settled = async (page) => {
+		if (await page.locator(PASSWORD_FIELD).isVisible().catch(() => false)) return "locked";
+		return await isUnlocked?.(page).catch(() => false) === true ? "unlocked" : void 0;
+	};
+	const settleWithin = (page, timeoutMs) => waitUntil(() => settled(page), {
+		intervalMs: PROBE_INTERVAL_MS,
+		timeoutMs
+	});
+	const reachUnlockScreen = async (context, extensionId) => {
+		const page = await context.newPage();
+		await gotoWithRetry(page, `chrome-extension://${extensionId}/${entry}`, {
+			label: `${wallet} ${entry}`,
+			timeoutMs: NAVIGATION_TIMEOUT_MS$1
+		});
+		let state = await settleWithin(page, FIRST_SETTLE_TIMEOUT_MS);
+		for (let attempt = 0; attempt < RELOAD_ATTEMPTS && state === void 0; attempt++) {
+			await page.reload().catch(() => {});
+			state = await settleWithin(page, RELOAD_SETTLE_TIMEOUT_MS);
+		}
+		if (state === void 0) throw new Error(`[walletwright] ${wallet} never reached its unlock screen (gave up after ${formatTimeout(45e3)})`);
+		return page;
+	};
+	const unlock = async (page, password) => {
+		const field = page.locator(PASSWORD_FIELD);
+		if (!await field.isVisible().catch(() => false)) {
+			if (await isUnlocked?.(page).catch(() => false) === true) return;
+			throw new Error(`[walletwright] ${wallet} showed neither an unlock screen nor an unlocked wallet`);
+		}
+		await field.fill(password);
+		await (submit === void 0 ? field.press("Enter") : submit(page, field));
+		if (!await field.waitFor({
+			state: "hidden",
+			timeout: PASSWORD_CLEARED_TIMEOUT_MS
+		}).then(() => true).catch(() => false)) throw new Error(`[walletwright] ${wallet} unlock failed (password screen still visible after ${formatTimeout(PASSWORD_CLEARED_TIMEOUT_MS)})`);
+	};
+	return {
+		reachUnlockScreen,
+		unlock
+	};
+};
+
+//#endregion
+//#region src/wallets/metamask/onboarding.ts
+const SRP_RETYPE_TIMEOUT_MS = 4e4;
+const SRP_CONFIRM_TIMEOUT_MS = 5e3;
+const { reachUnlockScreen: reachUnlockScreen$4, unlock: unlock$4 } = createUnlockScreen({
+	entry: "home.html",
+	wallet: "MetaMask"
+});
+const importWallet$2 = async (page, seedPhrase, password) => {
+	await page.getByTestId("onboarding-import-wallet").click();
+	await page.getByTestId("onboarding-import-with-srp-button").click();
+	const srpField = page.getByTestId("srp-input-import__srp-note");
+	const confirmEnabled = page.locator("[data-testid=\"import-srp-confirm\"]:not([disabled])");
+	if (await waitUntil(async () => {
+		await srpField.click();
+		await srpField.fill("");
+		await srpField.pressSequentially(seedPhrase, { delay: 50 });
+		return confirmEnabled.waitFor({
+			state: "visible",
+			timeout: SRP_CONFIRM_TIMEOUT_MS
+		}).then(() => true).catch(() => void 0);
+	}, {
+		intervalMs: 0,
+		timeoutMs: SRP_RETYPE_TIMEOUT_MS
+	}) === void 0) throw new Error("[walletwright] MetaMask rejected the seed phrase (confirm stayed disabled)");
+	await confirmEnabled.click();
+	await page.getByTestId("create-password-new-input").fill(password);
+	await page.getByTestId("create-password-confirm-input").fill(password);
+	await page.getByTestId("create-password-terms").click();
+	await page.locator("[data-testid=\"create-password-submit\"]:not([disabled])").click();
+	await page.getByTestId("passkey-maybe-later-button").click({ timeout: 1e4 }).catch(() => {});
+	await page.getByTestId("metametrics-i-agree").click({ timeout: 1e4 }).catch(() => {});
+};
+
+//#endregion
+//#region src/wallets/metamask/actions/settings.ts
+const settings = {
+	lock: async ({ home }) => {
+		await home.getByTestId("account-options-menu-button").click();
+		await home.getByTestId("global-menu-lock").filter({ visible: true }).first().click();
+		await home.locator("input[type=\"password\"]").waitFor({
+			state: "visible",
+			timeout: 15e3
+		});
+	},
+	unlock: async ({ home, password }) => {
+		await unlock$4(home, password);
+	}
+};
+
+//#endregion
+//#region src/wallets/metamask/approve.ts
+/**
+* How long a confirm or cancel button gets to become clickable, once the page is already showing
+* one. Generous because a loaded CI runner renders MetaMask's footer slowly.
+*/
+const BUTTON_TIMEOUT_MS = 45e3;
+/** The retry only covers a notice that rendered late, so it does not need the full budget again. */
+const RETRY_TIMEOUT_MS = 1e4;
+/**
+* First-time requests that MetaMask routes through a protocol Snap (e.g. adding a custom chain)
+* open a "Third-party software notice" modal over the confirm footer, and every click is
+* intercepted until it is accepted. Its buttons carry no testids, only text, and Accept stays
+* disabled until the notice is scrolled to the bottom.
+*/
+const acceptThirdPartyNotice = async (popup) => {
+	const modal = popup.locator(".snap-install-warning");
+	if (await modal.count().catch(() => 0) === 0) return;
+	await modal.locator("p").last().scrollIntoViewIfNeeded().catch(() => {});
+	await modal.getByRole("button", { name: "Accept" }).click({ timeout: 3e3 }).catch(() => {});
+};
+/**
+* Confirm buttons differ by request type: connect popups use `confirm-btn`, signature and
+* transaction popups use `confirm-footer-button`, older builds used `page-container-footer-next`,
+* and requests routed through a protocol Snap (e.g. Solana) use
+* `confirm-<type>-confirm-snap-footer-button`, matched by suffix so every snap confirmation type is
+* covered. A popup renders exactly one of these buttons; the `.or()` union resolves whichever one
+* is present by DOM order, not by the order it's written in below, so one locator covers every
+* popup.
+*/
+const confirmButton = (popup) => popup.getByTestId("confirm-btn").or(popup.getByTestId("confirm-footer-button")).or(popup.locator("[data-testid=\"page-container-footer-next\"]")).or(popup.locator("[data-testid$=\"-confirm-snap-footer-button\"]")).first();
+const cancelButton = (popup) => popup.getByTestId("cancel-btn").or(popup.getByTestId("confirm-footer-cancel-button")).or(popup.locator("[data-testid=\"page-container-footer-cancel\"]")).or(popup.locator("[data-testid$=\"-cancel-snap-footer-button\"]")).first();
+/**
+* What "this page is showing a request" means for MetaMask, as opposed to its wallet home. The
+* distinction matters for the page walletwright opens itself: `notification.html` renders the home
+* screen (account header, Buy/Swap/Send, a news carousel) when nothing is pending, so buttons on
+* screen prove nothing. A CI run handed that home screen to `approve` and waited out the full click
+* budget against a confirm button that was never going to exist.
+*/
+const approvalControls = (popup) => confirmButton(popup).or(cancelButton(popup));
+const approve = async (popup) => {
+	const button = confirmButton(popup);
+	await acceptThirdPartyNotice(popup);
+	try {
+		await button.click({ timeout: BUTTON_TIMEOUT_MS });
+	} catch (error) {
+		await acceptThirdPartyNotice(popup);
+		await button.click({ timeout: RETRY_TIMEOUT_MS }).catch(() => {
+			throw error;
+		});
+	}
+};
+/** The cancel counterparts of `approve`; same union-by-DOM-order resolution, not written order. */
+const reject = async (popup) => {
+	await cancelButton(popup).click({ timeout: BUTTON_TIMEOUT_MS });
+};
+
+//#endregion
+//#region src/internal/utils.ts
+const DEFAULT_CACHE_DIR = ".walletwright";
+/** MetaMask/Phantom approval-popup URL token; Slush overrides it with `notificationMatch: "isPopup=1"`. */
+const DEFAULT_NOTIFICATION_MATCH = "notification.html";
+/** Stable per-setup profile directory name, so the same wallet+seed+password reuses one cache. */
+const profileKey = (setup) => createHash("sha256").update(`${setup.wallet}:${setup.version ?? "default"}:${setup.seedPhrase}:${setup.password}`).digest("hex").slice(0, 20);
+/**
+* Compute an extension's id without querying the browser (`chrome://extensions` is blocked headless,
+* and the service worker starts lazily). Chrome derives the id from the sha256 of either the
+* manifest's public `key` (if present, e.g. Phantom → its fixed Web Store id) or the absolute load
+* path (no key, e.g. MetaMask), taking the first 16 bytes and mapping each nibble 0-f → a-p.
+*
+* The path is resolved through symlinks (`realpathSync`) because Chrome hashes the *real* path, a
+* cache under a symlinked dir (e.g. macOS `/tmp` → `/private/tmp`) would otherwise yield a wrong id.
+*/
+const extensionIdFromPath = (extensionPath) => {
+	const resolved = path.resolve(extensionPath);
+	const abs = (() => {
+		try {
+			return realpathSync(resolved);
+		} catch {
+			return resolved;
+		}
+	})();
+	let key;
+	try {
+		const manifest = JSON.parse(readFileSync(path.join(abs, "manifest.json"), "utf8"));
+		if (typeof manifest === "object" && manifest !== null && "key" in manifest) key = typeof manifest.key === "string" ? manifest.key : void 0;
+	} catch {}
+	const source = key === void 0 || key === "" ? Buffer.from(abs, "utf8") : Buffer.from(key, "base64");
+	const hex = createHash("sha256").update(source).digest("hex").slice(0, 32);
+	return Array.from(hex, (nibble) => String.fromCodePoint(97 + Number.parseInt(nibble, 16))).join("");
+};
+/**
+* Approval popups open as `about:blank` and then navigate, so `waitForEvent('page', { predicate })`
+* misses them, poll the open pages instead. `match` is the URL token identifying the popup
+* (`notification.html` for MetaMask/Phantom; `isPopup=1` for Slush's single-page `index.html`).
+*/
+const isApprovalPopup = (page, extensionId, match) => page.url().startsWith(`chrome-extension://${extensionId}`) && page.url().includes(match) && !page.isClosed();
+const isVisible = async (locator) => {
+	try {
+		return await locator.isVisible();
+	} catch {
+		return false;
+	}
+};
+const hasVisibleButton = (page) => isVisible(page.locator("button").first());
+const findNotificationPopup = ({ approvalControls, context, extensionId, match = DEFAULT_NOTIFICATION_MATCH, timeoutMs = 1e4 }) => waitUntil(async () => {
+	const popup = context.pages().find((page) => isApprovalPopup(page, extensionId, match));
+	if (!popup) return;
+	await popup.waitForLoadState("domcontentloaded").catch(() => {});
+	return (approvalControls === void 0 ? await hasVisibleButton(popup) : await isVisible(approvalControls(popup).first())) ? popup : void 0;
+}, { timeoutMs });
+/** MetaMask's own popup dimensions, which its layout is built for. */
+const APPROVAL_WINDOW = {
+	height: 592,
+	width: 360
+};
+/** Far enough from the edge that a popup this size lands fully on any usable display. */
+const APPROVAL_WINDOW_OFFSET = 50;
+/**
+* Put a wallet-spawned approval window somewhere it can be clicked. It can open partly off-screen
+* on a small or virtual display, and Playwright will not click what is out of view, so a confirm
+* button that is rendered and enabled still times out. Synpress carries the same workaround.
+*
+* Best-effort throughout: headless has no window to move, and nothing here is required for a window
+* that already sits on screen.
+*/
+const placeApprovalWindow = async (page) => {
+	await page.setViewportSize(APPROVAL_WINDOW).catch(() => {});
+	try {
+		const session = await page.context().newCDPSession(page);
+		const { targetInfo } = await session.send("Target.getTargetInfo");
+		const { windowId } = await session.send("Browser.getWindowForTarget", { targetId: targetInfo.targetId });
+		await session.send("Browser.setWindowBounds", {
+			bounds: {
+				left: APPROVAL_WINDOW_OFFSET,
+				top: APPROVAL_WINDOW_OFFSET
+			},
+			windowId
+		});
+		await session.detach();
+	} catch {}
+};
+/** Where Chrome persists an extension's `chrome.storage.local` inside a browser profile. */
+const extensionStateDir = (profileDir, extensionId) => path.join(profileDir, "Default", "Local Extension Settings", extensionId);
+const hasNotificationPopup = (context, extensionId, match = DEFAULT_NOTIFICATION_MATCH) => context.pages().some((page) => isApprovalPopup(page, extensionId, match));
+
+//#endregion
+//#region src/wallets/metamask/onboarding-patch.ts
+const asState = (value) => typeof value === "object" && value !== null ? { ...value } : void 0;
+const markOnboarded = (onboarding) => ({
+	...onboarding,
+	completedOnboarding: true,
+	firstTimeFlowType: typeof onboarding.firstTimeFlowType === "string" ? onboarding.firstTimeFlowType : "import",
+	onboardingTabs: {}
+});
+/**
+* Force `completedOnboarding=true` in MetaMask's persisted state so the cached wallet boots straight
+* to the unlock screen instead of getting stuck on the "wallet is ready" screen (whose "Open wallet"
+* action goes through the MV3 service worker and is unreliable under automation).
+*
+* MetaMask 13.13.x stored all state under a single `data` key; 13.3x stores each controller under its
+* own key (`OnboardingController`). Both are handled. Must run while the browser is closed.
+*
+* Every branch that can't find the state it means to patch throws: leaving the cache unpatched means
+* a wallet that boots to "wallet is ready" and ignores every dapp request, which is far harder to
+* diagnose from a spec than a failed cache build.
+*/
+const markMetaMaskOnboarded = async (profileDir, extensionId) => {
+	const dbDir = extensionStateDir(profileDir, extensionId);
+	if (!existsSync(dbDir)) throw new Error(`[walletwright] MetaMask wrote no extension state to ${dbDir}`);
+	const db = new ClassicLevel(dbDir, {
+		createIfMissing: false,
+		keyEncoding: "utf8",
+		valueEncoding: "utf8"
+	});
+	try {
+		await db.open();
+		const perController = await db.get("OnboardingController").catch(() => null);
+		if (perController !== null && perController !== "") {
+			const onboarding = asState(JSON.parse(perController));
+			if (onboarding === void 0) throw new Error(`[walletwright] MetaMask's OnboardingController state is not an object`);
+			if (onboarding.completedOnboarding !== true) await db.put("OnboardingController", JSON.stringify(markOnboarded(onboarding)));
+			return;
+		}
+		const raw = await db.get("data").catch(() => null);
+		if (raw === null || raw === "") throw new Error(`[walletwright] MetaMask persisted no onboarding state in ${dbDir} (neither an OnboardingController key nor a data key)`);
+		const state = asState(JSON.parse(raw));
+		if (state === void 0) throw new Error(`[walletwright] MetaMask's "data" state is not an object`);
+		const nested = asState(state.data);
+		const controller = asState((nested ?? state).OnboardingController);
+		if (controller === void 0) throw new Error(`[walletwright] MetaMask's "data" state holds no OnboardingController`);
+		const patched = markOnboarded(controller);
+		await db.put("data", JSON.stringify(nested === void 0 ? {
+			...state,
+			OnboardingController: patched
+		} : {
+			...state,
+			data: {
+				...nested,
+				OnboardingController: patched
+			}
+		}));
+	} finally {
+		await db.close();
+	}
+};
+
+//#endregion
+//#region src/wallets/metamask.ts
+const DEFAULT_VERSION = "13.35.1";
+/**
+* sha256 of each pinned `metamask-chrome-<version>.zip` release asset, so a pinned download is
+* verified rather than trusted. This is the one place to fill in when bumping `DEFAULT_VERSION`:
+*
+*   curl -sL https://github.com/MetaMask/metamask-extension/releases/download/v<v>/metamask-chrome-<v>.zip | shasum -a 256
+*
+* A version a caller pins through `setup.version` has no entry here and downloads unverified, and
+* the Web-Store wallets can't be pinned at all (that endpoint always serves the current version).
+*/
+const RELEASE_SHA256 = { "13.35.1": "4e0f8626df0ae9fb15f5f3ad6784a0b518f3ede067b2b0d4f539f9f457c5049c" };
+/** Download inputs for a MetaMask release, split out so the integrity wiring is unit-testable. */
+const metamaskDownload = (cacheDir, version) => ({
+	cacheDir,
+	kind: "zip",
+	name: `metamask-chrome-${version}`,
+	sha256: RELEASE_SHA256[version],
+	url: `https://github.com/MetaMask/metamask-extension/releases/download/v${version}/metamask-chrome-${version}.zip`
+});
+/**
+* MetaMask's backup-and-sync restores account names for whichever SRP a profile holds, and test
+* seeds are shared (the public `test test … junk` one by thousands), so a synced profile reports a
+* stranger's account names in place of the ones a test just set: CI runs showed accounts called
+* `dev1` and `personal`, holding a real balance, where `Account 2` was expected. It only happens
+* where the sync actually lands, which makes it look like a flake. MetaMask's own e2e suite mocks
+* its external services for the same reason.
+*
+* Just the one host that stores the names. Cutting the auth stack around it (`authentication`,
+* `oidc`) reaches further than intended: other features authenticate through it too, and a wallet
+* that cannot authenticate can leave a request's confirm button disabled with nothing to explain it.
+*/
+const ACCOUNT_SYNC_HOST = "user-storage.api.cx.metamask.io";
+const metamask = {
+	actions: {
+		accounts,
+		network,
+		settings
+	},
+	approvalControls,
+	approve,
+	ecosystems: ["evm", "svm"],
+	extensionName: "MetaMask",
+	prepareContext: async (context) => {
+		await context.route(`**://${ACCOUNT_SYNC_HOST}/**`, (route) => route.abort());
+	},
+	prepareExtension: (cacheDir, version = DEFAULT_VERSION) => downloadAndExtractExtension(metamaskDownload(cacheDir, version)),
+	finalizeCache: markMetaMaskOnboarded,
+	importWallet: importWallet$2,
+	onboardingPage: "home.html",
+	reachUnlockScreen: reachUnlockScreen$4,
+	reject,
+	unlock: unlock$4
+};
+
+//#endregion
+//#region src/wallets/phantom.ts
+const PHANTOM_EXTENSION_ID = "bfnaelmomeimhlpmgjnjophhpkkoljpa";
+const { reachUnlockScreen: reachUnlockScreen$3, unlock: unlock$3 } = createUnlockScreen({
+	entry: "popup.html",
+	isUnlocked: async (page) => {
+		return await page.locator("button").first().isVisible().catch(() => false);
+	},
+	submit: async (page, field) => {
+		const unlockButton = page.getByRole("button", { name: /* @__PURE__ */ new RegExp("unlock", "iv") });
+		await (await unlockButton.isVisible().catch(() => false) ? unlockButton.click() : field.press("Enter"));
+	},
+	wallet: "Phantom"
+});
+const phantom = {
+	ecosystems: ["evm", "svm"],
+	extensionName: "Phantom",
+	headlessApprovals: true,
+	importWallet: async (page, seedPhrase, password) => {
+		const testId = (id) => page.locator(`[data-testid="${id}"]`);
+		await page.locator("text=I already have a wallet").click();
+		await sleep(1e3);
+		await page.locator("text=Import Recovery Phrase").click();
+		await sleep(1500);
+		const words = seedPhrase.trim().split(/* @__PURE__ */ new RegExp("\\s+", "v"));
+		for (let i = 0; i < words.length; i++) await testId(`secret-recovery-phrase-word-input-${i}`).fill(words[i] ?? "");
+		await testId("onboarding-form-submit-button").click();
+		await testId("onboarding-form-secondary-button").waitFor({
+			state: "visible",
+			timeout: 6e4
+		});
+		await testId("onboarding-form-submit-button").click();
+		await testId("onboarding-form-password-input").fill(password);
+		await testId("onboarding-form-confirm-password-input").fill(password);
+		await testId("onboarding-form-terms-of-service-checkbox").click();
+		await testId("onboarding-form-submit-button").click();
+		await sleep(2500);
+		const getStarted = page.locator("text=Get Started");
+		if (await getStarted.isVisible().catch(() => false)) await getStarted.click();
+		await sleep(1500);
+	},
+	onboardingPage: "onboarding.html",
+	prepareExtension: (cacheDir) => prepareWebStoreExtension({
+		cacheDir,
+		extensionId: PHANTOM_EXTENSION_ID,
+		name: "phantom-chrome-latest"
+	}),
+	reachUnlockScreen: reachUnlockScreen$3,
+	unlock: unlock$3,
+	approve: async (popup) => {
+		await popup.getByTestId("primary-button").click({ timeout: 15e3 });
+	},
+	reject: async (popup) => {
+		await popup.getByTestId("secondary-button").click({ timeout: 15e3 });
+	}
+};
+
+//#endregion
+//#region src/wallets/rabby.ts
+const ROUTE_TIMEOUT_MS = 3e4;
+const SEED_PASTE_TIMEOUT_MS = 3e3;
+const APPROVAL_TIMEOUT_MS = 3e4;
+const RABBY_EXTENSION_ID = "acmacodkjbdgmoleebolmdjonilkdbch";
+const ONBOARDING_ROUTE = "index.html#/new-user/guide";
+const { reachUnlockScreen: reachUnlockScreen$2, unlock: unlock$2 } = createUnlockScreen({
+	entry: "index.html",
+	wallet: "Rabby"
+});
+const clickText = async (page, text, timeoutMs = 3e4) => {
+	const target = page.getByText(text, { exact: true }).first();
+	await target.waitFor({
+		state: "visible",
+		timeout: timeoutMs
+	});
+	await target.click();
+};
+/**
+* Rabby routes with a hash router, so `waitForURL` never settles (a hash change fires no navigation
+* event). Poll the URL instead. Anchoring each onboarding step on its route matters because several
+* screens share the same `input[type="password"]` selector.
+*/
+const waitForRoute = async (page, fragment, timeoutMs = ROUTE_TIMEOUT_MS) => {
+	await waitUntilOrThrow(() => page.url().includes(fragment), {
+		message: `Rabby never reached ${fragment}`,
+		timeoutMs
+	});
+};
+const importWallet$1 = async (page, seedPhrase, password) => {
+	await clickText(page, "I already have an address");
+	await clickText(page, "Seed Phrase or Private Key");
+	await waitForRoute(page, "seed-or-key");
+	const words = page.locator("input[type=\"password\"]");
+	await words.first().waitFor({
+		state: "visible",
+		timeout: 3e4
+	});
+	await page.context().grantPermissions(["clipboard-read", "clipboard-write"]).catch(() => {});
+	const list = seedPhrase.trim().split(/* @__PURE__ */ new RegExp("\\s+", "v"));
+	const lastFilled = async () => {
+		return (await words.nth(list.length - 1).inputValue().catch(() => "")).trim().length > 0;
+	};
+	await words.first().click();
+	await page.evaluate((phrase) => navigator.clipboard.writeText(phrase), seedPhrase.trim());
+	await page.keyboard.press("ControlOrMeta+v");
+	if (await waitUntil(lastFilled, { timeoutMs: SEED_PASTE_TIMEOUT_MS }) === void 0) for (let index = 0; index < list.length; index++) {
+		const box = words.nth(index);
+		await box.click();
+		await box.fill(list[index] ?? "");
+	}
+	await page.getByRole("button", {
+		exact: true,
+		name: "Next"
+	}).first().click();
+	await waitForRoute(page, "set-password");
+	const passwords = page.locator("input[type=\"password\"]");
+	await passwords.nth(1).waitFor({
+		state: "visible",
+		timeout: 3e4
+	});
+	await passwords.nth(0).fill(password);
+	await passwords.nth(1).fill(password);
+	await page.getByRole("button", {
+		exact: true,
+		name: "Confirm"
+	}).first().click();
+	await page.getByText("Address Imported", { exact: false }).first().waitFor({
+		state: "visible",
+		timeout: 3e4
+	});
+	await sleep(1e3);
+};
+const CONFIRM_LABELS = [
+	"Connect",
+	"Sign",
+	"Confirm"
+];
+const CANCEL_LABELS = ["Cancel", "Reject"];
+/**
+* Rabby's approval window is focus-fragile: it unmounts its contents a few seconds after losing
+* focus, and Playwright's click (which waits for actionability, then for the click to settle) loses
+* the window mid-action. Rabby reads the vanished window as a dismissal, so the dapp gets
+* "User rejected the request" even though the confirm button was visible and enabled. Dispatching
+* the click inside the page skips focus, actionability, and post-click bookkeeping entirely. Rabby
+* is a plain React app, so `evaluate` works here (unlike MetaMask, which scuttles the realm).
+*
+* Signing is a two-step footer: "Sign" swaps itself for "Confirm", which must be clicked too, and
+* both start disabled while Rabby analyses the request. So keep clicking whichever labelled button
+* is currently enabled until the window closes, which is the only signal the request was answered.
+*/
+const clickApprovalButton = async (popup, labels) => {
+	let lastClicked = "";
+	return await waitUntil(async () => {
+		if (popup.isClosed()) return true;
+		const clicked = await popup.evaluate((arg) => {
+			const target = [...document.querySelectorAll("button")].find((button) => {
+				const text = (button.textContent ?? "").trim();
+				return arg.names.includes(text) && !button.disabled && text !== arg.skip;
+			});
+			target?.click();
+			return target ? (target.textContent ?? "").trim() : "";
+		}, {
+			names: [...labels],
+			skip: lastClicked
+		}).catch(() => "");
+		if (clicked) lastClicked = clicked;
+	}, {
+		intervalMs: 300,
+		timeoutMs: APPROVAL_TIMEOUT_MS
+	}) === true || popup.isClosed();
+};
+const rabby = {
+	approve: async (popup) => {
+		if (!await clickApprovalButton(popup, CONFIRM_LABELS)) throw new Error("[walletwright] Rabby approval: no confirm button became actionable");
+	},
+	ecosystems: ["evm"],
+	extensionName: "Rabby",
+	headlessApprovals: true,
+	importWallet: importWallet$1,
+	onboardingPage: ONBOARDING_ROUTE,
+	prepareExtension: (cacheDir) => prepareWebStoreExtension({
+		cacheDir,
+		extensionId: RABBY_EXTENSION_ID,
+		name: "rabby-chrome-latest"
+	}),
+	reachUnlockScreen: reachUnlockScreen$2,
+	reject: async (popup) => {
+		if (!await clickApprovalButton(popup, CANCEL_LABELS)) throw new Error("[walletwright] Rabby reject: no cancel button became actionable");
+	},
+	unlock: unlock$2
+};
+
+//#endregion
+//#region src/wallets/slush.ts
+const SLUSH_EXTENSION_ID = "opcgpfmipidbgpenhmajoajpbobppdil";
+const HOME_ROUTE = "#/tokens";
+const IMPORT_HOME_TIMEOUT_MS = 3e4;
+const atHome = async (page) => await page.evaluate(() => globalThis.location.hash).catch(() => "") === HOME_ROUTE;
+const fclick = async (page, text, timeoutMs = 15e3) => {
+	const target = page.getByText(text, { exact: true }).first();
+	if (!await target.waitFor({
+		state: "visible",
+		timeout: timeoutMs
+	}).then(() => true).catch(() => false)) return false;
+	await target.scrollIntoViewIfNeeded().catch(() => {});
+	await target.click({
+		force: true,
+		timeout: timeoutMs
+	});
+	return true;
+};
+const { reachUnlockScreen: reachUnlockScreen$1, unlock: unlock$1 } = createUnlockScreen({
+	entry: "index.html",
+	isUnlocked: atHome,
+	submit: async (page) => {
+		await fclick(page, "Unlock");
+	},
+	wallet: "Slush"
+});
+const slush = {
+	approve: async (popup, password) => {
+		await sleep(2e3);
+		if (!(await fclick(popup, "Approve", 4e3) || await fclick(popup, "Sign"))) throw new Error("[walletwright] Slush approval: neither Approve nor Sign was actionable");
+		await sleep(1500);
+		const input = popup.locator("input[type=\"password\"]");
+		if (await input.isVisible().catch(() => false)) {
+			await input.fill(password);
+			await fclick(popup, "Unlock");
+		}
+	},
+	ecosystems: ["sui"],
+	extensionName: "Slush",
+	importWallet: async (page, seedPhrase, password) => {
+		await fclick(page, "More options");
+		await sleep(1e3);
+		await fclick(page, "Import existing from passphrase");
+		await sleep(1500);
+		const words = seedPhrase.trim().split(/* @__PURE__ */ new RegExp("\\s+", "v"));
+		for (let i = 0; i < words.length; i++) await page.locator(`input[placeholder="Word ${i + 1}"]`).fill(words[i] ?? "");
+		await page.getByRole("button", { name: "Next" }).click();
+		await sleep(2e3);
+		await page.locator("input[placeholder=\"Password\"]").fill(password);
+		await page.locator("input[placeholder=\"Confirm Password\"]").fill(password);
+		await page.getByRole("button", { name: "Next" }).click();
+		await sleep(2e3);
+		await page.getByRole("button", { name: "Next" }).click().catch(() => {});
+		await waitUntilOrThrow(() => atHome(page), {
+			intervalMs: 1e3,
+			message: `Slush import never reached the wallet home (${HOME_ROUTE})`,
+			timeoutMs: IMPORT_HOME_TIMEOUT_MS
+		});
+	},
+	notificationMatch: "isPopup=1",
+	onboardingPage: "index.html",
+	prepareContext: async (context) => {
+		await context.route("**://*.slush.app/**", (route) => route.fulfill({
+			body: JSON.stringify({ data: {} }),
+			contentType: "application/json",
+			status: 200
+		}));
+	},
+	prepareExtension: (cacheDir) => prepareWebStoreExtension({
+		cacheDir,
+		extensionId: SLUSH_EXTENSION_ID,
+		name: "slush-chrome-latest"
+	}),
+	reachUnlockScreen: reachUnlockScreen$1,
+	reject: async (popup) => {
+		await sleep(2e3);
+		if (!await fclick(popup, "Reject")) throw new Error("[walletwright] Slush reject: no Reject control was actionable");
+	},
+	unlock: unlock$1
+};
+
+//#endregion
+//#region src/wallets/solflare.ts
+const SOLFLARE_EXTENSION_ID = "bhhhlbepdkbapadjdnnojkbgioiodbic";
+const { reachUnlockScreen, unlock } = createUnlockScreen({
+	entry: "wallet.html",
+	wallet: "Solflare"
+});
+const importWallet = async (page, seedPhrase, password) => {
+	await page.getByTestId("btn-import-existing-wallet").click({ timeout: 3e4 });
+	await page.getByText("Recovery phrase", { exact: true }).first().click({ timeout: 3e4 });
+	const words = seedPhrase.trim().split(/* @__PURE__ */ new RegExp("\\s+", "v"));
+	await page.getByTestId("input-recovery-phrase-1").waitFor({
+		state: "visible",
+		timeout: 3e4
+	});
+	for (let index = 0; index < words.length; index++) await page.getByTestId(`input-recovery-phrase-${index + 1}`).fill(words[index] ?? "");
+	await page.getByTestId("btn-continue").click({ timeout: 3e4 });
+	await page.getByTestId("input-new-password").waitFor({
+		state: "visible",
+		timeout: 3e4
+	});
+	await page.getByTestId("input-new-password").fill(password);
+	await page.getByTestId("input-repeat-password").fill(password);
+	await page.getByTestId("btn-continue").click({ timeout: 3e4 });
+	await page.getByTestId("btn-quick-setup").click({ timeout: 6e4 });
+	await page.getByTestId("btn-explore").click({ timeout: 6e4 });
+};
+const solflare = {
+	approve: async (popup) => {
+		await popup.getByTestId("btn-connect").or(popup.getByTestId("btn-approve")).first().click({ timeout: 3e4 });
+	},
+	ecosystems: ["svm"],
+	extensionName: "Solflare",
+	importWallet,
+	notificationMatch: "confirm_popup.html",
+	onboardingPage: "wallet.html",
+	prepareExtension: (cacheDir) => prepareWebStoreExtension({
+		cacheDir,
+		extensionId: SOLFLARE_EXTENSION_ID,
+		name: "solflare-chrome-latest"
+	}),
+	reachUnlockScreen,
+	reject: async (popup) => {
+		await popup.getByTestId("btn-cancel").or(popup.getByTestId("btn-reject")).first().click({ timeout: 3e4 });
+	},
+	unlock
+};
+
+//#endregion
+//#region src/wallets/index.ts
+const wallets = {
+	metamask,
+	phantom,
+	rabby,
+	slush,
+	solflare
+};
+/** Narrow an arbitrary string (CLI flag, setup file field) to a supported wallet. */
+const isWalletKind = (value) => Object.hasOwn(wallets, value);
+const walletKinds = Object.keys(wallets).filter(isWalletKind);
+/** Wallet kinds that can drive the given ecosystem (e.g. `"evm"` → MetaMask, Phantom). */
+const walletKindsByEcosystem = (ecosystem) => walletKinds.filter((kind) => wallets[kind].ecosystems.includes(ecosystem));
+
+//#endregion
+//#region src/internal/chromium.ts
+/**
+* How walletwright launches Chromium with a wallet extension loaded. Shared by the cache build and
+* the test run so the two cannot drift: an extension that loads for onboarding but not for the
+* tests (or the reverse) fails far from its cause.
+*/
+const extensionContextOptions = (extensionPath, headless) => ({
+	args: [`--disable-extensions-except=${extensionPath}`, `--load-extension=${extensionPath}`],
+	channel: "chromium",
+	headless
+});
+
+//#endregion
+//#region src/internal/cache.ts
+const NAVIGATION_TIMEOUT_MS = 15e3;
+const FLUSH_SETTLE_MS = 3e3;
+const STATE_WRITE_TIMEOUT_MS = 1e4;
+/**
+* Chrome stores an extension's `chrome.storage.local` under `Local Extension Settings/<id>` and its
+* IndexedDB (what some single-page wallets persist their vault to) under
+* `IndexedDB/chrome-extension_<id>_0…`. Bytes in either one mean onboarding actually landed in the
+* profile; bytes in neither mean the "cache" is empty, and every later run would fail at unlock with
+* no hint that the build was the thing that went wrong.
+*/
+const hasPersistedState = async (profileDir, extensionId) => {
+	const stores = [extensionStateDir(profileDir, extensionId), path.join(profileDir, "Default", "IndexedDB", `chrome-extension_${extensionId}_0.indexeddb.leveldb`)];
+	return (await Promise.allSettled(stores.map((dir) => readdir(dir)))).some((listing) => listing.status === "fulfilled" && listing.value.length > 0);
+};
+/**
+* Import the wallet once and persist an onboarded browser profile to disk (the "cache"), so tests
+* launch a ready-to-unlock wallet instead of re-running onboarding each time. Returns the profile
+* directory. Idempotent per (wallet, version, seed, password).
+*
+* `headless` only affects this build step; the tests choose their own mode via `launchWallet`.
+*/
+const buildCache = async (setup, options = {}) => {
+	const definition = wallets[setup.wallet];
+	const cacheDir = path.resolve(setup.cacheDir ?? ".walletwright");
+	const extensionPath = await definition.prepareExtension(cacheDir, setup.version);
+	const profileDir = path.join(cacheDir, profileKey(setup));
+	await rm(profileDir, {
+		force: true,
+		recursive: true
+	});
+	await mkdir(profileDir, { recursive: true });
+	const context = await chromium.launchPersistentContext(profileDir, extensionContextOptions(extensionPath, options.headless === true));
+	try {
+		await definition.prepareContext?.(context);
+		const extensionId = extensionIdFromPath(extensionPath);
+		const page = context.pages().find((candidate) => candidate.url() === "about:blank") ?? await context.newPage();
+		await gotoWithRetry(page, `chrome-extension://${extensionId}/${definition.onboardingPage}`, {
+			label: `${definition.extensionName} onboarding page`,
+			timeoutMs: NAVIGATION_TIMEOUT_MS
+		});
+		await sleep(2e3);
+		await definition.importWallet(page, setup.seedPhrase, setup.password);
+		await sleep(FLUSH_SETTLE_MS);
+		await waitUntilOrThrow(() => hasPersistedState(profileDir, extensionId), {
+			intervalMs: 500,
+			message: `${definition.extensionName} onboarding wrote no wallet state into ${profileDir}`,
+			timeoutMs: STATE_WRITE_TIMEOUT_MS
+		});
+		await context.close();
+		await definition.finalizeCache?.(profileDir, extensionId);
+		return profileDir;
+	} catch (error) {
+		await context.close().catch(() => {});
+		throw error;
+	}
+};
+
+//#endregion
+export { wallets as a, extensionIdFromPath as c, placeApprovalWindow as d, profileKey as f, walletKindsByEcosystem as i, findNotificationPopup as l, waitUntil as m, extensionContextOptions as n, DEFAULT_CACHE_DIR as o, formatTimeout as p, isWalletKind as r, DEFAULT_NOTIFICATION_MATCH as s, buildCache as t, hasNotificationPopup as u };
+//# sourceMappingURL=cache-Bqz3Mchl.mjs.map