@avalix/chroma 0.0.11 → 0.0.12

package/README.md

@@ -2,8 +2,6 @@
 
 End-to-end testing library for Polkadot wallet interactions using Playwright.
 
-> **⚠️ Active Development**: This library is currently under active development. The API may change and breaking changes can occur between versions. Please pin your version and review changelogs carefully when updating.
-
 ## Installation
 
 ```bash
@@ -27,7 +25,7 @@ This will download the wallet extensions (Polkadot JS and Talisman) to `./.chrom
 ```json
 {
   "scripts": {
-    "prepare": "chroma download-extensions"
+    "test:prepare": "chroma download-extensions"
   }
 }
 ```
@@ -36,258 +34,60 @@ This will download the wallet extensions (Polkadot JS and Talisman) to `./.chrom
 
 ## Quick Start
 
-### Basic Usage
-
 ```typescript
-import { expect, test } from '@avalix/chroma'
+import { createWalletTest, expect } from '@avalix/chroma'
 
-test('should connect wallet and sign transaction', async ({ page, wallets }) => {
+const test = createWalletTest({
+  wallets: [{ type: 'polkadot-js' }]
+})
+
+test('connect wallet and sign transaction', async ({ page, wallets }) => {
   const polkadotJs = wallets['polkadot-js']
 
-  // Import a test account
   await polkadotJs.importMnemonic({
     seed: 'bottom drive obey lake curtain smoke basket hold race lonely fit walk',
     name: 'Test Account',
     password: 'securePassword123'
   })
 
-  // Navigate to your dApp
   await page.goto('http://localhost:3000')
-
-  // Connect wallet
   await page.click('button:has-text("Connect Wallet")')
   await polkadotJs.authorize()
 
-  // Perform transaction
   await page.click('button:has-text("Send Transaction")')
   await polkadotJs.approveTx({ password: 'securePassword123' })
 
-  // Verify transaction success
   await expect(page.locator('.transaction-success')).toBeVisible()
 })
 ```
 
-### Custom Configuration
-
-```typescript
-import { createWalletTest, expect } from '@avalix/chroma'
-
-const customTest = createWalletTest({
-  wallets: [{ type: 'polkadot-js' }],
-  headless: false,
-  slowMo: 100
-})
-
-customTest('test with custom config', async ({ page, wallets }) => {
-  const polkadotJs = wallets['polkadot-js']
-
-  await polkadotJs.importMnemonic({
-    seed: 'your seed phrase here...',
-    name: 'My Test Account'
-  })
-  await page.goto('http://localhost:3000')
-  await polkadotJs.authorize()
-})
-```
-
 ### Multiple Wallets
 
 ```typescript
-import { createWalletTest, expect } from '@avalix/chroma'
+import { createWalletTest } from '@avalix/chroma'
 
-// Test with multiple wallet extensions
-const multiWalletTest = createWalletTest({
-  wallets: [
-    { type: 'polkadot-js' },
-    { type: 'talisman' }
-  ],
-  headless: false,
-  slowMo: 150
+const test = createWalletTest({
+  wallets: [{ type: 'polkadot-js' }, { type: 'talisman' }]
 })
 
-multiWalletTest('test with multiple wallets', async ({ page, wallets }) => {
+test('multi-wallet test', async ({ page, wallets }) => {
   const polkadotJs = wallets['polkadot-js']
   const talisman = wallets.talisman
 
-  // Import to Polkadot JS
-  await polkadotJs.importMnemonic({
-    seed: 'bottom drive obey lake curtain smoke basket hold race lonely fit walk',
-    name: 'Alice'
-  })
-
-  // Import to Talisman using Ethereum private key
-  await talisman.importEthPrivateKey({
-    privateKey: '0x...',
-    name: 'Bob'
-  })
+  await polkadotJs.importMnemonic({ seed: '...', name: 'Alice' })
+  await talisman.importEthPrivateKey({ privateKey: '0x...', name: 'Bob' })
 
   await page.goto('http://localhost:3000')
-
-  // Use specific wallet
   await polkadotJs.authorize()
-  await polkadotJs.approveTx()
 })
 ```
 
 ## Features
 
-- 🔐 **Easy Extension Setup**: Simple command to download wallet extensions
-- 🧪 **Test Fixtures**: Ready-to-use Playwright fixtures for wallet operations
-- 📝 **Account Management**: Import accounts with seed phrases and custom names
-- ✅ **Transaction Approval**: Approve transactions with password authentication
-- 🔗 **dApp Authorization**: Connect wallet to decentralized applications
-- 🔀 **Multi-Wallet Support**: Test with multiple wallet extensions simultaneously
-- ⚙️ **Configurable**: Custom extension paths, headless mode, and slow motion settings
-
-## API Reference
-
-### Core Functions
-
-#### `test` (Default Test Function)
-Pre-configured test function with Polkadot JS extension.
-
-```typescript
-import { test } from '@avalix/chroma'
-
-test('my wallet test', async ({ page, wallets }) => {
-  const polkadotJs = wallets['polkadot-js']
-
-  await polkadotJs.importMnemonic({ seed: '...' })
-  await polkadotJs.authorize()
-})
-```
-
-#### `createWalletTest(options?: ChromaTestOptions)`
-Create a custom test function with specific configuration. Supports single and multi-wallet modes.
-
-```typescript
-import { createWalletTest } from '@avalix/chroma'
-
-// Single wallet (default)
-const test = createWalletTest()
-
-// Single wallet with custom config
-const customTest = createWalletTest({
-  wallets: [{ type: 'polkadot-js' }],
-  headless: false,
-  slowMo: 150
-})
-
-// Multiple wallets
-const multiTest = createWalletTest({
-  wallets: [
-    { type: 'polkadot-js' },
-    { type: 'talisman' }
-  ]
-})
-
-// Usage
-test('example', async ({ page, wallets }) => {
-  const polkadotJs = wallets['polkadot-js']
-
-  await polkadotJs.importMnemonic({ seed: '...' })
-  await polkadotJs.authorize()
-  await polkadotJs.approveTx()
-})
-```
-
-### Test Fixtures
-
-#### `page`
-Playwright page instance with wallet extension(s) loaded.
-
-#### `wallets`
-Typed object containing wallet instances for each configured wallet. Provides full TypeScript autocomplete.
-
-```typescript
-// Base wallet instance (common methods)
-interface BaseWalletInstance {
-  extensionId: string
-  importMnemonic: (options: WalletAccount) => Promise<void>
-  authorize: (options?: { accountName?: string }) => Promise<void>
-  approveTx: (options?: { password?: string }) => Promise<void>
-}
-
-// Polkadot-JS wallet instance
-interface PolkadotJsWalletInstance extends BaseWalletInstance {
-  type: 'polkadot-js'
-}
-
-// Talisman wallet instance (with additional methods)
-interface TalismanWalletInstance extends BaseWalletInstance {
-  type: 'talisman'
-  importEthPrivateKey: (options: { privateKey: string, name?: string, password?: string }) => Promise<void>
-}
-
-// Note: Talisman currently does not support importMnemonic - use importEthPrivateKey instead
-
-// Wallets collection - each wallet has its specific type
-interface Wallets {
-  'polkadot-js': PolkadotJsWalletInstance
-  'talisman': TalismanWalletInstance
-}
-
-interface WalletAccount {
-  seed: string
-  name?: string // Default: 'Test Account'
-  password?: string // Default: 'h3llop0lkadot!'
-}
-```
-
-**Usage:**
-
-```typescript
-test('example', async ({ page, wallets }) => {
-  const polkadotJs = wallets['polkadot-js'] // Type: PolkadotJsWalletInstance
-
-  // Import mnemonic (available on all wallets)
-  await polkadotJs.importMnemonic({
-    seed: 'bottom drive obey lake curtain smoke basket hold race lonely fit walk',
-    name: 'Test Account',
-    password: 'securePassword123'
-  })
-
-  await page.goto('http://localhost:3000')
-  await polkadotJs.authorize()
-  await polkadotJs.approveTx({ password: 'securePassword123' })
-})
-
-// Talisman-specific features
-test('talisman example', async ({ page, wallets }) => {
-  const talisman = wallets.talisman // Type: TalismanWalletInstance
-
-  // Talisman-specific method: import Ethereum private key
-  await talisman.importEthPrivateKey({
-    privateKey: '0x...',
-    name: 'My Account',
-    password: 'mypassword'
-  })
-
-  // Common methods also available
-  await talisman.authorize({ accountName: 'My Account' })
-  await talisman.approveTx()
-})
-```
-
-## Configuration
-
-### Extension Download
-Run the download command to get the required wallet extensions:
-
-```bash
-npx chroma download-extensions
-```
-
-Extensions will be downloaded to `./.chroma` directory in your project root. Add this directory to your `.gitignore`:
-
-```gitignore
-.chroma/
-```
-
-### Browser Settings
-- **Headless Mode**: Disabled by default for better debugging
-- **Slow Motion**: 150ms delay between actions (configurable)
-- **Extension Loading**: Automatically loads configured wallet extensions
+- **Easy Extension Setup** - Download wallet extensions with a single command
+- **Multi-Wallet Support** - Test with multiple wallet extensions simultaneously
+- **TypeScript Support** - Full type safety and autocomplete
+- **VS Code Integration** - Works with [Playwright Test for VS Code](https://marketplace.visualstudio.com/items?itemName=ms-playwright.playwright)
 
 ## Supported Chains
 
@@ -304,20 +104,13 @@ Extensions will be downloaded to `./.chroma` directory in your project root. Add
 | Polkadot JS Extension | ✅ Supported | v0.62.6 |
 | Talisman | ✅ Supported | v3.1.13 |
 | SubWallet | ⏳ Planned | - |
+| MetaMask | ⏳ Planned | - |
 
 ## Requirements
 
 - Node.js 24+
 - @playwright/test ^1.55.0
 
-## Contributing
-
-This project is in active development. Currently focusing on:
-- Polkadot JS Extension and Talisman support
-- Core testing fixtures
-- Additional wallet integrations
-- Documentation improvements
-
 ## License
 
 MIT

package/dist/index.d.mts

@@ -9923,38 +9923,45 @@ declare namespace test_d_exports {
   export { BlobReporterOptions, Config, Expect, ExpectMatcherState, ExpectMatcherUtils, Fixtures, FullConfig, FullProject, HtmlReporterOptions, JUnitReporterOptions, JsonReporterOptions, ListReporterOptions, Location, MatcherHintOptions, MatcherReturnType, Metadata, PageAssertionsToHaveScreenshotOptions, PlaywrightTestArgs, PlaywrightTestConfig, PlaywrightTestOptions, PlaywrightTestProject, PlaywrightWorkerArgs, PlaywrightWorkerOptions, Project, ReporterDescription, ScreenshotMode, TestAnnotation, TestDetails, TestDetailsAnnotation, TestFixture, TestInfo, TestInfoError, TestStatus, TestStepInfo, TestType, TraceMode, VideoMode, WorkerFixture, WorkerInfo, _baseTest, test$2 as default, defineConfig, expect$1 as expect, mergeExpects, mergeTests, test$2 as test };
 }
 //#endregion
-//#region src/context-playwright/types.d.ts
-type WalletType = 'polkadot-js' | 'talisman';
-interface WalletAccount {
-  seed: string;
-  name?: string;
-  password?: string;
-}
-interface WalletConfig {
-  type: WalletType;
-  downloadUrl?: string;
-}
-interface BaseWalletInstance {
+//#region src/context-playwright/wallet-factory.d.ts
+declare function createPolkadotJsWallet(extensionId: string, context: BrowserContext): {
   extensionId: string;
+  type: "polkadot-js";
   importMnemonic: (options: WalletAccount) => Promise<void>;
-  authorize: (options?: {
-    accountName?: string;
-  }) => Promise<void>;
+  authorize: () => Promise<void>;
   approveTx: (options?: {
     password?: string;
   }) => Promise<void>;
   rejectTx: () => Promise<void>;
-}
-interface PolkadotJsWalletInstance extends BaseWalletInstance {
-  type: 'polkadot-js';
-}
-interface TalismanWalletInstance extends BaseWalletInstance {
-  type: 'talisman';
+};
+declare function createTalismanWallet(extensionId: string, context: BrowserContext): {
+  extensionId: string;
+  type: "talisman";
+  importPolkadotMnemonic: (options: WalletAccount) => Promise<void>;
   importEthPrivateKey: (options: {
     privateKey: string;
     name?: string;
     password?: string;
   }) => Promise<void>;
+  authorize: (options?: {
+    accountName?: string;
+  }) => Promise<void>;
+  approveTx: () => Promise<void>;
+  rejectTx: () => Promise<void>;
+};
+type PolkadotJsWalletInstance = ReturnType<typeof createPolkadotJsWallet>;
+type TalismanWalletInstance = ReturnType<typeof createTalismanWallet>;
+//#endregion
+//#region src/context-playwright/types.d.ts
+type WalletType = 'polkadot-js' | 'talisman';
+interface WalletAccount {
+  seed: string;
+  name?: string;
+  password?: string;
+}
+interface WalletConfig {
+  type: WalletType;
+  downloadUrl?: string;
 }
 interface WalletTypeMap {
   'polkadot-js': PolkadotJsWalletInstance;

package/dist/index.mjs

@@ -103,35 +103,63 @@ async function getTalismanExtensionPath() {
 	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!" }) {
+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 +169,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,23 +192,16 @@ 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"];
-
 //#endregion
 //#region src/context-playwright/wallet-factory.ts
 function createExtendedPage(page, context, extensionId) {
@@ -185,80 +210,58 @@ function createExtendedPage(page, context, extensionId) {
 	extPage.__extensionId = extensionId;
 	return extPage;
 }
-function createWalletInstance(walletType, extensionId, context) {
-	let importedAccountName;
-	const baseInstance = {
+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));
+		}
+	};
+}
+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}`);
-	}
 }
+const walletFactories = {
+	"polkadot-js": createPolkadotJsWallet,
+	"talisman": createTalismanWallet
+};
 
 //#endregion
 //#region src/context-playwright/index.ts
@@ -306,7 +309,10 @@ 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);
 		}
 	});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@avalix/chroma",
   "type": "module",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "End-to-end testing library for Polkadot wallet interactions",
   "author": "Avalix Labs",
   "license": "MIT",
