@avalix/chroma 0.0.11 → 0.0.13

package/dist/index.mjs

@@ -9,6 +9,7 @@ const POLKADOT_JS_CONFIG = {
 	downloadUrl: `https://github.com/polkadot-js/extension/releases/download/v${VERSION$1}/master-chrome-build.zip`,
 	extensionName: `polkadot-extension-${VERSION$1}`
 };
+/* c8 ignore start */
 async function findExtensionPopup$1(context, extensionId) {
 	const maxAttempts = 10;
 	const retryDelay = 500;
@@ -22,12 +23,14 @@ async function findExtensionPopup$1(context, extensionId) {
 	}
 	throw new Error(`Extension popup not found for ID: ${extensionId}`);
 }
+/* c8 ignore stop */
 async function getPolkadotJSExtensionPath() {
 	const extensionsDir = path.resolve(process.cwd(), ".chroma");
 	const extensionDir = path.join(extensionsDir, POLKADOT_JS_CONFIG.extensionName);
 	if (!fs.existsSync(extensionDir) || fs.readdirSync(extensionDir).length === 0) throw new Error(`Polkadot-JS extension not found at: ${extensionDir}\n\nPlease download the extension first by running:\n  npx @avalix/chroma download-extensions\n`);
 	return extensionDir;
 }
