@walletwright/core 0.4.0 → 0.5.0

package/dist/{cache-BaWu5vyM.mjs → cache-ztGj4R8m.mjs}

@@ -1,89 +1,11 @@
 import { access, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat } from "node:fs/promises";
 import path from "node:path";
-import { chromium } from "@playwright/test";
-import { createHash } from "node:crypto";
-import AdmZip from "adm-zip";
 import { ClassicLevel } from "classic-level";
 import { z } from "zod";
+import { createHash } from "node:crypto";
+import { chromium } from "@playwright/test";
+import AdmZip from "adm-zip";
 
-//#region src/internal/download.ts
-const ZIP_SIGNATURE = Buffer.from([
-	80,
-	75,
-	3,
-	4
-]);
-/**
-* Prefix for in-progress extractions. It has to live inside `cacheDir` so publishing is a `rename`
-* on one filesystem (a cross-device rename fails with EXDEV), and it starts with a dot so it can
-* never collide with a wallet's `name`.
-*/
-const STAGING_PREFIX = ".staging-";
-const pathExists$1 = async (target) => {
-	try {
-		await stat(target);
-		return true;
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
-		throw error;
-	}
-};
-/** Download and validate an extension archive, then publish its extraction atomically from staging. */
-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 (await pathExists$1(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);
-	}
-	const staging = await mkdtemp(path.join(cacheRoot, STAGING_PREFIX));
-	try {
-		const zip = new AdmZip(zipBytes);
-		for (const entry of zip.getEntries()) {
-			const target = path.resolve(staging, entry.entryName);
-			if (target !== staging && !target.startsWith(staging + path.sep)) throw new Error(`[walletwright] refusing to extract ${entry.entryName}: escapes ${outDir}`);
-		}
-		zip.extractAllTo(staging, true);
-		if (!await pathExists$1(path.join(staging, "manifest.json"))) throw new Error(`[walletwright] extracted ${name} but no manifest.json found in ${outDir}`);
-		if (await pathExists$1(path.join(outDir, "manifest.json"))) return outDir;
-		await rm(outDir, {
-			force: true,
-			recursive: true
-		});
-		await rename(staging, outDir);
-		return outDir;
-	} finally {
-		await rm(staging, {
-			force: true,
-			recursive: true
-		}).catch(() => {});
-	}
-};
-/** 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();
@@ -169,6 +91,22 @@ const add = async ({ home }, config) => {
 };
 const network = { add };
 
+//#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 ({ unlock }) => {
+		await unlock();
+	}
+};
+
 //#endregion
 //#region src/internal/wait.ts
 const DEFAULT_INTERVAL_MS = 200;
@@ -206,74 +144,65 @@ const gotoWithRetry = async (page, url, { intervalMs = DEFAULT_NAVIGATION_INTERV
 };
 
 //#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;
+//#region src/wallets/metamask/approve.ts
 /**
-* Short on purpose. `unlock` is normally handed a page `reachUnlockScreen` already settled, so this
-* budget only matters when it is called on its own (the `settings.unlock` path), where a wallet with a
-* late-mounting UI needs a poll rather than a single read but a dead page should still fail fast.
+* 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 UNLOCK_SETTLE_TIMEOUT_MS = 5e3;
+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;
+/** Snap notices intercept footer clicks and disable Accept until their content is scrolled. */
+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(() => {});
+};
+/** Resolve the confirm test id used by standard, legacy, and Snap request footers. */
+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();
+/** Distinguishes a pending request from MetaMask's requestless notification home screen. */
+const approvalControls = (popup) => confirmButton(popup).or(cancelButton(popup));
 /**
-* 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.
+* Click one of the popup's footer buttons. The third-party notice covers that whole footer, so both
+* confirm and cancel are intercepted while it is up, and both need the dismiss-then-retry: without it
+* a click times out against a button that is rendered and enabled, which reads as a stale selector.
 */
-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
+const clickFooterButton = async (popup, button) => {
+	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;
 		});