@@ -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"

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.ts

@@ -4,16 +4,13 @@ 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> {
@@ -117,17 +114,17 @@ 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)
     },
   })
 }

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

package/src/context-playwright/wallet-factory.ts

@@ -1,11 +1,5 @@
 import type { BrowserContext, Page } from '@playwright/test'
-import type {
-  BaseWalletInstance,
-  PolkadotJsWalletInstance,
-  TalismanWalletInstance,
-  WalletAccount,
-  WalletInstance,
-} from './types.js'
+import type { WalletAccount } from './types.js'
 import {
   approvePolkadotJSTx,
   authorizePolkadotJS,
@@ -16,6 +10,7 @@ import {
   approveTalismanTx,
   authorizeTalisman,
   importEthPrivateKey,
+  importPolkadotMnemonic,
   rejectTalismanTx,
 } from '../wallets/talisman.js'
 
@@ -27,114 +22,83 @@ function createExtendedPage(page: Page, context: BrowserContext, extensionId: st
   return extPage
 }
 
-// Create wallet instance helper with proper typing
-export function createWalletInstance(
-  walletType: string,
-  extensionId: string,
-  context: BrowserContext,
-): WalletInstance {
-  // Store the imported account name for later use
-  let importedAccountName: string | undefined
-
-  // Common methods for all wallets
-  const baseInstance: BaseWalletInstance = {
+// Factory function for Polkadot-JS wallet
+export function createPolkadotJsWallet(extensionId: string, context: BrowserContext) {
+  return {
     extensionId,
+    type: 'polkadot-js' as const,
     importMnemonic: async (options: WalletAccount) => {
       const page = context.pages()[0] || await context.newPage()
       const extPage = createExtendedPage(page, context, extensionId)
+      await importPolkadotJSAccount(extPage, options)
+    },
+    authorize: async () => {
+      const page = context.pages()[0] || await context.newPage()
+      const extPage = createExtendedPage(page, context, extensionId)
+      await authorizePolkadotJS(extPage)
+    },
+    approveTx: async (options: { password?: string } = {}) => {
+      const page = context.pages()[0] || await context.newPage()
+      const extPage = createExtendedPage(page, context, extensionId)
+      await approvePolkadotJSTx(extPage, options)
+    },
+    rejectTx: async () => {
+      const page = context.pages()[0] || await context.newPage()
+      const extPage = createExtendedPage(page, context, extensionId)
+      await rejectPolkadotJSTx(extPage)
+    },
+  }
+}
 
-      // Store the account name for future authorize calls
-      importedAccountName = options.name || 'Test Account'
+// Factory function for Talisman wallet
+export function createTalismanWallet(extensionId: string, context: BrowserContext) {
+  let importedAccountName: string | undefined
 
-      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}`)
-      }
+  return {
+    extensionId,
+    type: 'talisman' as const,
+    importPolkadotMnemonic: async (options: WalletAccount) => {
+      const page = context.pages()[0] || await context.newPage()
+      const extPage = createExtendedPage(page, context, extensionId)
+      importedAccountName = options.name || 'Test Account'
+      await importPolkadotMnemonic(extPage, options)
+    },
+    importEthPrivateKey: async (options: { privateKey: string, name?: string, password?: string }) => {
+      const page = context.pages()[0] || await context.newPage()
+      const extPage = createExtendedPage(page, context, extensionId)
+      importedAccountName = options.name || 'Test Account'
+      await importEthPrivateKey(extPage, {
+        seed: options.privateKey,
+        name: options.name,
+        password: options.password,
+      })
     },
     authorize: async (options: { accountName?: string } = {}) => {
       const page = context.pages()[0] || await context.newPage()
       const extPage = createExtendedPage(page, context, extensionId)
-
-      // Use provided account name or fall back to the imported one
       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}`)
-      }
+      await authorizeTalisman(extPage, { accountName })
     },
