@solana/connector 0.1.7 → 0.1.9

package/dist/{chunk-VA6LKXCQ.js → chunk-5HRJKCIL.js}

@@ -1,15 +1,32 @@
 'use strict';
 
-var chunkI64FD2EH_js = require('./chunk-I64FD2EH.js');
+var chunkDSUCH44G_js = require('./chunk-DSUCH44G.js');
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var webcryptoEd25519Polyfill = require('@solana/webcrypto-ed25519-polyfill');
 var addresses = require('@solana/addresses');
-var transactions = require('@solana/transactions');
 var codecs = require('@solana/codecs');
+var transactions = require('@solana/transactions');
 
-// src/lib/adapters/wallet-standard-shim.ts
-var registry = null;
+// src/lib/wallet/standard-shim.ts
+var registry = null, registryInitPromise = null, registryInitResolve = null, ready = new Promise((resolve, reject) => {
+  if (typeof window > "u") {
+    resolve();
+    return;
+  }
+  registryInitResolve = resolve;
+  let nav = window.navigator;
+  if (nav.wallets && typeof nav.wallets.get == "function") {
+    registry = nav.wallets, resolve();
+    return;
+  }
+  registryInitPromise = import('@wallet-standard/app').then((mod) => {
+    let walletStandardRegistry = mod.getWallets?.();
+    walletStandardRegistry && (registry = walletStandardRegistry), resolve();
+  }).catch((err) => {
+    console.warn("[standard-shim] Failed to load @wallet-standard/app:", err), resolve();
+  });
+});
 function getWalletsRegistry() {
   if (typeof window > "u")
     return {
@@ -17,12 +34,13 @@ function getWalletsRegistry() {
       on: () => () => {
       }
     };
-  if (!registry) {
+  if (!registry && !registryInitPromise) {
     let nav = window.navigator;
-    nav.wallets && typeof nav.wallets.get == "function" ? registry = nav.wallets : import('@wallet-standard/app').then((mod) => {
+    nav.wallets && typeof nav.wallets.get == "function" ? (registry = nav.wallets, registryInitResolve?.()) : registryInitPromise = import('@wallet-standard/app').then((mod) => {
       let walletStandardRegistry = mod.getWallets?.();
-      walletStandardRegistry && (registry = walletStandardRegistry);
+      walletStandardRegistry && (registry = walletStandardRegistry), registryInitResolve?.();
     }).catch(() => {
+      registryInitResolve?.();
     });
   }
   return {
@@ -51,135 +69,6 @@ function getWalletsRegistry() {
   };
 }
 
-// src/lib/errors/index.ts
-var ConnectorError = class extends Error {
-  constructor(message, context, originalError) {
-    super(message);
-    chunkI64FD2EH_js.__publicField(this, "context");
-    chunkI64FD2EH_js.__publicField(this, "originalError");
-    chunkI64FD2EH_js.__publicField(this, "timestamp");
-    this.name = this.constructor.name, this.context = context, this.originalError = originalError, this.timestamp = (/* @__PURE__ */ new Date()).toISOString(), Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      recoverable: this.recoverable,
-      context: this.context,
-      timestamp: this.timestamp,
-      originalError: this.originalError?.message
-    };
-  }
-}, ConnectionError = class extends ConnectorError {
-  constructor(code, message, context, originalError) {
-    super(message, context, originalError);
-    chunkI64FD2EH_js.__publicField(this, "code");
-    chunkI64FD2EH_js.__publicField(this, "recoverable", true);
-    this.code = code;
-  }
-}, ValidationError = class extends ConnectorError {
-  constructor(code, message, context, originalError) {
-    super(message, context, originalError);
-    chunkI64FD2EH_js.__publicField(this, "code");
-    chunkI64FD2EH_js.__publicField(this, "recoverable", false);
-    this.code = code;
-  }
-}, ConfigurationError = class extends ConnectorError {
-  constructor(code, message, context, originalError) {
-    super(message, context, originalError);
-    chunkI64FD2EH_js.__publicField(this, "code");
-    chunkI64FD2EH_js.__publicField(this, "recoverable", false);
-    this.code = code;
-  }
-}, NetworkError = class extends ConnectorError {
-  constructor(code, message, context, originalError) {
-    super(message, context, originalError);
-    chunkI64FD2EH_js.__publicField(this, "code");
-    chunkI64FD2EH_js.__publicField(this, "recoverable", true);
-    this.code = code;
-  }
-}, TransactionError = class extends ConnectorError {
-  constructor(code, message, context, originalError) {
-    super(message, context, originalError);
-    chunkI64FD2EH_js.__publicField(this, "code");
-    chunkI64FD2EH_js.__publicField(this, "recoverable");
-    this.code = code, this.recoverable = ["USER_REJECTED", "SEND_FAILED", "SIMULATION_FAILED"].includes(code);
-  }
-};
-function isConnectorError(error) {
-  return error instanceof ConnectorError;
-}
-function isConnectionError(error) {
-  return error instanceof ConnectionError;
-}
-function isValidationError(error) {
-  return error instanceof ValidationError;
-}
-function isConfigurationError(error) {
-  return error instanceof ConfigurationError;
-}
-function isNetworkError(error) {
-  return error instanceof NetworkError;
-}
-function isTransactionError(error) {
-  return error instanceof TransactionError;
-}
-var Errors = {
-  walletNotConnected: (context) => new ConnectionError("WALLET_NOT_CONNECTED", "No wallet connected", context),
-  walletNotFound: (walletName) => new ConnectionError("WALLET_NOT_FOUND", `Wallet not found${walletName ? `: ${walletName}` : ""}`, {
-    walletName
-  }),
-  connectionFailed: (originalError) => new ConnectionError("CONNECTION_FAILED", "Failed to connect to wallet", void 0, originalError),
-  accountNotAvailable: (address) => new ConnectionError("ACCOUNT_NOT_AVAILABLE", "Requested account not available", { address }),
-  invalidTransaction: (reason, context) => new ValidationError("INVALID_TRANSACTION", `Invalid transaction: ${reason}`, context),
-  invalidFormat: (expectedFormat, actualFormat) => new ValidationError("INVALID_FORMAT", `Invalid format: expected ${expectedFormat}`, {
-    expectedFormat,
-    actualFormat
-  }),
-  unsupportedFormat: (format) => new ValidationError("UNSUPPORTED_FORMAT", `Unsupported format: ${format}`, { format }),
-  missingProvider: (hookName) => new ConfigurationError(
-    "MISSING_PROVIDER",
-    `${hookName} must be used within ConnectorProvider. Wrap your app with <ConnectorProvider> or <UnifiedProvider>.`,
-    { hookName }
-  ),
-  clusterNotFound: (clusterId, availableClusters) => new ConfigurationError(
-    "CLUSTER_NOT_FOUND",
-    `Cluster ${clusterId} not found. Available clusters: ${availableClusters.join(", ")}`,
-    { clusterId, availableClusters }
-  ),
-  rpcError: (message, originalError) => new NetworkError("RPC_ERROR", message, void 0, originalError),
-  networkTimeout: () => new NetworkError("NETWORK_TIMEOUT", "Network request timed out"),
-  signingFailed: (originalError) => new TransactionError("SIGNING_FAILED", "Failed to sign transaction", void 0, originalError),
-  featureNotSupported: (feature) => new TransactionError("FEATURE_NOT_SUPPORTED", `Wallet does not support ${feature}`, { feature }),
-  userRejected: (operation) => new TransactionError("USER_REJECTED", `User rejected ${operation}`, { operation })
-};
-function toConnectorError(error, defaultMessage = "An unexpected error occurred") {
-  if (isConnectorError(error))
-    return error;
-  if (error instanceof Error) {
-    let message = error.message.toLowerCase();
-    return message.includes("user rejected") || message.includes("user denied") ? Errors.userRejected("transaction") : message.includes("wallet not found") || message.includes("not installed") ? Errors.walletNotFound() : message.includes("not connected") ? Errors.walletNotConnected() : message.includes("network") || message.includes("fetch") ? Errors.rpcError(error.message, error) : message.includes("invalid") ? new ValidationError("VALIDATION_FAILED", error.message, void 0, error) : new TransactionError("SIGNING_FAILED", error.message, void 0, error);
-  }
-  return new TransactionError("SIGNING_FAILED", defaultMessage, { originalError: String(error) });
-}
-function getUserFriendlyMessage(error) {
-  return isConnectorError(error) ? {
-    WALLET_NOT_CONNECTED: "Please connect your wallet to continue.",
-    WALLET_NOT_FOUND: "Wallet not found. Please install a supported wallet.",
-    CONNECTION_FAILED: "Failed to connect to wallet. Please try again.",
-    USER_REJECTED: "Transaction was cancelled.",
-    FEATURE_NOT_SUPPORTED: "This wallet does not support this feature.",
-    SIGNING_FAILED: "Failed to sign transaction. Please try again.",
-    SEND_FAILED: "Failed to send transaction. Please try again.",
-    INVALID_CLUSTER: "Invalid network configuration.",
-    CLUSTER_NOT_FOUND: "Network not found.",
-    MISSING_PROVIDER: "Application not properly configured.",
-    RPC_ERROR: "Network error. Please check your connection.",
-    NETWORK_TIMEOUT: "Request timed out. Please try again."
-  }[error.code] || error.message || "An error occurred." : "An unexpected error occurred. Please try again.";
-}
-
 // src/utils/network.ts
 var PUBLIC_RPC_ENDPOINTS = {
   mainnet: "https://api.mainnet-beta.solana.com",
@@ -207,7 +96,7 @@ function toClusterId(network) {
 function getDefaultRpcUrl(network) {
   let normalized = normalizeNetwork(network);
   try {
-    return chunkI64FD2EH_js.getPublicSolanaRpcUrl(normalized);
+    return chunkDSUCH44G_js.getPublicSolanaRpcUrl(normalized);
   } catch {
     return PUBLIC_RPC_ENDPOINTS[normalized] ?? PUBLIC_RPC_ENDPOINTS.localnet;
   }
@@ -262,14 +151,14 @@ function getClusterExplorerUrl(cluster, path) {
 }
 function getTransactionUrl(signature, cluster) {
   let clusterType = getClusterType(cluster), explorerCluster = clusterType === "custom" || clusterType === "localnet" ? "devnet" : clusterType;
-  return chunkI64FD2EH_js.getExplorerLink({
+  return chunkDSUCH44G_js.getExplorerLink({
     transaction: signature,
     cluster: explorerCluster === "mainnet" ? "mainnet" : explorerCluster
   });
 }
 function getAddressUrl(address, cluster) {
   let clusterType = getClusterType(cluster), explorerCluster = clusterType === "custom" || clusterType === "localnet" ? "devnet" : clusterType;
-  return chunkI64FD2EH_js.getExplorerLink({
+  return chunkDSUCH44G_js.getExplorerLink({
     address,
     cluster: explorerCluster === "mainnet" ? "mainnet" : explorerCluster
   });
@@ -332,9 +221,9 @@ var POLL_INTERVALS_MS = [1e3, 2e3, 3e3, 5e3, 5e3], DEFAULT_MAX_RETRIES = 3, DEFA
 // src/lib/core/state-manager.ts
 var StateManager = class {
   constructor(initialState) {
-    chunkI64FD2EH_js.__publicField(this, "state");
-    chunkI64FD2EH_js.__publicField(this, "listeners", /* @__PURE__ */ new Set());
-    chunkI64FD2EH_js.__publicField(this, "notifyTimeout");
+    chunkDSUCH44G_js.__publicField(this, "state");
+    chunkDSUCH44G_js.__publicField(this, "listeners", /* @__PURE__ */ new Set());
+    chunkDSUCH44G_js.__publicField(this, "notifyTimeout");
     this.state = initialState;
   }
   /**
@@ -393,10 +282,10 @@ var StateManager = class {
 };
 
 // src/lib/core/event-emitter.ts
-var logger = chunkI64FD2EH_js.createLogger("EventEmitter"), EventEmitter = class {
+var logger = chunkDSUCH44G_js.createLogger("EventEmitter"), EventEmitter = class {
   constructor(debug = false) {
-    chunkI64FD2EH_js.__publicField(this, "listeners", /* @__PURE__ */ new Set());
-    chunkI64FD2EH_js.__publicField(this, "debug");
+    chunkDSUCH44G_js.__publicField(this, "listeners", /* @__PURE__ */ new Set());
+    chunkDSUCH44G_js.__publicField(this, "debug");
     this.debug = debug;
   }
   /**
@@ -452,12 +341,12 @@ var logger = chunkI64FD2EH_js.createLogger("EventEmitter"), EventEmitter = class
 // src/lib/core/debug-metrics.ts
 var DebugMetrics = class {
   constructor() {
-    chunkI64FD2EH_js.__publicField(this, "stateUpdates", 0);
-    chunkI64FD2EH_js.__publicField(this, "noopUpdates", 0);
-    chunkI64FD2EH_js.__publicField(this, "updateTimes", []);
-    chunkI64FD2EH_js.__publicField(this, "lastUpdateTime", 0);
-    chunkI64FD2EH_js.__publicField(this, "eventListenerCount", 0);
-    chunkI64FD2EH_js.__publicField(this, "subscriptionCount", 0);
+    chunkDSUCH44G_js.__publicField(this, "stateUpdates", 0);
+    chunkDSUCH44G_js.__publicField(this, "noopUpdates", 0);
+    chunkDSUCH44G_js.__publicField(this, "updateTimes", []);
+    chunkDSUCH44G_js.__publicField(this, "lastUpdateTime", 0);
+    chunkDSUCH44G_js.__publicField(this, "eventListenerCount", 0);
+    chunkDSUCH44G_js.__publicField(this, "subscriptionCount", 0);
   }
   /**
    * Record a state update attempt
@@ -497,11 +386,11 @@ var DebugMetrics = class {
 // src/lib/core/base-collaborator.ts
 var BaseCollaborator = class {
   constructor(config, loggerPrefix) {
-    chunkI64FD2EH_js.__publicField(this, "stateManager");
-    chunkI64FD2EH_js.__publicField(this, "eventEmitter");
-    chunkI64FD2EH_js.__publicField(this, "debug");
-    chunkI64FD2EH_js.__publicField(this, "logger");
-    this.stateManager = config.stateManager, this.eventEmitter = config.eventEmitter, this.debug = config.debug ?? false, this.logger = chunkI64FD2EH_js.createLogger(loggerPrefix);
+    chunkDSUCH44G_js.__publicField(this, "stateManager");
+    chunkDSUCH44G_js.__publicField(this, "eventEmitter");
+    chunkDSUCH44G_js.__publicField(this, "debug");
+    chunkDSUCH44G_js.__publicField(this, "logger");
+    this.stateManager = config.stateManager, this.eventEmitter = config.eventEmitter, this.debug = config.debug ?? false, this.logger = chunkDSUCH44G_js.createLogger(loggerPrefix);
   }
   /**
    * Log debug message if debug mode is enabled
@@ -523,8 +412,8 @@ var BaseCollaborator = class {
   }
 };
 
-// src/lib/connection/wallet-authenticity-verifier.ts
-var logger2 = chunkI64FD2EH_js.createLogger("WalletAuthenticity"), WalletAuthenticityVerifier = class {
+// src/lib/wallet/authenticity-verifier.ts
+var logger2 = chunkDSUCH44G_js.createLogger("WalletAuthenticity"), WalletAuthenticityVerifier = class {
   /**
    * Verify a wallet's authenticity using dynamic heuristics
    *
@@ -733,8 +622,8 @@ var logger2 = chunkI64FD2EH_js.createLogger("WalletAuthenticity"), WalletAuthent
   }
 };
 
-// src/lib/connection/wallet-detector.ts
-var logger3 = chunkI64FD2EH_js.createLogger("WalletDetector");
+// src/lib/wallet/detector.ts
+var logger3 = chunkDSUCH44G_js.createLogger("WalletDetector");
 function hasFeature(wallet, featureName) {
   return wallet.features != null && wallet.features[featureName] !== void 0;
 }
@@ -756,10 +645,17 @@ function verifyWalletName(wallet, requestedName) {
 var WalletDetector = class extends BaseCollaborator {
   constructor(stateManager, eventEmitter, debug = false) {
     super({ stateManager, eventEmitter, debug }, "WalletDetector");
-    chunkI64FD2EH_js.__publicField(this, "unsubscribers", []);
+    chunkDSUCH44G_js.__publicField(this, "unsubscribers", []);
   }
   /**
-   * Initialize wallet detection
+   * Initialize wallet detection (synchronous)
+   *
+   * Sets up registry listeners immediately. Due to the async nature of registry initialization,
+   * the initial call to `get()` may return an empty array if called before the registry is ready.
+   * Event listeners will fire as wallets register, providing eventual consistency.
+   *
+   * For deterministic detection where you need all wallets available immediately,
+   * use `initializeAsync()` instead.
    */
   initialize() {
     if (!(typeof window > "u"))
@@ -782,6 +678,24 @@ var WalletDetector = class extends BaseCollaborator {
       } catch {
       }
   }
+  /**
+   * Initialize wallet detection with deterministic registry availability (async)
+   *
+   * Awaits the registry `ready` Promise before performing initial detection,
+   * ensuring all registered wallets are available on the first `get()` call.
+   *
+   * Use this when you need guaranteed wallet availability before proceeding
+   * (e.g., auto-reconnect logic, checking if a specific wallet is installed).
+   *
+   * @example
+   * ```ts
+   * await walletDetector.initializeAsync();
+   * const wallets = walletDetector.getDetectedWallets(); // Guaranteed populated
+   * ```
+   */
+  async initializeAsync() {
+    typeof window > "u" || (await ready, this.initialize());
+  }
   /**
    * Check if a specific wallet is available immediately via direct window object detection
    */
@@ -868,7 +782,7 @@ var WalletDetector = class extends BaseCollaborator {
   }
 };
 
-// src/lib/connection/connection-manager.ts
+// src/lib/wallet/connection-manager.ts
 function getConnectFeature(wallet) {
   return wallet.features["standard:connect"]?.connect ?? null;
 }
@@ -881,10 +795,10 @@ function getEventsFeature(wallet) {
 var ConnectionManager = class extends BaseCollaborator {
   constructor(stateManager, eventEmitter, walletStorage, debug = false) {
     super({ stateManager, eventEmitter, debug }, "ConnectionManager");
-    chunkI64FD2EH_js.__publicField(this, "walletStorage");
-    chunkI64FD2EH_js.__publicField(this, "walletChangeUnsub", null);
-    chunkI64FD2EH_js.__publicField(this, "pollTimer", null);
-    chunkI64FD2EH_js.__publicField(this, "pollAttempts", 0);
+    chunkDSUCH44G_js.__publicField(this, "walletStorage");
+    chunkDSUCH44G_js.__publicField(this, "walletChangeUnsub", null);
+    chunkDSUCH44G_js.__publicField(this, "pollTimer", null);
+    chunkDSUCH44G_js.__publicField(this, "pollAttempts", 0);
     this.walletStorage = walletStorage;
   }
   /**
@@ -1078,14 +992,14 @@ var ConnectionManager = class extends BaseCollaborator {
   }
 };
 
-// src/lib/connection/auto-connector.ts
-var logger4 = chunkI64FD2EH_js.createLogger("AutoConnector"), MIN_ADDRESS_LENGTH = 30, AutoConnector = class {
+// src/lib/wallet/auto-connector.ts
+var logger4 = chunkDSUCH44G_js.createLogger("AutoConnector"), MIN_ADDRESS_LENGTH = 30, AutoConnector = class {
   constructor(walletDetector, connectionManager, stateManager, walletStorage, debug = false) {
-    chunkI64FD2EH_js.__publicField(this, "walletDetector");
-    chunkI64FD2EH_js.__publicField(this, "connectionManager");
-    chunkI64FD2EH_js.__publicField(this, "stateManager");
-    chunkI64FD2EH_js.__publicField(this, "walletStorage");
-    chunkI64FD2EH_js.__publicField(this, "debug");
+    chunkDSUCH44G_js.__publicField(this, "walletDetector");
+    chunkDSUCH44G_js.__publicField(this, "connectionManager");
+    chunkDSUCH44G_js.__publicField(this, "stateManager");
+    chunkDSUCH44G_js.__publicField(this, "walletStorage");
+    chunkDSUCH44G_js.__publicField(this, "debug");
     this.walletDetector = walletDetector, this.connectionManager = connectionManager, this.stateManager = stateManager, this.walletStorage = walletStorage, this.debug = debug;
   }
   async attemptAutoConnect() {
@@ -1192,7 +1106,7 @@ var logger4 = chunkI64FD2EH_js.createLogger("AutoConnector"), MIN_ADDRESS_LENGTH
           ]
         },
         true
-      );
+      ), await ready;
       let walletsApi = getWalletsRegistry(), registryWallet = walletsApi.get().find((w) => w.name === storedWalletName), walletToUse = registryWallet || wallet;
       return this.debug && logger4.info("Attempting to connect via instant auto-connect", {
         walletName: storedWalletName,
@@ -1239,7 +1153,7 @@ var logger4 = chunkI64FD2EH_js.createLogger("AutoConnector"), MIN_ADDRESS_LENGTH
 var ClusterManager = class extends BaseCollaborator {
   constructor(stateManager, eventEmitter, clusterStorage, config, debug = false) {
     super({ stateManager, eventEmitter, debug }, "ClusterManager");
-    chunkI64FD2EH_js.__publicField(this, "clusterStorage");
+    chunkDSUCH44G_js.__publicField(this, "clusterStorage");
     if (this.clusterStorage = clusterStorage, config) {
       let clusters = config.clusters ?? [], initialClusterId = this.clusterStorage?.get() ?? config.initialCluster ?? "solana:mainnet", initialCluster = clusters.find((c) => c.id === initialClusterId) ?? clusters[0] ?? null;
       this.stateManager.updateState({
@@ -1254,7 +1168,7 @@ var ClusterManager = class extends BaseCollaborator {
   async setCluster(clusterId) {
     let state = this.getState(), previousClusterId = state.cluster?.id || null, cluster = state.clusters.find((c) => c.id === clusterId);
     if (!cluster)
-      throw Errors.clusterNotFound(
+      throw chunkDSUCH44G_js.Errors.clusterNotFound(
         clusterId,
         state.clusters.map((c) => c.id)
       );
@@ -1283,9 +1197,9 @@ var ClusterManager = class extends BaseCollaborator {
 var TransactionTracker = class extends BaseCollaborator {
   constructor(stateManager, eventEmitter, maxTransactions = 20, debug = false) {
     super({ stateManager, eventEmitter, debug }, "TransactionTracker");
-    chunkI64FD2EH_js.__publicField(this, "transactions", []);
-    chunkI64FD2EH_js.__publicField(this, "totalTransactions", 0);
-    chunkI64FD2EH_js.__publicField(this, "maxTransactions");
+    chunkDSUCH44G_js.__publicField(this, "transactions", []);
+    chunkDSUCH44G_js.__publicField(this, "totalTransactions", 0);
+    chunkDSUCH44G_js.__publicField(this, "maxTransactions");
     this.maxTransactions = maxTransactions;
   }
   /**
@@ -1339,10 +1253,10 @@ var TransactionTracker = class extends BaseCollaborator {
 // src/lib/health/health-monitor.ts
 var HealthMonitor = class {
   constructor(stateManager, walletStorage, clusterStorage, isInitialized) {
-    chunkI64FD2EH_js.__publicField(this, "stateManager");
-    chunkI64FD2EH_js.__publicField(this, "walletStorage");
-    chunkI64FD2EH_js.__publicField(this, "clusterStorage");
-    chunkI64FD2EH_js.__publicField(this, "isInitialized");
+    chunkDSUCH44G_js.__publicField(this, "stateManager");
+    chunkDSUCH44G_js.__publicField(this, "walletStorage");
+    chunkDSUCH44G_js.__publicField(this, "clusterStorage");
+    chunkDSUCH44G_js.__publicField(this, "isInitialized");
     this.stateManager = stateManager, this.walletStorage = walletStorage, this.clusterStorage = clusterStorage, this.isInitialized = isInitialized ?? (() => true);
   }
   /**
@@ -1394,19 +1308,19 @@ var HealthMonitor = class {
 };
 
 // src/lib/core/connector-client.ts
-var logger5 = chunkI64FD2EH_js.createLogger("ConnectorClient"), ConnectorClient = class {
+var logger5 = chunkDSUCH44G_js.createLogger("ConnectorClient"), ConnectorClient = class {
   constructor(config = {}) {
-    chunkI64FD2EH_js.__publicField(this, "stateManager");
-    chunkI64FD2EH_js.__publicField(this, "eventEmitter");
-    chunkI64FD2EH_js.__publicField(this, "walletDetector");
-    chunkI64FD2EH_js.__publicField(this, "connectionManager");
-    chunkI64FD2EH_js.__publicField(this, "autoConnector");
-    chunkI64FD2EH_js.__publicField(this, "clusterManager");
-    chunkI64FD2EH_js.__publicField(this, "transactionTracker");
-    chunkI64FD2EH_js.__publicField(this, "debugMetrics");
-    chunkI64FD2EH_js.__publicField(this, "healthMonitor");
-    chunkI64FD2EH_js.__publicField(this, "initialized", false);
-    chunkI64FD2EH_js.__publicField(this, "config");
+    chunkDSUCH44G_js.__publicField(this, "stateManager");
+    chunkDSUCH44G_js.__publicField(this, "eventEmitter");
+    chunkDSUCH44G_js.__publicField(this, "walletDetector");
+    chunkDSUCH44G_js.__publicField(this, "connectionManager");
+    chunkDSUCH44G_js.__publicField(this, "autoConnector");
+    chunkDSUCH44G_js.__publicField(this, "clusterManager");
+    chunkDSUCH44G_js.__publicField(this, "transactionTracker");
+    chunkDSUCH44G_js.__publicField(this, "debugMetrics");
+    chunkDSUCH44G_js.__publicField(this, "healthMonitor");
+    chunkDSUCH44G_js.__publicField(this, "initialized", false);
+    chunkDSUCH44G_js.__publicField(this, "config");
     this.config = config;
     let initialState = {
       wallets: [],
@@ -1448,16 +1362,15 @@ var logger5 = chunkI64FD2EH_js.createLogger("ConnectorClient"), ConnectorClient
     ), this.initialize();
   }
   initialize() {
-    if (!(typeof window > "u") && !this.initialized)
-      try {
-        this.walletDetector.initialize(), this.config.autoConnect && setTimeout(() => {
-          this.autoConnector.attemptAutoConnect().catch((err) => {
-            this.config.debug && logger5.error("Auto-connect error", { error: err });
-          });
-        }, 100), this.initialized = true;
-      } catch (e) {
-        this.config.debug && logger5.error("Connector initialization failed", { error: e });
-      }
+    if (typeof window > "u" || this.initialized) return;
+    let { error } = chunkDSUCH44G_js.tryCatchSync(() => {
+      this.walletDetector.initialize(), this.config.autoConnect && setTimeout(() => {
+        this.autoConnector.attemptAutoConnect().catch((err) => {
+          this.config.debug && logger5.error("Auto-connect error", { error: err });
+        });
+      }, 100), this.initialized = true;
+    });
+    error && this.config.debug && logger5.error("Connector initialization failed", { error });
   }
   async select(walletName) {
     let wallet = this.stateManager.getSnapshot().wallets.find((w) => w.wallet.name === walletName)?.wallet;
@@ -1482,11 +1395,8 @@ var logger5 = chunkI64FD2EH_js.createLogger("ConnectorClient"), ConnectorClient
   getRpcUrl() {
     let cluster = this.clusterManager.getCluster();
     if (!cluster) return null;
-    try {
-      return getClusterRpcUrl(cluster);
-    } catch (error) {
-      return this.config.debug && logger5.error("Failed to get RPC URL", { error }), null;
-    }
+    let { data, error } = chunkDSUCH44G_js.tryCatchSync(() => getClusterRpcUrl(cluster));
+    return error ? (this.config.debug && logger5.error("Failed to get RPC URL", { error }), null) : data;
   }
   subscribe(listener) {
     return this.stateManager.subscribe(listener);
@@ -1499,12 +1409,10 @@ var logger5 = chunkI64FD2EH_js.createLogger("ConnectorClient"), ConnectorClient
     let storageKeys = ["account", "wallet", "cluster"];
     for (let key of storageKeys) {
       let storage = this.config.storage?.[key];
-      if (storage && "reset" in storage && typeof storage.reset == "function")
-        try {
-          storage.reset(), this.config.debug && logger5.debug("Reset storage", { key });
-        } catch (error) {
-          this.config.debug && logger5.error("Failed to reset storage", { key, error });
-        }
+      if (storage && "reset" in storage && typeof storage.reset == "function") {
+        let resetFn = storage.reset, { error } = chunkDSUCH44G_js.tryCatchSync(() => resetFn());
+        error ? this.config.debug && logger5.error("Failed to reset storage", { key, error }) : this.config.debug && logger5.debug("Reset storage", { key });
+      }
     }
     this.eventEmitter.emit({
       type: "storage:reset",
@@ -1560,7 +1468,7 @@ var logger5 = chunkI64FD2EH_js.createLogger("ConnectorClient"), ConnectorClient
     }), this.walletDetector.destroy(), this.eventEmitter.offAll(), this.stateManager.clear();
   }
 };
-var logger6 = chunkI64FD2EH_js.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 {
+var logger6 = chunkDSUCH44G_js.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,
@@ -1579,7 +1487,7 @@ var logger6 = chunkI64FD2EH_js.createLogger("ErrorBoundary"), WalletErrorType =
   }
 };
 function classifyError(error) {
-  if (isConnectorError(error))
+  if (chunkDSUCH44G_js.isConnectorError(error))
     return {
       ...error,
       type: {
@@ -1608,8 +1516,8 @@ function classifyError(error) {
 var ConnectorErrorBoundary = class extends react.Component {
   constructor(props) {
     super(props);
-    chunkI64FD2EH_js.__publicField(this, "retryTimeouts", /* @__PURE__ */ new Set());
-    chunkI64FD2EH_js.__publicField(this, "retry", () => {
+    chunkDSUCH44G_js.__publicField(this, "retryTimeouts", /* @__PURE__ */ new Set());
+    chunkDSUCH44G_js.__publicField(this, "retry", () => {
       let { maxRetries = 3 } = this.props;
       this.state.retryCount >= maxRetries || this.setState((prevState) => ({
         hasError: false,
@@ -1831,7 +1739,7 @@ function withErrorBoundary(Component2, errorBoundaryProps) {
   let WrappedComponent = (props) => /* @__PURE__ */ jsxRuntime.jsx(ConnectorErrorBoundary, { ...errorBoundaryProps, children: /* @__PURE__ */ jsxRuntime.jsx(Component2, { ...props }) });
   return WrappedComponent.displayName = `withErrorBoundary(${Component2.displayName || Component2.name})`, WrappedComponent;
 }
-var logger7 = chunkI64FD2EH_js.createLogger("Polyfills"), installed = false;
+var logger7 = chunkDSUCH44G_js.createLogger("Polyfills"), installed = false;
 function installPolyfills() {
   if (!(installed || typeof window > "u"))
     try {
@@ -2069,7 +1977,7 @@ async function copySignatureToClipboard(signature, options) {
 }
 
 // src/lib/transaction/transaction-validator.ts
-var logger8 = chunkI64FD2EH_js.createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232, MIN_TRANSACTION_SIZE = 64, TransactionValidator = class {
+var logger8 = chunkDSUCH44G_js.createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232, MIN_TRANSACTION_SIZE = 64, TransactionValidator = class {
   /**
    * Validate a transaction before signing
    *
@@ -2172,9 +2080,28 @@ var logger8 = chunkI64FD2EH_js.createLogger("TransactionValidator"), MAX_TRANSAC
     return transactions.map((tx, index) => (logger8.debug(`Validating transaction ${index + 1}/${transactions.length}`), this.validate(tx, options)));
   }
 };
-
-// src/lib/transaction/transaction-signer.ts
-var logger9 = chunkI64FD2EH_js.createLogger("TransactionSigner");
+var logger9 = chunkDSUCH44G_js.createLogger("TransactionSigner");
+function signatureBytesToBase58(bytes) {
+  if (bytes.length !== 64)
+    throw new Error(`Invalid signature length: expected 64 bytes, got ${bytes.length}`);
+  return codecs.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)
@@ -2188,13 +2115,13 @@ function createTransactionSigner(config) {
     address,
     async signTransaction(transaction) {
       if (!capabilities.canSign)
-        throw Errors.featureNotSupported("transaction signing");
+        throw chunkDSUCH44G_js.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(", "));
+        throw logger9.error("Transaction validation failed", { errors: validation.errors }), chunkDSUCH44G_js.Errors.invalidTransaction(validation.errors.join(", "));
       validation.warnings.length > 0 && logger9.warn("Transaction validation warnings", { warnings: validation.warnings });
       try {
-        let signFeature = features["solana:signTransaction"], { serialized, wasWeb3js } = chunkI64FD2EH_js.prepareTransactionForWallet(transaction);
+        let signFeature = features["solana:signTransaction"], { serialized, wasWeb3js } = chunkDSUCH44G_js.prepareTransactionForWallet(transaction);
         logger9.debug("Signing transaction", {
           wasWeb3js,
           serializedLength: serialized.length,
@@ -2247,19 +2174,19 @@ function createTransactionSigner(config) {
           logger9.debug("Found signedTransaction property");
           let bytes = signedTx.signedTransaction;
           if (bytes instanceof Uint8Array)
-            return await chunkI64FD2EH_js.convertSignedTransaction(bytes, wasWeb3js);
+            return await chunkDSUCH44G_js.convertSignedTransaction(bytes, wasWeb3js);
         }
         if (signedTx instanceof Uint8Array)
-          return await chunkI64FD2EH_js.convertSignedTransaction(signedTx, wasWeb3js);
+          return await chunkDSUCH44G_js.convertSignedTransaction(signedTx, wasWeb3js);
         throw logger9.error("Unexpected wallet response format", {
           type: typeof signedTx,
           constructor: signedTx?.constructor?.name
-        }), new ValidationError(
+        }), new chunkDSUCH44G_js.ValidationError(
           "INVALID_FORMAT",
           "Wallet returned unexpected format - not a Transaction or Uint8Array"
         );
       } catch (error) {
-        throw Errors.signingFailed(error);
+        throw chunkDSUCH44G_js.Errors.signingFailed(error);
       }
     },
     async signAllTransactions(transactions) {
@@ -2267,18 +2194,18 @@ function createTransactionSigner(config) {
         return [];
       if (capabilities.supportsBatchSigning)
         try {
-          let signFeature = features["solana:signAllTransactions"], prepared = transactions.map((tx) => chunkI64FD2EH_js.prepareTransactionForWallet(tx)), serializedTxs = prepared.map((p) => p.serialized), wasWeb3js = prepared[0].wasWeb3js, result = await signFeature.signAllTransactions({
+          let signFeature = features["solana:signAllTransactions"], prepared = transactions.map((tx) => chunkDSUCH44G_js.prepareTransactionForWallet(tx)), serializedTxs = prepared.map((p) => p.serialized), wasWeb3js = prepared[0].wasWeb3js, result = await signFeature.signAllTransactions({
             account,
             transactions: serializedTxs,
             ...cluster ? { chain: cluster.id } : {}
           });
           return await Promise.all(
             result.signedTransactions.map(
-              (signedBytes) => chunkI64FD2EH_js.convertSignedTransaction(signedBytes, wasWeb3js)
+              (signedBytes) => chunkDSUCH44G_js.convertSignedTransaction(signedBytes, wasWeb3js)
             )
           );
         } catch (error) {
-          throw new TransactionError(
+          throw new chunkDSUCH44G_js.TransactionError(
             "SIGNING_FAILED",
             "Failed to sign transactions in batch",
             { count: transactions.length },
@@ -2286,14 +2213,14 @@ function createTransactionSigner(config) {
           );
         }
       if (!capabilities.canSign)
-        throw Errors.featureNotSupported("transaction signing");
+        throw chunkDSUCH44G_js.Errors.featureNotSupported("transaction signing");
       let signed = [];
       for (let i = 0; i < transactions.length; i++)
         try {
           let signedTx = await signer.signTransaction(transactions[i]);
           signed.push(signedTx);
         } catch (error) {
-          throw new TransactionError(
+          throw new chunkDSUCH44G_js.TransactionError(
             "SIGNING_FAILED",
             `Failed to sign transaction ${i + 1} of ${transactions.length}`,
             { index: i, total: transactions.length },
@@ -2304,9 +2231,9 @@ function createTransactionSigner(config) {
     },
     async signAndSendTransaction(transaction, options) {
       if (!capabilities.canSend)
-        throw Errors.featureNotSupported("sending transactions");
+        throw chunkDSUCH44G_js.Errors.featureNotSupported("sending transactions");
       try {
-        let sendFeature = features["solana:signAndSendTransaction"], { serialized } = chunkI64FD2EH_js.prepareTransactionForWallet(transaction);
+        let sendFeature = features["solana:signAndSendTransaction"], { serialized } = chunkDSUCH44G_js.prepareTransactionForWallet(transaction);
         eventEmitter && eventEmitter.emit({
           type: "transaction:preparing",
           transaction: serialized,
@@ -2334,28 +2261,28 @@ 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,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         }), signature;
       } catch (error) {
-        throw new TransactionError("SEND_FAILED", "Failed to send transaction", void 0, error);
+        throw new chunkDSUCH44G_js.TransactionError("SEND_FAILED", "Failed to send transaction", void 0, error);
       }
     },
     async signAndSendTransactions(transactions, options) {
       if (transactions.length === 0)
         return [];
       if (!capabilities.canSend)
-        throw Errors.featureNotSupported("sending transactions");
+        throw chunkDSUCH44G_js.Errors.featureNotSupported("sending transactions");
       let signatures = [];
       for (let i = 0; i < transactions.length; i++)
         try {
           let sig = await signer.signAndSendTransaction(transactions[i], options);
           signatures.push(sig);
         } catch (error) {
-          throw new TransactionError(
+          throw new chunkDSUCH44G_js.TransactionError(
             "SEND_FAILED",
             `Failed to send transaction ${i + 1} of ${transactions.length}`,
             { index: i, total: transactions.length },
@@ -2373,7 +2300,7 @@ function createTransactionSigner(config) {
             ...cluster ? { chain: cluster.id } : {}
           })).signature;
         } catch (error) {
-          throw new TransactionError("SIGNING_FAILED", "Failed to sign message", void 0, error);
+          throw new chunkDSUCH44G_js.TransactionError("SIGNING_FAILED", "Failed to sign message", void 0, error);
         }
       }
     },
@@ -2383,16 +2310,16 @@ function createTransactionSigner(config) {
   };
   return signer;
 }
-var TransactionSignerError = class extends TransactionError {
+var TransactionSignerError = class extends chunkDSUCH44G_js.TransactionError {
   constructor(message, code, originalError) {
     let newCode = code === "WALLET_NOT_CONNECTED" ? "FEATURE_NOT_SUPPORTED" : code;
     super(newCode, message, void 0, originalError), this.name = "TransactionSignerError";
   }
 };
 function isTransactionSignerError(error) {
-  return error instanceof TransactionSignerError || error instanceof TransactionError;
+  return error instanceof TransactionSignerError || error instanceof chunkDSUCH44G_js.TransactionError;
 }
-var logger10 = chunkI64FD2EH_js.createLogger("KitTransactionSigner");
+var logger10 = chunkDSUCH44G_js.createLogger("KitTransactionSigner");
 function encodeShortVecLength(value) {
   let bytes = [], remaining = value;
   for (; remaining >= 128; )
@@ -2412,6 +2339,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 = codecs.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;
@@ -2424,7 +2374,7 @@ function extractSignature(signedTx) {
     let signatureStart = bytesConsumed;
     return signedTx.slice(signatureStart, signatureStart + 64);
   }
-  if (chunkI64FD2EH_js.isWeb3jsTransaction(signedTx)) {
+  if (chunkDSUCH44G_js.isWeb3jsTransaction(signedTx)) {
     let signatures = signedTx.signatures;
     if (!signatures || signatures.length === 0)
       throw new Error("No signatures found in web3.js transaction");
@@ -2443,7 +2393,7 @@ function createKitTransactionSigner(connectorSigner) {
     address: signerAddress,
     async modifyAndSignTransactions(transactions$1) {
       let transactionData = transactions$1.map((tx) => {
-        let messageBytes = new Uint8Array(tx.messageBytes), numSigners = Object.keys(tx.signatures).length, wireFormat = createTransactionBytesForSigning(messageBytes, numSigners);
+        let messageBytes = new Uint8Array(tx.messageBytes), { numSigners } = parseMessageSigners(messageBytes), wireFormat = createTransactionBytesForSigning(messageBytes, numSigners);
         return logger10.debug("Preparing wire format for wallet", {
           signerAddress,
           messageBytesLength: messageBytes.length,
@@ -2465,7 +2415,7 @@ function createKitTransactionSigner(connectorSigner) {
           let signedTxBytes;
           if (signedTx instanceof Uint8Array)
             signedTxBytes = signedTx;
-          else if (chunkI64FD2EH_js.isWeb3jsTransaction(signedTx)) {
+          else if (chunkDSUCH44G_js.isWeb3jsTransaction(signedTx)) {
             let txObj = signedTx;
             if (typeof txObj.serialize == "function")
               signedTxBytes = txObj.serialize();
@@ -2521,18 +2471,11 @@ function createKitTransactionSigner(connectorSigner) {
 var createGillTransactionSigner = createKitTransactionSigner;
 
 exports.ClipboardErrorType = ClipboardErrorType;
-exports.ConfigurationError = ConfigurationError;
-exports.ConnectionError = ConnectionError;
 exports.ConnectorClient = ConnectorClient;
-exports.ConnectorError = ConnectorError;
 exports.ConnectorErrorBoundary = ConnectorErrorBoundary;
 exports.DEFAULT_MAX_RETRIES = DEFAULT_MAX_RETRIES;
-exports.Errors = Errors;
-exports.NetworkError = NetworkError;
 exports.PUBLIC_RPC_ENDPOINTS = PUBLIC_RPC_ENDPOINTS;
-exports.TransactionError = TransactionError;
 exports.TransactionSignerError = TransactionSignerError;
-exports.ValidationError = ValidationError;
 exports.WalletErrorType = WalletErrorType;
 exports.copyAddressToClipboard = copyAddressToClipboard;
 exports.copySignatureToClipboard = copySignatureToClipboard;
@@ -2561,13 +2504,9 @@ exports.getNetworkDisplayName = getNetworkDisplayName;
 exports.getPolyfillStatus = getPolyfillStatus;
 exports.getTokenUrl = getTokenUrl;
 exports.getTransactionUrl = getTransactionUrl;
-exports.getUserFriendlyMessage = getUserFriendlyMessage;
 exports.getWalletsRegistry = getWalletsRegistry;
 exports.installPolyfills = installPolyfills;
 exports.isClipboardAvailable = isClipboardAvailable;
-exports.isConfigurationError = isConfigurationError;
-exports.isConnectionError = isConnectionError;
-exports.isConnectorError = isConnectorError;
 exports.isCryptoAvailable = isCryptoAvailable;
 exports.isDevnet = isDevnet;
 exports.isDevnetCluster = isDevnetCluster;
@@ -2575,17 +2514,14 @@ exports.isLocalCluster = isLocalCluster;
 exports.isLocalnet = isLocalnet;
 exports.isMainnet = isMainnet;
 exports.isMainnetCluster = isMainnetCluster;
-exports.isNetworkError = isNetworkError;
 exports.isPolyfillInstalled = isPolyfillInstalled;
 exports.isTestnet = isTestnet;
 exports.isTestnetCluster = isTestnetCluster;
-exports.isTransactionError = isTransactionError;
 exports.isTransactionSignerError = isTransactionSignerError;
-exports.isValidationError = isValidationError;
 exports.normalizeNetwork = normalizeNetwork;
+exports.ready = ready;
 exports.toClusterId = toClusterId;
-exports.toConnectorError = toConnectorError;
 exports.truncate = truncate;
 exports.withErrorBoundary = withErrorBoundary;
-//# sourceMappingURL=chunk-VA6LKXCQ.js.map
-//# sourceMappingURL=chunk-VA6LKXCQ.js.map
+//# sourceMappingURL=chunk-5HRJKCIL.js.map
+//# sourceMappingURL=chunk-5HRJKCIL.js.map