@solana/connector 0.1.8 → 0.1.10

package/dist/{chunk-6F6M6L7R.mjs → chunk-QOIQBWMP.mjs}

@@ -1,10 +1,13 @@
-import { createLogger, getPublicSolanaRpcUrl, getExplorerLink, __publicField, tryCatchSync, TransactionError, isWeb3jsTransaction, Errors, prepareTransactionForWallet, convertSignedTransaction, ValidationError, isConnectorError } from './chunk-J7DHGLW6.mjs';
+import { tryCatchSync, isWeb3jsTransaction, prepareTransactionForWallet, convertSignedTransaction } from './chunk-HO6QNKFM.mjs';
+import { createLogger, getPublicSolanaRpcUrl, getExplorerLink, __publicField, TransactionError, Errors, ValidationError, isConnectorError } from './chunk-DKCZA2QI.mjs';
 import { Component, useTransition, useState, useCallback, useMemo } from 'react';
 import { jsx, jsxs } from 'react/jsx-runtime';
 import { install } from '@solana/webcrypto-ed25519-polyfill';
-import { address, isAddress } from '@solana/addresses';
-import { getTransactionDecoder, assertIsTransactionWithinSizeLimit } from '@solana/transactions';
+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/lib/wallet/standard-shim.ts
 var registry = null, registryInitPromise = null, registryInitResolve = null, ready = new Promise((resolve, reject) => {
@@ -620,6 +623,38 @@ var logger2 = createLogger("WalletAuthenticity"), WalletAuthenticityVerifier = c
   }
 };
 
