@solana/connector 0.1.6 → 0.1.8

package/dist/{chunk-JUZVCBAI.js → chunk-FTXIXM43.js}

@@ -1,6 +1,6 @@
 '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');
@@ -8,8 +8,25 @@ var addresses = require('@solana/addresses');
 var transactions = require('@solana/transactions');
 var codecs = require('@solana/codecs');
 
-// 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;
   }
@@ -230,6 +119,11 @@ function getNetworkDisplayName(network) {
 }
 
 // src/utils/cluster.ts
+function getMaybeStringProp(value, prop) {
+  if (typeof value != "object" || value === null) return;
+  let v = value[prop];
+  return typeof v == "string" ? v : void 0;
+}
 function getClusterRpcUrl(cluster) {
   if (typeof cluster == "string") {
     let presets2 = {
@@ -240,7 +134,7 @@ function getClusterRpcUrl(cluster) {
       return presets2[cluster];
     throw new Error(`Unknown cluster: ${cluster}`);
   }
-  let url = cluster.url || cluster.rpcUrl;
+  let url = cluster.url ?? getMaybeStringProp(cluster, "rpcUrl");
   if (!url)
     throw new Error("Cluster URL is required");
   if (url.startsWith("http://") || url.startsWith("https://"))
@@ -257,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
   });
@@ -285,16 +179,17 @@ function isTestnetCluster(cluster) {
   return cluster.id === "solana:testnet";
 }
 function isLocalCluster(cluster) {
-  let url = cluster.url || cluster.rpcUrl;
+  let url = cluster.url ?? getMaybeStringProp(cluster, "rpcUrl");
   return url ? cluster.id === "solana:localnet" || url.includes("localhost") || url.includes("127.0.0.1") : cluster.id === "solana:localnet";
 }
 function getClusterName(cluster) {
   if (cluster.label) return cluster.label;
-  if (cluster.name) return cluster.name;
+  let name = getMaybeStringProp(cluster, "name");
+  if (name) return name;
   let parts = cluster.id.split(":");
   if (parts.length >= 2 && parts[1]) {
-    let name = parts.slice(1).join(":");
-    return name.charAt(0).toUpperCase() + name.slice(1).replace(/-/g, " ");
+    let name2 = parts.slice(1).join(":");
+    return name2.charAt(0).toUpperCase() + name2.slice(1).replace(/-/g, " ");
   }
   return "Unknown";
 }
@@ -326,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;
   }
   /**
@@ -387,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;
   }
   /**
@@ -446,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
@@ -491,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
@@ -517,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
    *
@@ -727,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;
 }
@@ -750,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"))
@@ -776,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
    */
@@ -862,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;
 }
