@avalix/chroma 0.0.12 → 0.0.14

package/README.md

@@ -2,6 +2,10 @@
 
 End-to-end testing library for Polkadot wallet interactions using Playwright.
 
+## Documentation
+
+We highly recommend you take a look at the [Chroma documentation](https://chroma-docs.up.railway.app/docs) to level up. It's a great resource for learning more about the library. It covers everything from getting started to advanced topics like CI/CD integration and Docker setup.
+
 ## Installation
 
 ```bash
@@ -82,14 +86,9 @@ test('multi-wallet test', async ({ page, wallets }) => {
 })
 ```
 
-## Features
-
-- **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 Wallets & Chains
 
-## Supported Chains
+### Supported Chains
 
 | Chain | Status |
 |-------|--------|
@@ -97,7 +96,7 @@ test('multi-wallet test', async ({ page, wallets }) => {
 | Ethereum | ✅ Supported |
 | Solana | ⏳ Planned |
 
-## Supported Wallets
+### Supported Wallets
 
 | Wallet | Status | Version |
 |--------|--------|---------|
@@ -106,6 +105,13 @@ test('multi-wallet test', async ({ page, wallets }) => {
 | SubWallet | ⏳ Planned | - |
 | MetaMask | ⏳ Planned | - |
 
+## Features
+
+- **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)
+
 ## Requirements
 
 - Node.js 24+

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,12 +102,14 @@ 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;
 }
+/* c8 ignore start */
 async function findOnboardingPage(context, extensionId) {
 	const popupUrl = `chrome-extension://${extensionId}/dashboard.html`;
 	const newPage = await context.newPage();
@@ -199,17 +206,21 @@ async function rejectTalismanTx(page) {
 	const context = page.__extensionContext;
 	const extensionId = page.__extensionId;
 	const extensionPopup = await findExtensionPopup(context, extensionId);
-	await extensionPopup.getByTestId("connection-reject-button").or(extensionPopup.getByRole("button", { name: "Cancel" })).click();
+	await extensionPopup.getByTestId("connection-reject-button").or(extensionPopup.getByRole("button", { name: "Cancel" })).or(extensionPopup.getByRole("button", { name: "Reject" })).click();
 }
+/* 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;
 }
+/* c8 ignore stop */
+/* c8 ignore start */
 function createPolkadotJsWallet(extensionId, context) {
 	return {
 		extensionId,
@@ -228,6 +239,8 @@ function createPolkadotJsWallet(extensionId, context) {
 		}
 	};
 }
+/* c8 ignore stop */
+/* c8 ignore start */
 function createTalismanWallet(extensionId, context) {
 	let importedAccountName;
 	return {
@@ -258,6 +271,7 @@ function createTalismanWallet(extensionId, context) {
 		}
 	};
 }
+/* c8 ignore stop */
 const walletFactories = {
 	"polkadot-js": createPolkadotJsWallet,
 	"talisman": createTalismanWallet
@@ -277,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(",");
@@ -316,6 +331,7 @@ function createWalletTest(options = {}) {
 			await use(walletMap);
 		}
 	});
+	/* c8 ignore stop */
 }
 const test = createWalletTest();
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@avalix/chroma",
   "type": "module",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "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",
@@ -61,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/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

@@ -13,7 +13,7 @@ import { getTalismanExtensionPath } from '../wallets/talisman.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) {
@@ -43,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
@@ -127,6 +136,7 @@ export function createWalletTest<const T extends readonly WalletConfig[]>(
       await use(walletMap)
     },
   })
+  /* c8 ignore stop */
 }
 
 // Default test with Polkadot JS wallet (with persistent wallet support via worker-scoped fixtures)

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

