@solana/connector 0.1.9 → 0.2.0

package/dist/{chunk-MAXA3HEP.mjs → chunk-IDTUFDNB.mjs}

@@ -1,11 +1,55 @@
-import { createLogger, getPublicSolanaRpcUrl, getExplorerLink, __publicField, tryCatchSync, TransactionError, isWeb3jsTransaction, Errors, prepareTransactionForWallet, convertSignedTransaction, ValidationError, isConnectorError } from './chunk-J7DHGLW6.mjs';
-import { Component, useTransition, useState, useCallback, useMemo } from 'react';
-import { jsx, jsxs } from 'react/jsx-runtime';
+import { tryCatchSync, isWeb3jsTransaction, prepareTransactionForWallet, convertSignedTransaction } from './chunk-HO6QNKFM.mjs';
+import { createLogger, getPublicSolanaRpcUrl, getExplorerLink, __publicField, TransactionError, Errors, ValidationError } from './chunk-ZZTY3O4N.mjs';
 import { install } from '@solana/webcrypto-ed25519-polyfill';
-import { address, isAddress } from '@solana/addresses';
+import { Storage, createSolanaMainnet, createSolanaDevnet, createSolanaTestnet, createSolanaLocalnet } from '@wallet-ui/core';
+import { isAddress, address } from '@solana/addresses';
+import { z } from 'zod/v4';
 import { getBase58Decoder } from '@solana/codecs';
 import { getTransactionDecoder, assertIsTransactionWithinSizeLimit } from '@solana/transactions';
 
+// src/types/session.ts
+function createConnectorId(walletName) {
+  return `wallet-standard:${walletName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")}`;
+}
+function isWalletConnectorId(value) {
+  return typeof value == "string" && (value.startsWith("wallet-standard:") || value === "walletconnect" || value.startsWith("mwa:"));
+}
+function getWalletNameFromConnectorId(connectorId) {
+  return connectorId === "walletconnect" ? "WalletConnect" : connectorId.startsWith("mwa:") ? connectorId.slice(4) : connectorId.startsWith("wallet-standard:") ? connectorId.slice(16).split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ") : connectorId;
+}
+function isDisconnected(status) {
+  return status.status === "disconnected";
+}
+function isConnecting(status) {
+  return status.status === "connecting";
+}
+function isConnected(status) {
+  return status.status === "connected";
+}
+function isStatusError(status) {
+  return status.status === "error";
+}
+var isWalletStatusError = isStatusError, INITIAL_WALLET_STATUS = {
+  status: "disconnected"
+};
+function toLegacyWalletState(wallet) {
+  switch (wallet.status) {
+    case "disconnected":
+      return { connected: false, connecting: false, selectedAccount: null, accounts: [] };
+    case "connecting":
+      return { connected: false, connecting: true, selectedAccount: null, accounts: [] };
+    case "connected":
+      return {
+        connected: true,
+        connecting: false,
+        selectedAccount: wallet.session.selectedAccount.address,
+        accounts: wallet.session.accounts.map((a) => ({ address: a.address, label: a.label }))
+      };
+    case "error":
+      return { connected: false, connecting: false, selectedAccount: null, accounts: [] };
+  }
+}
+
 // src/lib/wallet/standard-shim.ts
 var registry = null, registryInitPromise = null, registryInitResolve = null, ready = new Promise((resolve, reject) => {
   if (typeof window > "u") {
@@ -620,8 +664,43 @@ var logger2 = createLogger("WalletAuthenticity"), WalletAuthenticityVerifier = c
   }
 };
 
+// src/lib/wallet/wallet-icon-overrides.ts
+var PHANTOM_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjI0IiBoZWlnaHQ9IjI0IiBmaWxsPSIjOTc4NkU0Ii8+CjxnIGNsaXAtcGF0aD0idXJsKCNjbGlwMF80NF82MTApIj4KPHBhdGggZD0iTTUuNzY1NSAxNS43OTdDNS43NjU1IDE3LjIyMiA2LjQ5ODc5IDE3LjU1IDcuMjYxNDEgMTcuNTVDOC44NzQ2MyAxNy41NSAxMC4wODcgMTYuMDg0MSAxMC44MTA1IDE0LjkyNTZDMTAuNzIyNSAxNS4xODE5IDEwLjY3MzYgMTUuNDM4MiAxMC42NzM2IDE1LjY4NDJDMTAuNjczNiAxNi4zNjA5IDExLjA0NTIgMTYuODQyNyAxMS43Nzg1IDE2Ljg0MjdDMTIuNzg1NSAxNi44NDI3IDEzLjg2MSAxNS45MiAxNC40MTgzIDE0LjkyNTZDMTQuMzc5MiAxNS4wNjkyIDE0LjM1OTYgMTUuMjAyNCAxNC4zNTk2IDE1LjMyNTRDMTQuMzU5NiAxNS43OTcgMTQuNjEzOCAxNi4wOTQzIDE1LjEzMiAxNi4wOTQzQzE2Ljc2NDggMTYuMDk0MyAxOC40MDc0IDEzLjA3MDEgMTguNDA3NCAxMC40MjUyQzE4LjQwNzQgOC4zNjQ1OSAxNy40MTAxIDYuNTUwMDUgMTQuOTA3MSA2LjU1MDA1QzEwLjUwNzQgNi41NTAwNSA1Ljc2NTUgMTIuMTY3OSA1Ljc2NTUgMTUuNzk3Wk0xMy4zOTE3IDEwLjE5OTZDMTMuMzkxNyA5LjY4NzA1IDEzLjY2NTQgOS4zMjgyNSAxNC4wNjYzIDkuMzI4MjVDMTQuNDU3NCA5LjMyODI1IDE0LjczMTIgOS42ODcwNSAxNC43MzEyIDEwLjE5OTZDMTQuNzMxMiAxMC43MTIyIDE0LjQ1NzQgMTEuMDgxMyAxNC4wNjYzIDExLjA4MTNDMTMuNjY1NCAxMS4wODEzIDEzLjM5MTcgMTAuNzEyMiAxMy4zOTE3IDEwLjE5OTZaTTE1LjQ4NCAxMC4xOTk2QzE1LjQ4NCA5LjY4NzA1IDE1Ljc1NzggOS4zMjgyNSAxNi4xNTg2IDkuMzI4MjVDMTYuNTQ5NyA5LjMyODI1IDE2LjgyMzUgOS42ODcwNSAxNi44MjM1IDEwLjE5OTZDMTYuODIzNSAxMC43MTIyIDE2LjU0OTcgMTEuMDgxMyAxNi4xNTg2IDExLjA4MTNDMTUuNzU3OCAxMS4wODEzIDE1LjQ4NCAxMC43MTIyIDE1LjQ4NCAxMC4xOTk2WiIgZmlsbD0iI0ZFRkRGOCIvPgo8L2c+CjxkZWZzPgo8Y2xpcFBhdGggaWQ9ImNsaXAwXzQ0XzYxMCI+CjxyZWN0IHdpZHRoPSIxMi43NiIgaGVpZ2h0PSIxMSIgZmlsbD0id2hpdGUiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDUuNzA2NDIgNi41NDk5MykiLz4KPC9jbGlwUGF0aD4KPC9kZWZzPgo8L3N2Zz4=", SOLFLARE_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjI0IiBoZWlnaHQ9IjI0IiBmaWxsPSIjRkZFRjQ2Ii8+CjxwYXRoIGQ9Ik0xMi4xMjg1IDEyLjUyNjZMMTIuOTU1NiAxMS43Mjc2TDE0LjQ5NzYgMTIuMjMyM0MxNS41MDcgMTIuNTY4NyAxNi4wMTE3IDEzLjE4NTUgMTYuMDExNyAxNC4wNTQ3QzE2LjAxMTcgMTQuNzEzNiAxNS43NTkzIDE1LjE0ODIgMTUuMjU0NyAxNS43MDg5TDE1LjEwMDUgMTUuODc3MUwxNS4xNTY1IDE1LjQ4NDZDMTUuMzgwOCAxNC4wNTQ3IDE0Ljk2MDMgMTMuNDM3OSAxMy41NzI0IDEyLjk4OTJMMTIuMTI4NSAxMi41MjY2Wk0xMC4wNTM3IDcuNjM0MTRMMTQuMjU5MyA5LjAzNkwxMy4zNDgxIDkuOTA1MTdMMTEuMTYxMiA5LjE3NjE5QzEwLjQwNDIgOC45MjM4NSAxMC4xNTE4IDguNTE3MzEgMTAuMDUzNyA3LjY2MjE3VjcuNjM0MTRaTTkuODAxMzUgMTQuNzU1NkwxMC43NTQ2IDEzLjg0NDRMMTIuNTQ5MSAxNC40MzMyQzEzLjQ4ODMgMTQuNzQxNiAxMy44MTA3IDE1LjE0ODIgMTMuNzEyNiAxNi4xNzE1TDkuODAxMzUgMTQuNzU1NlpNOC41OTU3NyAxMC42OTAyQzguNTk1NzcgMTAuNDIzOSA4LjczNTk1IDEwLjE3MTUgOC45NzQyNyA5Ljk2MTIyQzkuMjI2NjEgMTAuMzI1NyA5LjY2MTE4IDEwLjY0ODEgMTAuMzQ4MSAxMC44NzI1TDExLjgzNDEgMTEuMzYzMUwxMS4wMDcgMTIuMTYyMkw5LjU0OTAzIDExLjY4NTVDOC44NzYxNCAxMS40NjEyIDguNTk1NzcgMTEuMTI0OCA4LjU5NTc3IDEwLjY5MDJaTTEyLjk5NzYgMTguMDVDMTYuMDgxNyAxNi4wMDMzIDE3LjczNTkgMTQuNjE1NCAxNy43MzU5IDEyLjkwNTJDMTcuNzM1OSAxMS43Njk2IDE3LjA2MyAxMS4xMzg4IDE1LjU3NzEgMTAuNjQ4MUwxNC40NTU2IDEwLjI2OTZMMTcuNTI1NyA3LjMyNTcyTDE2LjkwODggNi42NjY4NEwxNS45OTc2IDcuNDY1OUwxMS42OTM5IDYuMDUwMDJDMTAuMzYyMSA2LjQ4NDYgOC42Nzk4OCA3Ljc2MDMgOC42Nzk4OCA5LjAzNkM4LjY3OTg4IDkuMTc2MTggOC42OTM5IDkuMzE2MzcgOC43MzU5NSA5LjQ3MDU5QzcuNjI4NDcgMTAuMTAxNCA3LjE3OTg4IDEwLjY5MDIgNy4xNzk4OCAxMS40MTkxQzcuMTc5ODggMTIuMTA2MSA3LjU0NDM2IDEyLjc5MyA4LjcwNzkyIDEzLjE3MTVMOS42MzMxNCAxMy40Nzk5TDYuNDM2ODkgMTYuNTVMNy4wNTM3MSAxNy4yMDg5TDguMDQ5MDQgMTYuMjk3N0wxMi45OTc2IDE4LjA1WiIgZmlsbD0iIzAyMDUwQSIvPgo8L3N2Zz4=", BACKPACK_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjI0IiBoZWlnaHQ9IjI0IiBmaWxsPSIjRTMzRTNGIi8+CjxwYXRoIGQ9Ik0xNS41MTg2IDEzLjkyNzJDMTUuOTgxMSAxMy45MjcyIDE2LjIxMjcgMTMuOTI3MSAxNi4zNTY0IDE0LjA3MDhDMTYuNTAwMiAxNC4yMTQ1IDE2LjUgMTQuNDQ2MiAxNi41IDE0LjkwODdWMTUuNTY0QzE2LjUgMTYuNDg5MyAxNi41MDAyIDE2Ljk1MjIgMTYuMjEyOSAxNy4yMzk3QzE1LjkyNTMgMTcuNTI3MyAxNS40NjE4IDE3LjUyNzggMTQuNTM2MSAxNy41Mjc4SDkuNDYzODdDOC41Mzg0MiAxNy41Mjc4IDguMDc1NjcgMTcuNTI3MSA3Ljc4ODA5IDE3LjIzOTdDNy41MDA1NCAxNi45NTIyIDcuNSAxNi40ODk0IDcuNSAxNS41NjRWMTQuOTA4N0M3LjUgMTQuNDQ2MiA3LjQ5OTgyIDE0LjIxNDUgNy42NDM1NSAxNC4wNzA4QzcuNzg3MyAxMy45MjcxIDguMDE4OTEgMTMuOTI3MiA4LjQ4MTQ1IDEzLjkyNzJIMTUuNTE4NlpNMTIgNi4zNTg4OUMxNi41NjUzIDYuMzU4ODkgMTYuNSA5LjQwMjM4IDE2LjUgMTAuODU4OVYxMi40OTU2QzE2LjQ5OTkgMTIuNzY2NyAxNi4yNzk5IDEyLjk4NjggMTYuMDA4OCAxMi45ODY4SDcuOTkxMjFDNy43MjAxMiAxMi45ODY4IDcuNTAwMDYgMTIuNzY2NyA3LjUgMTIuNDk1NkM3LjUgMTIuNDk1NiA3LjUgMTIuMzE1MyA3LjUgMTAuODU4OUM3LjQ5OTk5IDkuNDAyMzkgNy40MzQ3OCA2LjM1ODkzIDEyIDYuMzU4ODlaTTEyIDcuNTE5MDRDMTEuMjMxOSA3LjUxOTEgMTAuNjA5NCA4LjE0MTU1IDEwLjYwOTQgOC45MDk2N0MxMC42MDk0IDkuNjc3NzggMTEuMjMxOSAxMC4zMDAyIDEyIDEwLjMwMDNDMTIuNzY4MiAxMC4zMDAzIDEzLjM5MDYgOS42Nzc4MiAxMy4zOTA2IDguOTA5NjdDMTMuMzkwNiA4LjE0MTUxIDEyLjc2ODIgNy41MTkwNCAxMiA3LjUxOTA0Wk0xMS45OTkgNC40NzIxN0MxMi45ODQxIDQuNDcyMjIgMTMuODQ2MiA0LjgxNjczIDE0LjA3NDIgNS4zNzc0NEMxNC4xMDg1IDUuNDczODcgMTQuMTI1OCA1LjUyMjIyIDE0LjA5NTcgNS41NTgxMUMxNC4wNjUyIDUuNTk0MDIgMTQuMDA1OCA1LjU4MzQyIDEzLjg4NzcgNS41NjIwMUMxMy41ODIyIDUuNTA2NjUgMTMuMTQ5MyA1LjQ2ODc3IDEyLjc2ODYgNS40NTc1MkMxMi41MjU4IDUuNDQ0NDggMTIuMjY5NSA1LjQzNzk5IDEyIDUuNDM3OTlDMTEuNzMwNSA1LjQzNzk5IDExLjQ3NDIgNS40NDQ0OCAxMS4yMzE0IDUuNDU3NTJDMTAuODQ5IDUuNDY4NzcgMTAuNDE0OSA1LjUwNjU4IDEwLjEwODQgNS41NjAwNkM5Ljk5MzM1IDUuNTgwMTMgOS45MzU2NSA1LjU5MDQ3IDkuOTA1MjcgNS41NTUxOEM5Ljg3NDk3IDUuNTE5MzUgOS44OTEyOCA1LjQ3MTQ0IDkuOTI0OCA1LjM3NjQ2QzEwLjE1MSA0LjgxNzQ4IDExLjAxNDIgNC40NzIxNyAxMS45OTkgNC40NzIxN1oiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPg==", WALLET_ICON_OVERRIDES = {
+  Phantom: PHANTOM_ICON,
+  Solflare: SOLFLARE_ICON,
+  Backpack: BACKPACK_ICON
+}, ICON_PROXY_CACHE = /* @__PURE__ */ new WeakMap();
+function getWalletIconOverride(walletName) {
+  return WALLET_ICON_OVERRIDES[walletName];
+}
+function createIconProxy(wallet, icon) {
+  let cached = ICON_PROXY_CACHE.get(wallet);
+  if (cached) return cached;
+  let proxy = new Proxy(wallet, {
+    get(target, prop) {
+      if (prop === "icon") return icon;
+      let value = Reflect.get(target, prop, target);
+      return typeof value == "function" ? value.bind(target) : value;
+    }
+  });
+  return ICON_PROXY_CACHE.set(wallet, proxy), proxy;
+}
+function applyWalletIconOverride(wallet) {
+  let override = getWalletIconOverride(wallet.name);
+  if (!override || wallet.icon === override) return wallet;
+  if (Object.isExtensible(wallet))
+    try {
+      return wallet.icon = override, wallet;
+    } catch {
+    }
+  return createIconProxy(wallet, override);
+}
+
 // src/lib/wallet/detector.ts
 var logger3 = createLogger("WalletDetector");