+/* c8 ignore start */
 async function importPolkadotJSAccount(page, { seed, name = "Test Account", password = "h3llop0lkadot!" }) {
 	const context = page.__extensionContext;
 	const extensionPopupUrl = `chrome-extension://${page.__extensionId}/index.html`;
@@ -72,6 +75,7 @@ async function rejectPolkadotJSTx(page) {
 	const extensionId = page.__extensionId;
 	await (await findExtensionPopup$1(context, extensionId)).getByRole("link", { name: "Cancel" }).click();
 }
+/* c8 ignore stop */
 
 //#endregion
 //#region src/wallets/talisman.ts
@@ -80,6 +84,7 @@ const TALISMAN_CONFIG = {
 	downloadUrl: `https://github.com/avalix-labs/polkadot-wallets/raw/refs/heads/main/talisman/talisman-${VERSION}.zip`,
 	extensionName: `talisman-extension-${VERSION}`
 };
+/* c8 ignore start */
 async function findExtensionPopup(context, extensionId) {
 	const maxAttempts = 10;
 	const retryDelay = 500;
@@ -97,41 +102,71 @@ async function findExtensionPopup(context, extensionId) {
 	}
 	throw new Error(`Extension popup not found for ID: ${extensionId}`);
 }
+/* c8 ignore stop */
 async function getTalismanExtensionPath() {
 	const extensionsDir = path.resolve(process.cwd(), ".chroma");
 	const extensionDir = path.join(extensionsDir, TALISMAN_CONFIG.extensionName);
 	if (!fs.existsSync(extensionDir) || fs.readdirSync(extensionDir).length === 0) throw new Error(`Talisman extension not found at: ${extensionDir}\n\nPlease download the extension first by running:\n  npx @avalix/chroma download-extensions\n`);
 	return extensionDir;
 }
-async function importEthPrivateKey(page, { seed, name = "Test Account", password = "h3llop0lkadot!" }) {
+/* c8 ignore start */
+async function findOnboardingPage(context, extensionId) {
+	const popupUrl = `chrome-extension://${extensionId}/dashboard.html`;
+	const newPage = await context.newPage();
+	await newPage.goto(popupUrl);
+	await newPage.waitForLoadState("domcontentloaded");
+	for (const p of context.pages()) if (p !== newPage && p.url().includes(`chrome-extension://${extensionId}/`)) await p.close();
+	return newPage;
+}
+async function completeOnboarding(extensionPage, password) {
+	await extensionPage.bringToFront();
+	await extensionPage.waitForLoadState("domcontentloaded");
+	if (await extensionPage.getByRole("button", { name: "Settings" }).isVisible()) {
+		await extensionPage.getByRole("button", { name: "Settings" }).click({ force: true });
+		return;
+	}
+	await extensionPage.getByTestId("onboarding-get-started-button").click();
+	await extensionPage.getByRole("textbox", { name: "Enter password" }).fill(password);
+	await extensionPage.getByRole("textbox", { name: "Confirm password" }).fill(password);
+	await extensionPage.getByTestId("onboarding-password-confirm-button").click();
+	await extensionPage.getByRole("button", { name: "No thanks" }).click();
+	await extensionPage.getByTestId("onboarding-enter-talisman-button").click();
+	const extensionId = extensionPage.url().match(/chrome-extension:\/\/([^/]+)/)?.[1];
+	await extensionPage.goto(`chrome-extension://${extensionId}/dashboard.html#/settings/general`);
+	await extensionPage.waitForLoadState("domcontentloaded");
+	await extensionPage.getByRole("link", { name: "Security & Privacy" }).click();
+	await extensionPage.getByTestId("component-toggle-button").first().click();
+}
+async function importPolkadotMnemonic(page, { seed, name = "Test Account", password = "h3llop0lkadot!" }) {
 	const context = page.__extensionContext;
 	const extensionId = page.__extensionId;
-	const maxAttempts = 20;
-	const retryDelay = 500;
-	let extensionPage = null;
-	for (let attempt = 0; attempt < maxAttempts; attempt++) {
-		const pages = context.pages();
-		for (const p of pages) {
-			const url = p.url();
-			if (url.includes("onboarding.html") || url.includes(`chrome-extension://${extensionId}/`)) {
-				extensionPage = p;
-				break;
-			}
-		}
-		if (extensionPage) break;
-		if (attempt < maxAttempts - 1) await new Promise((resolve) => setTimeout(resolve, retryDelay));
+	const extensionPage = await findOnboardingPage(context, extensionId);
+	try {
+		await completeOnboarding(extensionPage, password);
+		await extensionPage.getByRole("link", { name: "Manage Accounts" }).click();
+		await extensionPage.getByRole("button", { name: "Get Started" }).click();
+		await extensionPage.getByRole("button", { name: "Add Account" }).click();
+		await extensionPage.getByRole("button", { name: "Import Import an existing" }).click();
+		await extensionPage.getByRole("button", { name: "Import via Recovery Phrase" }).click();
+		await extensionPage.getByRole("button", { name: "Polkadot Relay Chain, Asset" }).click();
+		await extensionPage.getByRole("textbox", { name: "Choose a name" }).fill(name);
+		await extensionPage.getByRole("textbox", { name: "Enter your 12 or 24 word" }).fill(seed);
+		await extensionPage.getByTestId("account-add-mnemonic-import-button").click();
+		await extensionPage.close();
+	} catch (error) {
+		console.error("❌ Error during Talisman Polkadot account import:", error);
+		throw error;
 	}
-	if (!extensionPage) throw new Error(`Talisman onboarding page not found after ${maxAttempts} attempts`);
+}
+async function importEthPrivateKey(page, { seed, name = "Test Account", password = "h3llop0lkadot!" }) {
+	const context = page.__extensionContext;
+	const extensionId = page.__extensionId;
+	const extensionPage = await findOnboardingPage(context, extensionId);
 	try {
-		await extensionPage.bringToFront();
-		await extensionPage.waitForLoadState("domcontentloaded");
-		await extensionPage.getByTestId("onboarding-get-started-button").click();
-		await extensionPage.getByRole("textbox", { name: "Enter password" }).fill(password);
-		await extensionPage.getByRole("textbox", { name: "Confirm password" }).fill(password);
-		await extensionPage.getByTestId("onboarding-password-confirm-button").click();
-		await extensionPage.getByRole("button", { name: "No thanks" }).click();
-		await extensionPage.getByTestId("onboarding-enter-talisman-button").click();
-		await extensionPage.getByRole("button", { name: "Add account Create or import" }).click();
+		await completeOnboarding(extensionPage, password);
+		await extensionPage.getByRole("link", { name: "Manage Accounts" }).click();
+		await extensionPage.getByRole("button", { name: "Get Started" }).click();
+		await extensionPage.getByRole("button", { name: "Add Account" }).click();
 		await extensionPage.getByRole("button", { name: "Import Import an existing" }).click();
 		await extensionPage.getByRole("button", { name: "Import via Private Key" }).click();
 		await extensionPage.getByRole("button", { name: "Select account platform" }).click();
@@ -141,16 +176,20 @@ async function importEthPrivateKey(page, { seed, name = "Test Account", password
 		await extensionPage.getByRole("button", { name: "Save" }).click();
 		await extensionPage.close();
 	} catch (error) {
-		console.error("❌ Error during Talisman account import:", error);
+		console.error("❌ Error during Talisman Ethereum account import:", error);
 		throw error;
 	}
 }
 async function authorizeTalisman(page, options = {}) {
-	const { accountName = "Test Account" } = options;
 	const context = page.__extensionContext;
 	const extensionId = page.__extensionId;
+	const { accountName = "Test Account" } = options;
 	const extensionPopup = await findExtensionPopup(context, extensionId);
-	await extensionPopup.getByRole("button", { name: accountName }).click();
+	await extensionPopup.waitForLoadState("domcontentloaded");
+	const accountButton = extensionPopup.getByRole("button", { name: accountName });
+	await accountButton.waitFor({ state: "visible" });
+	await accountButton.scrollIntoViewIfNeeded();
+	await accountButton.click({ force: true });
 	await extensionPopup.getByTestId("connection-connect-button").click();
 	try {
 		await (await findExtensionPopup(context, extensionId)).getByRole("button", { name: "Approve" }).click();
@@ -160,105 +199,83 @@ async function approveTalismanTx(page) {
 	const context = page.__extensionContext;
 	const extensionId = page.__extensionId;
 	const extensionPopup = await findExtensionPopup(context, extensionId);
-	try {
-		await extensionPopup.getByRole("button", { name: "Yes" }).click();
-	} catch {
-		console.log("No another popup found, skipping");
-	}
+	if (await extensionPopup.getByRole("button", { name: "Yes" }).isVisible()) await extensionPopup.getByRole("button", { name: "Yes" }).click();
 	await extensionPopup.getByRole("button", { name: "Approve" }).click();
 }
 async function rejectTalismanTx(page) {
 	const context = page.__extensionContext;
 	const extensionId = page.__extensionId;
-	await (await findExtensionPopup(context, extensionId)).getByTestId("connection-reject-button").click();
+	const extensionPopup = await findExtensionPopup(context, extensionId);
+	await extensionPopup.getByTestId("connection-reject-button").or(extensionPopup.getByRole("button", { name: "Cancel" })).click();
 }
-
-//#endregion
-//#region src/context-playwright/types.ts
-const WALLET_TYPES = ["polkadot-js", "talisman"];
+/* c8 ignore stop */
 
 //#endregion
 //#region src/context-playwright/wallet-factory.ts
+/* c8 ignore start */
 function createExtendedPage(page, context, extensionId) {
 	const extPage = page;
 	extPage.__extensionContext = context;
 	extPage.__extensionId = extensionId;
 	return extPage;
 }
-function createWalletInstance(walletType, extensionId, context) {
-	let importedAccountName;
-	const baseInstance = {
+/* c8 ignore stop */
+/* c8 ignore start */
+function createPolkadotJsWallet(extensionId, context) {
+	return {
 		extensionId,
+		type: "polkadot-js",
 		importMnemonic: async (options) => {
+			await importPolkadotJSAccount(createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId), options);
+		},
+		authorize: async () => {
+			await authorizePolkadotJS(createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId));
+		},
+		approveTx: async (options = {}) => {
+			await approvePolkadotJSTx(createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId), options);
+		},
+		rejectTx: async () => {
+			await rejectPolkadotJSTx(createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId));
+		}
+	};
+}
+/* c8 ignore stop */
+/* c8 ignore start */
+function createTalismanWallet(extensionId, context) {
+	let importedAccountName;
+	return {
+		extensionId,
+		type: "talisman",
+		importPolkadotMnemonic: async (options) => {
 			const extPage = createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId);
 			importedAccountName = options.name || "Test Account";
-			switch (walletType) {
-				case "polkadot-js":
-					await importPolkadotJSAccount(extPage, options);
-					break;
-				case "talisman": throw new Error("Talisman importMnemonic is not yet implemented.");
-				default: throw new Error(`Unsupported wallet type: ${walletType}`);
-			}
+			await importPolkadotMnemonic(extPage, options);
 		},
-		authorize: async (options = {}) => {
+		importEthPrivateKey: async (options) => {
 			const extPage = createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId);
-			const accountName = options.accountName || importedAccountName;
-			switch (walletType) {
-				case "polkadot-js":
-					await authorizePolkadotJS(extPage);
-					break;
-				case "talisman":
-					await authorizeTalisman(extPage, { accountName });
-					break;
-				default: throw new Error(`Unsupported wallet type: ${walletType}`);
-			}
+			importedAccountName = options.name || "Test Account";
+			await importEthPrivateKey(extPage, {
+				seed: options.privateKey,
+				name: options.name,
+				password: options.password
+			});
 		},
-		approveTx: async (options = {}) => {
-			const extPage = createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId);
-			switch (walletType) {
-				case "polkadot-js":
-					await approvePolkadotJSTx(extPage, options);
-					break;
-				case "talisman":
-					await approveTalismanTx(extPage);
-					break;
-				default: throw new Error(`Unsupported wallet type: ${walletType}`);
-			}
+		authorize: async (options = {}) => {
+			await authorizeTalisman(createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId), { accountName: options.accountName || importedAccountName });
+		},
+		approveTx: async () => {
+			await approveTalismanTx(createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId));
 		},
 		rejectTx: async () => {
-			const extPage = createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId);
-			switch (walletType) {
-				case "polkadot-js":
-					await rejectPolkadotJSTx(extPage);
-					break;
-				case "talisman":
-					await rejectTalismanTx(extPage);
-					break;
-				default: throw new Error(`Unsupported wallet type: ${walletType}`);
-			}
+			await rejectTalismanTx(createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId));
 		}
 	};
-	switch (walletType) {
-		case "polkadot-js": return {
-			...baseInstance,
-			type: "polkadot-js"
-		};
-		case "talisman": return {
-			...baseInstance,
-			type: "talisman",
-			importEthPrivateKey: async (options) => {
-				const extPage = createExtendedPage(context.pages()[0] || await context.newPage(), context, extensionId);
-				importedAccountName = options.name || "Test Account";
-				await importEthPrivateKey(extPage, {
-					seed: options.privateKey,
-					name: options.name,
-					password: options.password
-				});
-			}
-		};
-		default: throw new Error(`Unsupported wallet type: ${walletType}`);
-	}
 }