@@ -0,0 +1,106 @@
+import type { BrowserContext, Page } from '@playwright/test'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  createPolkadotJsWallet,
+  createTalismanWallet,
+  walletFactories,
+} from './wallet-factory.js'
+
+// Mock wallet implementations
+vi.mock('../wallets/polkadot-js.js', () => ({
+  importPolkadotJSAccount: vi.fn(),
+  authorizePolkadotJS: vi.fn(),
+  approvePolkadotJSTx: vi.fn(),
+  rejectPolkadotJSTx: vi.fn(),
+}))
+
+vi.mock('../wallets/talisman.js', () => ({
+  importPolkadotMnemonic: vi.fn(),
+  importEthPrivateKey: vi.fn(),
+  authorizeTalisman: vi.fn(),
+  approveTalismanTx: vi.fn(),
+  rejectTalismanTx: vi.fn(),
+}))
+
+// Create mock browser context
+function createMockContext(): BrowserContext {
+  const mockPage = {
+    url: () => 'https://example.com',
+    __extensionContext: null,
+    __extensionId: '',
+  } as unknown as Page
+
+  return {
+    pages: vi.fn().mockReturnValue([mockPage]),
+    newPage: vi.fn().mockResolvedValue(mockPage),
+  } as unknown as BrowserContext
+}
+
+describe('wallet-factory', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('walletFactories', () => {
+    it('should have polkadot-js factory', () => {
+      expect(walletFactories['polkadot-js']).toBeDefined()
+      expect(typeof walletFactories['polkadot-js']).toBe('function')
+    })
+
+    it('should have talisman factory', () => {
+      expect(walletFactories.talisman).toBeDefined()
+      expect(typeof walletFactories.talisman).toBe('function')
+    })
+  })
+
+  describe('createPolkadotJsWallet', () => {
+    const extensionId = 'test-extension-id'
+    let mockContext: BrowserContext
+
+    beforeEach(() => {
+      mockContext = createMockContext()
+    })
+
+    it('should create wallet with correct type and extensionId', () => {
+      const wallet = createPolkadotJsWallet(extensionId, mockContext)
+
+      expect(wallet.type).toBe('polkadot-js')
+      expect(wallet.extensionId).toBe(extensionId)
+    })
+
+    it('should have all required methods', () => {
+      const wallet = createPolkadotJsWallet(extensionId, mockContext)
+
+      expect(typeof wallet.importMnemonic).toBe('function')
+      expect(typeof wallet.authorize).toBe('function')
+      expect(typeof wallet.approveTx).toBe('function')
+      expect(typeof wallet.rejectTx).toBe('function')
+    })
+  })
+
+  describe('createTalismanWallet', () => {
+    const extensionId = 'test-extension-id'
+    let mockContext: BrowserContext
+
+    beforeEach(() => {
+      mockContext = createMockContext()
+    })
+
+    it('should create wallet with correct type and extensionId', () => {
+      const wallet = createTalismanWallet(extensionId, mockContext)
+
+      expect(wallet.type).toBe('talisman')
+      expect(wallet.extensionId).toBe(extensionId)
+    })
+
+    it('should have all required methods', () => {
+      const wallet = createTalismanWallet(extensionId, mockContext)
+
+      expect(typeof wallet.importPolkadotMnemonic).toBe('function')
+      expect(typeof wallet.importEthPrivateKey).toBe('function')
+      expect(typeof wallet.authorize).toBe('function')
+      expect(typeof wallet.approveTx).toBe('function')
+      expect(typeof wallet.rejectTx).toBe('function')
+    })
+  })
+})

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

@@ -15,14 +15,20 @@ import {
 } from '../wallets/talisman.js'
 
 // Helper to create extended page with wallet context
+/* c8 ignore start */
 function createExtendedPage(page: Page, context: BrowserContext, extensionId: string) {
   const extPage = page as Page & { __extensionContext: BrowserContext, __extensionId: string }
   extPage.__extensionContext = context
   extPage.__extensionId = extensionId
   return extPage
 }
+/* c8 ignore stop */
 
-// Factory function for Polkadot-JS wallet
+/*
+ * Factory function for Polkadot-JS wallet
+ * Coverage excluded: methods interact with Chrome extension APIs via browser context.
+ */
+/* c8 ignore start */
 export function createPolkadotJsWallet(extensionId: string, context: BrowserContext) {
   return {
     extensionId,
@@ -49,8 +55,13 @@ export function createPolkadotJsWallet(extensionId: string, context: BrowserCont
     },
   }
 }
+/* c8 ignore stop */
 
-// Factory function for Talisman wallet
+/*
+ * Factory function for Talisman wallet
+ * Coverage excluded: methods interact with Chrome extension APIs via browser context.
+ */
+/* c8 ignore start */
 export function createTalismanWallet(extensionId: string, context: BrowserContext) {
   let importedAccountName: string | undefined
 
@@ -91,6 +102,7 @@ export function createTalismanWallet(extensionId: string, context: BrowserContex
     },
   }
 }