@@ -875,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;
   }
   /**
@@ -1072,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() {
@@ -1186,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,
@@ -1233,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({
@@ -1248,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)
       );
@@ -1277,16 +1197,16 @@ 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;
   }
   /**
    * Track a transaction for debugging and monitoring
    */
   trackTransaction(activity) {
-    let clusterId = this.getState().cluster?.id || "solana:devnet", fullActivity = {
+    let clusterId = this.getState().cluster?.id ?? "solana:devnet", fullActivity = {
       ...activity,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       cluster: clusterId
@@ -1302,10 +1222,10 @@ var TransactionTracker = class extends BaseCollaborator {
    * Update transaction status (e.g., from pending to confirmed/failed)
    */
   updateStatus(signature, status, error) {
-    let tx = this.transactions.find((t) => t.signature === signature);
+    let tx = this.transactions.find((t) => String(t.signature) === signature);
     tx && (tx.status = status, error && (tx.error = error), this.eventEmitter.emit({
       type: "transaction:updated",
-      signature,
+      signature: tx.signature,
       status,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     }), this.log("[Connector] Transaction updated:", { signature, status, error }));
@@ -1333,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);
   }
   /**
@@ -1388,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: [],
@@ -1442,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;
@@ -1476,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);
@@ -1493,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",
@@ -1554,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,
@@ -1573,7 +1487,7 @@ var logger6 = chunkI64FD2EH_js.createLogger("ErrorBoundary"), WalletErrorType =
   }
 };
 function classifyError(error) {
-  if (isConnectorError(error))
+  if (chunkDSUCH44G_js.isConnectorError(error))
     return {
       ...error,
       type: {
@@ -1602,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,
@@ -1825,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 {
@@ -1888,6 +1802,71 @@ function formatTokenAmount(amount, decimals, options = {}) {
     maximumFractionDigits: maxDecimals
   });
 }
+var MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+function isSafeInteger(value) {
+  return value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
+}
+function splitBigIntDecimals(amount, decimals) {
+  if (decimals <= 0)
+    return { whole: amount.toString(), fraction: "" };
+  let str = amount.toString(), isNegative = str.startsWith("-"), absStr = isNegative ? str.slice(1) : str;
+  if (absStr.length <= decimals) {
+    let padded = absStr.padStart(decimals, "0");
+    return {
+      whole: isNegative ? "-0" : "0",
+      fraction: padded
+    };
+  }
+  let splitPoint = absStr.length - decimals;
+  return {
+    whole: (isNegative ? "-" : "") + absStr.slice(0, splitPoint),
+    fraction: absStr.slice(splitPoint)
+  };
+}
+function formatBigIntBalance(amount, decimals, options = {}) {
+  let { maxDecimals = Math.min(decimals, 6), minDecimals = 0, locale, useGrouping = true } = options;
+  if (isSafeInteger(amount))
+    return (Number(amount) / Math.pow(10, decimals)).toLocaleString(locale, {
+      minimumFractionDigits: minDecimals,
+      maximumFractionDigits: maxDecimals,
+      useGrouping
+    });
+  let { whole, fraction } = splitBigIntDecimals(amount, decimals), truncatedFraction = fraction.slice(0, maxDecimals);
+  for (; truncatedFraction.length > minDecimals && truncatedFraction.endsWith("0"); )
+    truncatedFraction = truncatedFraction.slice(0, -1);
+  truncatedFraction = truncatedFraction.padEnd(minDecimals, "0");
+  let formattedWhole = whole;
+  if (useGrouping) {
+    let isNegative = whole.startsWith("-"), absWhole = isNegative ? whole.slice(1) : whole, parts = [];
+    for (let i = absWhole.length; i > 0; i -= 3)
+      parts.unshift(absWhole.slice(Math.max(0, i - 3), i));
+    formattedWhole = (isNegative ? "-" : "") + parts.join(",");
+  }
+  return truncatedFraction.length === 0 ? formattedWhole : `${formattedWhole}.${truncatedFraction}`;
+}
+function formatLamportsToSolSafe(lamports, options = {}) {
+  let { maxDecimals = 4, minDecimals = 0, suffix = false, locale } = options, formatted = formatBigIntBalance(lamports, 9, {
+    maxDecimals,
+    minDecimals,
+    locale
+  });
+  return suffix ? `${formatted} SOL` : formatted;
+}
+function formatBigIntUsd(amount, decimals, usdPrice, options = {}) {
+  let { locale, currency = "USD" } = options, { whole, fraction } = splitBigIntDecimals(amount, decimals), wholeNum = parseFloat(whole), fractionNum = fraction ? parseFloat("0." + fraction) : 0;
+  return ((wholeNum + fractionNum) * usdPrice).toLocaleString(locale, {
+    style: "currency",
+    currency,
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+}
+function formatTokenBalanceSafe(amount, decimals, options = {}) {
+  return formatBigIntBalance(amount, decimals, {
+    maxDecimals: options.maxDecimals ?? Math.min(decimals, 6),
+    locale: options.locale
+  });
+}
 var ClipboardErrorType = /* @__PURE__ */ ((ClipboardErrorType2) => (ClipboardErrorType2.NOT_SUPPORTED = "not_supported", ClipboardErrorType2.PERMISSION_DENIED = "permission_denied", ClipboardErrorType2.SSR = "ssr", ClipboardErrorType2.EMPTY_VALUE = "empty_value", ClipboardErrorType2.INVALID_VALUE = "invalid_value", ClipboardErrorType2.UNKNOWN = "unknown", ClipboardErrorType2))(ClipboardErrorType || {});
 function isClipboardAvailable() {
   if (typeof window > "u" || typeof document > "u")
@@ -1998,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
    *
@@ -2103,7 +2082,7 @@ var logger8 = chunkI64FD2EH_js.createLogger("TransactionValidator"), MAX_TRANSAC
 };
 
 // src/lib/transaction/transaction-signer.ts
-var logger9 = chunkI64FD2EH_js.createLogger("TransactionSigner");
+var logger9 = chunkDSUCH44G_js.createLogger("TransactionSigner");
 function createTransactionSigner(config) {
   let { wallet, account, cluster, eventEmitter } = config;
   if (!wallet || !account)
@@ -2117,13 +2096,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,
@@ -2176,19 +2155,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) {
@@ -2196,18 +2175,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 },
@@ -2215,14 +2194,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 },
@@ -2233,9 +2212,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,
@@ -2270,21 +2249,21 @@ function createTransactionSigner(config) {
           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 },
@@ -2302,7 +2281,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);
         }
       }
     },
@@ -2312,16 +2291,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; )
@@ -2353,7 +2332,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");
@@ -2394,7 +2373,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();
@@ -2450,18 +2429,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;
@@ -2470,9 +2442,13 @@ exports.createGillTransactionSigner = createGillTransactionSigner;
 exports.createKitTransactionSigner = createKitTransactionSigner;
 exports.createTransactionSigner = createTransactionSigner;
 exports.formatAddress = formatAddress;
+exports.formatBigIntBalance = formatBigIntBalance;
+exports.formatBigIntUsd = formatBigIntUsd;
+exports.formatLamportsToSolSafe = formatLamportsToSolSafe;
 exports.formatNumber = formatNumber;
 exports.formatSOL = formatSOL;
 exports.formatTokenAmount = formatTokenAmount;
+exports.formatTokenBalanceSafe = formatTokenBalanceSafe;
 exports.getAddressUrl = getAddressUrl;
 exports.getBlockUrl = getBlockUrl;
 exports.getChainIdForWalletStandard = getChainIdForWalletStandard;
@@ -2486,13 +2462,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;
@@ -2500,17 +2472,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-JUZVCBAI.js.map
-//# sourceMappingURL=chunk-JUZVCBAI.js.map
+//# sourceMappingURL=chunk-FTXIXM43.js.map
+//# sourceMappingURL=chunk-FTXIXM43.js.map