-    approveTx: async (options: { password?: string } = {}) => {
+    approveTx: async () => {
       const page = context.pages()[0] || await context.newPage()
       const extPage = createExtendedPage(page, 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}`)
-      }
+      await approveTalismanTx(extPage)
     },
     rejectTx: async () => {
       const page = context.pages()[0] || await context.newPage()
       const extPage = createExtendedPage(page, 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(extPage)
     },
   }
+}
 
-  // Return wallet-specific instance with type discriminator
-  switch (walletType) {
-    case 'polkadot-js':
-      return {
-        ...baseInstance,
-        type: 'polkadot-js',
-      } as PolkadotJsWalletInstance
-
-    case 'talisman':
-      return {
-        ...baseInstance,
-        type: 'talisman',
-        importEthPrivateKey: async (options: { privateKey: string, name?: string, password?: string }) => {
-          const page = context.pages()[0] || await context.newPage()
-          const extPage = createExtendedPage(page, context, extensionId)
-
-          // Store the account name for future authorize calls
-          importedAccountName = options.name || 'Test Account'
-
-          // Use the seed property to pass the private key
-          await importEthPrivateKey(extPage, {
-            seed: options.privateKey,
-            name: options.name,
-            password: options.password,
-          })
-        },
-      } as TalismanWalletInstance
-
-    default:
-      throw new Error(`Unsupported wallet type: ${walletType}`)
-  }
+// Wallet factories map - auto-inferred types
+export const walletFactories = {
+  'polkadot-js': createPolkadotJsWallet,
+  'talisman': createTalismanWallet,
 }
+
+// Auto-inferred types from factory functions
+export type PolkadotJsWalletInstance = ReturnType<typeof createPolkadotJsWallet>
+export type TalismanWalletInstance = ReturnType<typeof createTalismanWallet>
+export type WalletInstance = PolkadotJsWalletInstance | TalismanWalletInstance

package/src/utils/download-extension.ts

@@ -34,7 +34,7 @@ export async function downloadAndExtractExtension(options: DownloadExtensionOpti
   }
 
   try {
-    console.log(`📥 Downloading ${extensionName}...`)
+    console.log(`\n📥 Downloading ${extensionName}...`)
 
     // Download the ZIP file
     const response = await fetch(downloadUrl)

package/src/wallets/talisman.ts

@@ -54,65 +54,114 @@ export async function getTalismanExtensionPath(): Promise<string> {
   return extensionDir
 }
 
-// Talisman specific Ethereum private key import implementation
-export async function importEthPrivateKey(
+// Helper function to find Talisman onboarding page
+async function findOnboardingPage(
+  context: BrowserContext,
+  extensionId: string,
+): Promise<Page> {
+  // Open new dashboard page
+  const popupUrl = `chrome-extension://${extensionId}/dashboard.html`
+  const newPage = await context.newPage()
+  await newPage.goto(popupUrl)
+  await newPage.waitForLoadState('domcontentloaded')
+
+  // Close any other extension tabs that may have been opened automatically
+  for (const p of context.pages()) {
+    if (p !== newPage && p.url().includes(`chrome-extension://${extensionId}/`)) {
+      await p.close()
+    }
+  }
+
+  return newPage
+}
+
+// Helper function to complete Talisman onboarding flow
+async function completeOnboarding(
+  extensionPage: Page,
+  password: string,
+): Promise<void> {
+  // Bring the onboarding page to front
+  await extensionPage.bringToFront()
+
+  // Wait for the page to load and become interactive
+  await extensionPage.waitForLoadState('domcontentloaded')
+
+  if (await extensionPage.getByRole('button', { name: 'Settings' }).isVisible()) {
+    await extensionPage.getByRole('button', { name: 'Settings' }).click({ force: true })
+    return
+  }
+
+  // Click the get started button
+  await extensionPage.getByTestId('onboarding-get-started-button').click()
+
+  // Fill the password
+  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()
+
+  // Click the no thanks button
+  await extensionPage.getByRole('button', { name: 'No thanks' }).click()
+  await extensionPage.getByTestId('onboarding-enter-talisman-button').click()
+
+  // Navigate directly to settings/general page
+  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()
+
+  // Toggle the risk scan setting
+  await extensionPage.getByTestId('component-toggle-button').first().click()
+}
+
+// Talisman specific Polkadot mnemonic import implementation
+export async function importPolkadotMnemonic(
   page: Page & { __extensionContext: BrowserContext, __extensionId: string },
   { seed, name = 'Test Account', password = 'h3llop0lkadot!' }: WalletAccount,
 ): Promise<void> {
   const context = page.__extensionContext
   const extensionId = page.__extensionId
 
-  // Wait for Talisman to open its onboarding tab with retry logic
-  const maxAttempts = 20
-  const retryDelay = 500
-  let extensionPage: Page | null = null
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const pages = context.pages()
+  const extensionPage = await findOnboardingPage(context, extensionId)
 
-    for (const p of pages) {
-      const url = p.url()
-      if (url.includes('onboarding.html') || url.includes(`chrome-extension://${extensionId}/`)) {
-        extensionPage = p
-        break
-      }
-    }
+  try {
+    await completeOnboarding(extensionPage, password!)
 
-    if (extensionPage) {
-      break
-    }
+    // Import Polkadot account via Recovery Phrase
+    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()
 
-    // If not found, wait before retrying
-    if (attempt < maxAttempts - 1) {
-      await new Promise(resolve => setTimeout(resolve, retryDelay))
-    }
+    await extensionPage.close()
   }
-
-  if (!extensionPage) {
-    throw new Error(`Talisman onboarding page not found after ${maxAttempts} attempts`)
+  catch (error) {
+    console.error('❌ Error during Talisman Polkadot account import:', error)
+    throw error
   }
+}
 
-  try {
-    // Bring the onboarding page to front
-    await extensionPage.bringToFront()
-
-    // Wait for the page to load and become interactive
-    await extensionPage.waitForLoadState('domcontentloaded')
-
-    // Click the get started button
-    await extensionPage.getByTestId('onboarding-get-started-button').click()
+// Talisman specific Ethereum private key import implementation
+export async function importEthPrivateKey(
+  page: Page & { __extensionContext: BrowserContext, __extensionId: string },
+  { seed, name = 'Test Account', password = 'h3llop0lkadot!' }: WalletAccount,
+): Promise<void> {
+  const context = page.__extensionContext
+  const extensionId = page.__extensionId
 
-    // Fill the password
-    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()
+  const extensionPage = await findOnboardingPage(context, extensionId)
 
-    // Click the no thanks button
-    await extensionPage.getByRole('button', { name: 'No thanks' }).click()
-    await extensionPage.getByTestId('onboarding-enter-talisman-button').click()
+  try {
+    await completeOnboarding(extensionPage, password!)
 
-    // Import Ethereum account
-    await extensionPage.getByRole('button', { name: 'Add account Create or import' }).click()
+    // Import Ethereum account via Private Key
+    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()
@@ -124,7 +173,7 @@ export async function importEthPrivateKey(
     await extensionPage.close()
   }
   catch (error) {
-    console.error('❌ Error during Talisman account import:', error)
+    console.error('❌ Error during Talisman Ethereum account import:', error)
     throw error
   }
 }
@@ -134,14 +183,18 @@ export async function authorizeTalisman(
   page: Page & { __extensionContext: BrowserContext, __extensionId: string },
   options: { accountName?: string } = {},
 ): Promise<void> {
-  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.waitForLoadState('domcontentloaded')
 
   // Authorize Talisman account
-  await extensionPopup.getByRole('button', { name: accountName }).click()
+  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 {
@@ -161,12 +214,9 @@ export async function approveTalismanTx(
 
   const extensionPopup = await findExtensionPopup(context, extensionId)
 
-  try {
+  if (await extensionPopup.getByRole('button', { name: 'Yes' }).isVisible()) {
     await extensionPopup.getByRole('button', { name: 'Yes' }).click()
   }
-  catch {
-    console.log('No another popup found, skipping')
-  }
 
   await extensionPopup.getByRole('button', { name: 'Approve' }).click()
 }
@@ -179,5 +229,9 @@ export async function rejectTalismanTx(
   const extensionId = page.__extensionId
 
   const extensionPopup = await findExtensionPopup(context, extensionId)
-  await extensionPopup.getByTestId('connection-reject-button').click()
+
+  const rejectButton = extensionPopup.getByTestId('connection-reject-button')
+    .or(extensionPopup.getByRole('button', { name: 'Cancel' }))
+
+  await rejectButton.click()
 }