+/* c8 ignore stop */
 
 // Wallet factories map - auto-inferred types
 export const walletFactories = {

package/src/index.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it, vi } from 'vitest'
+
+// Mock playwright before importing
+vi.mock('@playwright/test', () => ({
+  test: {
+    extend: vi.fn().mockReturnValue({}),
+  },
+  chromium: {
+    launchPersistentContext: vi.fn(),
+  },
+  expect: vi.fn(),
+}))
+
+vi.mock('./wallets/polkadot-js.js', () => ({
+  getPolkadotJSExtensionPath: vi.fn().mockResolvedValue('/mock/path'),
+}))
+
+vi.mock('./wallets/talisman.js', () => ({
+  getTalismanExtensionPath: vi.fn().mockResolvedValue('/mock/path'),
+}))
+
+vi.mock('./context-playwright/wallet-factory.js', () => ({
+  walletFactories: {
+    'polkadot-js': vi.fn(),
+    'talisman': vi.fn(),
+  },
+}))
+
+describe('index exports', () => {
+  it('should export createWalletTest function', async () => {
+    const { createWalletTest } = await import('./index.js')
+    expect(createWalletTest).toBeDefined()
+    expect(typeof createWalletTest).toBe('function')
+  })
+
+  it('should export test function', async () => {
+    const { test } = await import('./index.js')
+    expect(test).toBeDefined()
+  })
+
+  it('should export expect function', async () => {
+    const { expect: playwrightExpect } = await import('./index.js')
+    expect(playwrightExpect).toBeDefined()
+  })
+
+  it('should be able to call createWalletTest', async () => {
+    const { createWalletTest } = await import('./index.js')
+    const result = createWalletTest()
+    expect(result).toBeDefined()
+  })
+
+  it('should be able to call createWalletTest with options', async () => {
+    const { createWalletTest } = await import('./index.js')
+    const result = createWalletTest({ headless: true })
+    expect(result).toBeDefined()
+  })
+})

package/src/wallets/polkadot-js.test.ts

@@ -0,0 +1,97 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  getPolkadotJSExtensionPath,
+  POLKADOT_JS_CONFIG,
+} from './polkadot-js.js'
+
+// Mock node:fs module
+vi.mock('node:fs', async () => {
+  const actual = await vi.importActual<typeof import('node:fs')>('node:fs')
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      existsSync: vi.fn(),
+      readdirSync: vi.fn(),
+    },
+    existsSync: vi.fn(),
+    readdirSync: vi.fn(),
+  }
+})
+
+describe('polkadot-js wallet', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('polkadot_js_config', () => {
+    it('should have correct extension name format', () => {
+      expect(POLKADOT_JS_CONFIG.extensionName).toMatch(/^polkadot-extension-\d+\.\d+\.\d+$/)
+    })
+
+    it('should have valid download URL', () => {
+      expect(POLKADOT_JS_CONFIG.downloadUrl).toContain('github.com')
+      expect(POLKADOT_JS_CONFIG.downloadUrl).toContain('polkadot-js/extension')
+      expect(POLKADOT_JS_CONFIG.downloadUrl.endsWith('.zip')).toBe(true)
+    })
+  })
+
+  describe('getPolkadotJSExtensionPath', () => {
+    it('should return extension path when extension exists', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await getPolkadotJSExtensionPath()
+
+      expect(result).toContain('.chroma')
+      expect(result).toContain(POLKADOT_JS_CONFIG.extensionName)
+      expect(mockedFs.existsSync).toHaveBeenCalled()
+    })
+
+    it('should throw error when extension directory does not exist', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(false)
+
+      await expect(getPolkadotJSExtensionPath()).rejects.toThrow(
+        'Polkadot-JS extension not found',
+      )
+    })
+
+    it('should throw error when extension directory is empty', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue([])
+
+      await expect(getPolkadotJSExtensionPath()).rejects.toThrow(
+        'Polkadot-JS extension not found',
+      )
+    })
+
+    it('should include download instructions in error message', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(false)
+
+      await expect(getPolkadotJSExtensionPath()).rejects.toThrow(
+        'npx @avalix/chroma download-extensions',
+      )
+    })
+
+    it('should use correct path structure', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await getPolkadotJSExtensionPath()
+
+      const expectedPath = path.join(process.cwd(), '.chroma', POLKADOT_JS_CONFIG.extensionName)
+      expect(result).toBe(expectedPath)
+    })
+  })
+})

package/src/wallets/polkadot-js.ts

@@ -12,7 +12,11 @@ export const POLKADOT_JS_CONFIG = {
   extensionName: `polkadot-extension-${VERSION}`,
 } as const
 
-// Helper function to find extension popup
+/*
+ * Helper function to find extension popup
+ * Coverage excluded: requires real browser context with Chrome extension APIs.
+ */
+/* c8 ignore start */
 async function findExtensionPopup(context: BrowserContext, extensionId: string): Promise<Page> {
   // Wait for extension popup to appear with retry logic
   const maxAttempts = 10
@@ -35,6 +39,7 @@ async function findExtensionPopup(context: BrowserContext, extensionId: string):
 
   throw new Error(`Extension popup not found for ID: ${extensionId}`)
 }