+/* c8 ignore stop */
+const walletFactories = {
+	"polkadot-js": createPolkadotJsWallet,
+	"talisman": createTalismanWallet
+};
 
 //#endregion
 //#region src/context-playwright/index.ts
@@ -274,6 +291,7 @@ function createWalletTest(options = {}) {
 	const { headless = false, slowMo = 150 } = options;
 	const walletConfigs = options.wallets && options.wallets.length > 0 ? options.wallets : [{ type: "polkadot-js" }];
 	const isMultiWallet = walletConfigs.length > 1;
+	/* c8 ignore start */
 	return test$1.extend({
 		walletContext: [async ({}, use) => {
 			const extensionPathsString = (await Promise.all(walletConfigs.map((config) => getExtensionPathForWallet(config)))).join(",");
@@ -306,10 +324,14 @@ function createWalletTest(options = {}) {
 		},
 		wallets: async ({ walletContext, walletExtensionIds }, use) => {
 			const walletMap = {};
-			for (const [walletType, extensionId] of walletExtensionIds) if (WALLET_TYPES.includes(walletType)) walletMap[walletType] = createWalletInstance(walletType, extensionId, walletContext);
+			for (const [walletType, extensionId] of walletExtensionIds) {
+				const factory = walletFactories[walletType];
+				if (factory) walletMap[walletType] = factory(extensionId, walletContext);
+			}
 			await use(walletMap);
 		}
 	});
+	/* c8 ignore stop */
 }
 const test = createWalletTest();
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@avalix/chroma",
   "type": "module",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "End-to-end testing library for Polkadot wallet interactions",
   "author": "Avalix Labs",
   "license": "MIT",
-  "homepage": "https://github.com/avalix-labs/chroma#readme",
+  "homepage": "https://chroma-docs.up.railway.app/docs",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/avalix-labs/chroma.git",
@@ -44,7 +44,8 @@
     "lint": "eslint --fix .",
     "prepublishOnly": "npm run build",
     "download-extensions": "rm -rf .chroma && tsx scripts/download-extensions.ts",
-    "test": "playwright test --ui",
+    "test": "playwright test",
+    "test:ui": "playwright test --ui",
     "test:unit": "vitest",
     "test:unit:run": "vitest run",
     "test:unit:coverage": "vitest run --coverage"
@@ -60,6 +61,7 @@
     "@playwright/test": "^1.57.0",
     "@types/node": "^24.10.2",
     "@types/unzipper": "^0.10.11",
+    "@vitest/coverage-v8": "4.0.18",
     "eslint": "^9.39.1",
     "tsdown": "^0.20.1",
     "tsx": "^4.21.0",

package/scripts/download-extensions.ts

@@ -19,15 +19,15 @@ async function clearChromaDir(): Promise<void> {
   const chromaDir = path.resolve(process.cwd(), '.chroma')
 
   if (fs.existsSync(chromaDir)) {
-    console.log('🗑️  Clearing existing .chroma directory...')
+    console.log('🗑️ Clearing existing .chroma directory...')
     await fs.promises.rm(chromaDir, { recursive: true, force: true })
   }
 }
 
 async function main() {
   const version = await getVersion()
-  console.log(`🎨 Chroma v${version}\n`)
-  console.log('🚀 Downloading wallet extensions...\n')
+  console.log(`\n🎨 Chroma v${version}`)
+  console.log('🚀 Downloading wallet extensions...')
 
   try {
     // Clear existing .chroma directory

package/src/context-playwright/index.test.ts

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { getPolkadotJSExtensionPath } from '../wallets/polkadot-js.js'
+import { getTalismanExtensionPath } from '../wallets/talisman.js'
+import { createWalletTest, getExtensionPathForWallet } from './index.js'
+
+// Mock @playwright/test
+vi.mock('@playwright/test', () => {
+  const mockExtend = vi.fn().mockReturnValue({
+    extend: vi.fn(),
+  })
+
+  return {
+    test: {
+      extend: mockExtend,
+    },
+    chromium: {
+      launchPersistentContext: vi.fn(),
+    },
+    expect: vi.fn(),
+  }
+})
+
+// Mock wallet extension paths
+vi.mock('../wallets/polkadot-js.js', () => ({
+  getPolkadotJSExtensionPath: vi.fn().mockResolvedValue('/mock/path/polkadot-extension'),
+}))
+
+vi.mock('../wallets/talisman.js', () => ({
+  getTalismanExtensionPath: vi.fn().mockResolvedValue('/mock/path/talisman-extension'),
+}))
+
+// Mock wallet factories
+vi.mock('./wallet-factory.js', () => ({
+  walletFactories: {
+    'polkadot-js': vi.fn().mockReturnValue({ type: 'polkadot-js' }),
+    'talisman': vi.fn().mockReturnValue({ type: 'talisman' }),
+  },
+}))
+
+describe('context-playwright/index', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('createWalletTest', () => {
+    it('should create a test function', () => {
+      const result = createWalletTest()
+
+      expect(result).toBeDefined()
+    })
+
+    it('should accept empty options', () => {
+      const result = createWalletTest({})
+
+      expect(result).toBeDefined()
+    })
+
+    it('should accept headless option', () => {
+      const result = createWalletTest({ headless: true })
+
+      expect(result).toBeDefined()
+    })
+
+    it('should accept slowMo option', () => {
+      const result = createWalletTest({ slowMo: 200 })
+
+      expect(result).toBeDefined()
+    })
+
+    it('should accept single wallet configuration', () => {
+      const result = createWalletTest({
+        wallets: [{ type: 'polkadot-js' }],
+      })
+
+      expect(result).toBeDefined()
+    })
+
+    it('should accept talisman wallet configuration', () => {
+      const result = createWalletTest({
+        wallets: [{ type: 'talisman' }],
+      })
+
+      expect(result).toBeDefined()
+    })
+
+    it('should accept multi-wallet configuration', () => {
+      const result = createWalletTest({
+        wallets: [
+          { type: 'polkadot-js' },
+          { type: 'talisman' },
+        ],
+      })
+
+      expect(result).toBeDefined()
+    })
+
+    it('should accept all options combined', () => {
+      const result = createWalletTest({
+        headless: true,
+        slowMo: 100,
+        wallets: [{ type: 'polkadot-js' }],
+      })
+
+      expect(result).toBeDefined()
+    })
+
+    it('should default to polkadot-js when wallets array is empty', () => {
+      const result = createWalletTest({
+        wallets: [],
+      })
+
+      expect(result).toBeDefined()
+    })
+
+    it('should handle wallets with downloadUrl option', () => {
+      const result = createWalletTest({
+        wallets: [{
+          type: 'polkadot-js',
+          downloadUrl: 'https://custom-url.com/extension.zip',
+        }],
+      })
+
+      expect(result).toBeDefined()
+    })
+  })
+
+  describe('getExtensionPathForWallet', () => {
+    it('should return polkadot-js extension path', async () => {
+      const result = await getExtensionPathForWallet({ type: 'polkadot-js' })
+
+      expect(result).toBe('/mock/path/polkadot-extension')
+      expect(getPolkadotJSExtensionPath).toHaveBeenCalled()
+    })
+
+    it('should return talisman extension path', async () => {
+      const result = await getExtensionPathForWallet({ type: 'talisman' })
+
+      expect(result).toBe('/mock/path/talisman-extension')
+      expect(getTalismanExtensionPath).toHaveBeenCalled()
+    })
+
+    it('should throw error for unsupported wallet type', async () => {
+      await expect(
+        getExtensionPathForWallet({ type: 'unsupported' as any }),
+      ).rejects.toThrow('Unsupported wallet type: unsupported')
+    })
+  })
+})

package/src/context-playwright/index.ts

@@ -4,19 +4,16 @@ import type {
   ExtendedPage,
   WalletConfig,
   WalletFixtures,
-  WalletInstance,
   Wallets,
-  WalletType,
   WalletWorkerFixtures,
 } from './types.js'
 import { test as base, chromium } from '@playwright/test'
 import { getPolkadotJSExtensionPath } from '../wallets/polkadot-js.js'
 import { getTalismanExtensionPath } from '../wallets/talisman.js'
-import { WALLET_TYPES } from './types.js'
-import { createWalletInstance } from './wallet-factory.js'
+import { walletFactories } from './wallet-factory.js'
 
 // Helper function to get extension path for a wallet config
-async function getExtensionPathForWallet(config: WalletConfig): Promise<string> {
+export async function getExtensionPathForWallet(config: WalletConfig): Promise<string> {
   const { type } = config
 
   switch (type) {
@@ -46,6 +43,15 @@ export function createWalletTest<const T extends readonly WalletConfig[]>(
   // Compute the expected wallets type
   type ExpectedWallets = T extends readonly WalletConfig[] ? ConfiguredWallets<T> : Wallets
 
+  /*
+   * Playwright Fixtures - Coverage Exclusion
+   *
+   * The fixture implementations below are excluded from unit test coverage because:
+   * 1. They require a real Chromium browser with extension support
+   * 2. They interact with Chrome's extension APIs (service workers, extension IDs)
+   * 3. They are thoroughly tested via E2E tests in the tests/ directory
+   */
+  /* c8 ignore start */
   return base.extend<WalletFixtures<ExpectedWallets>, WalletWorkerFixtures>({
     // Worker-scoped: Browser context with extension(s) (persists across all tests in worker)
     // eslint-disable-next-line no-empty-pattern
@@ -117,19 +123,20 @@ export function createWalletTest<const T extends readonly WalletConfig[]>(
 
     // Wallet instances for each configured wallet
     wallets: async ({ walletContext, walletExtensionIds }, use) => {
-      const walletMap: Partial<ExpectedWallets> = {}
+      const walletMap = {} as ExpectedWallets
 
       // Create wallet instance for each configured wallet
       for (const [walletType, extensionId] of walletExtensionIds) {
-        if (WALLET_TYPES.includes(walletType as WalletType)) {
-          const instance = createWalletInstance(walletType, extensionId, walletContext);
-          (walletMap as Record<string, WalletInstance>)[walletType] = instance
+        const factory = walletFactories[walletType as keyof typeof walletFactories]
+        if (factory) {
+          walletMap[walletType as keyof ExpectedWallets] = factory(extensionId, walletContext) as ExpectedWallets[keyof ExpectedWallets]
         }
       }
 
-      await use(walletMap as ExpectedWallets)
+      await use(walletMap)
     },
   })
+  /* c8 ignore stop */
 }
 
 // Default test with Polkadot JS wallet (with persistent wallet support via worker-scoped fixtures)

package/src/context-playwright/types.ts

@@ -1,11 +1,16 @@
 import type { BrowserContext, Page } from '@playwright/test'
+import type {
+  PolkadotJsWalletInstance,
+  TalismanWalletInstance,
+  WalletInstance,
+} from './wallet-factory.js'
+
+// Re-export wallet instance types
+export type { PolkadotJsWalletInstance, TalismanWalletInstance, WalletInstance }
 
 // Wallet types - single source of truth
 export type WalletType = 'polkadot-js' | 'talisman'
 
-// Available wallet types as constant array
-export const WALLET_TYPES: readonly WalletType[] = ['polkadot-js', 'talisman'] as const
-
 // Wallet account configuration
 export interface WalletAccount {
   seed: string
@@ -19,29 +24,6 @@ export interface WalletConfig {
   downloadUrl?: string
 }
 
-// Base wallet instance - common methods for all wallets
-export interface BaseWalletInstance {
-  extensionId: string
-  importMnemonic: (options: WalletAccount) => Promise<void>
-  authorize: (options?: { accountName?: string }) => Promise<void>
-  approveTx: (options?: { password?: string }) => Promise<void>
-  rejectTx: () => Promise<void>
-}
-
-// Polkadot-JS specific wallet instance
-export interface PolkadotJsWalletInstance extends BaseWalletInstance {
-  type: 'polkadot-js'
-}
-
-// Talisman specific wallet instance (with additional methods)
-export interface TalismanWalletInstance extends BaseWalletInstance {
-  type: 'talisman'
-  importEthPrivateKey: (options: { privateKey: string, name?: string, password?: string }) => Promise<void>
-}
-
-// Union type of all wallet instances
-export type WalletInstance = PolkadotJsWalletInstance | TalismanWalletInstance
-
 // Map wallet type to its instance
 export interface WalletTypeMap {
   'polkadot-js': PolkadotJsWalletInstance