+// src/lib/wallet/wallet-icon-overrides.ts
+var PHANTOM_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cmVjdCB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHJ4PSIxMiIgZmlsbD0iIzk3ODZFNCIvPjxnIGNsaXAtcGF0aD0idXJsKCNjbGlwMF80NF82MTApIj48cGF0aCBkPSJNNS43NjU1IDE1Ljc5N0M1Ljc2NTUgMTcuMjIyIDYuNDk4NzkgMTcuNTUgNy4yNjE0MSAxNy41NUM4Ljg3NDYzIDE3LjU1IDEwLjA4NyAxNi4wODQxIDEwLjgxMDUgMTQuOTI1NkMxMC43MjI1IDE1LjE4MTkgMTAuNjczNiAxNS40MzgyIDEwLjY3MzYgMTUuNjg0MkMxMC42NzM2IDE2LjM2MDkgMTEuMDQ1MiAxNi44NDI3IDExLjc3ODUgMTYuODQyN0MxMi43ODU1IDE2Ljg0MjcgMTMuODYxIDE1LjkyIDE0LjQxODMgMTQuOTI1NkMxNC4zNzkyIDE1LjA2OTIgMTQuMzU5NiAxNS4yMDI0IDE0LjM1OTYgMTUuMzI1NEMxNC4zNTk2IDE1Ljc5NyAxNC42MTM4IDE2LjA5NDMgMTUuMTMyIDE2LjA5NDNDMTYuNzY0OCAxNi4wOTQzIDE4LjQwNzQgMTMuMDcwMSAxOC40MDc0IDEwLjQyNTJDMTguNDA3NCA4LjM2NDU5IDE3LjQxMDEgNi41NTAwNSAxNC45MDcxIDYuNTUwMDVDMTAuNTA3NCA2LjU1MDA1IDUuNzY1NSAxMi4xNjc5IDUuNzY1NSAxNS43OTdaTTEzLjM5MTcgMTAuMTk5NkMxMy4zOTE3IDkuNjg3MDUgMTMuNjY1NCA5LjMyODI1IDE0LjA2NjMgOS4zMjgyNUMxNC40NTc0IDkuMzI4MjUgMTQuNzMxMiA5LjY4NzA1IDE0LjczMTIgMTAuMTk5NkMxNC43MzEyIDEwLjcxMjIgMTQuNDU3NCAxMS4wODEzIDE0LjA2NjMgMTEuMDgxM0MxMy42NjU0IDExLjA4MTMgMTMuMzkxNyAxMC43MTIyIDEzLjM5MTcgMTAuMTk5NlpNMTUuNDg0IDEwLjE5OTZDMTUuNDg0IDkuNjg3MDUgMTUuNzU3OCA5LjMyODI1IDE2LjE1ODYgOS4zMjgyNUMxNi41NDk3IDkuMzI4MjUgMTYuODIzNSA5LjY4NzA1IDE2LjgyMzUgMTAuMTk5NkMxNi44MjM1IDEwLjcxMjIgMTYuNTQ5NyAxMS4wODEzIDE2LjE1ODYgMTEuMDgxM0MxNS43NTc4IDExLjA4MTMgMTUuNDg0IDEwLjcxMjIgMTUuNDg0IDEwLjE5OTZaIiBmaWxsPSIjRkVGREY4Ii8+PC9nPjxkZWZzPjxjbGlwUGF0aCBpZD0iY2xpcDBfNDRfNjEwIj48cmVjdCB3aWR0aD0iMTIuNzYiIGhlaWdodD0iMTEiIGZpbGw9IndoaXRlIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSg1LjcwNjQyIDYuNTQ5OTMpIi8+PC9jbGlwUGF0aD48L2RlZnM+PC9zdmc+", SOLFLARE_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cmVjdCB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHJ4PSIxMiIgZmlsbD0iI0ZGRUY0NiIvPjxwYXRoIGQ9Ik0xMi4xMjg1IDEyLjUyNjZMMTIuOTU1NiAxMS43Mjc2TDE0LjQ5NzYgMTIuMjMyM0MxNS41MDcgMTIuNTY4NyAxNi4wMTE3IDEzLjE4NTUgMTYuMDExNyAxNC4wNTQ3QzE2LjAxMTcgMTQuNzEzNiAxNS43NTkzIDE1LjE0ODIgMTUuMjU0NyAxNS43MDg5TDE1LjEwMDUgMTUuODc3MUwxNS4xNTY1IDE1LjQ4NDZDMTUuMzgwOCAxNC4wNTQ3IDE0Ljk2MDMgMTMuNDM3OSAxMy41NzI0IDEyLjk4OTJMMTIuMTI4NSAxMi41MjY2Wk0xMC4wNTM3IDcuNjM0MTRMMTQuMjU5MyA5LjAzNkwxMy4zNDgxIDkuOTA1MTdMMTEuMTYxMiA5LjE3NjE5QzEwLjQwNDIgOC45MjM4NSAxMC4xNTE4IDguNTE3MzEgMTAuMDUzNyA3LjY2MjE3VjcuNjM0MTRaTTkuODAxMzUgMTQuNzU1NkwxMC43NTQ2IDEzLjg0NDRMMTIuNTQ5MSAxNC40MzMyQzEzLjQ4ODMgMTQuNzQxNiAxMy44MTA3IDE1LjE0ODIgMTMuNzEyNiAxNi4xNzE1TDkuODAxMzUgMTQuNzU1NlpNOC41OTU3NyAxMC42OTAyQzguNTk1NzcgMTAuNDIzOSA4LjczNTk1IDEwLjE3MTUgOC45NzQyNyA5Ljk2MTIyQzkuMjI2NjEgMTAuMzI1NyA5LjY2MTE4IDEwLjY0ODEgMTAuMzQ4MSAxMC44NzI1TDExLjgzNDEgMTEuMzYzMUwxMS4wMDcgMTIuMTYyMkw5LjU0OTAzIDExLjY4NTVDOC44NzYxNCAxMS40NjEyIDguNTk1NzcgMTEuMTI0OCA4LjU5NTc3IDEwLjY5MDJaTTEyLjk5NzYgMTguMDVDMTYuMDgxNyAxNi4wMDMzIDE3LjczNTkgMTQuNjE1NCAxNy43MzU5IDEyLjkwNTJDMTcuNzM1OSAxMS43Njk2IDE3LjA2MyAxMS4xMzg4IDE1LjU3NzEgMTAuNjQ4MUwxNC40NTU2IDEwLjI2OTZMMTcuNTI1NyA3LjMyNTcyTDE2LjkwODggNi42NjY4NEwxNS45OTc2IDcuNDY1OUwxMS42OTM5IDYuMDUwMDJDMTAuMzYyMSA2LjQ4NDYgOC42Nzk4OCA3Ljc2MDMgOC42Nzk4OCA5LjAzNkM4LjY3OTg4IDkuMTc2MTggOC42OTM5IDkuMzE2MzcgOC43MzU5NSA5LjQ3MDU5QzcuNjI4NDcgMTAuMTAxNCA3LjE3OTg4IDEwLjY5MDIgNy4xNzk4OCAxMS40MTkxQzcuMTc5ODggMTIuMTA2MSA3LjU0NDM2IDEyLjc5MyA4LjcwNzkyIDEzLjE3MTVMOS42MzMxNCAxMy40Nzk5TDYuNDM2ODkgMTYuNTVMNy4wNTM3MSAxNy4yMDg5TDguMDQ5MDQgMTYuMjk3N0wxMi45OTc2IDE4LjA1WiIgZmlsbD0iIzAyMDUwQSIvPjwvc3ZnPg==", BACKPACK_ICON = "data:image/svg+xml;base64,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", 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 hasFeature(wallet, featureName) {
@@ -750,9 +785,9 @@ var WalletDetector = class extends BaseCollaborator {
    * Convert a Wallet Standard wallet to WalletInfo with capability checks
    */
   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"), hasDisconnect = hasFeature(walletWithIcon, "standard:disconnect"), isSolana = Array.isArray(walletWithIcon.chains) && walletWithIcon.chains.some((c) => typeof c == "string" && c.includes("solana"));
     return {
-      wallet,
+      wallet: walletWithIcon,
       installed: true,
       connectable: hasConnect && hasDisconnect && isSolana
     };
@@ -797,6 +832,9 @@ 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;
   }
   /**
@@ -804,8 +842,8 @@ var ConnectionManager = class extends BaseCollaborator {
    */
   async connect(wallet, walletName) {
     if (typeof window > "u") return;
-    let name = walletName || wallet.name;
-    this.eventEmitter.emit({
+    let name = walletName || wallet.name, attemptId = ++this.connectAttemptId;
+    this.pendingWallet = wallet, this.pendingWalletName = name, this.eventEmitter.emit({
       type: "connecting",
       wallet: name,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -813,7 +851,10 @@ var ConnectionManager = class extends BaseCollaborator {
     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(
@@ -840,6 +881,8 @@ 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) {
+      if (attemptId !== this.connectAttemptId)
+        throw e;
       let errorMessage = e instanceof Error ? e.message : String(e);
       throw this.eventEmitter.emit({
         type: "connection:failed",
@@ -861,22 +904,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.stateManager.updateState(
       {
         selectedWallet: null,
         connected: false,
+        connecting: false,
         accounts: [],
         selectedAccount: null
       },
@@ -884,7 +926,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
@@ -1092,12 +1141,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 +1154,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,6 +1368,7 @@ 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 = {
       wallets: [],
@@ -1362,7 +1412,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,6 +1422,19 @@ 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-I3PZUBTA.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 });
+      }
+  }
   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`);
@@ -1462,6 +1527,12 @@ var logger5 = createLogger("ConnectorClient"), ConnectorClient = class {
     this.debugMetrics.resetMetrics();
   }
   destroy() {
+    if (this.walletConnectRegistration)
+      try {
+        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();
   }
@@ -1764,6 +1835,355 @@ function getPolyfillStatus() {
     environment: typeof window < "u" ? "browser" : "server"
   };
 }
+var logger8 = 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) : (logger8.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) {
+    logger8.error("Storage error", { key: this.key, error }), this.errorHandlers.forEach((handler) => {
+      try {
+        handler(error);
+      } catch (err) {
+        logger8.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 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 logger9 = 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 && logger9.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 && logger9.error("Cluster Storage error", { error }), onError && onError(error, {
+        componentStack: "cluster-storage"
+      });
+    }
+  }), walletStorage = createEnhancedStorageWallet({
+    onError: (error) => {
+      debug && logger9.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) && logger9.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 +2395,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 logger10 = createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232, MIN_TRANSACTION_SIZE = 64, TransactionValidator = class {
   /**
    * Validate a transaction before signing
    *
@@ -1998,7 +2418,7 @@ var logger8 = createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232,
         try {
           serialized = transaction.serialize();
         } catch (serializeError) {
-          logger8.debug("Transaction not yet serializable (may need signing)", {
+          logger10.debug("Transaction not yet serializable (may need signing)", {
             error: serializeError instanceof Error ? serializeError.message : String(serializeError)
           });
         }
@@ -2008,10 +2428,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)`), logger10.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}`), logger10.error("Validation error", { error: errorMessage });
     }
     if (checkDuplicateSignatures && typeof transaction == "object" && "signatures" in transaction) {
       let signatures = transaction.signatures;
@@ -2024,7 +2444,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 ? logger10.debug("Transaction validation passed with warnings", { warnings, size }) : logger10.debug("Transaction validation passed", { size }) : logger10.warn("Transaction validation failed", { errors, size }), {
       valid,
       errors,
       warnings,
@@ -2064,7 +2484,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 && logger10.warn("Transaction validation warnings", { warnings: result.warnings });
   }
   /**
    * Batch validate multiple transactions
@@ -2075,12 +2495,31 @@ 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) => (logger10.debug(`Validating transaction ${index + 1}/${transactions.length}`), this.validate(tx, options)));
   }
 };
-
-// src/lib/transaction/transaction-signer.ts
-var logger9 = createLogger("TransactionSigner");
+var logger11 = createLogger("TransactionSigner");
+function signatureBytesToBase58(bytes) {
+  if (bytes.length !== 64)
+    throw new Error(`Invalid signature length: expected 64 bytes, got ${bytes.length}`);
+  return getBase58Decoder().decode(bytes);
+}
+function extractSignatureString(result) {
+  if (typeof result == "string")
+    return result;
+  if (result instanceof Uint8Array)
+    return signatureBytesToBase58(result);
+  if (Array.isArray(result) && result.length > 0)
+    return extractSignatureString(result[0]);
+  if (result && typeof result == "object") {
+    let record = result;
+    if ("signature" in record)
+      return extractSignatureString(record.signature);
+    if (Array.isArray(record.signatures) && record.signatures.length > 0)
+      return extractSignatureString(record.signatures[0]);
+  }
+  throw new Error("Unexpected wallet response format for signAndSendTransaction");
+}
 function createTransactionSigner(config) {
   let { wallet, account, cluster, eventEmitter } = config;
   if (!wallet || !account)
@@ -2097,11 +2536,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 logger11.error("Transaction validation failed", { errors: validation.errors }), Errors.invalidTransaction(validation.errors.join(", "));
+      validation.warnings.length > 0 && logger11.warn("Transaction validation warnings", { warnings: validation.warnings });
       try {
         let signFeature = features["solana:signTransaction"], { serialized, wasWeb3js } = prepareTransactionForWallet(transaction);
-        logger9.debug("Signing transaction", {
+        logger11.debug("Signing transaction", {
           wasWeb3js,
           serializedLength: serialized.length,
           serializedType: serialized.constructor.name,
@@ -2110,26 +2549,26 @@ function createTransactionSigner(config) {
         });
         let result, usedFormat = "";
         try {
-          logger9.debug("Trying array format: transactions: [Uint8Array]"), result = await signFeature.signTransaction({
+          logger11.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 });
+          logger11.debug("Array format failed, trying singular format", { error: error1.message });
           try {
-            logger9.debug("Trying singular format: transaction: Uint8Array"), result = await signFeature.signTransaction({
+            logger11.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 logger11.error("Both array and singular formats failed", { error: error2.message }), error2;
           }
         }
-        logger9.debug("Wallet signed successfully", { format: usedFormat });
+        logger11.debug("Wallet signed successfully", { format: usedFormat });
         let signedTx;
         if (Array.isArray(result.signedTransactions) && result.signedTransactions[0])
           signedTx = result.signedTransactions[0];
@@ -2141,23 +2580,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 (logger11.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 logger11.debug("Wallet returned web3.js object directly, no conversion needed"), signedTx;
         if (signedTx && signedTx.signedTransaction) {
-          logger9.debug("Found signedTransaction property");
+          logger11.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 logger11.error("Unexpected wallet response format", {
           type: typeof signedTx,
           constructor: signedTx?.constructor?.name
         }), new ValidationError(
@@ -2177,9 +2616,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)
             )
           );
@@ -2240,7 +2685,7 @@ function createTransactionSigner(config) {
             transaction: serialized
           });
         }
-        let signature = typeof result == "object" && result.signature ? result.signature : String(result);
+        let signature = extractSignatureString(result);
         return eventEmitter && eventEmitter.emit({
           type: "transaction:sent",
           signature,
@@ -2298,7 +2743,7 @@ var TransactionSignerError = class extends TransactionError {
 function isTransactionSignerError(error) {
   return error instanceof TransactionSignerError || error instanceof TransactionError;
 }
-var logger10 = createLogger("KitTransactionSigner");
+var logger12 = createLogger("KitTransactionSigner");
 function encodeShortVecLength(value) {
   let bytes = [], remaining = value;
   for (; remaining >= 128; )
@@ -2318,6 +2763,29 @@ function decodeShortVecLength(data) {
   }
   return { length, bytesConsumed: size };
 }
+function parseMessageSigners(messageBytes) {
+  let offset = 0;
+  if (messageBytes.length < 4)
+    throw new Error("Invalid message: too short for header");
+  if (messageBytes[0] === 128 && (offset = 1), offset + 3 > messageBytes.length)
+    throw new Error("Invalid message: incomplete header");
+  let numSignerAccounts = messageBytes[offset];
+  if (offset += 3, offset >= messageBytes.length)
+    throw new Error("Invalid message: no static accounts section");
+  let { length: numStaticAccounts, bytesConsumed } = decodeShortVecLength(messageBytes.subarray(offset));
+  offset += bytesConsumed;
+  let staticAccounts = [], base58Decoder = getBase58Decoder();
+  for (let i = 0; i < numStaticAccounts && i < numSignerAccounts; i++) {
+    if (offset + 32 > messageBytes.length)
+      throw new Error(`Invalid message: incomplete account ${i}`);
+    let accountBytes = messageBytes.subarray(offset, offset + 32), accountAddress = base58Decoder.decode(accountBytes);
+    staticAccounts.push(accountAddress), offset += 32;
+  }
+  return {
+    numSigners: numSignerAccounts,
+    staticAccounts
+  };
+}
 function createTransactionBytesForSigning(messageBytes, numSigners) {
   let numSignaturesBytes = encodeShortVecLength(numSigners), signatureSlots = new Uint8Array(numSigners * 64), totalLength = numSignaturesBytes.length + signatureSlots.length + messageBytes.length, transactionBytes = new Uint8Array(totalLength), offset = 0;
   return transactionBytes.set(numSignaturesBytes, offset), offset += numSignaturesBytes.length, transactionBytes.set(signatureSlots, offset), offset += signatureSlots.length, transactionBytes.set(messageBytes, offset), transactionBytes;
@@ -2349,8 +2817,8 @@ function createKitTransactionSigner(connectorSigner) {
     address: signerAddress,
     async modifyAndSignTransactions(transactions) {
       let transactionData = transactions.map((tx) => {
-        let messageBytes = new Uint8Array(tx.messageBytes), numSigners = Object.keys(tx.signatures).length, wireFormat = createTransactionBytesForSigning(messageBytes, numSigners);
-        return logger10.debug("Preparing wire format for wallet", {
+        let messageBytes = new Uint8Array(tx.messageBytes), { numSigners } = parseMessageSigners(messageBytes), wireFormat = createTransactionBytesForSigning(messageBytes, numSigners);
+        return logger12.debug("Preparing wire format for wallet", {
           signerAddress,
           messageBytesLength: messageBytes.length,
           wireFormatLength: wireFormat.length,
@@ -2379,14 +2847,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 (logger12.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", {
+            logger12.warn("Wallet modified transaction! Using wallet version", {
               originalLength: wireFormat.length,
               modifiedLength: signedTxBytes.length,
               difference: signedTxBytes.length - wireFormat.length
@@ -2397,13 +2865,13 @@ function createKitTransactionSigner(connectorSigner) {
                 lifetimeConstraint: originalWithLifetime.lifetimeConstraint
               } : {}
             };
-            return logger10.debug("Using modified transaction from wallet", {
+            return logger12.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)", {
+          logger12.debug("Extracted signature from wallet (unmodified)", {
             signerAddress,
             signatureLength: extractedSignatureBytes.length,
             signatureBase58
@@ -2418,7 +2886,7 @@ function createKitTransactionSigner(connectorSigner) {
           };
           return assertIsTransactionWithinSizeLimit(signedTransaction), signedTransaction;
         } catch (error) {
-          return logger10.error("Failed to decode signed transaction", { error }), assertIsTransactionWithinSizeLimit(originalTransaction), originalTransaction;
+          return logger12.error("Failed to decode signed transaction", { error }), assertIsTransactionWithinSizeLimit(originalTransaction), originalTransaction;
         }
       });
     }
@@ -2426,6 +2894,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-6F6M6L7R.mjs.map
-//# sourceMappingURL=chunk-6F6M6L7R.mjs.map
+export { ClipboardErrorType, ConnectorClient, ConnectorErrorBoundary, EnhancedStorage, EnhancedStorageAdapter, PUBLIC_RPC_ENDPOINTS, TransactionSignerError, WalletErrorType, copyAddressToClipboard, copySignatureToClipboard, copyToClipboard, createEnhancedStorageAccount, createEnhancedStorageCluster, createEnhancedStorageWallet, 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, getWalletsRegistry, installPolyfills, isClipboardAvailable, isCryptoAvailable, isDevnet, isDevnetCluster, isLocalCluster, isLocalnet, isMainnet, isMainnetCluster, isPolyfillInstalled, isTestnet, isTestnetCluster, isTransactionSignerError, normalizeNetwork, parseConfigOptions, ready, toClusterId, truncate, validateConfigOptions, withErrorBoundary };
+//# sourceMappingURL=chunk-QOIQBWMP.mjs.map
+//# sourceMappingURL=chunk-QOIQBWMP.mjs.map