+/* c8 ignore stop */
 
 // Get Polkadot-JS extension path
 export async function getPolkadotJSExtensionPath(): Promise<string> {
@@ -53,6 +58,13 @@ export async function getPolkadotJSExtensionPath(): Promise<string> {
   return extensionDir
 }
 
+/*
+ * Wallet interaction functions below are excluded from coverage because:
+ * - They require a real Chromium browser with extension support
+ * - They interact with Chrome extension popup pages
+ */
+/* c8 ignore start */
+
 // Polkadot-JS specific account import implementation
 export async function importPolkadotJSAccount(
   page: Page & { __extensionContext: BrowserContext, __extensionId: string },
@@ -142,3 +154,5 @@ export async function rejectPolkadotJSTx(
   const extensionPopup = await findExtensionPopup(context, extensionId)
   await extensionPopup.getByRole('link', { name: 'Cancel' }).click()
 }
+
+/* c8 ignore stop */

package/src/wallets/talisman.test.ts

@@ -0,0 +1,97 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  getTalismanExtensionPath,
+  TALISMAN_CONFIG,
+} from './talisman.js'
+
+// Mock node:fs module
+vi.mock('node:fs', async () => {
+  const actual = await vi.importActual<typeof import('node:fs')>('node:fs')
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      existsSync: vi.fn(),
+      readdirSync: vi.fn(),
+    },
+    existsSync: vi.fn(),
+    readdirSync: vi.fn(),
+  }
+})
+
+describe('talisman wallet', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('talisman_config', () => {
+    it('should have correct extension name format', () => {
+      expect(TALISMAN_CONFIG.extensionName).toMatch(/^talisman-extension-\d+\.\d+\.\d+$/)
+    })
+
+    it('should have valid download URL', () => {
+      expect(TALISMAN_CONFIG.downloadUrl).toContain('github.com')
+      expect(TALISMAN_CONFIG.downloadUrl).toContain('talisman')
+      expect(TALISMAN_CONFIG.downloadUrl.endsWith('.zip')).toBe(true)
+    })
+  })
+
+  describe('getTalismanExtensionPath', () => {
+    it('should return extension path when extension exists', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await getTalismanExtensionPath()
+
+      expect(result).toContain('.chroma')
+      expect(result).toContain(TALISMAN_CONFIG.extensionName)
+      expect(mockedFs.existsSync).toHaveBeenCalled()
+    })
+
+    it('should throw error when extension directory does not exist', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(false)
+
+      await expect(getTalismanExtensionPath()).rejects.toThrow(
+        'Talisman extension not found',
+      )
+    })
+
+    it('should throw error when extension directory is empty', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue([])
+
+      await expect(getTalismanExtensionPath()).rejects.toThrow(
+        'Talisman extension not found',
+      )
+    })
+
+    it('should include download instructions in error message', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(false)
+
+      await expect(getTalismanExtensionPath()).rejects.toThrow(
+        'npx @avalix/chroma download-extensions',
+      )
+    })
+
+    it('should use correct path structure', async () => {
+      const mockedFs = vi.mocked(fs)
+      mockedFs.existsSync.mockReturnValue(true)
+      mockedFs.readdirSync.mockReturnValue(['manifest.json'] as any)
+
+      const result = await getTalismanExtensionPath()
+
+      const expectedPath = path.join(process.cwd(), '.chroma', TALISMAN_CONFIG.extensionName)
+      expect(result).toBe(expectedPath)
+    })
+  })
+})

package/src/wallets/talisman.ts

@@ -12,7 +12,11 @@ export const TALISMAN_CONFIG = {
   extensionName: `talisman-extension-${VERSION}`,
 } as const
 
-// Helper function to find extension popup
+/*
+ * Helper function to find extension popup
+ * Coverage excluded: requires real browser context with Chrome extension APIs.
+ */
+/* c8 ignore start */
 async function findExtensionPopup(context: BrowserContext, extensionId: string): Promise<Page> {
   // Wait for extension popup to appear with retry logic
   const maxAttempts = 10
@@ -36,6 +40,7 @@ async function findExtensionPopup(context: BrowserContext, extensionId: string):
 
   throw new Error(`Extension popup not found for ID: ${extensionId}`)
 }
+/* c8 ignore stop */
 
 // Get Talisman extension path
 export async function getTalismanExtensionPath(): Promise<string> {
@@ -54,6 +59,13 @@ export async function getTalismanExtensionPath(): Promise<string> {
   return extensionDir
 }
 
+/*
+ * Wallet interaction functions below are excluded from coverage because:
+ * - They require a real Chromium browser with extension support
+ * - They interact with Chrome extension popup pages
+ */
+/* c8 ignore start */
+
 // Helper function to find Talisman onboarding page
 async function findOnboardingPage(
   context: BrowserContext,
@@ -232,6 +244,9 @@ export async function rejectTalismanTx(
 
   const rejectButton = extensionPopup.getByTestId('connection-reject-button')
     .or(extensionPopup.getByRole('button', { name: 'Cancel' }))
+    .or(extensionPopup.getByRole('button', { name: 'Reject' }))
 
   await rejectButton.click()
 }
+
+/* c8 ignore stop */