-		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 state = await settleWithin(page, UNLOCK_SETTLE_TIMEOUT_MS);
-		if (state === "unlocked") return;
-		if (state === void 0) throw new Error(`[walletwright] ${wallet} showed neither an unlock screen nor an unlocked wallet`);
-		const field = page.locator(PASSWORD_FIELD);
-		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
-	};
+	}
+};
+/** How long a connect page may keep Connect disabled before it counts as rendered too early. */
+const STALE_CONNECT_MS = 3e3;
+/**
+* MetaMask can render a connect page before enabling the requested network (seen with Solana): no
+* networks under Permissions, Connect disabled, never recomputed. The request is still pending, so
+* a reload renders it from current state. Connect route only: elsewhere a disabled confirm is busy.
+*/
+const reloadStaleConnectPage = async (popup) => {
+	if (!popup.url().includes("#/connect/")) return;
+	const connect = popup.getByTestId("confirm-btn");
+	if (await waitUntil(() => connect.isEnabled({ timeout: 500 }).catch(() => false), { timeoutMs: STALE_CONNECT_MS }) === void 0) await popup.reload();
+};
+const approve = async (popup) => {
+	await reloadStaleConnectPage(popup);
+	await clickFooterButton(popup, confirmButton(popup));
 };
+/** The cancel counterpart of `approve`; same union-by-DOM-order resolution, not written order. */
+const reject = (popup) => clickFooterButton(popup, cancelButton(popup));
 
 //#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();
@@ -301,135 +230,82 @@ const importWallet$2 = async (page, seedPhrase, password) => {
 };
 
 //#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;
