@avalix/chroma 0.0.10 → 0.0.12

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.10",
+  "version": "0.0.12",
   "description": "End-to-end testing library for Polkadot wallet interactions",
   "author": "Avalix Labs",
   "license": "MIT",
@@ -44,7 +44,11 @@
     "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"
   },
   "peerDependencies": {
     "@playwright/test": "^1.57.0"
@@ -58,8 +62,9 @@
     "@types/node": "^24.10.2",
     "@types/unzipper": "^0.10.11",
     "eslint": "^9.39.1",
-    "tsdown": "latest",
-    "tsx": "^4.21.0"
+    "tsdown": "^0.20.1",
+    "tsx": "^4.21.0",
+    "vitest": "^4.0.18"
   },
   "publishConfig": {
     "access": "public"

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