@avalix/chroma 0.0.6 → 0.0.7

package/README.md

@@ -2,7 +2,7 @@
 
 End-to-end testing library for Polkadot wallet interactions using Playwright.
 
-> **Current Status**: This library currently supports **Polkadot JS Extension** only. Support for other wallets like Talisman is planned for future releases.
+> **⚠️ 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
 
@@ -12,6 +12,18 @@ npm install @avalix/chroma @playwright/test
 
 **Note**: `@playwright/test` is a peer dependency and must be installed separately to avoid conflicts.
 
+### Download Extensions
+
+Before running your tests, you need to download the wallet extensions:
+
+```bash
+npx @avalix/chroma download-extensions
+```
+
+This will download the wallet extensions (Polkadot JS and Talisman) to `./.chroma` directory in your project root.
+
+**Important**: You must run this command before running Playwright tests. If the extension is not found, tests will fail with a helpful error message.
+
 ## Quick Start
 
 ### Basic Usage
@@ -19,9 +31,11 @@ npm install @avalix/chroma @playwright/test
 ```typescript
 import { expect, test } from '@avalix/chroma'
 
-test('should connect wallet and sign transaction', async ({ page, importAccount, authorize, approveTx }) => {
+test('should connect wallet and sign transaction', async ({ page, wallets }) => {
+  const polkadotJs = wallets['polkadot-js']
+
   // Import a test account
-  await importAccount({
+  await polkadotJs.importMnemonic({
     seed: 'bottom drive obey lake curtain smoke basket hold race lonely fit walk',
     name: 'Test Account',
     password: 'securePassword123'
@@ -32,11 +46,11 @@ test('should connect wallet and sign transaction', async ({ page, importAccount,
 
   // Connect wallet
   await page.click('button:has-text("Connect Wallet")')
-  await authorize()
+  await polkadotJs.authorize()
 
   // Perform transaction
   await page.click('button:has-text("Send Transaction")')
-  await approveTx({ password: 'securePassword123' })
+  await polkadotJs.approveTx({ password: 'securePassword123' })
 
   // Verify transaction success
   await expect(page.locator('.transaction-success')).toBeVisible()
@@ -48,33 +62,71 @@ test('should connect wallet and sign transaction', async ({ page, importAccount,
 ```typescript
 import { createWalletTest, expect } from '@avalix/chroma'
 
-// Create test with custom configuration
 const customTest = createWalletTest({
-  walletType: 'polkadot-js',
-  walletConfig: {
-    customPath: './my-custom-extension'
-  },
+  wallets: [{ type: 'polkadot-js' }],
   headless: false,
   slowMo: 100
 })
 
-customTest('test with custom config', async ({ page, importAccount, authorize }) => {
-  // Your test code here
-  await importAccount({
+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'
   })
-  // ... rest of your test
+  await page.goto('http://localhost:3000')
+  await polkadotJs.authorize()
+})
+```
+
+### Multiple Wallets
+
+```typescript
+import { createWalletTest, expect } from '@avalix/chroma'
+
+// Test with multiple wallet extensions
+const multiWalletTest = createWalletTest({
+  wallets: [
+    { type: 'polkadot-js' },
+    { type: 'talisman' }
+  ],
+  headless: false,
+  slowMo: 150
+})
+
+multiWalletTest('test with multiple wallets', 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 page.goto('http://localhost:3000')
+
+  // Use specific wallet
+  await polkadotJs.authorize()
+  await polkadotJs.approveTx()
 })
 ```
 
 ## Features
 
-- 🔐 **Automatic Extension Setup**: Downloads and configures Polkadot JS extension automatically
+- 🔐 **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
@@ -87,110 +139,152 @@ Pre-configured test function with Polkadot JS extension.
 ```typescript
 import { test } from '@avalix/chroma'
 