-/** Snap notices intercept footer clicks and disable Accept until their content is scrolled. */
-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(() => {});
-};
-/** Resolve the confirm test id used by standard, legacy, and Snap request footers. */
-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();
-/** Distinguishes a pending request from MetaMask's requestless notification home screen. */
-const approvalControls = (popup) => confirmButton(popup).or(cancelButton(popup));
-/**
-* Click one of the popup's footer buttons. The third-party notice covers that whole footer, so both
-* confirm and cancel are intercepted while it is up, and both need the dismiss-then-retry: without it
-* a click times out against a button that is rendered and enabled, which reads as a stale selector.
-*/
-const clickFooterButton = async (popup, button) => {
-	await acceptThirdPartyNotice(popup);
+//#region src/internal/fs.ts
+/** Run `operation`, answering `fallback` instead of throwing when its target does not exist. */
+const unlessMissing = async (operation, fallback) => {
 	try {
-		await button.click({ timeout: BUTTON_TIMEOUT_MS });
+		return await operation();
 	} catch (error) {
-		await acceptThirdPartyNotice(popup);
-		await button.click({ timeout: RETRY_TIMEOUT_MS }).catch(() => {
-			throw error;
-		});
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return fallback;
+		throw error;
 	}
 };
-const approve = (popup) => clickFooterButton(popup, confirmButton(popup));
-/** The cancel counterpart of `approve`; same union-by-DOM-order resolution, not written order. */
-const reject = (popup) => clickFooterButton(popup, cancelButton(popup));
+const pathExists = (target) => unlessMissing(async () => {
+	await stat(target);
+	return true;
+}, false);
+/** `rename`, reporting whether `from` existed to be moved rather than throwing when it did not. */
+const renameIfExists = (from, to) => unlessMissing(async () => {
+	await rename(from, to);
+	return true;
+}, false);
 
 //#endregion
-//#region src/internal/utils.ts
+//#region src/internal/profile.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";
+const PREVIOUS_SUFFIX = ".previous";
 /** 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);
-/** Mirror Chrome's extension-id derivation; resolve symlinks because Chrome hashes the real path. */
-const extensionIdFromPath = async (extensionPath) => {
-	const resolved = path.resolve(extensionPath);
-	let abs = resolved;
-	try {
-		abs = await realpath(resolved);
-	} catch {
-		abs = resolved;
-	}
-	let key;
-	try {
-		const text = await readFile(path.join(abs, "manifest.json"), "utf8");
-		key = z.object({ key: z.string().optional() }).parse(JSON.parse(text)).key;
-	} catch {
-		key = void 0;
+/** 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 previousProfileDir = (profileDir) => `${profileDir}${PREVIOUS_SUFFIX}`;
+/** Put back a profile that an interrupted publication left at its recovery path. */
+const restorePreviousProfile = async (profileDir) => {
+	const previous = previousProfileDir(profileDir);
+	if (await pathExists(profileDir)) {
+		await rm(previous, {
+			force: true,
+			recursive: true
+		});
+		return;
 	}
-	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("");
+	await renameIfExists(previous, profileDir);
 };
 /**
-* 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`).
+* The cache directory and this setup's profile inside it, with any interrupted publication already
+* recovered, so building and launching both start from the same answer.
 */
-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
+const locateProfile = async (setup) => {
+	const cacheDir = path.resolve(setup.cacheDir ?? DEFAULT_CACHE_DIR);
+	const profileDir = path.join(cacheDir, profileKey(setup));
+	await restorePreviousProfile(profileDir);
+	return {
+		cacheDir,
+		profileDir
+	};
 };
-/** Far enough from the edge that a popup this size lands fully on any usable display. */
-const APPROVAL_WINDOW_OFFSET = 50;
-/** Move approval popups on-screen; headless and unsupported CDP targets are ignored. */
-const placeApprovalWindow = async (page) => {
-	await page.setViewportSize(APPROVAL_WINDOW).catch(() => {});
+/** Swap `staging` in as the profile, keeping the prior one at its recovery path until it lands. */
+const publishProfile = async (staging, profileDir) => {
+	await restorePreviousProfile(profileDir);
+	const previous = previousProfileDir(profileDir);
+	const movedPrevious = await renameIfExists(profileDir, previous);
 	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 {}
+		await rename(staging, profileDir);
+	} catch (error) {
+		if (movedPrevious) try {
+			await rename(previous, profileDir);
+		} catch (rollbackError) {
+			const publishMessage = error instanceof Error ? error.message : String(error);
+			const rollbackMessage = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+			throw new Error(`[walletwright] failed to publish cache at ${profileDir}: ${publishMessage}; rollback failed: ${rollbackMessage}`, { cause: rollbackError });
+		}
+		throw error;
+	}
+	if (movedPrevious) await rm(previous, {
+		force: true,
+		recursive: true
+	});
 };
-/** 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);
 
 //#endregion
 //#region src/wallets/metamask/onboarding-patch.ts
@@ -500,10 +376,9 @@ const RELEASE_SHA256 = { "13.35.1": "4e0f8626df0ae9fb15f5f3ad6784a0b518f3ede067b
 */
 const DEFAULT_VERSION = "13.35.1";
 const releaseSha256 = (version) => Object.entries(RELEASE_SHA256).find(([pinned]) => pinned === version)?.[1];
-/** Download inputs for a MetaMask release, split out so the integrity wiring is unit-testable. */
-const metamaskDownload = (cacheDir, version) => ({
-	cacheDir,
-	kind: "zip",
+/** The archive for a MetaMask release, split out so the integrity wiring is unit-testable. */
+const metamaskRelease = (version) => ({
+	format: "zip",
 	name: `metamask-chrome-${version}`,
 	sha256: releaseSha256(version),
 	url: `https://github.com/MetaMask/metamask-extension/releases/download/v${version}/metamask-chrome-${version}.zip`
@@ -526,26 +401,17 @@ const metamask = {
 	prepareContext: async (context) => {
 		await context.route(`**://${ACCOUNT_SYNC_HOST}/**`, (route) => route.abort());
 	},
-	prepareExtension: (cacheDir, version = DEFAULT_VERSION) => downloadAndExtractExtension(metamaskDownload(cacheDir, version)),
-	reachUnlockScreen: reachUnlockScreen$4,
 	reject,
-	unlock: unlock$4
+	source: {
+		defaultVersion: DEFAULT_VERSION,
+		kind: "release",
+		release: metamaskRelease
+	},
+	unlockScreen: { entry: "home.html" }
 };
 
 //#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: new RegExp("unlock", "iv") });
-		await (await unlockButton.isVisible().catch(() => false) ? unlockButton.click() : field.press("Enter"));
-	},
-	wallet: "Phantom"
-});
 const phantom = {
 	approve: async (popup) => {
 		await popup.getByTestId("primary-button").click({ timeout: 15e3 });
@@ -577,16 +443,23 @@ const phantom = {
 		await sleep(1500);
 	},
 	onboardingPage: "onboarding.html",
-	prepareExtension: (cacheDir) => prepareWebStoreExtension({
-		cacheDir,
-		extensionId: PHANTOM_EXTENSION_ID,
-		name: "phantom-chrome-latest"
-	}),
-	reachUnlockScreen: reachUnlockScreen$3,
 	reject: async (popup) => {
 		await popup.getByTestId("secondary-button").click({ timeout: 15e3 });
 	},
-	unlock: unlock$3
+	source: {
+		id: "bfnaelmomeimhlpmgjnjophhpkkoljpa",
+		kind: "webStore"
+	},
+	unlockScreen: {
+		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: new RegExp("unlock", "iv") });
+			await (await unlockButton.isVisible().catch(() => false) ? unlockButton.click() : field.press("Enter"));
+		}
+	}
 };
 
 //#endregion
@@ -594,12 +467,7 @@ const phantom = {
 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({
@@ -676,11 +544,11 @@ const clickApprovalButton = async (popup, labels) => {
 		if (popup.isClosed()) return true;
 		const clicked = await popup.evaluate((arg) => {
 			const target = [...document.querySelectorAll("button")].find((button) => {
-				const text = (button.textContent ?? "").trim();
+				const text = button.textContent.trim();
 				return arg.names.includes(text) && !button.disabled && !arg.skip.includes(text);
 			});
 			target?.click();
-			return target ? (target.textContent ?? "").trim() : "";
+			return target ? target.textContent.trim() : "";
 		}, {
 			names: [...labels],
 			skip: [...clickedLabels]
@@ -700,21 +568,18 @@ const 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
+	source: {
+		id: "acmacodkjbdgmoleebolmdjonilkdbch",
+		kind: "webStore"
+	},
+	unlockScreen: { entry: "index.html" }
 };
 
 //#endregion
 //#region src/wallets/slush.ts
-const SLUSH_EXTENSION_ID = "opcgpfmipidbgpenhmajoajpbobppdil";
 const HOME_ROUTE = "#/tokens";
 const IMPORT_HOME_TIMEOUT_MS = 3e4;
 const PERSIST_TIMEOUT_MS = 6e4;
@@ -777,14 +642,6 @@ const fclick = async (page, text, timeoutMs = 15e3) => {
 	});
 	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);
@@ -832,26 +689,25 @@ const slush = {
 			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
+	source: {
+		id: "opcgpfmipidbgpenhmajoajpbobppdil",
+		kind: "webStore"
+	},
+	unlockScreen: {
+		entry: "index.html",
+		isUnlocked: atHome,
+		submit: async (page) => {
+			await fclick(page, "Unlock");
+		}
+	}
 };
 
 //#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 });
@@ -881,16 +737,14 @@ const 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
+	source: {
+		id: "bhhhlbepdkbapadjdnnojkbgioiodbic",
+		kind: "webStore"
+	},
+	unlockScreen: { entry: "wallet.html" }
 };
 
 //#endregion
@@ -904,108 +758,172 @@ const wallets = {
 };
 /** Narrow an arbitrary string (CLI flag, setup file field) to a supported wallet. */
 const isWalletKind = (value) => Object.hasOwn(wallets, value);
+/** Every supported wallet, in registry order. */
 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;
-/** Wallet state may live in `chrome.storage.local` or extension IndexedDB. */
-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);
-};
+//#region src/internal/download.ts
+const ZIP_SIGNATURE = Buffer.from([
+	80,
+	75,
+	3,
+	4
+]);
 /**
-* Prefix for an in-progress build. Inside `cacheDir` so publishing is a `rename` on one filesystem,
-* dot-prefixed so it can never be mistaken for a 20-hex-character `profileKey`.
+* Prefix for in-progress extractions. It has to live inside `cacheDir` so publishing is a `rename`
+* on one filesystem (a cross-device rename fails with EXDEV), and it starts with a dot so it can
+* never collide with a wallet's `name`.
 */
-const BUILD_PREFIX = ".building-";
-const PREVIOUS_SUFFIX = ".previous";
-const pathExists = async (target) => {
-	try {
-		await stat(target);
-		return true;
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
-		throw error;
+const STAGING_PREFIX = ".staging-";
+/** Download and validate an extension archive, then publish its extraction atomically from staging. */
+const downloadAndExtractExtension = async (options) => {
+	const { cacheDir, format, 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 (await pathExists(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}`);
 	}
-};
-const previousProfileDir = (profileDir) => `${profileDir}${PREVIOUS_SUFFIX}`;
-const restorePreviousProfile = async (profileDir) => {
-	const previous = previousProfileDir(profileDir);
-	if (await pathExists(profileDir)) {
-		await rm(previous, {
+	let zipBytes = bytes;
+	if (format === "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);
+	}
+	const staging = await mkdtemp(path.join(cacheRoot, STAGING_PREFIX));
+	try {
+		const zip = new AdmZip(zipBytes);
+		for (const entry of zip.getEntries()) {
+			const target = path.resolve(staging, entry.entryName);
+			if (target !== staging && !target.startsWith(staging + path.sep)) throw new Error(`[walletwright] refusing to extract ${entry.entryName}: escapes ${outDir}`);
+		}
+		zip.extractAllTo(staging, true);
+		if (!await pathExists(path.join(staging, "manifest.json"))) throw new Error(`[walletwright] extracted ${name} but no manifest.json found in ${outDir}`);
+		if (await pathExists(path.join(outDir, "manifest.json"))) return outDir;
+		await rm(outDir, {
 			force: true,
 			recursive: true
 		});
-		return;
-	}
-	try {
-		await rename(previous, profileDir);
-	} catch (error) {
-		if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+		await rename(staging, outDir);
+		return outDir;
+	} finally {
+		await rm(staging, {
+			force: true,
+			recursive: true
+		}).catch(() => {});
 	}
 };
-const publishProfile = async (staging, profileDir) => {
-	await restorePreviousProfile(profileDir);
-	const previous = previousProfileDir(profileDir);
-	let movedPrevious = false;
+/** 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`;
+
+//#endregion
+//#region src/internal/extension.ts
+/**
+* The archive a setup runs. A release source honours `version`; a Web Store source cannot pin one,
+* so asking for it is an error rather than a setting that forks the profile cache for the same build.
+*/
+const extensionArchive = (setup) => {
+	const { extensionName, source } = wallets[setup.wallet];
+	if (source.kind === "release") return source.release(setup.version ?? source.defaultVersion);
+	if (setup.version !== void 0) throw new Error(`[walletwright] ${extensionName} runs its Chrome Web Store build, which cannot be pinned; remove \`version\` from its WalletSetup.`);
+	return {
+		format: "crx",
+		name: `${setup.wallet}-chrome-latest`,
+		sha256: void 0,
+		url: chromeWebStoreCrxUrl(source.id)
+	};
+};
+/** Download and unpack the setup's extension into `cacheDir`, returning its path. */
+const prepareExtension = async (setup, cacheDir) => {
+	return await downloadAndExtractExtension({
+		cacheDir,
+		...extensionArchive(setup)
+	});
+};
+/** Mirror Chrome's extension-id derivation; resolve symlinks because Chrome hashes the real path. */
+const extensionIdFromPath = async (extensionPath) => {
+	const resolved = path.resolve(extensionPath);
+	const abs = await realpath(resolved).catch(() => resolved);
+	let key;
 	try {
-		await rename(profileDir, previous);
-		movedPrevious = true;
-	} catch (error) {
-		if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+		const text = await readFile(path.join(abs, "manifest.json"), "utf8");
+		key = z.object({ key: z.string().optional() }).parse(JSON.parse(text)).key;
+	} catch {
+		key = void 0;
 	}
+	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("");
+};
+
+//#endregion
+//#region src/internal/browser.ts
+const launchChromium = chromium.launchPersistentContext.bind(chromium);
+/**
+* Launch Chromium with the wallet's extension loaded and its `prepareContext` applied. The cache
+* build and the test run both open the wallet here, so a route stubbed or an extension loaded for
+* one but not the other cannot fail far from its cause. Closes the context if preparing it fails.
+*/
+const openWalletContext = async ({ definition, extensionPath, headless, launchPersistentContext = launchChromium, userDataDir }) => {
+	const context = await launchPersistentContext(userDataDir, {
+		args: [`--disable-extensions-except=${extensionPath}`, `--load-extension=${extensionPath}`],
+		channel: "chromium",
+		headless
+	});
 	try {
-		await rename(staging, profileDir);
+		await definition.prepareContext?.(context);
+		return {
+			context,
+			extensionId: await extensionIdFromPath(extensionPath)
+		};
 	} catch (error) {
-		if (movedPrevious) try {
-			await rename(previous, profileDir);
-		} catch (rollbackError) {
-			const publishMessage = error instanceof Error ? error.message : String(error);
-			const rollbackMessage = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
-			throw new Error(`[walletwright] failed to publish cache at ${profileDir}: ${publishMessage}; rollback failed: ${rollbackMessage}`, { cause: rollbackError });
-		}
+		await context.close().catch(() => {});
 		throw error;
 	}
-	if (movedPrevious) await rm(previous, {
-		force: true,
-		recursive: true
-	});
 };
-const defaultBuildCacheDependencies = {
-	launchPersistentContext: chromium.launchPersistentContext.bind(chromium),
-	prepareExtension: (definition, cacheDir, version) => definition.prepareExtension(cacheDir, version)
+
+//#endregion
+//#region src/internal/cache.ts
+const NAVIGATION_TIMEOUT_MS = 15e3;
+const FLUSH_SETTLE_MS = 3e3;
+const STATE_WRITE_TIMEOUT_MS = 1e4;
+/**
+* Prefix for an in-progress build. Inside `cacheDir` so publishing is a `rename` on one filesystem,
+* dot-prefixed so it can never be mistaken for a 20-hex-character `profileKey`.
+*/
+const BUILD_PREFIX = ".building-";
+/** Wallet state may live in `chrome.storage.local` or extension IndexedDB. */
+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);
 };
-const buildCacheWithDependencies = async (setup, options = {}, dependencies = defaultBuildCacheDependencies) => {
+const defaultDependencies = { prepareExtension };
+/** Build in staging and retain the prior cache until the new profile publishes successfully. */
+const buildCacheWithDependencies = async (setup, { headless = false } = {}, dependencies = defaultDependencies) => {
 	const definition = wallets[setup.wallet];
-	const cacheDir = path.resolve(setup.cacheDir ?? ".walletwright");
-	const extensionPath = await dependencies.prepareExtension(definition, cacheDir, setup.version);
-	const profileDir = path.join(cacheDir, profileKey(setup));
-	await restorePreviousProfile(profileDir);
+	const { cacheDir, profileDir } = await locateProfile(setup);
+	const extensionPath = await dependencies.prepareExtension(setup, cacheDir);
 	await mkdir(cacheDir, { recursive: true });
 	const staging = await mkdtemp(path.join(cacheDir, BUILD_PREFIX));
 	let context;
 	try {
-		context = await dependencies.launchPersistentContext(staging, extensionContextOptions(extensionPath, options.headless === true));
-		await definition.prepareContext?.(context);
-		const extensionId = await extensionIdFromPath(extensionPath);
+		const opened = await openWalletContext({
+			definition,
+			extensionPath,
+			headless,
+			launchPersistentContext: dependencies.launchPersistentContext,
+			userDataDir: staging
+		});
+		context = opened.context;
+		const { extensionId } = opened;
 		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`,
@@ -1036,5 +954,5 @@ const buildCacheWithDependencies = async (setup, options = {}, dependencies = de
 const buildCache = (setup, options) => buildCacheWithDependencies(setup, options);
 
 //#endregion
-export { walletKindsByEcosystem as a, DEFAULT_NOTIFICATION_MATCH as c, placeApprovalWindow as d, profileKey as f, isWalletKind as i, extensionIdFromPath as l, waitUntil as m, restorePreviousProfile as n, wallets as o, formatTimeout as p, extensionContextOptions as r, DEFAULT_CACHE_DIR as s, buildCache as t, findNotificationPopup as u };
-//# sourceMappingURL=cache-BaWu5vyM.mjs.map
+export { walletKinds as a, locateProfile as c, gotoWithRetry as d, waitUntil as f, isWalletKind as i, pathExists as l, openWalletContext as n, walletKindsByEcosystem as o, prepareExtension as r, wallets as s, buildCache as t, formatTimeout as u };
+//# sourceMappingURL=cache-ztGj4R8m.mjs.map