+function isSolanaWallet(wallet) {
+  return Array.isArray(wallet.chains) && wallet.chains.some((chain) => typeof chain == "string" && chain.startsWith("solana:"));
+}
 function hasFeature(wallet, featureName) {
   return wallet.features != null && wallet.features[featureName] !== void 0;
 }
@@ -644,6 +723,8 @@ var WalletDetector = class extends BaseCollaborator {
   constructor(stateManager, eventEmitter, debug = false) {
     super({ stateManager, eventEmitter, debug }, "WalletDetector");
     __publicField(this, "unsubscribers", []);
+    /** Map from stable connector ID to Wallet reference (not stored in state) */
+    __publicField(this, "connectorRegistry", /* @__PURE__ */ new Map());
   }
   /**
    * Initialize wallet detection (synchronous)
@@ -659,11 +740,10 @@ var WalletDetector = class extends BaseCollaborator {
     if (!(typeof window > "u"))
       try {
         let walletsApi = getWalletsRegistry(), update = () => {
-          let ws = walletsApi.get(), previousCount = this.getState().wallets.length, newCount = ws.length;
-          newCount !== previousCount && this.log("\u{1F50D} WalletDetector: found wallets:", newCount);
-          let unique = this.deduplicateWallets(ws);
-          this.stateManager.updateState({
-            wallets: unique.map((w) => this.mapToWalletInfo(w))
+          let solanaWallets = walletsApi.get().filter(isSolanaWallet), unique = this.deduplicateWallets(solanaWallets), previousCount = this.getState().wallets.length, newCount = unique.length;
+          newCount !== previousCount && this.log("\u{1F50D} WalletDetector: found wallets:", newCount), this.updateConnectorRegistry(unique), this.stateManager.updateState({
+            wallets: unique.map((w) => this.mapToWalletInfo(w)),
+            connectors: unique.map((w) => this.mapToConnectorMetadata(w))
           }), newCount !== previousCount && newCount > 0 && this.eventEmitter.emit({
             type: "wallets:detected",
             count: newCount,
@@ -741,20 +821,64 @@ var WalletDetector = class extends BaseCollaborator {
     return null;
   }
   /**
-   * Get currently detected wallets
+   * Get currently detected wallets (legacy)
+   * @deprecated Use getConnectors() for vNext API
    */
   getDetectedWallets() {
     return this.getState().wallets;
   }
   /**
-   * Convert a Wallet Standard wallet to WalletInfo with capability checks
+   * Get all available connectors (vNext API)
+   */
+  getConnectors() {
+    return this.getState().connectors;
+  }
+  /**
+   * Get a wallet by its stable connector ID (vNext API)
+   * Returns the Wallet reference for connection operations
+   */
+  getConnectorById(connectorId) {
+    return this.connectorRegistry.get(connectorId);
+  }
+  /**
+   * Get connector metadata by ID
+   */
+  getConnectorMetadata(connectorId) {
+    return this.getState().connectors.find((c) => c.id === connectorId);
+  }
+  /**
+   * Update the connector registry map
+   */
+  updateConnectorRegistry(wallets) {
+    this.connectorRegistry.clear();
+    for (let wallet of wallets) {
+      let connectorId = createConnectorId(wallet.name);
+      this.connectorRegistry.set(connectorId, wallet);
+    }
+  }
+  /**
+   * Convert a Wallet Standard wallet to WalletConnectorMetadata (serializable)
+   */
+  mapToConnectorMetadata(wallet) {
+    let walletWithIcon = applyWalletIconOverride(wallet), hasConnect = hasFeature(walletWithIcon, "standard:connect"), isSolana = isSolanaWallet(walletWithIcon), ready2 = hasConnect && isSolana;
+    return {
+      id: createConnectorId(wallet.name),
+      name: wallet.name,
+      icon: typeof walletWithIcon.icon == "string" ? walletWithIcon.icon : "",
+      ready: ready2,
+      chains: walletWithIcon.chains ?? [],
+      features: Object.keys(walletWithIcon.features ?? {})
+    };
+  }
+  /**
+   * Convert a Wallet Standard wallet to WalletInfo with capability checks (legacy)
    */
   mapToWalletInfo(wallet) {
-    let hasConnect = hasFeature(wallet, "standard:connect"), hasDisconnect = hasFeature(wallet, "standard:disconnect"), isSolana = Array.isArray(wallet.chains) && wallet.chains.some((c) => typeof c == "string" && c.includes("solana"));
+    let walletWithIcon = applyWalletIconOverride(wallet), hasConnect = hasFeature(walletWithIcon, "standard:connect"), isSolana = isSolanaWallet(walletWithIcon);
     return {
-      wallet,
+      wallet: walletWithIcon,
       installed: true,
-      connectable: hasConnect && hasDisconnect && isSolana
+      connectable: hasConnect && isSolana
     };
   }
   /**
@@ -797,26 +921,258 @@ var ConnectionManager = class extends BaseCollaborator {
     __publicField(this, "walletChangeUnsub", null);
     __publicField(this, "pollTimer", null);
     __publicField(this, "pollAttempts", 0);
+    __publicField(this, "connectAttemptId", 0);
+    __publicField(this, "pendingWallet", null);
+    __publicField(this, "pendingWalletName", null);
     this.walletStorage = walletStorage;
   }
+  // ========================================================================
+  // vNext Connection Methods (connector-id based, silent-first)
+  // ========================================================================
+  /**
+   * Connect to a wallet using the vNext API with silent-first support.
+   *
+   * @param wallet - Wallet Standard wallet instance
+   * @param connectorId - Stable connector identifier
+   * @param options - Connection options (silent mode, preferred account, etc.)
+   */
+  async connectWallet(wallet, connectorId, options) {
+    if (typeof window > "u") return;
+    let attemptId = ++this.connectAttemptId;
+    this.pendingWallet = wallet, this.pendingWalletName = wallet.name;
+    let { silent = false, allowInteractiveFallback = true, preferredAccount } = options ?? {};
+    this.updateWalletStatus({
+      status: "connecting",
+      connectorId
+    }), this.stateManager.updateState({ connecting: true }, true), this.eventEmitter.emit({
+      type: "connecting",
+      wallet: wallet.name,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    try {
+      let connect = getConnectFeature(wallet);
+      if (!connect) throw new Error(`Wallet ${wallet.name} does not support standard connect`);
+      let result;
+      if (silent)
+        try {
+          if (result = await connect({ silent: true }), attemptId !== this.connectAttemptId) throw new Error("Connection cancelled");
+          let hasAccounts = result.accounts.length > 0 || wallet.accounts.length > 0;
+          if (!hasAccounts && allowInteractiveFallback)
+            this.log("Silent connect returned no accounts, trying interactive..."), result = await connect({ silent: false });
+          else if (!hasAccounts)
+            throw new Error("Silent connection failed: no accounts returned");
+        } catch (silentError) {
+          if (attemptId !== this.connectAttemptId) throw new Error("Connection cancelled");
+          if (allowInteractiveFallback)
+            this.log("Silent connect failed, trying interactive...", silentError), result = await connect({ silent: false });
+          else
+            throw silentError;
+        }
+      else
+        result = await connect({ silent: false });
+      if (attemptId !== this.connectAttemptId) throw new Error("Connection cancelled");
+      let walletAccounts = wallet.accounts, accountMap = /* @__PURE__ */ new Map();
+      for (let a of [...walletAccounts, ...result.accounts]) accountMap.set(a.address, a);
+      let sessionAccounts = Array.from(accountMap.values()).map((a) => ({
+        address: a.address,
+        label: a.label,
+        account: a
+      })), legacyAccounts = sessionAccounts.map((a) => this.toAccountInfo(a.account)), selectedAccount = sessionAccounts[0];
+      if (preferredAccount) {
+        let preferred = sessionAccounts.find((a) => a.address === preferredAccount);
+        preferred && (selectedAccount = preferred);
+      }
+      let session = this.createSession(wallet, connectorId, sessionAccounts, selectedAccount);
+      this.updateWalletStatus({
+        status: "connected",
+        session
+      }), this.stateManager.updateState(
+        {
+          selectedWallet: wallet,
+          connected: true,
+          connecting: false,
+          accounts: legacyAccounts,
+          selectedAccount: selectedAccount?.address ?? null
+        },
+        true
+      ), this.log("\u2705 Connection successful (vNext)", {
+        connectorId,
+        selectedAccount: selectedAccount?.address,
+        accountsCount: sessionAccounts.length
+      }), selectedAccount && this.eventEmitter.emit({
+        type: "wallet:connected",
+        wallet: wallet.name,
+        account: selectedAccount.address,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }), this.walletStorage && (!("isAvailable" in this.walletStorage) || typeof this.walletStorage.isAvailable != "function" || this.walletStorage.isAvailable()) && this.walletStorage.set(wallet.name), this.subscribeToWalletEventsVNext(wallet, connectorId);
+    } catch (e) {
+      if (attemptId !== this.connectAttemptId) throw e;
+      let errorMessage = e instanceof Error ? e.message : String(e), error = e instanceof Error ? e : new Error(errorMessage);
+      throw this.updateWalletStatus({
+        status: "error",
+        error,
+        connectorId,
+        recoverable: this.isRecoverableError(error)
+      }), this.stateManager.updateState(
+        {
+          selectedWallet: null,
+          connected: false,
+          connecting: false,
+          accounts: [],
+          selectedAccount: null
+        },
+        true
+      ), this.eventEmitter.emit({
+        type: "connection:failed",
+        wallet: wallet.name,
+        error: errorMessage,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }), e;
+    } finally {
+      this.pendingWallet === wallet && (this.pendingWallet = null, this.pendingWalletName = null);
+    }
+  }
+  /**
+   * Create a WalletSession object
+   */
+  createSession(wallet, connectorId, accounts, selectedAccount) {
+    let listeners = /* @__PURE__ */ new Set();
+    return {
+      connectorId,
+      accounts,
+      selectedAccount,
+      onAccountsChanged: (listener) => (listeners.add(listener), () => listeners.delete(listener)),
+      selectAccount: async (address) => {
+        if (accounts.find((a) => a.address === address))
+          return this.selectAccount(address);
+      }
+    };
+  }
+  /**
+   * Update wallet status in state
+   */
+  updateWalletStatus(status) {
+    this.stateManager.updateState({ wallet: status });
+  }
+  /**
+   * Subscribe to wallet events (vNext version with improved account change handling)
+   */
+  subscribeToWalletEventsVNext(wallet, connectorId) {
+    this.walletChangeUnsub && (this.walletChangeUnsub(), this.walletChangeUnsub = null), this.stopPollingWalletAccounts();
+    let eventsOn = getEventsFeature(wallet);
+    if (!eventsOn) {
+      this.startPollingWalletAccountsVNext(wallet, connectorId);
+      return;
+    }
+    try {
+      this.walletChangeUnsub = eventsOn("change", (properties) => {
+        let changeAccounts = properties?.accounts ?? [];
+        this.handleAccountsChanged(changeAccounts, connectorId, wallet);
+      });
+    } catch {
+      this.startPollingWalletAccountsVNext(wallet, connectorId);
+    }
+  }
+  /**
+   * Handle accounts changed event with proper validation
+   */
+  handleAccountsChanged(newAccounts, connectorId, wallet) {
+    let state = this.getState();
+    if (newAccounts.length === 0) {
+      this.log("No accounts available, disconnecting..."), this.disconnect();
+      return;
+    }
+    let sessionAccounts = newAccounts.map((a) => ({
+      address: a.address,
+      label: a.label,
+      account: a
+    })), legacyAccounts = sessionAccounts.map((a) => this.toAccountInfo(a.account)), currentSelected = state.selectedAccount, selectedAccount = sessionAccounts.find((a) => a.address === currentSelected);
+    if (selectedAccount || (selectedAccount = sessionAccounts[0], this.eventEmitter.emit({
+      type: "account:changed",
+      account: selectedAccount.address,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    })), state.wallet.status === "connected") {
+      let session = this.createSession(wallet, connectorId, sessionAccounts, selectedAccount);
+      this.updateWalletStatus({
+        status: "connected",
+        session
+      });
+    }
+    this.stateManager.updateState({
+      accounts: legacyAccounts,
+      selectedAccount: selectedAccount.address
+    });
+  }
+  /**
+   * Start polling wallet accounts (vNext version)
+   */
+  startPollingWalletAccountsVNext(wallet, connectorId) {
+    if (this.pollTimer) return;
+    this.pollAttempts = 0;
+    let poll = () => {
+      if (this.pollAttempts >= 20) {
+        this.stopPollingWalletAccounts(), this.log("Stopped wallet polling after max attempts");
+        return;
+      }
+      try {
+        let walletAccounts = wallet.accounts;
+        walletAccounts.length > 0 && (this.handleAccountsChanged(walletAccounts, connectorId, wallet), this.pollAttempts = 0);
+      } catch (error) {
+        this.log("Wallet polling error:", error);
+      }
+      this.pollAttempts++;
+      let intervalIndex = Math.min(this.pollAttempts, POLL_INTERVALS_MS.length - 1), interval = POLL_INTERVALS_MS[intervalIndex];
+      this.pollTimer = setTimeout(poll, interval);
+    };
+    poll();
+  }
   /**
-   * Connect to a wallet
+   * Check if an error is recoverable
+   */
+  isRecoverableError(error) {
+    let message = error.message.toLowerCase();
+    return message.includes("user rejected") || message.includes("user denied") || message.includes("cancelled") || message.includes("canceled");
+  }
+  // ========================================================================
+  // Legacy Connection Methods (kept for backwards compatibility)
+  // ========================================================================
+  /**
+   * Connect to a wallet (legacy API)
+   * @deprecated Use connectWallet() instead
    */
   async connect(wallet, walletName) {
     if (typeof window > "u") return;
-    let name = walletName || wallet.name;
+    let name = walletName || wallet.name, attemptId = ++this.connectAttemptId;
+    this.pendingWallet = wallet, this.pendingWalletName = name;
+    let connectorId = createConnectorId(name);
     this.eventEmitter.emit({
       type: "connecting",
       wallet: name,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }), this.updateWalletStatus({
+      status: "connecting",
+      connectorId
     }), this.stateManager.updateState({ connecting: true }, true);
     try {
       let connect = getConnectFeature(wallet);
       if (!connect) throw new Error(`Wallet ${name} does not support standard connect`);
-      let result = await connect({ silent: false }), walletAccounts = wallet.accounts, accountMap = /* @__PURE__ */ new Map();
+      let result = await connect({ silent: false });
+      if (attemptId !== this.connectAttemptId)
+        throw new Error("Connection cancelled");
+      let walletAccounts = wallet.accounts, accountMap = /* @__PURE__ */ new Map();
       for (let a of [...walletAccounts, ...result.accounts]) accountMap.set(a.address, a);
-      let accounts = Array.from(accountMap.values()).map((a) => this.toAccountInfo(a)), state = this.getState(), previouslySelected = state.selectedAccount, previousAddresses = new Set(state.accounts.map((a) => a.address)), selected = accounts.find((a) => !previousAddresses.has(a.address))?.address ?? previouslySelected ?? accounts[0]?.address ?? null;
-      this.stateManager.updateState(
+      let sessionAccounts = Array.from(accountMap.values()).map((a) => ({
+        address: a.address,
+        label: a.label,
+        account: a
+      }));
+      if (sessionAccounts.length === 0)
+        throw new Error(`Wallet ${name} connected but returned no accounts`);
+      let accounts = sessionAccounts.map((a) => this.toAccountInfo(a.account)), state = this.getState(), previouslySelected = state.selectedAccount, previousAddresses = new Set(state.accounts.map((a) => a.address)), selected = accounts.find((a) => !previousAddresses.has(a.address))?.address ?? previouslySelected ?? accounts[0]?.address ?? null, selectedSessionAccount = (selected ? sessionAccounts.find((a) => a.address === selected) : void 0) ?? sessionAccounts[0], session = this.createSession(wallet, connectorId, sessionAccounts, selectedSessionAccount);
+      this.updateWalletStatus({
+        status: "connected",
+        session
+      }), this.stateManager.updateState(
         {
           selectedWallet: wallet,
           connected: true,
@@ -840,7 +1196,9 @@ var ConnectionManager = class extends BaseCollaborator {
         accountsCount: accounts.length
       }), this.walletStorage && (!("isAvailable" in this.walletStorage) || typeof this.walletStorage.isAvailable != "function" || this.walletStorage.isAvailable() ? this.walletStorage.set(name) : this.log("Storage not available (private browsing?), skipping wallet persistence")), this.subscribeToWalletEvents();
     } catch (e) {
-      let errorMessage = e instanceof Error ? e.message : String(e);
+      if (attemptId !== this.connectAttemptId)
+        throw e;
+      let errorMessage = e instanceof Error ? e.message : String(e), error = e instanceof Error ? e : new Error(errorMessage);
       throw this.eventEmitter.emit({
         type: "connection:failed",
         wallet: name,
@@ -848,9 +1206,14 @@ var ConnectionManager = class extends BaseCollaborator {
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }), this.eventEmitter.emit({
         type: "error",
-        error: e instanceof Error ? e : new Error(errorMessage),
+        error,
         context: "wallet-connection",
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }), this.updateWalletStatus({
+        status: "error",
+        error,
+        connectorId,
+        recoverable: this.isRecoverableError(error)
       }), this.stateManager.updateState(
         {
           selectedWallet: null,
@@ -861,22 +1224,21 @@ var ConnectionManager = class extends BaseCollaborator {
         },
         true
       ), e;
+    } finally {
+      this.pendingWallet === wallet && this.pendingWalletName === name && (this.pendingWallet = null, this.pendingWalletName = null);
     }
   }
   /**
    * Disconnect from wallet
    */
   async disconnect() {
-    this.walletChangeUnsub && (this.walletChangeUnsub(), this.walletChangeUnsub = null), this.stopPollingWalletAccounts();
-    let wallet = this.getState().selectedWallet;
-    if (wallet) {
-      let disconnect = getDisconnectFeature(wallet);
-      disconnect && await disconnect();
-    }
-    this.stateManager.updateState(
+    this.connectAttemptId++, this.walletChangeUnsub && (this.walletChangeUnsub(), this.walletChangeUnsub = null), this.stopPollingWalletAccounts();
+    let wallet = this.getState().selectedWallet ?? this.pendingWallet;
+    if (this.pendingWallet = null, this.pendingWalletName = null, this.updateWalletStatus(INITIAL_WALLET_STATUS), this.stateManager.updateState(
       {
         selectedWallet: null,
         connected: false,
+        connecting: false,
         accounts: [],
         selectedAccount: null
       },
@@ -884,7 +1246,14 @@ var ConnectionManager = class extends BaseCollaborator {
     ), this.eventEmitter.emit({
       type: "wallet:disconnected",
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }), this.walletStorage && "clear" in this.walletStorage && typeof this.walletStorage.clear == "function" ? this.walletStorage.clear() : this.walletStorage?.set(void 0);
+    }), this.walletStorage && "clear" in this.walletStorage && typeof this.walletStorage.clear == "function" ? this.walletStorage.clear() : this.walletStorage?.set(void 0), wallet) {
+      let disconnect = getDisconnectFeature(wallet);
+      if (disconnect)
+        try {
+          await disconnect();
+        } catch {
+        }
+    }
   }
   /**
    * Select a different account
@@ -992,16 +1361,49 @@ var ConnectionManager = class extends BaseCollaborator {
 
 // src/lib/wallet/auto-connector.ts
 var logger4 = createLogger("AutoConnector"), MIN_ADDRESS_LENGTH = 30, AutoConnector = class {
-  constructor(walletDetector, connectionManager, stateManager, walletStorage, debug = false) {
+  constructor(walletDetector, connectionManager, stateManager, walletStorage, debug = false, walletStateStorage) {
     __publicField(this, "walletDetector");
     __publicField(this, "connectionManager");
     __publicField(this, "stateManager");
+    /** Legacy wallet name storage */
     __publicField(this, "walletStorage");
+    /** vNext wallet state storage (connector ID + account) */
+    __publicField(this, "walletStateStorage");
     __publicField(this, "debug");
-    this.walletDetector = walletDetector, this.connectionManager = connectionManager, this.stateManager = stateManager, this.walletStorage = walletStorage, this.debug = debug;
+    this.walletDetector = walletDetector, this.connectionManager = connectionManager, this.stateManager = stateManager, this.walletStorage = walletStorage, this.walletStateStorage = walletStateStorage, this.debug = debug;
   }
   async attemptAutoConnect() {
-    return await this.attemptInstantConnect() ? true : (await this.attemptStandardConnect(), this.stateManager.getSnapshot().connected);
+    return this.walletStateStorage && await this.attemptVNextAutoConnect() || await this.attemptInstantConnect() ? true : (await this.attemptStandardConnect(), this.stateManager.getSnapshot().connected);
+  }
+  /**
+   * vNext auto-connect using stored connector ID with silent-first approach.
+   * This won't prompt the user unless they explicitly initiated the connect.
+   */
+  async attemptVNextAutoConnect() {
+    let walletState = this.walletStateStorage?.get();
+    if (!walletState || !walletState.autoConnect)
+      return this.debug && logger4.debug("vNext auto-connect: No stored wallet state or autoConnect disabled"), false;
+    let { connectorId, lastAccount } = walletState;
+    await ready;
+    let wallet = this.walletDetector.getConnectorById(connectorId);
+    if (!wallet)
+      return this.debug && logger4.debug("vNext auto-connect: Connector not found", { connectorId }), false;
+    try {
+      return this.debug && logger4.info("vNext auto-connect: Attempting silent connect", {
+        connectorId,
+        lastAccount
+      }), await this.connectionManager.connectWallet(wallet, connectorId, {
+        silent: true,
+        allowInteractiveFallback: false,
+        // Don't prompt on auto-connect
+        preferredAccount: lastAccount
+      }), this.debug && logger4.info("vNext auto-connect: Silent connect successful", { connectorId }), true;
+    } catch (error) {
+      return this.debug && logger4.debug("vNext auto-connect: Silent connect failed (expected for first-time or revoked)", {
+        connectorId,
+        error: error instanceof Error ? error.message : error
+      }), false;
+    }
   }
   async attemptInstantConnect() {
     let storedWalletName = this.walletStorage?.get();
@@ -1092,12 +1494,12 @@ var logger4 = createLogger("AutoConnector"), MIN_ADDRESS_LENGTH = 30, AutoConnec
         ],
         features,
         accounts: []
-      };
+      }, walletWithIcon = applyWalletIconOverride(wallet);
       this.stateManager.updateState(
         {
           wallets: [
             {
-              wallet,
+              wallet: walletWithIcon,
               installed: true,
               connectable: true
             }
@@ -1105,7 +1507,7 @@ var logger4 = createLogger("AutoConnector"), MIN_ADDRESS_LENGTH = 30, AutoConnec
         },
         true
       ), await ready;
-      let walletsApi = getWalletsRegistry(), registryWallet = walletsApi.get().find((w) => w.name === storedWalletName), walletToUse = registryWallet || wallet;
+      let walletsApi = getWalletsRegistry(), registryWallet = walletsApi.get().find((w) => w.name === storedWalletName), walletToUse = applyWalletIconOverride(registryWallet || walletWithIcon);
       return this.debug && logger4.info("Attempting to connect via instant auto-connect", {
         walletName: storedWalletName,
         usingRegistry: !!registryWallet
@@ -1319,8 +1721,13 @@ var logger5 = createLogger("ConnectorClient"), ConnectorClient = class {
     __publicField(this, "healthMonitor");
     __publicField(this, "initialized", false);
     __publicField(this, "config");
+    __publicField(this, "walletConnectRegistration", null);
     this.config = config;
     let initialState = {
+      // vNext wallet status
+      wallet: INITIAL_WALLET_STATUS,
+      connectors: [],
+      // Legacy fields (for backwards compatibility)
       wallets: [],
       selectedWallet: null,
       connected: false,
@@ -1362,7 +1769,9 @@ var logger5 = createLogger("ConnectorClient"), ConnectorClient = class {
   initialize() {
     if (typeof window > "u" || this.initialized) return;
     let { error } = tryCatchSync(() => {
-      this.walletDetector.initialize(), this.config.autoConnect && setTimeout(() => {
+      this.walletDetector.initialize(), this.config.walletConnect?.enabled && this.initializeWalletConnect().catch((err) => {
+        this.config.debug && logger5.error("WalletConnect initialization failed", { error: err });
+      }), this.config.autoConnect && setTimeout(() => {
         this.autoConnector.attemptAutoConnect().catch((err) => {
           this.config.debug && logger5.error("Auto-connect error", { error: err });
         });
@@ -1370,11 +1779,62 @@ var logger5 = createLogger("ConnectorClient"), ConnectorClient = class {
     });
     error && this.config.debug && logger5.error("Connector initialization failed", { error });
   }
+  /**
+   * Initialize WalletConnect integration
+   * Dynamically imports and registers the WalletConnect wallet
+   */
+  async initializeWalletConnect() {
+    if (this.config.walletConnect?.enabled)
+      try {
+        let { registerWalletConnectWallet } = await import('./walletconnect-U455PO4I.mjs');
+        this.walletConnectRegistration = await registerWalletConnectWallet(this.config.walletConnect), this.config.debug && logger5.info("WalletConnect wallet registered successfully");
+      } catch (error) {
+        this.config.debug && logger5.error("Failed to register WalletConnect wallet", { error });
+      }
+  }
+  // ========================================================================
+  // vNext Wallet Actions (connector-id based)
+  // ========================================================================
+  /**
+   * Connect to a wallet using its stable connector ID.
+   * This is the recommended way to connect in vNext.
+   *
+   * @param connectorId - Stable connector identifier
+   * @param options - Connection options (silent mode, preferred account, etc.)
+   */
+  async connectWallet(connectorId, options) {
+    let connector = this.walletDetector.getConnectorById(connectorId);
+    if (!connector)
+      throw new Error(`Connector ${connectorId} not found`);
+    await this.connectionManager.connectWallet(connector, connectorId, options);
+  }
+  /**
+   * Disconnect the current wallet session.
+   * This is the vNext equivalent of disconnect().
+   */
+  async disconnectWallet() {
+    await this.connectionManager.disconnect();
+  }
+  /**
+   * Get a connector by its ID (for advanced use cases).
+   */
+  getConnector(connectorId) {
+    return this.walletDetector.getConnectorById(connectorId);
+  }
+  // ========================================================================
+  // Legacy Actions (kept for backwards compatibility)
+  // ========================================================================
+  /**
+   * @deprecated Use `connectWallet(connectorId)` instead.
+   */
   async select(walletName) {
     let wallet = this.stateManager.getSnapshot().wallets.find((w) => w.wallet.name === walletName)?.wallet;
     if (!wallet) throw new Error(`Wallet ${walletName} not found`);
     await this.connectionManager.connect(wallet, walletName);
   }
+  /**
+   * @deprecated Use `disconnectWallet()` instead.
+   */
   async disconnect() {
     await this.connectionManager.disconnect();
   }
@@ -1462,288 +1922,23 @@ var logger5 = createLogger("ConnectorClient"), ConnectorClient = class {
     this.debugMetrics.resetMetrics();
   }
   destroy() {
-    this.connectionManager.disconnect().catch(() => {
-    }), this.walletDetector.destroy(), this.eventEmitter.offAll(), this.stateManager.clear();
-  }
-};
-var logger6 = createLogger("ErrorBoundary"), WalletErrorType = /* @__PURE__ */ ((WalletErrorType2) => (WalletErrorType2.CONNECTION_FAILED = "CONNECTION_FAILED", WalletErrorType2.TRANSACTION_FAILED = "TRANSACTION_FAILED", WalletErrorType2.NETWORK_ERROR = "NETWORK_ERROR", WalletErrorType2.WALLET_NOT_FOUND = "WALLET_NOT_FOUND", WalletErrorType2.USER_REJECTED = "USER_REJECTED", WalletErrorType2.INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS", WalletErrorType2.UNKNOWN_ERROR = "UNKNOWN_ERROR", WalletErrorType2))(WalletErrorType || {}), ErrorLogger = class {
-  static log(error, errorInfo, context) {
-    if (process.env.NODE_ENV === "development" && logger6.error(error.message, {
-      error,
-      errorInfo,
-      context
-    }), process.env.NODE_ENV === "production" && typeof window < "u")
+    if (this.walletConnectRegistration)
       try {
-        let gtag = window.gtag;
-        typeof gtag == "function" && gtag("event", "exception", {
-          description: error.message,
-          fatal: false,
-          custom_map: { error_type: "wallet_error", ...context }
-        });
-      } catch {
+        this.walletConnectRegistration.unregister(), this.walletConnectRegistration = null;
+      } catch (error) {
+        this.config.debug && logger5.warn("Error unregistering WalletConnect wallet", { error });
       }
+    this.connectionManager.disconnect().catch(() => {
+    }), this.walletDetector.destroy(), this.eventEmitter.offAll(), this.stateManager.clear();
   }
 };
-function classifyError(error) {
-  if (isConnectorError(error))
-    return {
-      ...error,
-      type: {
-        WALLET_NOT_CONNECTED: "CONNECTION_FAILED" /* CONNECTION_FAILED */,
-        WALLET_NOT_FOUND: "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
-        CONNECTION_FAILED: "CONNECTION_FAILED" /* CONNECTION_FAILED */,
-        USER_REJECTED: "USER_REJECTED" /* USER_REJECTED */,
-        RPC_ERROR: "NETWORK_ERROR" /* NETWORK_ERROR */,
-        NETWORK_TIMEOUT: "NETWORK_ERROR" /* NETWORK_ERROR */,
-        SIGNING_FAILED: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
-        SEND_FAILED: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */
-      }[error.code] || "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-      recoverable: error.recoverable,
-      context: error.context
-    };
-  let walletError = error;
-  if (walletError.type) return walletError;
-  let type = "UNKNOWN_ERROR" /* UNKNOWN_ERROR */, recoverable = false;
-  return error.message.includes("User rejected") || error.message.includes("User denied") ? (type = "USER_REJECTED" /* USER_REJECTED */, recoverable = true) : error.message.includes("Insufficient funds") ? (type = "INSUFFICIENT_FUNDS" /* INSUFFICIENT_FUNDS */, recoverable = false) : error.message.includes("Network") || error.message.includes("fetch") ? (type = "NETWORK_ERROR" /* NETWORK_ERROR */, recoverable = true) : error.message.includes("Wallet not found") || error.message.includes("not installed") ? (type = "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */, recoverable = true) : (error.message.includes("Failed to connect") || error.message.includes("Connection")) && (type = "CONNECTION_FAILED" /* CONNECTION_FAILED */, recoverable = true), {
-    ...error,
-    type,
-    recoverable,
-    context: { originalMessage: error.message }
-  };
-}
-var ConnectorErrorBoundary = class extends Component {
-  constructor(props) {
-    super(props);
-    __publicField(this, "retryTimeouts", /* @__PURE__ */ new Set());
-    __publicField(this, "retry", () => {
-      let { maxRetries = 3 } = this.props;
-      this.state.retryCount >= maxRetries || this.setState((prevState) => ({
-        hasError: false,
-        error: null,
-        errorInfo: null,
-        retryCount: prevState.retryCount + 1
-      }));
-    });
-    this.state = {
-      hasError: false,
-      error: null,
-      errorInfo: null,
-      errorId: "",
-      retryCount: 0
-    };
-  }
-  static getDerivedStateFromError(error) {
-    return {
-      hasError: true,
-      error,
-      errorId: `error_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-    };
-  }
-  componentDidCatch(error, errorInfo) {
-    this.setState({ errorInfo }), ErrorLogger.log(error, errorInfo, {
-      retryCount: this.state.retryCount,
-      errorId: this.state.errorId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }), this.props.onError?.(error, errorInfo);
-  }
-  componentWillUnmount() {
-    this.retryTimeouts.forEach((timeout) => clearTimeout(timeout));
-  }
-  render() {
-    if (this.state.hasError && this.state.error) {
-      let walletError = classifyError(this.state.error);
-      return this.props.fallback ? this.props.fallback(walletError, this.retry) : /* @__PURE__ */ jsx(DefaultErrorFallback, { error: walletError, onRetry: this.retry });
-    }
-    return this.props.children;
-  }
-};
-function DefaultErrorFallback({ error, onRetry }) {
-  let [isPending, startTransition] = useTransition(), [isRetrying, setIsRetrying] = useState(false), handleRetry = useCallback(() => {
-    setIsRetrying(true), startTransition(() => {
-      setTimeout(() => {
-        onRetry(), setIsRetrying(false);
-      }, 500);
-    });
-  }, [onRetry]), { title, message, actionText, showRetry } = useMemo(() => {
-    switch (error.type) {
-      case "USER_REJECTED" /* USER_REJECTED */:
-        return {
-          title: "Transaction Cancelled",
-          message: "You cancelled the transaction. No problem!",
-          actionText: "Try Again",
-          showRetry: true
-        };
-      case "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */:
-        return {
-          title: "Wallet Not Found",
-          message: "Please install a supported Solana wallet to continue.",
-          actionText: "Check Wallets",
-          showRetry: true
-        };
-      case "NETWORK_ERROR" /* NETWORK_ERROR */:
-        return {
-          title: "Network Error",
-          message: "Having trouble connecting. Please check your internet connection.",
-          actionText: "Retry",
-          showRetry: true
-        };
-      case "INSUFFICIENT_FUNDS" /* INSUFFICIENT_FUNDS */:
-        return {
-          title: "Insufficient Funds",
-          message: "You don't have enough SOL for this transaction.",
-          actionText: "Add Funds",
-          showRetry: false
-        };
-      default:
-        return {
-          title: "Something went wrong",
-          message: "An unexpected error occurred. Please try again.",
-          actionText: "Retry",
-          showRetry: error.recoverable
-        };
-    }
-  }, [error.type, error.recoverable]);
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      style: {
-        display: "flex",
-        flexDirection: "column",
-        alignItems: "center",
-        justifyContent: "center",
-        padding: "2rem",
-        textAlign: "center",
-        borderRadius: "12px",
-        border: "1px solid #e5e7eb",
-        backgroundColor: "#fafafa",
-        maxWidth: "400px",
-        margin: "0 auto"
-      },
-      children: [
-        /* @__PURE__ */ jsx(
-          "div",
-          {
-            style: {
-              width: "48px",
-              height: "48px",
-              borderRadius: "50%",
-              backgroundColor: "#fee2e2",
-              display: "flex",
-              alignItems: "center",
-              justifyContent: "center",
-              marginBottom: "1rem"
-            },
-            children: /* @__PURE__ */ jsx("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "#dc2626", children: /* @__PURE__ */ jsx("path", { d: "M12 9v3.75m-9.303 3.376c-.866 1.5.217 3.374 1.948 3.374h14.71c1.73 0 2.813-1.874 1.948-3.374L13.949 3.378c-.866-1.5-3.032-1.5-3.898 0L2.697 16.126zM12 15.75h.007v.008H12v-.008z" }) })
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          "h3",
-          {
-            style: {
-              margin: "0 0 0.5rem 0",
-              fontSize: "1.125rem",
-              fontWeight: "600",
-              color: "#111827"
-            },
-            children: title
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          "p",
-          {
-            style: {
-              margin: "0 0 1.5rem 0",
-              fontSize: "0.875rem",
-              color: "#6b7280",
-              lineHeight: "1.5"
-            },
-            children: message
-          }
-        ),
-        /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "0.75rem", flexWrap: "wrap" }, children: [
-          showRetry && /* @__PURE__ */ jsx(
-            "button",
-            {
-              onClick: handleRetry,
-              disabled: isPending || isRetrying,
-              style: {
-                padding: "0.5rem 1rem",
-                backgroundColor: "#3b82f6",
-                color: "white",
-                border: "none",
-                borderRadius: "6px",
-                fontSize: "0.875rem",
-                fontWeight: "500",
-                cursor: isPending || isRetrying ? "wait" : "pointer",
-                opacity: isPending || isRetrying ? 0.7 : 1,
-                transition: "all 0.2s"
-              },
-              children: isRetrying ? "Retrying..." : actionText
-            }
-          ),
-          /* @__PURE__ */ jsx(
-            "button",
-            {
-              onClick: () => window.location.reload(),
-              style: {
-                padding: "0.5rem 1rem",
-                backgroundColor: "transparent",
-                color: "#6b7280",
-                border: "1px solid #d1d5db",
-                borderRadius: "6px",
-                fontSize: "0.875rem",
-                fontWeight: "500",
-                cursor: "pointer",
-                transition: "all 0.2s"
-              },
-              children: "Refresh Page"
-            }
-          )
-        ] }),
-        process.env.NODE_ENV === "development" && /* @__PURE__ */ jsxs(
-          "details",
-          {
-            style: {
-              marginTop: "1rem",
-              fontSize: "0.75rem",
-              color: "#6b7280",
-              width: "100%"
-            },
-            children: [
-              /* @__PURE__ */ jsx("summary", { style: { cursor: "pointer", marginBottom: "0.5rem" }, children: "Error Details" }),
-              /* @__PURE__ */ jsx(
-                "pre",
-                {
-                  style: {
-                    whiteSpace: "pre-wrap",
-                    wordBreak: "break-all",
-                    backgroundColor: "#f3f4f6",
-                    padding: "0.5rem",
-                    borderRadius: "4px",
-                    overflow: "auto",
-                    maxHeight: "200px"
-                  },
-                  children: error.message
-                }
-              )
-            ]
-          }
-        )
-      ]
-    }
-  );
-}
-function withErrorBoundary(Component2, errorBoundaryProps) {
-  let WrappedComponent = (props) => /* @__PURE__ */ jsx(ConnectorErrorBoundary, { ...errorBoundaryProps, children: /* @__PURE__ */ jsx(Component2, { ...props }) });
-  return WrappedComponent.displayName = `withErrorBoundary(${Component2.displayName || Component2.name})`, WrappedComponent;
-}
-var logger7 = createLogger("Polyfills"), installed = false;
+var logger6 = createLogger("Polyfills"), installed = false;
 function installPolyfills() {
   if (!(installed || typeof window > "u"))
     try {
-      install(), installed = true, logger7.info("Browser compatibility polyfills installed");
+      install(), installed = true, logger6.info("Browser compatibility polyfills installed");
     } catch (error) {
-      logger7 && logger7.warn("Failed to install polyfills", { error }), installed = true;
+      logger6 && logger6.warn("Failed to install polyfills", { error }), installed = true;
     }
 }
 function isPolyfillInstalled() {
@@ -1764,6 +1959,404 @@ function getPolyfillStatus() {
     environment: typeof window < "u" ? "browser" : "server"
   };
 }
+var logger7 = createLogger("EnhancedStorage"), STORAGE_VERSION = "v1", EnhancedStorage = class extends Storage {
+  constructor(key, initial, options) {
+    super(key, initial);
+    this.options = options;
+    __publicField(this, "errorHandlers", /* @__PURE__ */ new Set());
+    __publicField(this, "validators", []);
+    __publicField(this, "memoryFallback");
+    this.memoryFallback = initial, options?.onError && this.errorHandlers.add(options.onError), options?.validator && this.validators.push(options.validator);
+  }
+  set(value) {
+    try {
+      return this.validate(value) ? (super.set(value), this.memoryFallback = value, true) : (logger7.warn("Validation failed", { key: this.key }), false);
+    } catch (error) {
+      return this.handleError(error), this.options?.useMemoryFallback ? (this.memoryFallback = value, true) : false;
+    }
+  }
+  get() {
+    try {
+      return super.get();
+    } catch (error) {
+      return this.handleError(error), this.options?.useMemoryFallback ? this.memoryFallback : this.initial;
+    }
+  }
+  validate(value) {
+    return this.validators.every((validator) => validator(value));
+  }
+  addValidator(validator) {
+    return this.validators.push(validator), this;
+  }
+  onError(handler) {
+    return this.errorHandlers.add(handler), this;
+  }
+  transform(transformer) {
+    return transformer(this.get());
+  }
+  reset() {
+    this.set(this.initial);
+  }
+  clear() {
+    try {
+      typeof window < "u" && window.localStorage && window.localStorage.removeItem(this.key), this.reset();
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  isAvailable() {
+    try {
+      if (typeof window > "u") return false;
+      let testKey = `__storage_test_${this.key}__`;
+      return window.localStorage.setItem(testKey, "test"), window.localStorage.removeItem(testKey), true;
+    } catch {
+      return false;
+    }
+  }
+  static migrate(oldKey, newStorage) {
+    try {
+      if (typeof window > "u") return false;
+      let oldValue = window.localStorage.getItem(oldKey);
+      if (oldValue) {
+        let parsed = JSON.parse(oldValue);
+        return newStorage.set(parsed), window.localStorage.removeItem(oldKey), true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  handleError(error) {
+    logger7.error("Storage error", { key: this.key, error }), this.errorHandlers.forEach((handler) => {
+      try {
+        handler(error);
+      } catch (err) {
+        logger7.error("Error in error handler", { error: err });
+      }
+    });
+  }
+};
+function createEnhancedStorageAccount(options) {
+  let key = options?.key ?? `connector-kit:${STORAGE_VERSION}:account`;
+  return new EnhancedStorage(key, options?.initial, {
+    validator: options?.validator,
+    onError: options?.onError,
+    useMemoryFallback: true
+    // Always fallback for SSR
+  });
+}
+function createEnhancedStorageCluster(options) {
+  let key = options?.key ?? `connector-kit:${STORAGE_VERSION}:cluster`, storage = new EnhancedStorage(key, options?.initial ?? "solana:mainnet", {
+    onError: options?.onError,
+    useMemoryFallback: true
+  });
+  return options?.validClusters && storage.addValidator((clusterId) => options.validClusters.includes(clusterId)), storage;
+}
+function createEnhancedStorageWallet(options) {
+  let key = options?.key ?? `connector-kit:${STORAGE_VERSION}:wallet`;
+  return new EnhancedStorage(key, options?.initial, {
+    onError: options?.onError,
+    useMemoryFallback: true
+  });
+}
+var WALLET_STATE_VERSION = 1;
+function createEnhancedStorageWalletState(options) {
+  let key = options?.key ?? `connector-kit:${STORAGE_VERSION}:wallet-state`, legacyKey = `connector-kit:${STORAGE_VERSION}:wallet`, storage = new EnhancedStorage(key, options?.initial ?? null, {
+    onError: options?.onError,
+    useMemoryFallback: true
+  });
+  if (typeof window < "u" && storage.isAvailable())
+    try {
+      if (!storage.get()) {
+        let legacyValue = window.localStorage.getItem(legacyKey);
+        if (legacyValue) {
+          let legacyWalletName = JSON.parse(legacyValue);
+          if (legacyWalletName && typeof legacyWalletName == "string") {
+            let connectorId = options?.migrateLegacy ? options.migrateLegacy(legacyWalletName) : createConnectorId(legacyWalletName);
+            if (connectorId) {
+              let migratedState = {
+                version: WALLET_STATE_VERSION,
+                connectorId,
+                autoConnect: true,
+                lastConnected: (/* @__PURE__ */ new Date()).toISOString()
+              };
+              storage.set(migratedState), logger7.info("Migrated legacy wallet storage", {
+                from: legacyWalletName,
+                to: connectorId
+              }), window.localStorage.removeItem(legacyKey);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      logger7.warn("Failed to migrate legacy wallet storage", { error });
+    }
+  return storage;
+}
+function saveWalletState(storage, connectorId, account, autoConnect = true) {
+  let state = {
+    version: WALLET_STATE_VERSION,
+    connectorId,
+    lastAccount: account,
+    autoConnect,
+    lastConnected: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  storage.set(state);
+}
+function clearWalletState(storage) {
+  storage.set(null);
+}
+var EnhancedStorageAdapter = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  get() {
+    return this.storage.get();
+  }
+  set(value) {
+    this.storage.set(value);
+  }
+  subscribe(callback) {
+    return this.storage.value.subscribe(callback);
+  }
+  validate(value) {
+    return this.storage.validate(value);
+  }
+  reset() {
+    this.storage.reset();
+  }
+  clear() {
+    this.storage.clear();
+  }
+  isAvailable() {
+    return this.storage.isAvailable();
+  }
+  transform(transformer) {
+    return this.storage.transform(transformer);
+  }
+  addValidator(validator) {
+    return this.storage.addValidator(validator), this;
+  }
+  onError(handler) {
+    return this.storage.onError(handler), this;
+  }
+};
+var logger8 = createLogger("DefaultConfig");
+function getDefaultConfig(options) {
+  let {
+    appName,
+    appUrl,
+    autoConnect = true,
+    debug,
+    network = "mainnet-beta",
+    enableMobile = true,
+    storage,
+    clusters,
+    customClusters = [],
+    persistClusterSelection = true,
+    clusterStorageKey,
+    enableErrorBoundary = true,
+    maxRetries = DEFAULT_MAX_RETRIES,
+    onError,
+    imageProxy,
+    programLabels,
+    coingecko,
+    walletConnect
+  } = options, defaultClusters = clusters ?? [
+    createSolanaMainnet(),
+    createSolanaDevnet(),
+    createSolanaTestnet(),
+    ...network === "localnet" ? [createSolanaLocalnet()] : [],
+    ...customClusters || []
+  ], validClusterIds = defaultClusters.map((c) => c.id), accountStorage = createEnhancedStorageAccount({
+    validator: (address) => address ? isAddress(address) : true,
+    onError: (error) => {
+      debug && logger8.error("Account Storage error", { error }), onError && onError(error, {
+        componentStack: "account-storage"
+      });
+    }
+  }), clusterStorage = createEnhancedStorageCluster({
+    key: clusterStorageKey,
+    initial: getInitialCluster(network),
+    validClusters: persistClusterSelection ? validClusterIds : void 0,
+    onError: (error) => {
+      debug && logger8.error("Cluster Storage error", { error }), onError && onError(error, {
+        componentStack: "cluster-storage"
+      });
+    }
+  }), walletStorage = createEnhancedStorageWallet({
+    onError: (error) => {
+      debug && logger8.error("Wallet Storage error", { error }), onError && onError(error, {
+        componentStack: "wallet-storage"
+      });
+    }
+  });
+  if (typeof window < "u") {
+    let oldAccountKey = "connector-kit:account", oldWalletKey = "connector-kit:wallet", oldClusterKey = clusterStorageKey || "connector-kit:cluster";
+    EnhancedStorage.migrate(oldAccountKey, accountStorage), EnhancedStorage.migrate(oldWalletKey, walletStorage), EnhancedStorage.migrate(oldClusterKey, clusterStorage);
+  }
+  let defaultStorage = storage ?? {
+    account: new EnhancedStorageAdapter(accountStorage),
+    cluster: new EnhancedStorageAdapter(clusterStorage),
+    wallet: new EnhancedStorageAdapter(walletStorage)
+  }, walletConnectConfig = buildWalletConnectConfig(walletConnect, appName, appUrl, clusterStorageKey ?? "connector-kit:v1:cluster");
+  return {
+    autoConnect,
+    debug: debug ?? process.env.NODE_ENV === "development",
+    storage: defaultStorage,
+    appName,
+    appUrl,
+    enableMobile,
+    network,
+    cluster: {
+      clusters: defaultClusters,
+      persistSelection: persistClusterSelection,
+      initialCluster: getInitialCluster(network)
+    },
+    errorBoundary: {
+      enabled: enableErrorBoundary,
+      maxRetries,
+      onError
+    },
+    imageProxy,
+    programLabels,
+    coingecko,
+    walletConnect: walletConnectConfig
+  };
+}
+function buildWalletConnectConfig(walletConnect, appName, appUrl, clusterStorageKey) {
+  if (!walletConnect) return;
+  let configProjectId = typeof walletConnect == "object" ? walletConnect.projectId : void 0, envProjectId = typeof process < "u" ? process.env.NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID : void 0, projectId = configProjectId || envProjectId;
+  if (!projectId) {
+    (typeof walletConnect == "object" || walletConnect === true) && logger8.warn(
+      "WalletConnect enabled but no project ID found. Set NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID or provide projectId in config."
+    );
+    return;
+  }
+  let origin = appUrl || (typeof window < "u" ? window.location.origin : "http://localhost:3000"), customMetadata = typeof walletConnect == "object" ? walletConnect.metadata : void 0, customDefaultChain = typeof walletConnect == "object" ? walletConnect.defaultChain : void 0, customRelayUrl = typeof walletConnect == "object" ? walletConnect.relayUrl : void 0;
+  return {
+    enabled: true,
+    projectId,
+    metadata: {
+      name: customMetadata?.name ?? appName,
+      description: customMetadata?.description ?? `${appName} - Powered by ConnectorKit`,
+      url: customMetadata?.url ?? origin,
+      icons: customMetadata?.icons ?? [`${origin}/icon.svg`]
+    },
+    defaultChain: customDefaultChain ?? "solana:mainnet",
+    relayUrl: customRelayUrl,
+    // Auto-sync with cluster storage
+    getCurrentChain: () => {
+      if (typeof window > "u") return "solana:mainnet";
+      let storageKey = clusterStorageKey || "connector-kit:v1:cluster";
+      try {
+        let stored = localStorage.getItem(storageKey);
+        if (stored) {
+          let id = JSON.parse(stored);
+          if (id === "solana:mainnet" || id === "solana:devnet" || id === "solana:testnet")
+            return id;
+        }
+      } catch {
+      }
+      return customDefaultChain ?? "solana:mainnet";
+    }
+    // Note: onDisplayUri, onSessionEstablished, onSessionDisconnected are auto-wired by AppProvider
+  };
+}
+function getInitialCluster(network = "mainnet-beta") {
+  return toClusterId(network);
+}
+function getDefaultMobileConfig(options) {
+  let baseUrl = options.appUrl || (typeof window < "u" ? window.location.origin : "https://localhost:3000");
+  return {
+    appIdentity: {
+      name: options.appName,
+      uri: baseUrl,
+      icon: `${baseUrl}/favicon.ico`
+    },
+    cluster: options.network || "mainnet-beta"
+  };
+}
+var solanaNetworkSchema = z.enum(["mainnet", "mainnet-beta", "devnet", "testnet", "localnet"]), solanaClusterIdSchema = z.string().regex(/^solana:(mainnet|devnet|testnet|localnet|[a-zA-Z0-9-]+)$/, {
+  message: 'Cluster ID must be in format "solana:<network>" (e.g., "solana:mainnet")'
+}), urlSchema = z.string().url("Invalid URL format"), optionalUrlSchema = urlSchema.optional(), coinGeckoConfigSchema = z.strictObject({
+  apiKey: z.string().optional(),
+  isPro: z.boolean().optional(),
+  maxRetries: z.number().int().positive().max(10).optional(),
+  baseDelay: z.number().int().positive().max(3e4).optional(),
+  maxTimeout: z.number().int().positive().max(12e4).optional()
+}).optional(), walletConnectMetadataSchema = z.object({
+  name: z.string().min(1, "WalletConnect app name is required"),
+  description: z.string(),
+  url: urlSchema,
+  icons: z.array(z.string())
+}), walletConnectObjectConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  projectId: z.string().min(1, "WalletConnect projectId is required"),
+  metadata: walletConnectMetadataSchema,
+  defaultChain: z.enum(["solana:mainnet", "solana:devnet", "solana:testnet"]).optional(),
+  onDisplayUri: z.custom((val) => typeof val == "function").optional(),
+  onSessionEstablished: z.custom((val) => typeof val == "function").optional(),
+  onSessionDisconnected: z.custom((val) => typeof val == "function").optional(),
+  relayUrl: urlSchema.optional()
+}), walletConnectConfigSchema = z.union([z.literal(true), walletConnectObjectConfigSchema]).optional(), storageAdapterSchema = z.looseObject({
+  get: z.custom((val) => typeof val == "function"),
+  set: z.custom((val) => typeof val == "function")
+}), storageConfigSchema = z.object({
+  account: storageAdapterSchema,
+  cluster: storageAdapterSchema,
+  wallet: storageAdapterSchema
+}).optional(), solanaClusterSchema = z.object({
+  id: solanaClusterIdSchema,
+  label: z.string().min(1, "Cluster label cannot be empty"),
+  url: urlSchema,
+  urlWs: urlSchema.optional()
+}), clusterConfigSchema = z.object({
+  clusters: z.array(solanaClusterSchema).optional(),
+  persistSelection: z.boolean().optional(),
+  initialCluster: solanaClusterIdSchema.optional()
+}).optional(), defaultConfigOptionsSchema = z.object({
+  // Required
+  appName: z.string().min(1, "Application name is required"),
+  // Optional strings
+  appUrl: optionalUrlSchema,
+  imageProxy: z.string().optional(),
+  clusterStorageKey: z.string().optional(),
+  // Optional booleans
+  autoConnect: z.boolean().optional(),
+  debug: z.boolean().optional(),
+  enableMobile: z.boolean().optional(),
+  persistClusterSelection: z.boolean().optional(),
+  enableErrorBoundary: z.boolean().optional(),
+  // Network
+  network: solanaNetworkSchema.optional(),
+  // Numbers
+  maxRetries: z.number().int().positive().max(10).optional(),
+  // Complex types
+  storage: storageConfigSchema,
+  clusters: z.array(solanaClusterSchema).optional(),
+  customClusters: z.array(solanaClusterSchema).optional(),
+  programLabels: z.record(z.string(), z.string()).optional(),
+  coingecko: coinGeckoConfigSchema,
+  walletConnect: walletConnectConfigSchema,
+  // Functions (can't validate implementation, just existence)
+  onError: z.custom((val) => typeof val == "function").optional()
+}); z.strictObject({
+  autoConnect: z.boolean().optional(),
+  debug: z.boolean().optional(),
+  storage: storageConfigSchema,
+  cluster: clusterConfigSchema,
+  imageProxy: z.string().optional(),
+  programLabels: z.record(z.string(), z.string()).optional(),
+  coingecko: coinGeckoConfigSchema,
+  walletConnect: walletConnectConfigSchema
+}).optional();
+function validateConfigOptions(options) {
+  return defaultConfigOptionsSchema.safeParse(options);
+}
+function parseConfigOptions(options) {
+  return defaultConfigOptionsSchema.parse(options);
+}
 
 // src/utils/formatting.ts
 function formatAddress(address, options = {}) {
@@ -1975,7 +2568,7 @@ async function copySignatureToClipboard(signature, options) {
 }
 
 // src/lib/transaction/transaction-validator.ts
-var logger8 = createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232, MIN_TRANSACTION_SIZE = 64, TransactionValidator = class {
+var logger9 = createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232, MIN_TRANSACTION_SIZE = 64, TransactionValidator = class {
   /**
    * Validate a transaction before signing
    *
@@ -1998,7 +2591,7 @@ var logger8 = createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232,
         try {
           serialized = transaction.serialize();
         } catch (serializeError) {
-          logger8.debug("Transaction not yet serializable (may need signing)", {
+          logger9.debug("Transaction not yet serializable (may need signing)", {
             error: serializeError instanceof Error ? serializeError.message : String(serializeError)
           });
         }
@@ -2008,10 +2601,10 @@ var logger8 = createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232,
         return errors.push(
           "Transaction type not recognized - must be a Transaction object with serialize() or Uint8Array"
         ), { valid: false, errors, warnings };
-      serialized && (size = serialized.length, size > maxSize && (errors.push(`Transaction too large: ${size} bytes (max ${maxSize} bytes)`), logger8.warn("Transaction exceeds maximum size", { size, maxSize })), size < minSize && warnings.push(`Transaction is very small: ${size} bytes (min recommended ${minSize} bytes)`), size === 0 && errors.push("Transaction is empty (0 bytes)"), this.hasSuspiciousPattern(serialized) && warnings.push("Transaction contains unusual patterns - please review carefully"));
+      serialized && (size = serialized.length, size > maxSize && (errors.push(`Transaction too large: ${size} bytes (max ${maxSize} bytes)`), logger9.warn("Transaction exceeds maximum size", { size, maxSize })), size < minSize && warnings.push(`Transaction is very small: ${size} bytes (min recommended ${minSize} bytes)`), size === 0 && errors.push("Transaction is empty (0 bytes)"), this.hasSuspiciousPattern(serialized) && warnings.push("Transaction contains unusual patterns - please review carefully"));
     } catch (error) {
       let errorMessage = error instanceof Error ? error.message : String(error);
-      errors.push(`Transaction validation failed: ${errorMessage}`), logger8.error("Validation error", { error: errorMessage });
+      errors.push(`Transaction validation failed: ${errorMessage}`), logger9.error("Validation error", { error: errorMessage });
     }
     if (checkDuplicateSignatures && typeof transaction == "object" && "signatures" in transaction) {
       let signatures = transaction.signatures;
@@ -2024,7 +2617,7 @@ var logger8 = createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232,
     }
     strict && warnings.length > 0 && (errors.push(...warnings.map((w) => `Strict mode: ${w}`)), warnings.length = 0);
     let valid = errors.length === 0;
-    return valid ? warnings.length > 0 ? logger8.debug("Transaction validation passed with warnings", { warnings, size }) : logger8.debug("Transaction validation passed", { size }) : logger8.warn("Transaction validation failed", { errors, size }), {
+    return valid ? warnings.length > 0 ? logger9.debug("Transaction validation passed with warnings", { warnings, size }) : logger9.debug("Transaction validation passed", { size }) : logger9.warn("Transaction validation failed", { errors, size }), {
       valid,
       errors,
       warnings,
@@ -2064,7 +2657,7 @@ var logger8 = createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232,
     let result = this.validate(transaction, options);
     if (!result.valid)
       throw new Error(`Transaction validation failed: ${result.errors.join(", ")}`);
-    result.warnings.length > 0 && logger8.warn("Transaction validation warnings", { warnings: result.warnings });
+    result.warnings.length > 0 && logger9.warn("Transaction validation warnings", { warnings: result.warnings });
   }
   /**
    * Batch validate multiple transactions
@@ -2075,10 +2668,10 @@ var logger8 = createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232,
    * @returns Array of validation results
    */
   static validateBatch(transactions, options) {
-    return transactions.map((tx, index) => (logger8.debug(`Validating transaction ${index + 1}/${transactions.length}`), this.validate(tx, options)));
+    return transactions.map((tx, index) => (logger9.debug(`Validating transaction ${index + 1}/${transactions.length}`), this.validate(tx, options)));
   }
 };
-var logger9 = createLogger("TransactionSigner");
+var logger10 = createLogger("TransactionSigner");
 function signatureBytesToBase58(bytes) {
   if (bytes.length !== 64)
     throw new Error(`Invalid signature length: expected 64 bytes, got ${bytes.length}`);
@@ -2100,6 +2693,24 @@ function extractSignatureString(result) {
   }
   throw new Error("Unexpected wallet response format for signAndSendTransaction");
 }
+function extractSignatureBytes(result) {
+  if (result instanceof Uint8Array)
+    return result;
+  if (Array.isArray(result)) {
+    let [first] = result;
+    if (!first)
+      throw new Error("Wallet returned empty results array");
+    return extractSignatureBytes(first);
+  }
+  if (result && typeof result == "object") {
+    let record = result;
+    if ("signature" in record)
+      return extractSignatureBytes(record.signature);
+    if (Array.isArray(record.signatures) && record.signatures.length > 0)
+      return extractSignatureBytes(record.signatures[0]);
+  }
+  throw new Error("Unexpected wallet response format for signMessage");
+}
 function createTransactionSigner(config) {
   let { wallet, account, cluster, eventEmitter } = config;
   if (!wallet || !account)
@@ -2116,11 +2727,11 @@ function createTransactionSigner(config) {
         throw Errors.featureNotSupported("transaction signing");
       let validation = TransactionValidator.validate(transaction);
       if (!validation.valid)
-        throw logger9.error("Transaction validation failed", { errors: validation.errors }), Errors.invalidTransaction(validation.errors.join(", "));
-      validation.warnings.length > 0 && logger9.warn("Transaction validation warnings", { warnings: validation.warnings });
+        throw logger10.error("Transaction validation failed", { errors: validation.errors }), Errors.invalidTransaction(validation.errors.join(", "));
+      validation.warnings.length > 0 && logger10.warn("Transaction validation warnings", { warnings: validation.warnings });
       try {
         let signFeature = features["solana:signTransaction"], { serialized, wasWeb3js } = prepareTransactionForWallet(transaction);
-        logger9.debug("Signing transaction", {
+        logger10.debug("Signing transaction", {
           wasWeb3js,
           serializedLength: serialized.length,
           serializedType: serialized.constructor.name,
@@ -2129,26 +2740,26 @@ function createTransactionSigner(config) {
         });
         let result, usedFormat = "";
         try {
-          logger9.debug("Trying array format: transactions: [Uint8Array]"), result = await signFeature.signTransaction({
+          logger10.debug("Trying array format: transactions: [Uint8Array]"), result = await signFeature.signTransaction({
             account,
             transactions: [serialized],
             ...cluster ? { chain: cluster.id } : {}
           }), usedFormat = "array";
         } catch (err1) {
           let error1 = err1 instanceof Error ? err1 : new Error(String(err1));
-          logger9.debug("Array format failed, trying singular format", { error: error1.message });
+          logger10.debug("Array format failed, trying singular format", { error: error1.message });
           try {
-            logger9.debug("Trying singular format: transaction: Uint8Array"), result = await signFeature.signTransaction({
+            logger10.debug("Trying singular format: transaction: Uint8Array"), result = await signFeature.signTransaction({
               account,
               transaction: serialized,
               ...cluster ? { chain: cluster.id } : {}
             }), usedFormat = "singular";
           } catch (err2) {
             let error2 = err2 instanceof Error ? err2 : new Error(String(err2));
-            throw logger9.error("Both array and singular formats failed", { error: error2.message }), error2;
+            throw logger10.error("Both array and singular formats failed", { error: error2.message }), error2;
           }
         }
-        logger9.debug("Wallet signed successfully", { format: usedFormat });
+        logger10.debug("Wallet signed successfully", { format: usedFormat });
         let signedTx;
         if (Array.isArray(result.signedTransactions) && result.signedTransactions[0])
           signedTx = result.signedTransactions[0];
@@ -2160,23 +2771,23 @@ function createTransactionSigner(config) {
           signedTx = result;
         else
           throw new Error(`Unexpected wallet response format: ${JSON.stringify(Object.keys(result))}`);
-        if (logger9.debug("Extracted signed transaction", {
+        if (logger10.debug("Extracted signed transaction", {
           hasSignedTx: !!signedTx,
           signedTxType: signedTx?.constructor?.name,
           signedTxLength: signedTx?.length,
           isUint8Array: signedTx instanceof Uint8Array,
           hasSerialize: typeof signedTx?.serialize == "function"
         }), signedTx && typeof signedTx.serialize == "function")
-          return logger9.debug("Wallet returned web3.js object directly, no conversion needed"), signedTx;
+          return logger10.debug("Wallet returned web3.js object directly, no conversion needed"), signedTx;
         if (signedTx && signedTx.signedTransaction) {
-          logger9.debug("Found signedTransaction property");
+          logger10.debug("Found signedTransaction property");
           let bytes = signedTx.signedTransaction;
           if (bytes instanceof Uint8Array)
             return await convertSignedTransaction(bytes, wasWeb3js);
         }
         if (signedTx instanceof Uint8Array)
           return await convertSignedTransaction(signedTx, wasWeb3js);
-        throw logger9.error("Unexpected wallet response format", {
+        throw logger10.error("Unexpected wallet response format", {
           type: typeof signedTx,
           constructor: signedTx?.constructor?.name
         }), new ValidationError(
@@ -2196,9 +2807,15 @@ function createTransactionSigner(config) {
             account,
             transactions: serializedTxs,
             ...cluster ? { chain: cluster.id } : {}
-          });
+          }), signedBytesArray;
+          if (Array.isArray(result))
+            signedBytesArray = result.map((item) => item.signedTransaction);
+          else if ("signedTransactions" in result)
+            signedBytesArray = result.signedTransactions;
+          else
+            throw new Error("Unexpected signAllTransactions response format");
           return await Promise.all(
-            result.signedTransactions.map(
+            signedBytesArray.map(
               (signedBytes) => convertSignedTransaction(signedBytes, wasWeb3js)
             )
           );
@@ -2292,11 +2909,12 @@ function createTransactionSigner(config) {
     ...capabilities.canSignMessage && {
       async signMessage(message) {
         try {
-          return (await features["solana:signMessage"].signMessage({
+          let result = await features["solana:signMessage"].signMessage({
             account,
             message,
             ...cluster ? { chain: cluster.id } : {}
-          })).signature;
+          });
+          return extractSignatureBytes(result);
         } catch (error) {
           throw new TransactionError("SIGNING_FAILED", "Failed to sign message", void 0, error);
         }
@@ -2317,7 +2935,7 @@ var TransactionSignerError = class extends TransactionError {
 function isTransactionSignerError(error) {
   return error instanceof TransactionSignerError || error instanceof TransactionError;
 }
-var logger10 = createLogger("KitTransactionSigner");
+var logger11 = createLogger("KitTransactionSigner");
 function encodeShortVecLength(value) {
   let bytes = [], remaining = value;
   for (; remaining >= 128; )
@@ -2392,7 +3010,7 @@ function createKitTransactionSigner(connectorSigner) {
     async modifyAndSignTransactions(transactions) {
       let transactionData = transactions.map((tx) => {
         let messageBytes = new Uint8Array(tx.messageBytes), { numSigners } = parseMessageSigners(messageBytes), wireFormat = createTransactionBytesForSigning(messageBytes, numSigners);
-        return logger10.debug("Preparing wire format for wallet", {
+        return logger11.debug("Preparing wire format for wallet", {
           signerAddress,
           messageBytesLength: messageBytes.length,
           wireFormatLength: wireFormat.length,
@@ -2421,14 +3039,14 @@ function createKitTransactionSigner(connectorSigner) {
               throw new Error("Web3.js transaction without serialize method");
           } else
             throw new Error("Unknown signed transaction format");
-          if (logger10.debug("Wallet returned signed transaction", {
+          if (logger11.debug("Wallet returned signed transaction", {
             returnedLength: signedTxBytes.length,
             sentLength: wireFormat.length,
             lengthsMatch: signedTxBytes.length === wireFormat.length,
             signedFirstBytes: Array.from(signedTxBytes.slice(0, 20)),
             sentFirstBytes: Array.from(wireFormat.slice(0, 20))
           }), signedTxBytes.length !== wireFormat.length) {
-            logger10.warn("Wallet modified transaction! Using wallet version", {
+            logger11.warn("Wallet modified transaction! Using wallet version", {
               originalLength: wireFormat.length,
               modifiedLength: signedTxBytes.length,
               difference: signedTxBytes.length - wireFormat.length
@@ -2439,13 +3057,13 @@ function createKitTransactionSigner(connectorSigner) {
                 lifetimeConstraint: originalWithLifetime.lifetimeConstraint
               } : {}
             };
-            return logger10.debug("Using modified transaction from wallet", {
+            return logger11.debug("Using modified transaction from wallet", {
               modifiedMessageBytesLength: walletTransaction.messageBytes.length,
               signatures: Object.keys(walletTransaction.signatures)
             }), assertIsTransactionWithinSizeLimit(result), result;
           }
           let extractedSignatureBytes = extractSignature(signedTxBytes), signatureBase58 = getBase58Decoder().decode(extractedSignatureBytes);
-          logger10.debug("Extracted signature from wallet (unmodified)", {
+          logger11.debug("Extracted signature from wallet (unmodified)", {
             signerAddress,
             signatureLength: extractedSignatureBytes.length,
             signatureBase58
@@ -2460,7 +3078,7 @@ function createKitTransactionSigner(connectorSigner) {
           };
           return assertIsTransactionWithinSizeLimit(signedTransaction), signedTransaction;
         } catch (error) {
-          return logger10.error("Failed to decode signed transaction", { error }), assertIsTransactionWithinSizeLimit(originalTransaction), originalTransaction;
+          return logger11.error("Failed to decode signed transaction", { error }), assertIsTransactionWithinSizeLimit(originalTransaction), originalTransaction;
         }
       });
     }
@@ -2468,6 +3086,6 @@ function createKitTransactionSigner(connectorSigner) {
 }
 var createGillTransactionSigner = createKitTransactionSigner;
 
-export { ClipboardErrorType, ConnectorClient, ConnectorErrorBoundary, DEFAULT_MAX_RETRIES, PUBLIC_RPC_ENDPOINTS, TransactionSignerError, WalletErrorType, copyAddressToClipboard, copySignatureToClipboard, copyToClipboard, createGillTransactionSigner, createKitTransactionSigner, createTransactionSigner, formatAddress, formatBigIntBalance, formatBigIntUsd, formatLamportsToSolSafe, formatNumber, formatSOL, formatTokenAmount, formatTokenBalanceSafe, getAddressUrl, getBlockUrl, getChainIdForWalletStandard, getClusterChainId, getClusterExplorerUrl, getClusterName, getClusterRpcUrl, getClusterType, getDefaultRpcUrl, getNetworkDisplayName, getPolyfillStatus, getTokenUrl, getTransactionUrl, getWalletsRegistry, installPolyfills, isClipboardAvailable, isCryptoAvailable, isDevnet, isDevnetCluster, isLocalCluster, isLocalnet, isMainnet, isMainnetCluster, isPolyfillInstalled, isTestnet, isTestnetCluster, isTransactionSignerError, normalizeNetwork, ready, toClusterId, truncate, withErrorBoundary };
-//# sourceMappingURL=chunk-MAXA3HEP.mjs.map
-//# sourceMappingURL=chunk-MAXA3HEP.mjs.map
+export { ClipboardErrorType, ConnectorClient, EnhancedStorage, EnhancedStorageAdapter, INITIAL_WALLET_STATUS, PUBLIC_RPC_ENDPOINTS, TransactionSignerError, WALLET_STATE_VERSION, clearWalletState, copyAddressToClipboard, copySignatureToClipboard, copyToClipboard, createConnectorId, createEnhancedStorageAccount, createEnhancedStorageCluster, createEnhancedStorageWallet, createEnhancedStorageWalletState, createGillTransactionSigner, createKitTransactionSigner, createTransactionSigner, formatAddress, formatBigIntBalance, formatBigIntUsd, formatLamportsToSolSafe, formatNumber, formatSOL, formatTokenAmount, formatTokenBalanceSafe, getAddressUrl, getBlockUrl, getChainIdForWalletStandard, getClusterChainId, getClusterExplorerUrl, getClusterName, getClusterRpcUrl, getClusterType, getDefaultConfig, getDefaultMobileConfig, getDefaultRpcUrl, getNetworkDisplayName, getPolyfillStatus, getTokenUrl, getTransactionUrl, getWalletNameFromConnectorId, getWalletsRegistry, installPolyfills, isClipboardAvailable, isConnected, isConnecting, isCryptoAvailable, isDevnet, isDevnetCluster, isDisconnected, isLocalCluster, isLocalnet, isMainnet, isMainnetCluster, isPolyfillInstalled, isStatusError, isTestnet, isTestnetCluster, isTransactionSignerError, isWalletConnectorId, isWalletStatusError, normalizeNetwork, parseConfigOptions, ready, saveWalletState, toClusterId, toLegacyWalletState, truncate, validateConfigOptions };
+//# sourceMappingURL=chunk-IDTUFDNB.mjs.map
+//# sourceMappingURL=chunk-IDTUFDNB.mjs.map