-test('my wallet test', async ({ page, importAccount, authorize, approveTx }) => {
-  // Test implementation
+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.
+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({
-  walletType: 'polkadot-js', // Currently only 'polkadot-js' is supported
-  walletConfig: {
-    customPath: './custom-extension', // Optional: path to custom extension
-    downloadUrl: 'https://...' // Optional: custom download URL
-  },
-  headless: true, // Optional: run in headless mode
-  slowMo: 150 // Optional: slow motion delay in ms (default: 150)
+  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
 
-#### `importAccount(options: WalletAccount)`
-Import a wallet account using seed phrase.
+#### `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!'
 }
-
-await importAccount({
-  seed: 'your twelve word seed phrase here...',
-  name: 'My Test Account',
-  password: 'securePassword123'
-})
 ```
 
-#### `authorize()`
-Authorize the dApp to connect with the wallet. Call this after triggering wallet connection from your dApp.
+**Usage:**
 
 ```typescript
-await authorize()
-```
+test('example', async ({ page, wallets }) => {
+  const polkadotJs = wallets['polkadot-js'] // Type: PolkadotJsWalletInstance
 
-#### `approveTx(options?)`
-Approve a transaction with the wallet password.
+  // 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'
+  })
 
-```typescript
-await approveTx({ password: 'myPassword' })
+  await page.goto('http://localhost:3000')
+  await polkadotJs.authorize()
+  await polkadotJs.approveTx({ password: 'securePassword123' })
+})
 
-// Or use default password
-await approveTx()
-```
+// Talisman-specific features
+test('talisman example', async ({ page, wallets }) => {
+  const talisman = wallets.talisman // Type: TalismanWalletInstance
 
-### Utility Functions
+  // Talisman-specific method: import Ethereum private key
+  await talisman.importEthPrivateKey({
+    privateKey: '0x...',
+    name: 'My Account',
+    password: 'mypassword'
+  })
 
-#### `downloadAndExtractPolkadotExtension(targetDir?)`
-Download and extract Polkadot JS extension to specified directory.
+  // Common methods also available
+  await talisman.authorize({ accountName: 'My Account' })
+  await talisman.approveTx()
+})
+```
 
-```typescript
-import { downloadAndExtractPolkadotExtension } from '@avalix/chroma'
+## Configuration
 
-// Download to custom directory
-const extensionPath = await downloadAndExtractPolkadotExtension('./my-extensions')
+### Extension Download
+Run the download command to get the required wallet extensions:
 
-// Download to default directory (./.chroma)
-const extensionPath = await downloadAndExtractPolkadotExtension()
+```bash
+npx @avalix/chroma download-extensions
 ```
 
-### TypeScript Types
+Extensions will be downloaded to `./.chroma` directory in your project root. Add this directory to your `.gitignore`:
 
-```typescript
-import type {
-  ChromaTestOptions,
-  WalletAccount,
-  WalletConfig,
-  WalletFixtures,
-  WalletType
-} from '@avalix/chroma'
+```gitignore
+.chroma/
 ```
 
-## Configuration
-
-### Default Directory
-The Polkadot JS extension will be automatically downloaded to `./.chroma` directory in your project root. You can customize this by:
-
-1. Using `downloadAndExtractPolkadotExtension('./custom-path')`
-2. Using `createWalletTest()` with `walletConfig.customPath`
-
 ### Browser Settings
 - **Headless Mode**: Disabled by default for better debugging
 - **Slow Motion**: 150ms delay between actions (configurable)
-- **Extension Loading**: Automatically loads only the Polkadot JS extension
+- **Extension Loading**: Automatically loads configured wallet extensions
 
 ## Supported Wallets
 
 | Wallet | Status | Version |
 |--------|--------|---------|
 | Polkadot JS Extension | ✅ Supported | v0.61.7 |
-| Talisman | ⏳ Planned | - |
+| Talisman | ✅ Supported | v3.0.5 |
 | SubWallet | ⏳ Planned | - |
 
 ## Requirements
@@ -201,8 +295,9 @@ The Polkadot JS extension will be automatically downloaded to `./.chroma` direct
 ## Contributing
 
 This project is in active development. Currently focusing on:
-- Polkadot JS Extension support
+- Polkadot JS Extension and Talisman support
 - Core testing fixtures
+- Additional wallet integrations
 - Documentation improvements
 
 ## License

package/dist/index.d.ts

@@ -1,40 +1,64 @@
-import { BrowserContext, BrowserContext as BrowserContext$1, Page, Page as Page$1, expect, test as test$1 } from "@playwright/test";
+import { BrowserContext, Page, expect } from "@playwright/test";
+import * as playwright_test0 from "playwright/test";
 
-//#region src/context-playwright/index.d.ts
-type WalletType = "polkadot-js" | "talisman";
-interface WalletConfig {
-  downloadUrl?: string;
-  customPath?: string;
-}
+//#region src/context-playwright/types.d.ts
+type WalletType = 'polkadot-js' | 'talisman';
 interface WalletAccount {
   seed: string;
   name?: string;
   password?: string;
 }
-interface ChromaTestOptions {
-  walletType?: WalletType;
-  walletConfig?: WalletConfig;
-  headless?: boolean;
-  slowMo?: number;
-}
-interface ExtendedPage extends Page$1 {
-  __extensionContext: BrowserContext$1;
-  __extensionId: string;
+interface WalletConfig {
+  type: WalletType;
+  downloadUrl?: string;
 }
-interface WalletFixtures {
-  page: ExtendedPage;
-  walletType: WalletType;
-  walletConfig: WalletConfig;
-  importAccount: (options: WalletAccount) => Promise<void>;
-  authorize: () => Promise<void>;
+interface BaseWalletInstance {
+  extensionId: string;
+  importMnemonic: (options: WalletAccount) => Promise<void>;
+  authorize: (options?: {
+    accountName?: string;
+  }) => Promise<void>;
   approveTx: (options?: {
     password?: string;
   }) => Promise<void>;
 }
-declare function createWalletTest(options?: ChromaTestOptions): ReturnType<typeof test$1.extend<WalletFixtures>>;
-declare const test: ReturnType<typeof createWalletTest>;
+interface PolkadotJsWalletInstance extends BaseWalletInstance {
+  type: 'polkadot-js';
+}
+interface TalismanWalletInstance extends BaseWalletInstance {
+  type: 'talisman';
+  importEthPrivateKey: (options: {
+    privateKey: string;
+    name?: string;
+    password?: string;
+  }) => Promise<void>;
+}
+interface WalletTypeMap {
+  'polkadot-js': PolkadotJsWalletInstance;
+  'talisman': TalismanWalletInstance;
+}
+type Wallets = WalletTypeMap;
+type ConfiguredWallets<T extends readonly WalletConfig[]> = { [K in T[number]['type']]: WalletTypeMap[K] };
+type ExtendedPage = Page & {
+  __extensionContext: BrowserContext;
+  __walletExtensionIds: Map<string, string>;
+};
+interface ChromaTestOptions<T extends readonly WalletConfig[] = WalletConfig[]> {
+  wallets?: T;
+  headless?: boolean;
+  slowMo?: number;
+}
+interface WalletFixtures<W = Wallets> {
+  page: ExtendedPage;
+  wallets: W;
+}
+interface WalletWorkerFixtures {
+  walletContext: BrowserContext;
+  walletExtensionIds: Map<string, string>;
+}
 //#endregion
-//#region src/context-playwright/download-polkadot-js.d.ts
-declare function downloadAndExtractPolkadotExtension(targetDir?: string): Promise<string>;
+//#region src/context-playwright/index.d.ts
+declare function createWalletTest<const T extends readonly WalletConfig[]>(options?: ChromaTestOptions<T>): playwright_test0.TestType<playwright_test0.PlaywrightTestArgs & playwright_test0.PlaywrightTestOptions & WalletFixtures<T extends readonly WalletConfig[] ? ConfiguredWallets<T> : WalletTypeMap>, playwright_test0.PlaywrightWorkerArgs & playwright_test0.PlaywrightWorkerOptions & WalletWorkerFixtures>;
+declare const test: ReturnType<typeof createWalletTest>;
 //#endregion
-export { type BrowserContext, type ChromaTestOptions, type Page, type WalletAccount, type WalletConfig, type WalletFixtures, type WalletType, createWalletTest, downloadAndExtractPolkadotExtension, expect, test };
+export { createWalletTest, expect, test };

package/dist/index.js

@@ -1,140 +1,289 @@
 import { chromium, expect, test as test$1 } from "@playwright/test";
-import fs, { createWriteStream } from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
-import { pipeline } from "node:stream/promises";
-import { Extract } from "unzipper";
 
-//#region src/context-playwright/download-polkadot-js.ts
-const POLKADOT_JS_EXTENSION = "https://github.com/polkadot-js/extension/releases/download/v0.61.7/master-chrome-build.zip";
-async function downloadAndExtractPolkadotExtension(targetDir) {
-	const extensionsDir = targetDir || path.resolve(process.cwd(), ".chroma");
-	const extensionDir = path.join(extensionsDir, "polkadot-extension-chrome");
-	const zipPath = path.join(extensionsDir, "polkadot-extension.zip");
-	await fs.promises.mkdir(extensionsDir, { recursive: true });
-	if (fs.existsSync(extensionDir) && fs.readdirSync(extensionDir).length > 0) {
-		console.log("✅ Polkadot extension already exists at:", extensionDir);
-		return extensionDir;
+//#region src/wallets/polkadot-js.ts
+const POLKADOT_JS_CONFIG = {
+	downloadUrl: "https://github.com/polkadot-js/extension/releases/download/v0.61.7/master-chrome-build.zip",
+	extensionName: "polkadot-extension-0.61.7"
+};
+async function findExtensionPopup$1(context, extensionId) {
+	const pages = context.pages();
+	for (const p of pages) if (p.url().includes(`chrome-extension://${extensionId}/`)) return p;
+	throw new Error(`Extension popup not found for ID: ${extensionId}`);
+}
+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\nOr if you're using this as a dependency:\n  npm run chroma:download\n`);
+	console.log(`✅ Found Polkadot-JS extension at: ${extensionDir}`);
+	return extensionDir;
+}
+async function importPolkadotJSAccount(page, { seed, name = "Test Account", password = "h3llop0lkadot!" }) {
+	const context = page.__extensionContext;
+	const extensionPopupUrl = `chrome-extension://${page.__extensionId}/index.html`;
+	const extensionPage = await context.newPage();
+	try {
+		await extensionPage.goto(extensionPopupUrl);
+		const understoodButton = extensionPage.getByRole("button", { name: "Understood, let me continue" });
+		if (await understoodButton.count() > 0) {
+			await understoodButton.click();
+			await extensionPage.waitForTimeout(100);
+		}
+		await extensionPage.goto(`${extensionPopupUrl}#/account/import-seed`);
+		await extensionPage.locator("textarea").fill(seed);
+		await extensionPage.locator("button:has-text(\"Next\")").click();
+		await extensionPage.locator("input[type=\"text\"]").fill(name);
+		await extensionPage.locator("input[type=\"password\"]").fill(password);
+		await extensionPage.locator("div").filter({ hasText: /^Repeat password for verification$/ }).getByRole("textbox").fill(password);
+		await extensionPage.getByRole("button", { name: "Add the account with the supplied seed" }).click();
+		console.log(`✅ Created Polkadot-JS wallet account: ${name}`);
+	} finally {
+		await extensionPage.close();
+	}
+}
+async function authorizePolkadotJS(page) {
+	const context = page.__extensionContext;
+	const extensionId = page.__extensionId;
+	await new Promise((resolve) => setTimeout(resolve, 1e3));
+	const extensionPopup = await findExtensionPopup$1(context, extensionId);
+	await extensionPopup.getByText("Select all").click();
+	await extensionPopup.getByRole("button", { name: /Connect \d+ account\(s\)/ }).click();
+	console.log("✅ Polkadot-JS wallet connected successfully");
+}
+async function approvePolkadotJSTx(page, options = {}) {
+	const { password = "h3llop0lkadot!" } = options;
+	const context = page.__extensionContext;
+	const extensionId = page.__extensionId;
+	await new Promise((resolve) => setTimeout(resolve, 1e3));
+	const extensionPopup = await findExtensionPopup$1(context, extensionId);
+	await extensionPopup.getByRole("textbox").fill(password);
+	await extensionPopup.getByRole("button", { name: "Sign the transaction" }).click();
+	console.log("✅ Polkadot-JS transaction signed successfully");
+}
+
+//#endregion
+//#region src/wallets/talisman.ts
+const TALISMAN_CONFIG = {
+	downloadUrl: "https://github.com/avalix-labs/polkadot-wallets/raw/refs/heads/main/talisman/talisman-3.0.5.zip",
+	extensionName: "talisman-extension-3.0.5"
+};
+async function findExtensionPopup(context, extensionId) {
+	await new Promise((resolve) => setTimeout(resolve, 1e3));
+	const pages = context.pages();
+	for (const p of pages) if (p.url().includes(`chrome-extension://${extensionId}/`)) {
+		p.setViewportSize({
+			width: 400,
+			height: 600
+		});
+		p.waitForLoadState("domcontentloaded");
+		return p;
 	}
+	throw new Error(`Extension popup not found for ID: ${extensionId}`);
+}
+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\nOr if you're using this as a dependency:\n  npm run chroma:download\n`);
+	console.log(`✅ Found Talisman extension at: ${extensionDir}`);
+	return extensionDir;
+}
+async function importEthPrivateKey(page, { seed, name = "Test Account", password = "h3llop0lkadot!" }) {
+	const context = page.__extensionContext;
+	const extensionId = page.__extensionId;
+	await new Promise((resolve) => setTimeout(resolve, 2e3));
+	let extensionPage = null;
+	const pages = context.pages();
+	for (const page$1 of pages) {
+		const url = page$1.url();
+		console.log(`📄 Found page: ${url}`);
+		if (url.includes("onboarding.html") || url.includes(`chrome-extension://${extensionId}/`)) {
+			extensionPage = page$1;
+			console.log(`✅ Found Talisman onboarding page: ${url}`);
+			break;
+		}
+	}
+	if (!extensionPage) throw new Error(`Talisman onboarding page not found`);
 	try {
-		console.log("📥 Downloading Polkadot JS extension...");
-		const response = await fetch(POLKADOT_JS_EXTENSION);
-		if (!response.ok) throw new Error(`Failed to download extension: ${response.status} ${response.statusText}`);
-		const writeStream = createWriteStream(zipPath);
-		await pipeline(response.body, writeStream);
-		console.log("📦 Extracting extension...");
-		await pipeline(fs.createReadStream(zipPath), Extract({ path: extensionDir }));
-		await fs.promises.unlink(zipPath);
-		console.log("✅ Polkadot extension downloaded and extracted to:", extensionDir);
-		return extensionDir;
+		await extensionPage.bringToFront();
+		console.log("🔄 Reloading onboarding page for fresh state...");
+		await extensionPage.reload();
+		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 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();
+		await extensionPage.getByRole("option", { name: "Ethereum" }).locator("div").click();
+		await extensionPage.getByRole("textbox", { name: "Choose a name" }).fill(name);
+		await extensionPage.getByRole("textbox", { name: "Enter your private key" }).fill(seed);
+		await extensionPage.getByRole("button", { name: "Save" }).click();
+		await extensionPage.close();
+		console.log("✅ Talisman account import completed");
 	} catch (error) {
-		if (fs.existsSync(zipPath)) await fs.promises.unlink(zipPath).catch(() => {});
-		if (fs.existsSync(extensionDir)) await fs.promises.rmdir(extensionDir, { recursive: true }).catch(() => {});
-		throw new Error(`Failed to download/extract Polkadot extension: ${error instanceof Error ? error.message : String(error)}`);
+		console.error("❌ Error during Talisman account import:", error);
+		throw error;
+	}
+}
+async function authorizeTalisman(page, options = {}) {
+	const { accountName = "Test Account" } = options;
+	const context = page.__extensionContext;
+	const extensionId = page.__extensionId;
+	await new Promise((resolve) => setTimeout(resolve, 1e3));
+	const extensionPopup = await findExtensionPopup(context, extensionId);
+	await extensionPopup.getByRole("button", { name: accountName }).click();
+	await extensionPopup.getByTestId("connection-connect-button").click();
+	try {
+		await (await findExtensionPopup(context, extensionId)).getByRole("button", { name: "Approve" }).click();
+	} catch {
+		console.log("No another popup found, skipping");
 	}
 }
+async function approveTalismanTx(page) {
+	const context = page.__extensionContext;
+	const extensionId = page.__extensionId;
+	await new Promise((resolve) => setTimeout(resolve, 1e3));
+	await (await findExtensionPopup(context, extensionId)).getByRole("button", { name: "Approve" }).click();
+}
 
 //#endregion
-//#region src/context-playwright/index.ts
-const DEFAULT_WALLET_CONFIGS = {
-	"polkadot-js": { downloadUrl: "https://github.com/polkadot-js/extension/releases/download/v0.61.7/master-chrome-build.zip" },
-	"talisman": {}
-};
-async function getExtensionPath(walletType, walletConfig) {
-	const { customPath } = walletConfig;
-	if (customPath) return customPath;
+//#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) {
+	const extPage = page;
+	extPage.__extensionContext = context;
+	extPage.__extensionId = extensionId;
+	return extPage;
+}
+function createWalletInstance(walletType, extensionId, context) {
+	let importedAccountName;
+	const baseInstance = {
+		extensionId,
+		importMnemonic: async (options) => {
+			const page = context.pages()[0] || await context.newPage();
+			const extPage = createExtendedPage(page, 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}`);
+			}
+		},
+		authorize: async (options = {}) => {
+			const page = context.pages()[0] || await context.newPage();
+			const extPage = createExtendedPage(page, 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}`);
+			}
+		},
+		approveTx: async (options = {}) => {
+			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}`);
+			}
+		}
+	};
 	switch (walletType) {
-		case "polkadot-js": return await downloadAndExtractPolkadotExtension();
-		case "talisman": throw new Error("Talisman wallet download not implemented yet");
+		case "polkadot-js": return {
+			...baseInstance,
+			type: "polkadot-js"
+		};
+		case "talisman": return {
+			...baseInstance,
+			type: "talisman",
+			importEthPrivateKey: async (options) => {
+				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
+				});
+			}
+		};
 		default: throw new Error(`Unsupported wallet type: ${walletType}`);
 	}
 }
-async function findExtensionPopup(context, extensionId) {
-	const pages = context.pages();
-	for (const p of pages) if (p.url().includes(`chrome-extension://${extensionId}/`)) return p;
-	throw new Error(`Extension popup not found for ID: ${extensionId}`);
+
+//#endregion
+//#region src/context-playwright/index.ts
+async function getExtensionPathForWallet(config) {
+	const { type } = config;
+	switch (type) {
+		case "polkadot-js": return await getPolkadotJSExtensionPath();
+		case "talisman": return await getTalismanExtensionPath();
+		default: throw new Error(`Unsupported wallet type: ${type}`);
+	}
 }
 function createWalletTest(options = {}) {
-	const { walletType = "polkadot-js", walletConfig, headless = false, slowMo = 150 } = options;
-	const finalWalletConfig = walletConfig || DEFAULT_WALLET_CONFIGS[walletType];
+	const { headless = false, slowMo = 150 } = options;
+	const walletConfigs = options.wallets && options.wallets.length > 0 ? options.wallets : [{ type: "polkadot-js" }];
+	const isMultiWallet = walletConfigs.length > 1;
 	return test$1.extend({
-		walletType: async ({}, use) => {
-			await use(walletType);
-		},
-		walletConfig: async ({}, use) => {
-			await use(finalWalletConfig);
-		},
-		page: async ({}, use) => {
-			const extensionPath = await getExtensionPath(walletType, finalWalletConfig);
+		walletContext: [async ({}, use) => {
+			const extensionPathsString = (await Promise.all(walletConfigs.map((config) => getExtensionPathForWallet(config)))).join(",");
 			const context = await chromium.launchPersistentContext("", {
 				headless,
 				channel: "chromium",
-				args: [`--load-extension=${extensionPath}`, `--disable-extensions-except=${extensionPath}`],
+				args: [`--load-extension=${extensionPathsString}`, `--disable-extensions-except=${extensionPathsString}`],
 				slowMo
 			});
-			const page = context.pages()[0] || await context.newPage();
-			const extendedPage = page;
-			extendedPage.__extensionContext = context;
-			let [background] = context.serviceWorkers();
-			if (!background) background = await context.waitForEvent("serviceworker");
-			extendedPage.__extensionId = background.url().split("/")[2];
-			await use(page);
+			await use(context);
 			await context.close();
+		}, { scope: "worker" }],
+		walletExtensionIds: [async ({ walletContext }, use) => {
+			const extensionIds = /* @__PURE__ */ new Map();
+			if (walletContext.serviceWorkers().length === 0) await walletContext.waitForEvent("serviceworker");
+			if (isMultiWallet) await new Promise((resolve) => setTimeout(resolve, 1e3));
+			const allServiceWorkers = walletContext.serviceWorkers();
+			for (let i = 0; i < walletConfigs.length && i < allServiceWorkers.length; i++) {
+				const extensionId = allServiceWorkers[i].url().split("/")[2];
+				const walletType = walletConfigs[i].type;
+				extensionIds.set(walletType, extensionId);
+				console.log(`✅ Loaded ${walletType} extension with ID: ${extensionId}`);
+			}
+			await use(extensionIds);
+		}, { scope: "worker" }],
+		page: async ({ walletContext, walletExtensionIds }, use) => {
+			const extendedPage = walletContext.pages()[0] || await walletContext.newPage();
+			extendedPage.__extensionContext = walletContext;
+			extendedPage.__walletExtensionIds = walletExtensionIds;
+			await use(extendedPage);
 		},
-		importAccount: async ({ page }, use) => {
-			const importAccount = async ({ seed, name = "Test Account", password = "h3llop0lkadot!" }) => {
-				const context = page.__extensionContext;
-				const extensionPopupUrl = `chrome-extension://${page.__extensionId}/index.html`;
-				const extensionPage = await context.newPage();
-				try {
-					await extensionPage.goto(extensionPopupUrl);
-					const understoodButton = extensionPage.getByRole("button", { name: "Understood, let me continue" });
-					if (await understoodButton.count() > 0) {
-						await understoodButton.click();
-						await extensionPage.waitForTimeout(100);
-					}
-					await extensionPage.goto(`${extensionPopupUrl}#/account/import-seed`);
-					await extensionPage.locator("textarea").fill(seed);
-					await extensionPage.locator("button:has-text(\"Next\")").click();
-					await extensionPage.locator("input[type=\"text\"]").fill(name);
-					await extensionPage.locator("input[type=\"password\"]").fill(password);
-					await extensionPage.locator("div").filter({ hasText: /^Repeat password for verification$/ }).getByRole("textbox").fill(password);
-					await extensionPage.getByRole("button", { name: "Add the account with the supplied seed" }).click();
-					console.log(`✅ Created wallet account: ${name}`);
-				} finally {
-					await extensionPage.close();
-				}
-			};
-			await use(importAccount);
-		},
-		authorize: async ({ page }, use) => {
-			const authorize = async () => {
-				const context = page.__extensionContext;
-				const extensionId = page.__extensionId;
-				await new Promise((resolve) => setTimeout(resolve, 1e3));
-				const extensionPopup = await findExtensionPopup(context, extensionId);
-				await extensionPopup.getByText("Select all").click();
-				await extensionPopup.getByRole("button", { name: /Connect \d+ account\(s\)/ }).click();
-				console.log("✅ Wallet connected successfully");
-			};
-			await use(authorize);
-		},
-		approveTx: async ({ page }, use) => {
-			const approveTx = async (options$1 = {}) => {
-				const { password = "h3llop0lkadot!" } = options$1;
-				const context = page.__extensionContext;
-				const extensionId = page.__extensionId;
-				await new Promise((resolve) => setTimeout(resolve, 1e3));
-				const extensionPopup = await findExtensionPopup(context, extensionId);
-				await extensionPopup.getByRole("textbox").fill(password);
-				await extensionPopup.getByRole("button", { name: "Sign the transaction" }).click();
-				console.log("✅ Transaction signed successfully");
-			};
-			await use(approveTx);
+		wallets: async ({ walletContext, walletExtensionIds }, use) => {
+			const walletMap = {};
+			for (const [walletType, extensionId] of walletExtensionIds) if (WALLET_TYPES.includes(walletType)) walletMap[walletType] = createWalletInstance(walletType, extensionId, walletContext);
+			await use(walletMap);
 		}
 	});
 }
 const test = createWalletTest();
 
 //#endregion
-export { createWalletTest, downloadAndExtractPolkadotExtension, expect, test };
+export { createWalletTest, expect, test };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@avalix/chroma",
   "type": "module",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "End-to-end testing library for Polkadot wallet interactions",
   "author": "Avalix Labs",
   "license": "MIT",
@@ -30,14 +30,19 @@
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "bin": {
+    "chroma": "./scripts/cli.js"
+  },
   "files": [
-    "dist"
+    "dist",
+    "scripts"
   ],
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
     "lint": "eslint --fix .",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "download-extensions": "rm -rf .chroma && tsx scripts/download-extensions.ts"
   },
   "peerDependencies": {
     "@playwright/test": "^1.55.0"
@@ -51,7 +56,8 @@
     "@types/node": "^24.3.3",
     "@types/unzipper": "^0.10.10",
     "eslint": "^9.35.0",
-    "tsdown": "latest"
+    "tsdown": "latest",
+    "tsx": "^4.20.6"
   },
   "publishConfig": {
     "access": "public"

package/scripts/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import process from 'node:process'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+const command = process.argv[2]
+
+if (command === 'download-extensions') {
+  const scriptPath = path.join(__dirname, 'download-extensions.ts')
+
+  // Use tsx to run TypeScript file
+  const child = spawn('npx', ['tsx', scriptPath], {
+    stdio: 'inherit',
+    shell: true,
+  })
+
+  child.on('exit', (code) => {
+    process.exit(code || 0)
+  })
+}
+else {
+  console.log('Unknown command:', command)
+  console.log('\nAvailable commands:')
+  console.log('  download-extensions - Download wallet extensions for testing')
+  process.exit(1)
+}

package/scripts/download-extensions.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import process from 'node:process'
+import { downloadAndExtractExtension } from '../src/utils/download-extension.js'
+import { POLKADOT_JS_CONFIG } from '../src/wallets/polkadot-js.js'
+import { TALISMAN_CONFIG } from '../src/wallets/talisman.js'
+
+async function main() {
+  console.log('🚀 Downloading Chroma wallet extensions...\n')
+
+  try {
+    // Download Polkadot-JS extension
+    await downloadAndExtractExtension({
+      downloadUrl: POLKADOT_JS_CONFIG.downloadUrl,
+      extensionName: POLKADOT_JS_CONFIG.extensionName,
+    })
+
+    // Download Talisman extension
+    await downloadAndExtractExtension({
+      downloadUrl: TALISMAN_CONFIG.downloadUrl,
+      extensionName: TALISMAN_CONFIG.extensionName,
+    })
+
+    console.log('\n✅ All extensions downloaded successfully!')
+    console.log('You can now run your Playwright tests.')
+  }
+  catch (error) {
+    console.error('\n❌ Failed to download extensions:', error instanceof Error ? error.message : String(error))
+    process.exit(1)
+  }
+}
+
+main()