@solana/connector 0.0.0 → 0.1.0

package/dist/chunk-52WUWW5R.mjs

@@ -0,0 +1,2533 @@
+import { createLogger, __publicField, isWeb3jsTransaction, prepareTransactionForWallet, convertSignedTransaction } from './chunk-5ZUVZZWU.mjs';
+import { getPublicSolanaRpcUrl, getExplorerLink, LAMPORTS_PER_SOL, address, getTransactionDecoder, getSignatureFromBytes, isAddress } from 'gill';
+import { Component, useTransition, useState, useCallback, useMemo } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { install } from '@solana/webcrypto-ed25519-polyfill';
+
+// src/lib/adapters/wallet-standard-shim.ts
+var registry = null;
+function getWalletsRegistry() {
+  if (typeof window > "u")
+    return {
+      get: () => [],
+      on: () => () => {
+      }
+    };
+  if (!registry) {
+    let nav = window.navigator;
+    nav.wallets && typeof nav.wallets.get == "function" ? registry = nav.wallets : import('@wallet-standard/app').then((mod) => {
+      let walletStandardRegistry = mod.getWallets?.();
+      walletStandardRegistry && (registry = walletStandardRegistry);
+    }).catch(() => {
+    });
+  }
+  return {
+    get: () => {
+      try {
+        let activeRegistry = window.navigator.wallets || registry;
+        if (activeRegistry && typeof activeRegistry.get == "function") {
+          let wallets = activeRegistry.get();
+          return Array.isArray(wallets) ? wallets : [];
+        }
+        return [];
+      } catch {
+        return [];
+      }
+    },
+    on: (event, callback) => {
+      try {
+        let activeRegistry = window.navigator.wallets || registry;
+        return activeRegistry && typeof activeRegistry.on == "function" ? activeRegistry.on(event, callback) : () => {
+        };
+      } catch {
+        return () => {
+        };
+      }
+    }
+  };
+}
+
+// src/lib/errors/index.ts
+var ConnectorError = class extends Error {
+  constructor(message, context, originalError) {
+    super(message);
+    /**
+     * Additional context about the error
+     */
+    __publicField(this, "context");
+    /**
+     * The underlying error that caused this error
+     */
+    __publicField(this, "originalError");
+    /**
+     * Timestamp when error occurred
+     */
+    __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);
+  }
+  /**
+   * Get a JSON representation of the error
+   */
+  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);
+    __publicField(this, "code");
+    __publicField(this, "recoverable", true);
+    this.code = code;
+  }
+}, ValidationError = class extends ConnectorError {
+  constructor(code, message, context, originalError) {
+    super(message, context, originalError);
+    __publicField(this, "code");
+    __publicField(this, "recoverable", false);
+    this.code = code;
+  }
+}, ConfigurationError = class extends ConnectorError {
+  constructor(code, message, context, originalError) {
+    super(message, context, originalError);
+    __publicField(this, "code");
+    __publicField(this, "recoverable", false);
+    this.code = code;
+  }
+}, NetworkError = class extends ConnectorError {
+  constructor(code, message, context, originalError) {
+    super(message, context, originalError);
+    __publicField(this, "code");
+    __publicField(this, "recoverable", true);
+    this.code = code;
+  }
+}, TransactionError = class extends ConnectorError {
+  constructor(code, message, context, originalError) {
+    super(message, context, originalError);
+    __publicField(this, "code");
+    __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 = {
+  // Connection 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 }),
+  // Validation errors
+  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 }),
+  // Configuration errors
+  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 }
+  ),
+  // Network errors
+  rpcError: (message, originalError) => new NetworkError("RPC_ERROR", message, void 0, originalError),
+  networkTimeout: () => new NetworkError("NETWORK_TIMEOUT", "Network request timed out"),
+  // Transaction errors
+  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.";
+}
+var PUBLIC_RPC_ENDPOINTS = {
+  mainnet: "https://api.mainnet-beta.solana.com",
+  devnet: "https://api.devnet.solana.com",
+  testnet: "https://api.testnet.solana.com",
+  localnet: "http://localhost:8899"
+};
+function normalizeNetwork(network) {
+  switch (network.toLowerCase().replace("-beta", "")) {
+    case "mainnet":
+      return "mainnet";
+    case "devnet":
+      return "devnet";
+    case "testnet":
+      return "testnet";
+    case "localnet":
+      return "localnet";
+    default:
+      return "mainnet";
+  }
+}
+function toClusterId(network) {
+  return `solana:${normalizeNetwork(network)}`;
+}
+function getDefaultRpcUrl(network) {
+  let normalized = normalizeNetwork(network);
+  try {
+    return getPublicSolanaRpcUrl(normalized);
+  } catch {
+    return PUBLIC_RPC_ENDPOINTS[normalized] ?? PUBLIC_RPC_ENDPOINTS.localnet;
+  }
+}
+function isMainnet(network) {
+  return normalizeNetwork(network) === "mainnet";
+}
+function isDevnet(network) {
+  return normalizeNetwork(network) === "devnet";
+}
+function isTestnet(network) {
+  return normalizeNetwork(network) === "testnet";
+}
+function isLocalnet(network) {
+  return normalizeNetwork(network) === "localnet";
+}
+function getNetworkDisplayName(network) {
+  let normalized = normalizeNetwork(network);
+  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+function getClusterRpcUrl(cluster) {
+  if (!cluster)
+    throw new Error("Invalid cluster configuration: unable to determine RPC URL for cluster unknown");
+  let url;
+  if (typeof cluster == "string" ? url = cluster : typeof cluster == "object" && cluster !== null ? "url" in cluster && typeof cluster.url == "string" ? url = cluster.url : "rpcUrl" in cluster && typeof cluster.rpcUrl == "string" ? url = cluster.rpcUrl : url = "" : url = "", url?.startsWith("http://") || url?.startsWith("https://"))
+    return url;
+  let presets = {
+    ...PUBLIC_RPC_ENDPOINTS,
+    "mainnet-beta": PUBLIC_RPC_ENDPOINTS.mainnet
+  };
+  if (url && presets[url])
+    return presets[url];
+  if (!url || url === "[object Object]")
+    throw new Error(
+      `Invalid cluster configuration: unable to determine RPC URL for cluster ${cluster?.id ?? "unknown"}`
+    );
+  return url;
+}
+function getClusterExplorerUrl(cluster, path) {
+  if (!cluster || !cluster.id)
+    return path ? `https://explorer.solana.com/${path}?cluster=devnet` : "https://explorer.solana.com?cluster=devnet";
+  let parts = cluster.id.split(":"), clusterSegment = parts.length >= 2 && parts[1] ? parts[1] : "devnet", isMainnet2 = cluster.id === "solana:mainnet" || cluster.id === "solana:mainnet-beta" || clusterSegment === "mainnet" || clusterSegment === "mainnet-beta", base = isMainnet2 ? "https://explorer.solana.com" : `https://explorer.solana.com?cluster=${clusterSegment}`;
+  return path ? isMainnet2 ? `https://explorer.solana.com/${path}` : `https://explorer.solana.com/${path}?cluster=${clusterSegment}` : base;
+}
+function getTransactionUrl(signature, cluster) {
+  let clusterType = getClusterType(cluster), explorerCluster = clusterType === "custom" || clusterType === "localnet" ? "devnet" : clusterType;
+  return getExplorerLink({
+    transaction: signature,
+    cluster: explorerCluster === "mainnet" ? "mainnet" : explorerCluster
+  });
+}
+function getAddressUrl(address, cluster) {
+  let clusterType = getClusterType(cluster), explorerCluster = clusterType === "custom" || clusterType === "localnet" ? "devnet" : clusterType;
+  return getExplorerLink({
+    address,
+    cluster: explorerCluster === "mainnet" ? "mainnet" : explorerCluster
+  });
+}
+function getTokenUrl(tokenAddress, cluster) {
+  return getClusterExplorerUrl(cluster, `token/${tokenAddress}`);
+}
+function getBlockUrl(slot, cluster) {
+  return getClusterExplorerUrl(cluster, `block/${slot}`);
+}
+function isMainnetCluster(cluster) {
+  return cluster.id === "solana:mainnet" || cluster.id === "solana:mainnet-beta";
+}
+function isDevnetCluster(cluster) {
+  return cluster.id === "solana:devnet";
+}
+function isTestnetCluster(cluster) {
+  return cluster.id === "solana:testnet";
+}
+function isLocalCluster(cluster) {
+  let url = "";
+  return "url" in cluster && typeof cluster.url == "string" ? url = cluster.url : "rpcUrl" in cluster && typeof cluster.rpcUrl == "string" && (url = cluster.rpcUrl), cluster.id === "solana:localnet" || url.includes("localhost") || url.includes("127.0.0.1");
+}
+function getClusterName(cluster) {
+  if (cluster.label) return cluster.label;
+  if ("name" in cluster && typeof cluster.name == "string")
+    return cluster.name;
+  let parts = cluster.id.split(":");
+  return parts.length >= 2 && parts[1] ? parts.slice(1).join(":") : "Unknown";
+}
+function getClusterType(cluster) {
+  return isMainnetCluster(cluster) ? "mainnet" : isDevnetCluster(cluster) ? "devnet" : isTestnetCluster(cluster) ? "testnet" : isLocalCluster(cluster) ? "localnet" : "custom";
+}
+
+// src/lib/constants.ts
+var POLL_INTERVALS_MS = [1e3, 2e3, 3e3, 5e3, 5e3], DEFAULT_MAX_RETRIES = 3, DEFAULT_MAX_TRACKED_TRANSACTIONS = 20;
+
+// src/lib/core/state-manager.ts
+var StateManager = class {
+  constructor(initialState) {
+    __publicField(this, "state");
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "notifyTimeout");
+    this.state = initialState;
+  }
+  /**
+   * Optimized state update with structural sharing
+   * Only updates if values actually changed
+   */
+  updateState(updates, immediate = false) {
+    let hasChanges = false, nextState = { ...this.state };
+    for (let [key, value] of Object.entries(updates)) {
+      let stateKey = key, currentValue = nextState[stateKey];
+      Array.isArray(value) && Array.isArray(currentValue) ? this.arraysEqual(value, currentValue) || (nextState[stateKey] = value, hasChanges = true) : value && typeof value == "object" && currentValue && typeof currentValue == "object" ? this.objectsEqual(value, currentValue) || (nextState[stateKey] = value, hasChanges = true) : currentValue !== value && (nextState[stateKey] = value, hasChanges = true);
+    }
+    return hasChanges && (this.state = nextState, immediate ? this.notifyImmediate() : this.notify()), hasChanges;
+  }
+  /**
+   * Fast array equality check for wallet/account arrays
+   */
+  arraysEqual(a, b) {
+    return a.length !== b.length ? false : a[0] && typeof a[0] == "object" && "name" in a[0] && b[0] && typeof b[0] == "object" && "name" in b[0] ? a.every((item, i) => {
+      let aItem = item, bItem = b[i];
+      if (!bItem || typeof bItem != "object") return false;
+      let keysA = Object.keys(aItem), keysB = Object.keys(bItem);
+      return keysA.length !== keysB.length ? false : keysA.every((key) => aItem[key] === bItem[key]);
+    }) : a[0] && typeof a[0] == "object" && "address" in a[0] && b[0] && typeof b[0] == "object" && "address" in b[0] ? a.every((item, i) => {
+      let aItem = item, bItem = b[i];
+      return aItem.address === bItem?.address;
+    }) : a === b;
+  }
+  /**
+   * Deep equality check for objects
+   * Used to prevent unnecessary state updates when object contents haven't changed
+   */
+  objectsEqual(a, b) {
+    if (a === b) return true;
+    if (!a || !b || typeof a != "object" || typeof b != "object") return false;
+    let keysA = Object.keys(a), keysB = Object.keys(b);
+    return keysA.length !== keysB.length ? false : keysA.every((key) => a[key] === b[key]);
+  }
+  subscribe(listener) {
+    return this.listeners.add(listener), () => this.listeners.delete(listener);
+  }
+  getSnapshot() {
+    return this.state;
+  }
+  notify() {
+    this.notifyTimeout && clearTimeout(this.notifyTimeout), this.notifyTimeout = setTimeout(() => {
+      this.listeners.forEach((l) => l(this.state)), this.notifyTimeout = void 0;
+    }, 16);
+  }
+  notifyImmediate() {
+    this.notifyTimeout && (clearTimeout(this.notifyTimeout), this.notifyTimeout = void 0), this.listeners.forEach((l) => l(this.state));
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/lib/core/event-emitter.ts
+var logger = createLogger("EventEmitter"), EventEmitter = class {
+  constructor(debug = false) {
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "debug");
+    this.debug = debug;
+  }
+  /**
+   * Subscribe to connector events
+   */
+  on(listener) {
+    return this.listeners.add(listener), () => this.listeners.delete(listener);
+  }
+  /**
+   * Remove a specific event listener
+   */
+  off(listener) {
+    this.listeners.delete(listener);
+  }
+  /**
+   * Remove all event listeners
+   */
+  offAll() {
+    this.listeners.clear();
+  }
+  /**
+   * Emit an event to all listeners
+   * Automatically adds timestamp if not already present
+   */
+  emit(event) {
+    let eventWithTimestamp = {
+      ...event,
+      timestamp: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.debug && logger.debug("Event emitted", { type: eventWithTimestamp.type, event: eventWithTimestamp }), this.listeners.forEach((listener) => {
+      try {
+        listener(eventWithTimestamp);
+      } catch (error) {
+        logger.error("Event listener error", { error });
+      }
+    });
+  }
+  /**
+   * Get the number of active listeners
+   */
+  getListenerCount() {
+    return this.listeners.size;
+  }
+  /**
+   * Generate ISO timestamp for events
+   * Utility method for creating timestamps consistently
+   */
+  static timestamp() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+};
+
+// src/lib/core/debug-metrics.ts
+var DebugMetrics = class {
+  constructor() {
+    __publicField(this, "stateUpdates", 0);
+    __publicField(this, "noopUpdates", 0);
+    __publicField(this, "updateTimes", []);
+    __publicField(this, "lastUpdateTime", 0);
+    __publicField(this, "eventListenerCount", 0);
+    __publicField(this, "subscriptionCount", 0);
+  }
+  /**
+   * Record a state update attempt
+   */
+  recordUpdate(duration, hadChanges) {
+    hadChanges ? this.stateUpdates++ : this.noopUpdates++, this.updateTimes.push(duration), this.updateTimes.length > 100 && this.updateTimes.shift(), this.lastUpdateTime = Date.now();
+  }
+  /**
+   * Update listener counts
+   */
+  updateListenerCounts(eventListeners, subscriptions) {
+    this.eventListenerCount = eventListeners, this.subscriptionCount = subscriptions;
+  }
+  /**
+   * Get current metrics
+   */
+  getMetrics() {
+    let totalUpdates = this.stateUpdates + this.noopUpdates, optimizationRate = totalUpdates > 0 ? Math.round(this.noopUpdates / totalUpdates * 100) : 0, avgUpdateTime = this.updateTimes.length > 0 ? this.updateTimes.reduce((a, b) => a + b, 0) / this.updateTimes.length : 0;
+    return {
+      stateUpdates: this.stateUpdates,
+      noopUpdates: this.noopUpdates,
+      optimizationRate,
+      eventListenerCount: this.eventListenerCount,
+      subscriptionCount: this.subscriptionCount,
+      avgUpdateTimeMs: Math.round(avgUpdateTime * 100) / 100,
+      lastUpdateTime: this.lastUpdateTime
+    };
+  }
+  /**
+   * Reset all metrics
+   */
+  resetMetrics() {
+    this.stateUpdates = 0, this.noopUpdates = 0, this.updateTimes = [], this.lastUpdateTime = 0;
+  }
+};
+
+// src/lib/core/base-collaborator.ts
+var BaseCollaborator = class {
+  constructor(config, loggerPrefix) {
+    __publicField(this, "stateManager");
+    __publicField(this, "eventEmitter");
+    __publicField(this, "debug");
+    __publicField(this, "logger");
+    this.stateManager = config.stateManager, this.eventEmitter = config.eventEmitter, this.debug = config.debug ?? false, this.logger = createLogger(loggerPrefix);
+  }
+  /**
+   * Log debug message if debug mode is enabled
+   */
+  log(message, data) {
+    this.debug && this.logger.debug(message, data);
+  }
+  /**
+   * Log error message if debug mode is enabled
+   */
+  error(message, data) {
+    this.debug && this.logger.error(message, data);
+  }
+  /**
+   * Get current state snapshot
+   */
+  getState() {
+    return this.stateManager.getSnapshot();
+  }
+};
+
+// src/lib/connection/wallet-authenticity-verifier.ts
+var logger2 = createLogger("WalletAuthenticity"), WalletAuthenticityVerifier = class {
+  /**
+   * Verify a wallet's authenticity using dynamic heuristics
+   *
+   * @param wallet - The wallet object to verify
+   * @param walletName - Expected wallet name
+   * @returns Verification result with confidence score
+   */
+  static verify(wallet, walletName) {
+    let warnings = [], name = walletName.toLowerCase();
+    logger2.debug("Verifying wallet with dynamic heuristics", { name });
+    let securityScore = {
+      walletStandardCompliance: 0,
+      methodIntegrity: 0,
+      chainSupport: 0,
+      maliciousPatterns: 1,
+      // Start at 1, deduct for issues
+      identityConsistency: 0
+    }, walletStandardScore = this.checkWalletStandardCompliance(wallet);
+    securityScore.walletStandardCompliance = walletStandardScore.score, warnings.push(...walletStandardScore.warnings);
+    let methodIntegrityScore = this.checkMethodIntegrity(wallet);
+    securityScore.methodIntegrity = methodIntegrityScore.score, warnings.push(...methodIntegrityScore.warnings);
+    let chainSupportScore = this.checkChainSupport(wallet);
+    securityScore.chainSupport = chainSupportScore.score, warnings.push(...chainSupportScore.warnings);
+    let maliciousPatterns = this.detectMaliciousPatterns(wallet, name);
+    securityScore.maliciousPatterns = maliciousPatterns.score, warnings.push(...maliciousPatterns.warnings);
+    let identityScore = this.checkIdentityConsistency(wallet, name);
+    securityScore.identityConsistency = identityScore.score, warnings.push(...identityScore.warnings);
+    let weights = {
+      walletStandardCompliance: 0.25,
+      methodIntegrity: 0.2,
+      chainSupport: 0.15,
+      maliciousPatterns: 0.3,
+      // Highest weight - security critical
+      identityConsistency: 0.1
+    }, confidence = securityScore.walletStandardCompliance * weights.walletStandardCompliance + securityScore.methodIntegrity * weights.methodIntegrity + securityScore.chainSupport * weights.chainSupport + securityScore.maliciousPatterns * weights.maliciousPatterns + securityScore.identityConsistency * weights.identityConsistency, authentic = confidence >= 0.6 && securityScore.maliciousPatterns > 0.5, reason = authentic ? "Wallet passed all security checks" : `Wallet failed security checks (confidence: ${Math.round(confidence * 100)}%)`;
+    return logger2.debug("Wallet verification complete", {
+      name,
+      authentic,
+      confidence: Math.round(confidence * 100) / 100,
+      warnings: warnings.length
+    }), {
+      authentic,
+      confidence,
+      reason,
+      warnings,
+      securityScore
+    };
+  }
+  /**
+   * Check Wallet Standard compliance
+   * Returns score 0-1 based on how well the wallet implements the standard
+   */
+  static checkWalletStandardCompliance(wallet) {
+    let warnings = [], score = 0;
+    if (wallet.features && typeof wallet.features == "object") {
+      score += 0.3;
+      let requiredFeatures = ["standard:connect", "standard:disconnect", "standard:events"], presentFeatures = requiredFeatures.filter((feature) => feature in wallet.features);
+      score += presentFeatures.length / requiredFeatures.length * 0.4;
+      let solanaFeatures = [
+        "solana:signTransaction",
+        "solana:signAndSendTransaction",
+        "solana:signMessage",
+        "solana:signAllTransactions"
+      ], presentSolanaFeatures = solanaFeatures.filter((feature) => feature in wallet.features);
+      score += presentSolanaFeatures.length / solanaFeatures.length * 0.3, presentFeatures.length < requiredFeatures.length && warnings.push("Wallet missing some standard features");
+    } else
+      warnings.push("Wallet does not implement Wallet Standard");
+    return { score: Math.min(score, 1), warnings };
+  }
+  /**
+   * Validate method integrity
+   * Checks if methods appear to be genuine and not tampered with
+   */
+  static checkMethodIntegrity(wallet) {
+    let warnings = [], score = 0, walletObj = wallet, criticalMethods = ["connect", "disconnect"], existingMethods = criticalMethods.filter((method) => typeof walletObj[method] == "function");
+    if (existingMethods.length === 0)
+      return warnings.push("Wallet missing critical methods"), { score: 0, warnings };
+    score += existingMethods.length / criticalMethods.length * 0.5;
+    let suspiciousMethodCount = 0;
+    for (let method of existingMethods) {
+      let funcStr = walletObj[method].toString();
+      funcStr.length > 1e3 && (suspiciousMethodCount++, warnings.push(`Method ${method} has unusually long implementation`));
+      let suspiciousKeywords = ["fetch(", "XMLHttpRequest", "sendToServer", "exfiltrate", "steal", "phish"];
+      for (let keyword of suspiciousKeywords)
+        if (funcStr.includes(keyword)) {
+          suspiciousMethodCount++, warnings.push(`Method ${method} contains suspicious code pattern`);
+          break;
+        }
+    }
+    let suspiciousRatio = suspiciousMethodCount / existingMethods.length;
+    return score += (1 - suspiciousRatio) * 0.5, { score: Math.max(0, Math.min(score, 1)), warnings };
+  }
+  /**
+   * Verify Solana chain support
+   */
+  static checkChainSupport(wallet) {
+    let warnings = [], score = 0;
+    return Array.isArray(wallet.chains) ? wallet.chains.some((chain) => String(chain).toLowerCase().includes("solana")) ? score = 1 : (warnings.push("Wallet does not explicitly support Solana chain"), score = 0.3) : wallet.chains === void 0 && (warnings.push("Wallet does not declare supported chains"), score = 0.5), { score, warnings };
+  }
+  /**
+   * Detect common patterns used by malicious wallet extensions
+   */
+  static detectMaliciousPatterns(wallet, expectedName) {
+    let warnings = [], score = 1, walletObj = wallet, identityFlags = Object.keys(walletObj).filter(
+      (key) => key.startsWith("is") && (key.endsWith("Wallet") || key.endsWith("wallet") || /^is[A-Z]/.test(key)) && walletObj[key] === true
+    );
+    identityFlags.length > 2 && (score -= 0.3, warnings.push(`Multiple wallet identity flags detected: ${identityFlags.join(", ")}`));
+    let explicitlyMaliciousProps = [
+      "stealPrivateKey",
+      "getPrivateKey",
+      "exportPrivateKey",
+      "sendToAttacker",
+      "phishingUrl",
+      "malware",
+      "backdoor"
+    ], lowerCaseKeys = Object.keys(walletObj).map((k) => k.toLowerCase());
+    for (let prop of explicitlyMaliciousProps)
+      lowerCaseKeys.includes(prop.toLowerCase()) && (score = 0, warnings.push(`Explicitly malicious property detected: ${prop}`));
+    let urlProps = ["iconUrl", "url", "homepage", "website"];
+    for (let prop of urlProps) {
+      let value = walletObj[prop];
+      typeof value == "string" && this.isSuspiciousUrl(value) && (score -= 0.2, warnings.push(`Suspicious URL in ${prop}: ${value}`));
+    }
+    if ("__proto__" in walletObj || "constructor" in walletObj) {
+      let proto = Object.getPrototypeOf(walletObj);
+      proto !== Object.prototype && proto !== null && (score -= 0.1, warnings.push("Wallet has unusual prototype chain"));
+    }
+    let propCount = Object.keys(walletObj).length;
+    return propCount > 100 && (score -= 0.1, warnings.push(`Wallet has unusually many properties (${propCount})`)), { score: Math.max(0, score), warnings };
+  }
+  /**
+   * Check if wallet identity is consistent with expected name
+   */
+  static checkIdentityConsistency(wallet, expectedName) {
+    let warnings = [], score = 0, walletObj = wallet, name = expectedName.toLowerCase(), identityIndicators = [
+      walletObj.name,
+      walletObj.providerName,
+      walletObj.metadata?.name,
+      walletObj._metadata?.name
+    ].filter(Boolean), hasMatch = false;
+    for (let indicator of identityIndicators)
+      if (typeof indicator == "string" && indicator.toLowerCase().includes(name)) {
+        hasMatch = true, score += 0.5;
+        break;
+      }
+    let capitalizedName = name.charAt(0).toUpperCase() + name.slice(1), identityFlags = [
+      `is${capitalizedName}`,
+      `is${capitalizedName}Wallet`,
+      `is${capitalizedName.toLowerCase()}`
+    ];
+    for (let flag of identityFlags)
+      if (walletObj[flag] === true) {
+        hasMatch = true, score += 0.5;
+        break;
+      }
+    return hasMatch || warnings.push(`Wallet identity does not match expected name: ${expectedName}`), { score: Math.min(score, 1), warnings };
+  }
+  /**
+   * Check if a URL looks suspicious
+   */
+  static isSuspiciousUrl(url) {
+    try {
+      let parsed = new URL(url), suspiciousPatterns = [
+        "bit.ly",
+        "tinyurl.com",
+        "tiny.cc",
+        "is.gd",
+        "goo.gl",
+        "t.co",
+        ".tk",
+        // Free domain TLDs
+        ".ml",
+        ".ga",
+        ".cf",
+        ".gq"
+      ], hostname = parsed.hostname.toLowerCase();
+      return !!(suspiciousPatterns.some((pattern) => hostname.includes(pattern)) || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(hostname) || hostname.split(".").length > 4);
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * Batch verify multiple wallets
+   *
+   * @param wallets - Array of wallet objects with their names
+   * @returns Map of wallet names to verification results
+   */
+  static verifyBatch(wallets) {
+    let results = /* @__PURE__ */ new Map();
+    for (let { wallet, name } of wallets)
+      results.set(name, this.verify(wallet, name));
+    return results;
+  }
+  /**
+   * Get a human-readable security report for a wallet
+   *
+   * @param result - Verification result
+   * @returns Formatted security report
+   */
+  static getSecurityReport(result) {
+    let lines = [];
+    return lines.push(`Security Assessment: ${result.authentic ? "\u2705 PASSED" : "\u274C FAILED"}`), lines.push(`Overall Confidence: ${Math.round(result.confidence * 100)}%`), lines.push(""), lines.push("Score Breakdown:"), lines.push(
+      `  - Wallet Standard Compliance: ${Math.round(result.securityScore.walletStandardCompliance * 100)}%`
+    ), lines.push(`  - Method Integrity: ${Math.round(result.securityScore.methodIntegrity * 100)}%`), lines.push(`  - Chain Support: ${Math.round(result.securityScore.chainSupport * 100)}%`), lines.push(`  - Malicious Patterns: ${Math.round(result.securityScore.maliciousPatterns * 100)}%`), lines.push(`  - Identity Consistency: ${Math.round(result.securityScore.identityConsistency * 100)}%`), result.warnings.length > 0 && (lines.push(""), lines.push("Warnings:"), result.warnings.forEach((w) => lines.push(`  \u26A0\uFE0F  ${w}`))), lines.join(`
+`);
+  }
+};
+
+// src/lib/connection/wallet-detector.ts
+var logger3 = createLogger("WalletDetector");
+function hasFeature(wallet, featureName) {
+  return wallet.features != null && wallet.features[featureName] !== void 0;
+}
+function verifyWalletName(wallet, requestedName) {
+  let name = requestedName.toLowerCase(), walletObj = wallet, nameFields = [
+    walletObj.name,
+    walletObj.providerName,
+    walletObj.metadata?.name
+  ].filter(Boolean);
+  for (let field of nameFields)
+    if (typeof field == "string" && field.toLowerCase().includes(name))
+      return true;
+  let capitalizedName = name.charAt(0).toUpperCase() + name.slice(1), commonFlagPatterns = [`is${capitalizedName}`, `is${capitalizedName}Wallet`];
+  for (let flagName of commonFlagPatterns)
+    if (walletObj[flagName] === true)
+      return true;
+  return false;
+}
+var WalletDetector = class extends BaseCollaborator {
+  constructor(stateManager, eventEmitter, debug = false) {
+    super({ stateManager, eventEmitter, debug }, "WalletDetector");
+    __publicField(this, "unsubscribers", []);
+  }
+  /**
+   * Initialize wallet detection
+   */
+  initialize() {
+    if (!(typeof window > "u"))
+      try {
+        let walletsApi = getWalletsRegistry(), update = () => {
+          let ws = walletsApi.get(), previousCount = this.getState().wallets.length, newCount = ws.length;
+          newCount !== previousCount && this.log("\u{1F50D} WalletDetector: found wallets:", newCount);
+          let unique = this.deduplicateWallets(ws);
+          this.stateManager.updateState({
+            wallets: unique.map((w) => this.mapToWalletInfo(w))
+          }), newCount !== previousCount && newCount > 0 && this.eventEmitter.emit({
+            type: "wallets:detected",
+            count: newCount,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        };
+        update(), this.unsubscribers.push(walletsApi.on("register", update)), this.unsubscribers.push(walletsApi.on("unregister", update)), setTimeout(() => {
+          this.getState().connected || update();
+        }, 1e3);
+      } catch {
+      }
+  }
+  /**
+   * Check if a specific wallet is available immediately via direct window object detection
+   */
+  detectDirectWallet(walletName) {
+    if (typeof window > "u") return null;
+    let name = walletName.toLowerCase(), windowObj = window, checks = [
+      () => windowObj[name],
+      () => windowObj[`${name}Wallet`],
+      () => windowObj.solana,
+      () => {
+        let keys = Object.keys(window).filter((k) => k.toLowerCase().includes(name));
+        return keys.length > 0 ? windowObj[keys[0]] : null;
+      }
+    ];
+    for (let check of checks)
+      try {
+        let result = check();
+        if (result && typeof result == "object") {
+          let wallet = result;
+          if (!verifyWalletName(wallet, walletName))
+            continue;
+          let verification = WalletAuthenticityVerifier.verify(wallet, walletName);
+          if (!verification.authentic) {
+            logger3.warn("Rejecting potentially malicious wallet", {
+              name: walletName,
+              reason: verification.reason,
+              confidence: verification.confidence
+            });
+            continue;
+          }
+          verification.warnings.length > 0 && logger3.warn("Wallet verification warnings", {
+            name: walletName,
+            warnings: verification.warnings
+          });
+          let hasStandardConnect = wallet.features?.["standard:connect"], hasLegacyConnect = typeof wallet.connect == "function";
+          if (hasStandardConnect || hasLegacyConnect)
+            return logger3.debug("Authentic wallet detected", {
+              name: walletName,
+              confidence: verification.confidence
+            }), wallet;
+        }
+      } catch {
+        continue;
+      }
+    return null;
+  }
+  /**
+   * Get currently detected wallets
+   */
+  getDetectedWallets() {
+    return this.getState().wallets;
+  }
+  /**
+   * Convert a Wallet Standard wallet to WalletInfo with capability checks
+   */
+  mapToWalletInfo(wallet) {
+    let hasConnect = hasFeature(wallet, "standard:connect"), hasDisconnect = hasFeature(wallet, "standard:disconnect"), isSolana = Array.isArray(wallet.chains) && wallet.chains.some((c) => typeof c == "string" && c.includes("solana"));
+    return {
+      wallet,
+      installed: true,
+      connectable: hasConnect && hasDisconnect && isSolana
+    };
+  }
+  /**
+   * Deduplicate wallets by name (keeps first occurrence)
+   */
+  deduplicateWallets(wallets) {
+    let seen = /* @__PURE__ */ new Map();
+    for (let wallet of wallets)
+      seen.has(wallet.name) || seen.set(wallet.name, wallet);
+    return Array.from(seen.values());
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    for (let unsubscribe of this.unsubscribers)
+      try {
+        unsubscribe();
+      } catch {
+      }
+    this.unsubscribers = [];
+  }
+};
+
+// src/lib/connection/connection-manager.ts
+function getConnectFeature(wallet) {
+  return wallet.features["standard:connect"]?.connect ?? null;
+}
+function getDisconnectFeature(wallet) {
+  return wallet.features["standard:disconnect"]?.disconnect ?? null;
+}
+function getEventsFeature(wallet) {
+  return wallet.features["standard:events"]?.on ?? null;
+}
+var ConnectionManager = class extends BaseCollaborator {
+  constructor(stateManager, eventEmitter, walletStorage, debug = false) {
+    super({ stateManager, eventEmitter, debug }, "ConnectionManager");
+    __publicField(this, "walletStorage");
+    __publicField(this, "walletChangeUnsub", null);
+    __publicField(this, "pollTimer", null);
+    __publicField(this, "pollAttempts", 0);
+    this.walletStorage = walletStorage;
+  }
+  /**
+   * Connect to a wallet
+   */
+  async connect(wallet, walletName) {
+    if (typeof window > "u") return;
+    let name = walletName || wallet.name;
+    this.eventEmitter.emit({
+      type: "connecting",
+      wallet: name,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }), this.stateManager.updateState({ connecting: true }, true);
+    try {
+      let connect = getConnectFeature(wallet);
+      if (!connect) throw new Error(`Wallet ${name} does not support standard connect`);
+      let result = await connect({ silent: false }), walletAccounts = wallet.accounts, accountMap = /* @__PURE__ */ new Map();
+      for (let a of [...walletAccounts, ...result.accounts]) accountMap.set(a.address, a);
+      let accounts = Array.from(accountMap.values()).map((a) => this.toAccountInfo(a)), state = this.getState(), previouslySelected = state.selectedAccount, previousAddresses = new Set(state.accounts.map((a) => a.address)), selected = accounts.find((a) => !previousAddresses.has(a.address))?.address ?? previouslySelected ?? accounts[0]?.address ?? null;
+      this.stateManager.updateState(
+        {
+          selectedWallet: wallet,
+          connected: true,
+          connecting: false,
+          accounts,
+          selectedAccount: selected
+        },
+        true
+      ), this.log("\u2705 Connection successful - state updated:", {
+        connected: true,
+        selectedWallet: wallet.name,
+        selectedAccount: selected,
+        accountsCount: accounts.length
+      }), this.eventEmitter.emit({
+        type: "wallet:connected",
+        wallet: name,
+        account: selected || "",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }), this.walletStorage && (!("isAvailable" in this.walletStorage) || typeof this.walletStorage.isAvailable != "function" || this.walletStorage.isAvailable() ? this.walletStorage.set(name) : this.log("Storage not available (private browsing?), skipping wallet persistence")), this.subscribeToWalletEvents();
+    } catch (e) {
+      let errorMessage = e instanceof Error ? e.message : String(e);
+      throw this.eventEmitter.emit({
+        type: "connection:failed",
+        wallet: name,
+        error: errorMessage,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }), this.eventEmitter.emit({
+        type: "error",
+        error: e instanceof Error ? e : new Error(errorMessage),
+        context: "wallet-connection",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }), this.stateManager.updateState(
+        {
+          selectedWallet: null,
+          connected: false,
+          connecting: false,
+          accounts: [],
+          selectedAccount: null
+        },
+        true
+      ), e;
+    }
+  }
+  /**
+   * Disconnect from wallet
+   */
+  async disconnect() {
+    if (this.walletChangeUnsub) {
+      try {
+        this.walletChangeUnsub();
+      } catch {
+      }
+      this.walletChangeUnsub = null;
+    }
+    this.stopPollingWalletAccounts();
+    let wallet = this.getState().selectedWallet;
+    if (wallet) {
+      let disconnect = getDisconnectFeature(wallet);
+      if (disconnect)
+        try {
+          await disconnect();
+        } catch {
+        }
+    }
+    this.stateManager.updateState(
+      {
+        selectedWallet: null,
+        connected: false,
+        accounts: [],
+        selectedAccount: null
+      },
+      true
+    ), this.eventEmitter.emit({
+      type: "wallet:disconnected",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }), this.walletStorage && "clear" in this.walletStorage && typeof this.walletStorage.clear == "function" ? this.walletStorage.clear() : this.walletStorage?.set(void 0);
+  }
+  /**
+   * Select a different account
+   */
+  async selectAccount(address) {
+    let state = this.getState(), current = state.selectedWallet;
+    if (!current) throw new Error("No wallet connected");
+    if (!address || address.length < 5)
+      throw new Error(`Invalid address format: ${address}`);
+    let target = state.accounts.find((acc) => acc.address === address)?.raw ?? null;
+    if (!target)
+      try {
+        let connect = getConnectFeature(current);
+        if (connect) {
+          let accounts = (await connect()).accounts.map((a) => this.toAccountInfo(a));
+          target = accounts.find((acc) => acc.address === address)?.raw ?? null, this.stateManager.updateState({ accounts });
+        }
+      } catch {
+        throw new Error("Failed to reconnect wallet for account selection");
+      }
+    if (!target) throw new Error(`Requested account not available: ${address}`);
+    this.stateManager.updateState({ selectedAccount: target.address }), this.eventEmitter.emit({
+      type: "account:changed",
+      account: target.address,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Convert wallet account to AccountInfo
+   */
+  toAccountInfo(account) {
+    return {
+      address: account.address,
+      icon: account.icon,
+      raw: account
+    };
+  }
+  /**
+   * Subscribe to wallet change events
+   */
+  subscribeToWalletEvents() {
+    if (this.walletChangeUnsub) {
+      try {
+        this.walletChangeUnsub();
+      } catch {
+      }
+      this.walletChangeUnsub = null;
+    }
+    this.stopPollingWalletAccounts();
+    let wallet = this.getState().selectedWallet;
+    if (!wallet) return;
+    let eventsOn = getEventsFeature(wallet);
+    if (!eventsOn) {
+      this.startPollingWalletAccounts();
+      return;
+    }
+    try {
+      this.walletChangeUnsub = eventsOn("change", (properties) => {
+        let changeAccounts = properties?.accounts ?? [];
+        if (changeAccounts.length === 0) return;
+        let nextAccounts = changeAccounts.map((a) => this.toAccountInfo(a));
+        nextAccounts.length > 0 && this.stateManager.updateState({
+          accounts: nextAccounts
+        });
+      });
+    } catch {
+      this.startPollingWalletAccounts();
+    }
+  }
+  /**
+   * Start polling wallet accounts (fallback when events not available)
+   * Uses exponential backoff to reduce polling frequency over time
+   */
+  startPollingWalletAccounts() {
+    if (this.pollTimer) return;
+    let wallet = this.getState().selectedWallet;
+    if (!wallet) return;
+    this.pollAttempts = 0;
+    let poll = () => {
+      if (this.pollAttempts >= 20) {
+        this.stopPollingWalletAccounts(), this.log("Stopped wallet polling after max attempts");
+        return;
+      }
+      try {
+        let state = this.getState(), nextAccounts = wallet.accounts.map((a) => this.toAccountInfo(a));
+        state.accounts.length === 0 && nextAccounts.length > 0 && (this.stateManager.updateState({
+          accounts: nextAccounts,
+          selectedAccount: state.selectedAccount || nextAccounts[0]?.address || null
+        }), this.pollAttempts = 0);
+      } catch (error) {
+        this.log("Wallet polling error:", error);
+      }
+      this.pollAttempts++;
+      let intervalIndex = Math.min(this.pollAttempts, POLL_INTERVALS_MS.length - 1), interval = POLL_INTERVALS_MS[intervalIndex];
+      this.pollTimer = setTimeout(poll, interval);
+    };
+    poll();
+  }
+  /**
+   * Stop polling wallet accounts
+   */
+  stopPollingWalletAccounts() {
+    this.pollTimer && (clearTimeout(this.pollTimer), this.pollTimer = null, this.pollAttempts = 0);
+  }
+  /**
+   * Get stored wallet name
+   */
+  getStoredWallet() {
+    return this.walletStorage?.get() ?? null;
+  }
+};
+
+// src/lib/connection/auto-connector.ts
+var logger4 = createLogger("AutoConnector"), MIN_ADDRESS_LENGTH = 30, AutoConnector = class {
+  constructor(walletDetector, connectionManager, stateManager, walletStorage, debug = false) {
+    __publicField(this, "walletDetector");
+    __publicField(this, "connectionManager");
+    __publicField(this, "stateManager");
+    __publicField(this, "walletStorage");
+    __publicField(this, "debug");
+    this.walletDetector = walletDetector, this.connectionManager = connectionManager, this.stateManager = stateManager, this.walletStorage = walletStorage, this.debug = debug;
+  }
+  /**
+   * Attempt auto-connection using both instant and fallback strategies
+   */
+  async attemptAutoConnect() {
+    return await this.attemptInstantConnect() ? true : (await this.attemptStandardConnect(), this.stateManager.getSnapshot().connected);
+  }
+  /**
+   * Attempt instant auto-connection using direct wallet detection
+   * Bypasses wallet standard initialization for maximum speed
+   */
+  async attemptInstantConnect() {
+    let storedWalletName = this.walletStorage?.get();
+    if (!storedWalletName) return false;
+    let directWallet = this.walletDetector.detectDirectWallet(storedWalletName);
+    if (!directWallet) return false;
+    this.debug && logger4.info("Instant auto-connect: found wallet directly in window", { walletName: storedWalletName });
+    try {
+      let features = {};
+      if (directWallet.connect && (features["standard:connect"] = {
+        connect: async (...args) => {
+          let options = args[0], result = await directWallet.connect(options);
+          if (this.debug && (logger4.debug("Direct wallet connect result", { result }), logger4.debug("Direct wallet publicKey property", { publicKey: directWallet.publicKey })), result && typeof result == "object" && "accounts" in result && Array.isArray(result.accounts))
+            return result;
+          let legacyResult = result;
+          if (legacyResult?.publicKey && typeof legacyResult.publicKey.toString == "function")
+            return {
+              accounts: [
+                {
+                  address: legacyResult.publicKey.toString(),
+                  publicKey: legacyResult.publicKey.toBytes ? legacyResult.publicKey.toBytes() : new Uint8Array(),
+                  chains: ["solana:mainnet", "solana:devnet", "solana:testnet"],
+                  features: []
+                }
+              ]
+            };
+          if (directWallet.publicKey && typeof directWallet.publicKey.toString == "function") {
+            let address = directWallet.publicKey.toString();
+            return this.debug && logger4.debug("Using legacy wallet pattern - publicKey from wallet object"), {
+              accounts: [
+                {
+                  address,
+                  publicKey: directWallet.publicKey.toBytes ? directWallet.publicKey.toBytes() : new Uint8Array(),
+                  chains: ["solana:mainnet", "solana:devnet", "solana:testnet"],
+                  features: []
+                }
+              ]
+            };
+          }
+          let publicKeyResult = result;
+          return publicKeyResult && typeof publicKeyResult.toString == "function" && publicKeyResult.toString().length > MIN_ADDRESS_LENGTH ? {
+            accounts: [
+              {
+                address: publicKeyResult.toString(),
+                publicKey: publicKeyResult.toBytes ? publicKeyResult.toBytes() : new Uint8Array(),
+                chains: ["solana:mainnet", "solana:devnet", "solana:testnet"],
+                features: []
+              }
+            ]
+          } : (this.debug && logger4.error("Legacy wallet: No valid publicKey found in any expected location"), { accounts: [] });
+        }
+      }), directWallet.disconnect) {
+        let disconnectFn = directWallet.disconnect;
+        features["standard:disconnect"] = {
+          disconnect: () => disconnectFn.call(directWallet)
+        };
+      }
+      if (directWallet.signTransaction) {
+        let signTransactionFn = directWallet.signTransaction;
+        features["standard:signTransaction"] = {
+          signTransaction: (tx) => signTransactionFn.call(directWallet, tx)
+        };
+      }
+      if (directWallet.signMessage) {
+        let signMessageFn = directWallet.signMessage;
+        features["standard:signMessage"] = {
+          signMessage: (...args) => {
+            let msg = args[0];
+            return signMessageFn.call(directWallet, msg);
+          }
+        };
+      }
+      directWallet.features && Object.assign(features, directWallet.features);
+      let walletIcon = directWallet.icon || directWallet._metadata?.icon || directWallet.adapter?.icon || directWallet.metadata?.icon || directWallet.iconUrl, wallet = {
+        version: "1.0.0",
+        name: storedWalletName,
+        icon: walletIcon,
+        chains: directWallet.chains || [
+          "solana:mainnet",
+          "solana:devnet",
+          "solana:testnet"
+        ],
+        features,
+        accounts: []
+      };
+      return this.stateManager.updateState(
+        {
+          wallets: [
+            {
+              wallet,
+              installed: true,
+              connectable: true
+            }
+          ]
+        },
+        true
+      ), this.debug && logger4.info("Attempting to connect via instant auto-connect", { walletName: storedWalletName }), await this.connectionManager.connect(wallet, storedWalletName), this.debug && logger4.info("Instant auto-connect successful", { walletName: storedWalletName }), setTimeout(() => {
+        let ws = getWalletsRegistry().get();
+        this.debug && logger4.debug("Checking for wallet standard update", {
+          wsLength: ws.length,
+          currentWalletsLength: this.stateManager.getSnapshot().wallets.length,
+          shouldUpdate: ws.length > 1
+        }), ws.length > 1 && this.walletDetector.initialize();
+      }, 500), true;
+    } catch (error) {
+      return this.debug && logger4.error("Instant auto-connect failed", {
+        walletName: storedWalletName,
+        error: error instanceof Error ? error.message : error
+      }), false;
+    }
+  }
+  /**
+   * Attempt auto-connection via standard wallet detection (fallback)
+   */
+  async attemptStandardConnect() {
+    try {
+      if (this.stateManager.getSnapshot().connected) {
+        this.debug && logger4.info("Auto-connect: Already connected, skipping fallback auto-connect");
+        return;
+      }
+      let storedWalletName = this.walletStorage?.get();
+      if (this.debug && (logger4.debug("Auto-connect: stored wallet", { storedWalletName }), logger4.debug("Auto-connect: available wallets", {
+        wallets: this.stateManager.getSnapshot().wallets.map((w) => w.wallet.name)
+      })), !storedWalletName) return;
+      let walletInfo = this.stateManager.getSnapshot().wallets.find((w) => w.wallet.name === storedWalletName);
+      walletInfo ? (this.debug && logger4.info("Auto-connect: Found stored wallet, connecting"), await this.connectionManager.connect(walletInfo.wallet, storedWalletName)) : setTimeout(() => {
+        let retryWallet = this.stateManager.getSnapshot().wallets.find((w) => w.wallet.name === storedWalletName);
+        retryWallet && (this.debug && logger4.info("Auto-connect: Retry successful"), this.connectionManager.connect(retryWallet.wallet, storedWalletName).catch((err) => {
+          logger4.error("Auto-connect retry connection failed", { error: err });
+        }));
+      }, 1e3);
+    } catch (e) {
+      this.debug && logger4.error("Auto-connect failed", { error: e }), this.walletStorage?.set(void 0);
+    }
+  }
+};
+
+// src/lib/cluster/cluster-manager.ts
+var ClusterManager = class extends BaseCollaborator {
+  constructor(stateManager, eventEmitter, clusterStorage, config, debug = false) {
+    super({ stateManager, eventEmitter, debug }, "ClusterManager");
+    __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({
+        cluster: initialCluster,
+        clusters
+      });
+    }
+  }
+  /**
+   * Set the active cluster (network)
+   */
+  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(
+        clusterId,
+        state.clusters.map((c) => c.id)
+      );
+    this.stateManager.updateState({ cluster }, true), this.clusterStorage && (!("isAvailable" in this.clusterStorage) || typeof this.clusterStorage.isAvailable != "function" || this.clusterStorage.isAvailable() ? this.clusterStorage.set(clusterId) : this.log("Storage not available (private browsing?), skipping cluster persistence")), previousClusterId !== clusterId && this.eventEmitter.emit({
+      type: "cluster:changed",
+      cluster: clusterId,
+      previousCluster: previousClusterId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }), this.log("\u{1F310} Cluster changed:", { from: previousClusterId, to: clusterId });
+  }
+  /**
+   * Get the currently active cluster
+   */
+  getCluster() {
+    return this.getState().cluster;
+  }
+  /**
+   * Get all available clusters
+   */
+  getClusters() {
+    return this.getState().clusters;
+  }
+};
+
+// src/lib/transaction/transaction-tracker.ts
+var TransactionTracker = class extends BaseCollaborator {
+  constructor(stateManager, eventEmitter, maxTransactions = 20, debug = false) {
+    super({ stateManager, eventEmitter, debug }, "TransactionTracker");
+    __publicField(this, "transactions", []);
+    __publicField(this, "totalTransactions", 0);
+    __publicField(this, "maxTransactions");
+    this.maxTransactions = maxTransactions;
+  }
+  /**
+   * Track a transaction for debugging and monitoring
+   */
+  trackTransaction(activity) {
+    let state = this.getState(), fullActivity = {
+      ...activity,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      cluster: state.cluster?.id || "solana:devnet"
+    };
+    this.transactions.unshift(fullActivity), this.transactions.length > this.maxTransactions && this.transactions.pop(), this.totalTransactions++, this.eventEmitter.emit({
+      type: "transaction:tracked",
+      signature: fullActivity.signature,
+      status: fullActivity.status,
+      timestamp: fullActivity.timestamp
+    }), this.log("[Connector] Transaction tracked:", fullActivity);
+  }
+  /**
+   * Update transaction status (e.g., from pending to confirmed/failed)
+   */
+  updateStatus(signature, status, error) {
+    let tx = this.transactions.find((t) => t.signature === signature);
+    tx && (tx.status = status, error && (tx.error = error), this.eventEmitter.emit({
+      type: "transaction:updated",
+      signature,
+      status,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }), this.log("[Connector] Transaction updated:", { signature, status, error }));
+  }
+  /**
+   * Get transaction history
+   */
+  getTransactions() {
+    return [...this.transactions];
+  }
+  /**
+   * Get total transaction count
+   */
+  getTotalCount() {
+    return this.totalTransactions;
+  }
+  /**
+   * Clear transaction history
+   */
+  clearHistory() {
+    this.transactions = [];
+  }
+};
+
+// src/lib/health/health-monitor.ts
+var HealthMonitor = class {
+  constructor(stateManager, walletStorage, clusterStorage, isInitialized) {
+    __publicField(this, "stateManager");
+    __publicField(this, "walletStorage");
+    __publicField(this, "clusterStorage");
+    __publicField(this, "isInitialized");
+    this.stateManager = stateManager, this.walletStorage = walletStorage, this.clusterStorage = clusterStorage, this.isInitialized = isInitialized ?? (() => true);
+  }
+  /**
+   * Check connector health and availability
+   */
+  getHealth() {
+    let errors = [], walletStandardAvailable = false;
+    try {
+      let registry2 = getWalletsRegistry();
+      walletStandardAvailable = !!(registry2 && typeof registry2.get == "function"), walletStandardAvailable || errors.push("Wallet Standard registry not properly initialized");
+    } catch (error) {
+      errors.push(`Wallet Standard error: ${error instanceof Error ? error.message : "Unknown error"}`), walletStandardAvailable = false;
+    }
+    let storageAvailable = false;
+    try {
+      if (!this.walletStorage || !this.clusterStorage)
+        errors.push("Storage adapters not configured"), storageAvailable = false;
+      else {
+        if ("isAvailable" in this.walletStorage && typeof this.walletStorage.isAvailable == "function")
+          storageAvailable = this.walletStorage.isAvailable();
+        else if (typeof window < "u")
+          try {
+            let testKey = "__connector_storage_test__";
+            window.localStorage.setItem(testKey, "test"), window.localStorage.removeItem(testKey), storageAvailable = true;
+          } catch {
+            storageAvailable = false;
+          }
+        storageAvailable || errors.push("localStorage unavailable (private browsing mode or quota exceeded)");
+      }
+    } catch (error) {
+      errors.push(`Storage error: ${error instanceof Error ? error.message : "Unknown error"}`), storageAvailable = false;
+    }
+    let state = this.stateManager.getSnapshot();
+    return state.connected && !state.selectedWallet && errors.push("Inconsistent state: marked as connected but no wallet selected"), state.connected && !state.selectedAccount && errors.push("Inconsistent state: marked as connected but no account selected"), state.connecting && state.connected && errors.push("Inconsistent state: both connecting and connected flags are true"), {
+      initialized: this.isInitialized(),
+      walletStandardAvailable,
+      storageAvailable,
+      walletsDetected: state.wallets.length,
+      errors,
+      connectionState: {
+        connected: state.connected,
+        connecting: state.connecting,
+        hasSelectedWallet: !!state.selectedWallet,
+        hasSelectedAccount: !!state.selectedAccount
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/lib/core/connector-client.ts
+var logger5 = createLogger("ConnectorClient"), ConnectorClient = class {
+  constructor(config = {}) {
+    __publicField(this, "stateManager");
+    __publicField(this, "eventEmitter");
+    __publicField(this, "walletDetector");
+    __publicField(this, "connectionManager");
+    __publicField(this, "autoConnector");
+    __publicField(this, "clusterManager");
+    __publicField(this, "transactionTracker");
+    __publicField(this, "debugMetrics");
+    __publicField(this, "healthMonitor");
+    __publicField(this, "initialized", false);
+    __publicField(this, "config");
+    this.config = config;
+    let initialState = {
+      wallets: [],
+      selectedWallet: null,
+      connected: false,
+      connecting: false,
+      accounts: [],
+      selectedAccount: null,
+      cluster: null,
+      clusters: []
+    };
+    this.stateManager = new StateManager(initialState), this.eventEmitter = new EventEmitter(config.debug), this.debugMetrics = new DebugMetrics(), this.walletDetector = new WalletDetector(this.stateManager, this.eventEmitter, config.debug ?? false), this.connectionManager = new ConnectionManager(
+      this.stateManager,
+      this.eventEmitter,
+      config.storage?.wallet,
+      config.debug ?? false
+    ), this.autoConnector = new AutoConnector(
+      this.walletDetector,
+      this.connectionManager,
+      this.stateManager,
+      config.storage?.wallet,
+      config.debug ?? false
+    ), this.clusterManager = new ClusterManager(
+      this.stateManager,
+      this.eventEmitter,
+      config.storage?.cluster,
+      config.cluster,
+      config.debug ?? false
+    ), this.transactionTracker = new TransactionTracker(
+      this.stateManager,
+      this.eventEmitter,
+      DEFAULT_MAX_TRACKED_TRANSACTIONS,
+      config.debug ?? false
+    ), this.healthMonitor = new HealthMonitor(
+      this.stateManager,
+      config.storage?.wallet,
+      config.storage?.cluster,
+      () => this.initialized
+    ), this.initialize();
+  }
+  /**
+   * Initialize the connector
+   */
+  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 });
+      }
+  }
+  // ============================================================================
+  // Public API - Delegates to collaborators
+  // ============================================================================
+  /**
+   * Connect to a wallet by name
+   */
+  async select(walletName) {
+    let wallet = this.stateManager.getSnapshot().wallets.find((w) => w.wallet.name === walletName)?.wallet;
+    if (!wallet) throw new Error(`Wallet ${walletName} not found`);
+    await this.connectionManager.connect(wallet, walletName);
+  }
+  /**
+   * Disconnect from the current wallet
+   */
+  async disconnect() {
+    await this.connectionManager.disconnect();
+  }
+  /**
+   * Select a different account
+   */
+  async selectAccount(address) {
+    await this.connectionManager.selectAccount(address);
+  }
+  /**
+   * Set the active cluster (network)
+   */
+  async setCluster(clusterId) {
+    await this.clusterManager.setCluster(clusterId);
+  }
+  /**
+   * Get the currently active cluster
+   */
+  getCluster() {
+    return this.clusterManager.getCluster();
+  }
+  /**
+   * Get all available clusters
+   */
+  getClusters() {
+    return this.clusterManager.getClusters();
+  }
+  /**
+   * Get the RPC URL for the current cluster
+   * @returns RPC URL or null if no cluster is selected
+   */
+  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;
+    }
+  }
+  /**
+   * Subscribe to state changes
+   */
+  subscribe(listener) {
+    return this.stateManager.subscribe(listener);
+  }
+  /**
+   * Get current state snapshot
+   */
+  getSnapshot() {
+    return this.stateManager.getSnapshot();
+  }
+  /**
+   * Reset all storage to initial values
+   * Useful for "logout", "forget this device", or clearing user data
+   *
+   * This will:
+   * - Clear saved wallet name
+   * - Clear saved account address
+   * - Reset cluster to initial value (does not clear)
+   *
+   * Note: This does NOT disconnect the wallet. Call disconnect() separately if needed.
+   *
+   * @example
+   * ```ts
+   * // Complete logout flow
+   * await client.disconnect();
+   * client.resetStorage();
+   * ```
+   */
+  resetStorage() {
+    this.config.debug && logger5.info("Resetting all storage to initial values");
+    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 });
+        }
+    }
+    this.eventEmitter.emit({
+      type: "storage:reset",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Subscribe to connector events
+   */
+  on(listener) {
+    return this.eventEmitter.on(listener);
+  }
+  /**
+   * Remove a specific event listener
+   */
+  off(listener) {
+    this.eventEmitter.off(listener);
+  }
+  /**
+   * Remove all event listeners
+   */
+  offAll() {
+    this.eventEmitter.offAll();
+  }
+  /**
+   * Emit a connector event
+   * Internal method used by transaction signer and other components
+   * @internal
+   */
+  emitEvent(event) {
+    this.eventEmitter.emit(event);
+  }
+  /**
+   * Track a transaction for debugging and monitoring
+   */
+  trackTransaction(activity) {
+    this.transactionTracker.trackTransaction(activity);
+  }
+  /**
+   * Update transaction status
+   */
+  updateTransactionStatus(signature, status, error) {
+    this.transactionTracker.updateStatus(signature, status, error);
+  }
+  /**
+   * Clear transaction history
+   */
+  clearTransactionHistory() {
+    this.transactionTracker.clearHistory();
+  }
+  /**
+   * Get connector health and diagnostics
+   */
+  getHealth() {
+    return this.healthMonitor.getHealth();
+  }
+  /**
+   * Get performance and debug metrics
+   */
+  getDebugMetrics() {
+    this.stateManager.getSnapshot();
+    return this.debugMetrics.updateListenerCounts(this.eventEmitter.getListenerCount(), 0), this.debugMetrics.getMetrics();
+  }
+  /**
+   * Get debug state including transactions
+   */
+  getDebugState() {
+    return {
+      ...this.getDebugMetrics(),
+      transactions: this.transactionTracker.getTransactions(),
+      totalTransactions: this.transactionTracker.getTotalCount()
+    };
+  }
+  /**
+   * Reset debug metrics
+   */
+  resetDebugMetrics() {
+    this.debugMetrics.resetMetrics();
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.connectionManager.disconnect().catch(() => {
+    }), this.walletDetector.destroy(), this.eventEmitter.offAll(), this.stateManager.clear();
+  }
+};
+var logger6 = createLogger("ErrorBoundary"), WalletErrorType = /* @__PURE__ */ ((WalletErrorType2) => (WalletErrorType2.CONNECTION_FAILED = "CONNECTION_FAILED", WalletErrorType2.TRANSACTION_FAILED = "TRANSACTION_FAILED", WalletErrorType2.NETWORK_ERROR = "NETWORK_ERROR", WalletErrorType2.WALLET_NOT_FOUND = "WALLET_NOT_FOUND", WalletErrorType2.USER_REJECTED = "USER_REJECTED", WalletErrorType2.INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS", WalletErrorType2.UNKNOWN_ERROR = "UNKNOWN_ERROR", WalletErrorType2))(WalletErrorType || {}), ErrorLogger = class {
+  static log(error, errorInfo, context) {
+    if (process.env.NODE_ENV === "development" && logger6.error(error.message, {
+      error,
+      errorInfo,
+      context
+    }), process.env.NODE_ENV === "production" && typeof window < "u")
+      try {
+        let gtag = window.gtag;
+        typeof gtag == "function" && gtag("event", "exception", {
+          description: error.message,
+          fatal: false,
+          custom_map: { error_type: "wallet_error", ...context }
+        });
+      } catch {
+      }
+  }
+};
+function classifyError(error) {
+  if (isConnectorError(error))
+    return {
+      ...error,
+      type: {
+        WALLET_NOT_CONNECTED: "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        WALLET_NOT_FOUND: "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+        CONNECTION_FAILED: "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        USER_REJECTED: "USER_REJECTED" /* USER_REJECTED */,
+        RPC_ERROR: "NETWORK_ERROR" /* NETWORK_ERROR */,
+        NETWORK_TIMEOUT: "NETWORK_ERROR" /* NETWORK_ERROR */,
+        SIGNING_FAILED: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+        SEND_FAILED: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */
+      }[error.code] || "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      recoverable: error.recoverable,
+      context: error.context
+    };
+  let walletError = error;
+  if (walletError.type) return walletError;
+  let type = "UNKNOWN_ERROR" /* UNKNOWN_ERROR */, recoverable = false;
+  return error.message.includes("User rejected") || error.message.includes("User denied") ? (type = "USER_REJECTED" /* USER_REJECTED */, recoverable = true) : error.message.includes("Insufficient funds") ? (type = "INSUFFICIENT_FUNDS" /* INSUFFICIENT_FUNDS */, recoverable = false) : error.message.includes("Network") || error.message.includes("fetch") ? (type = "NETWORK_ERROR" /* NETWORK_ERROR */, recoverable = true) : error.message.includes("Wallet not found") || error.message.includes("not installed") ? (type = "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */, recoverable = true) : (error.message.includes("Failed to connect") || error.message.includes("Connection")) && (type = "CONNECTION_FAILED" /* CONNECTION_FAILED */, recoverable = true), {
+    ...error,
+    type,
+    recoverable,
+    context: { originalMessage: error.message }
+  };
+}
+var ConnectorErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    __publicField(this, "retryTimeouts", /* @__PURE__ */ new Set());
+    __publicField(this, "retry", () => {
+      let { maxRetries = 3 } = this.props;
+      this.state.retryCount >= maxRetries || this.setState((prevState) => ({
+        hasError: false,
+        error: null,
+        errorInfo: null,
+        retryCount: prevState.retryCount + 1
+      }));
+    });
+    this.state = {
+      hasError: false,
+      error: null,
+      errorInfo: null,
+      errorId: "",
+      retryCount: 0
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return {
+      hasError: true,
+      error,
+      errorId: `error_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+    };
+  }
+  componentDidCatch(error, errorInfo) {
+    this.setState({ errorInfo }), ErrorLogger.log(error, errorInfo, {
+      retryCount: this.state.retryCount,
+      errorId: this.state.errorId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }), this.props.onError?.(error, errorInfo);
+  }
+  componentWillUnmount() {
+    this.retryTimeouts.forEach((timeout) => clearTimeout(timeout));
+  }
+  render() {
+    if (this.state.hasError && this.state.error) {
+      let walletError = classifyError(this.state.error);
+      return this.props.fallback ? this.props.fallback(walletError, this.retry) : /* @__PURE__ */ jsx(DefaultErrorFallback, { error: walletError, onRetry: this.retry });
+    }
+    return this.props.children;
+  }
+};
+function DefaultErrorFallback({ error, onRetry }) {
+  let [isPending, startTransition] = useTransition(), [isRetrying, setIsRetrying] = useState(false), handleRetry = useCallback(() => {
+    setIsRetrying(true), startTransition(() => {
+      setTimeout(() => {
+        onRetry(), setIsRetrying(false);
+      }, 500);
+    });
+  }, [onRetry]), { title, message, actionText, showRetry } = useMemo(() => {
+    switch (error.type) {
+      case "USER_REJECTED" /* USER_REJECTED */:
+        return {
+          title: "Transaction Cancelled",
+          message: "You cancelled the transaction. No problem!",
+          actionText: "Try Again",
+          showRetry: true
+        };
+      case "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */:
+        return {
+          title: "Wallet Not Found",
+          message: "Please install a supported Solana wallet to continue.",
+          actionText: "Check Wallets",
+          showRetry: true
+        };
+      case "NETWORK_ERROR" /* NETWORK_ERROR */:
+        return {
+          title: "Network Error",
+          message: "Having trouble connecting. Please check your internet connection.",
+          actionText: "Retry",
+          showRetry: true
+        };
+      case "INSUFFICIENT_FUNDS" /* INSUFFICIENT_FUNDS */:
+        return {
+          title: "Insufficient Funds",
+          message: "You don't have enough SOL for this transaction.",
+          actionText: "Add Funds",
+          showRetry: false
+        };
+      default:
+        return {
+          title: "Something went wrong",
+          message: "An unexpected error occurred. Please try again.",
+          actionText: "Retry",
+          showRetry: error.recoverable
+        };
+    }
+  }, [error.type, error.recoverable]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        padding: "2rem",
+        textAlign: "center",
+        borderRadius: "12px",
+        border: "1px solid #e5e7eb",
+        backgroundColor: "#fafafa",
+        maxWidth: "400px",
+        margin: "0 auto"
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              width: "48px",
+              height: "48px",
+              borderRadius: "50%",
+              backgroundColor: "#fee2e2",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              marginBottom: "1rem"
+            },
+            children: /* @__PURE__ */ jsx("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "#dc2626", children: /* @__PURE__ */ jsx("path", { d: "M12 9v3.75m-9.303 3.376c-.866 1.5.217 3.374 1.948 3.374h14.71c1.73 0 2.813-1.874 1.948-3.374L13.949 3.378c-.866-1.5-3.032-1.5-3.898 0L2.697 16.126zM12 15.75h.007v.008H12v-.008z" }) })
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "h3",
+          {
+            style: {
+              margin: "0 0 0.5rem 0",
+              fontSize: "1.125rem",
+              fontWeight: "600",
+              color: "#111827"
+            },
+            children: title
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "p",
+          {
+            style: {
+              margin: "0 0 1.5rem 0",
+              fontSize: "0.875rem",
+              color: "#6b7280",
+              lineHeight: "1.5"
+            },
+            children: message
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "0.75rem", flexWrap: "wrap" }, children: [
+          showRetry && /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: handleRetry,
+              disabled: isPending || isRetrying,
+              style: {
+                padding: "0.5rem 1rem",
+                backgroundColor: "#3b82f6",
+                color: "white",
+                border: "none",
+                borderRadius: "6px",
+                fontSize: "0.875rem",
+                fontWeight: "500",
+                cursor: isPending || isRetrying ? "wait" : "pointer",
+                opacity: isPending || isRetrying ? 0.7 : 1,
+                transition: "all 0.2s"
+              },
+              children: isRetrying ? "Retrying..." : actionText
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: () => window.location.reload(),
+              style: {
+                padding: "0.5rem 1rem",
+                backgroundColor: "transparent",
+                color: "#6b7280",
+                border: "1px solid #d1d5db",
+                borderRadius: "6px",
+                fontSize: "0.875rem",
+                fontWeight: "500",
+                cursor: "pointer",
+                transition: "all 0.2s"
+              },
+              children: "Refresh Page"
+            }
+          )
+        ] }),
+        process.env.NODE_ENV === "development" && /* @__PURE__ */ jsxs(
+          "details",
+          {
+            style: {
+              marginTop: "1rem",
+              fontSize: "0.75rem",
+              color: "#6b7280",
+              width: "100%"
+            },
+            children: [
+              /* @__PURE__ */ jsx("summary", { style: { cursor: "pointer", marginBottom: "0.5rem" }, children: "Error Details" }),
+              /* @__PURE__ */ jsx(
+                "pre",
+                {
+                  style: {
+                    whiteSpace: "pre-wrap",
+                    wordBreak: "break-all",
+                    backgroundColor: "#f3f4f6",
+                    padding: "0.5rem",
+                    borderRadius: "4px",
+                    overflow: "auto",
+                    maxHeight: "200px"
+                  },
+                  children: error.message
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function withErrorBoundary(Component2, errorBoundaryProps) {
+  let WrappedComponent = (props) => /* @__PURE__ */ jsx(ConnectorErrorBoundary, { ...errorBoundaryProps, children: /* @__PURE__ */ jsx(Component2, { ...props }) });
+  return WrappedComponent.displayName = `withErrorBoundary(${Component2.displayName || Component2.name})`, WrappedComponent;
+}
+var logger7 = createLogger("Polyfills"), installed = false;
+function installPolyfills() {
+  if (!(installed || typeof window > "u"))
+    try {
+      install(), installed = true, process.env.NODE_ENV === "development" && logger7 && logger7.info("Browser compatibility polyfills installed");
+    } catch (error) {
+      logger7 && logger7.warn("Failed to install polyfills", { error }), installed = true;
+    }
+}
+function isPolyfillInstalled() {
+  return installed;
+}
+function isCryptoAvailable() {
+  if (typeof window > "u") return false;
+  try {
+    return !!(window.crypto && window.crypto.subtle && typeof window.crypto.subtle.sign == "function");
+  } catch {
+    return false;
+  }
+}
+function getPolyfillStatus() {
+  return {
+    installed,
+    cryptoAvailable: isCryptoAvailable(),
+    environment: typeof window < "u" ? "browser" : "server"
+  };
+}
+function formatAddress(address, options = {}) {
+  let { length = 4, separator = "..." } = options;
+  return !address || address.length <= length * 2 + separator.length ? address : `${address.slice(0, length)}${separator}${address.slice(-length)}`;
+}
+function formatSOL(lamports, options = {}) {
+  let { decimals = 4, suffix = true, fast = false } = options;
+  if (fast && typeof lamports == "number") {
+    let formatted2 = (lamports / LAMPORTS_PER_SOL).toFixed(decimals);
+    return suffix ? `${formatted2} SOL` : formatted2;
+  }
+  let lamportsBigInt = typeof lamports == "bigint" ? lamports : BigInt(lamports), formatted = (Number(lamportsBigInt) / LAMPORTS_PER_SOL).toFixed(decimals);
+  return suffix ? `${formatted} SOL` : formatted;
+}
+function formatNumber(value, options = {}) {
+  let { decimals, locale = "en-US" } = options;
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(value);
+}
+function truncate(text, maxLength, position = "middle") {
+  if (!text || text.length <= maxLength) return text;
+  if (position === "end")
+    return text.slice(0, maxLength - 3) + "...";
+  let half = Math.floor((maxLength - 3) / 2);
+  return text.slice(0, half) + "..." + text.slice(-half);
+}
+function formatTokenAmount(amount, decimals, options = {}) {
+  let value = Number(amount) / Math.pow(10, decimals), minDecimals = options.minimumDecimals ?? 0, maxDecimals = options.maximumDecimals ?? decimals;
+  return value.toLocaleString("en-US", {
+    minimumFractionDigits: minDecimals,
+    maximumFractionDigits: maxDecimals
+  });
+}
+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")
+    return { modern: false, fallback: false, available: false };
+  let modern = typeof navigator?.clipboard?.writeText == "function", fallback = typeof document.execCommand == "function";
+  return {
+    modern,
+    fallback,
+    available: modern || fallback
+  };
+}
+function validateAddress(address) {
+  try {
+    return isAddress(address);
+  } catch {
+    return false;
+  }
+}
+function validateSignature(signature) {
+  return !signature || typeof signature != "string" || signature.length < 87 || signature.length > 88 ? false : /^[1-9A-HJ-NP-Za-km-z]+$/.test(signature);
+}
+function formatValue(value, options) {
+  let { format = "full", customFormatter, shortFormatChars = 4 } = options;
+  if (format === "custom" && customFormatter)
+    try {
+      return customFormatter(value);
+    } catch {
+      return value;
+    }
+  if (format === "short") {
+    if (value.length > 32 && value.length < 50)
+      return formatAddress(value, { length: shortFormatChars });
+    if (value.length > shortFormatChars * 2)
+      return `${value.slice(0, shortFormatChars)}...${value.slice(-shortFormatChars)}`;
+  }
+  return value;
+}
+function copyUsingFallback(text) {
+  try {
+    let textArea = document.createElement("textarea");
+    textArea.value = text, textArea.style.position = "fixed", textArea.style.left = "-999999px", textArea.style.top = "-999999px", document.body.appendChild(textArea), textArea.focus(), textArea.select();
+    let successful = document.execCommand("copy");
+    return document.body.removeChild(textArea), successful;
+  } catch {
+    return false;
+  }
+}
+async function copyToClipboard(text, options = {}) {
+  let { onSuccess, onError, validate, validateType = "none", useFallback = true } = options;
+  if (!text || typeof text != "string" || text.trim() === "") {
+    let error2 = "empty_value" /* EMPTY_VALUE */, message2 = "No text provided to copy";
+    return onError?.(error2, message2), { success: false, error: error2, errorMessage: message2 };
+  }
+  if (typeof window > "u" || typeof navigator > "u") {
+    let error2 = "ssr" /* SSR */, message2 = "Clipboard not available in server-side rendering context";
+    return onError?.(error2, message2), { success: false, error: error2, errorMessage: message2 };
+  }
+  if (validate && !validate(text)) {
+    let error2 = "invalid_value" /* INVALID_VALUE */, message2 = "Value failed custom validation";
+    return onError?.(error2, message2), { success: false, error: error2, errorMessage: message2 };
+  }
+  if (validateType === "address" && !validateAddress(text)) {
+    let error2 = "invalid_value" /* INVALID_VALUE */, message2 = "Invalid Solana address format";
+    return onError?.(error2, message2), { success: false, error: error2, errorMessage: message2 };
+  }
+  if (validateType === "signature" && !validateSignature(text)) {
+    let error2 = "invalid_value" /* INVALID_VALUE */, message2 = "Invalid transaction signature format";
+    return onError?.(error2, message2), { success: false, error: error2, errorMessage: message2 };
+  }
+  let formattedValue = formatValue(text, options), availability = isClipboardAvailable();
+  if (!availability.available) {
+    let error2 = "not_supported" /* NOT_SUPPORTED */, message2 = "Clipboard API not supported in this browser";
+    return onError?.(error2, message2), { success: false, error: error2, errorMessage: message2 };
+  }
+  if (availability.modern)
+    try {
+      return await navigator.clipboard.writeText(formattedValue), onSuccess?.(), { success: true, copiedValue: formattedValue };
+    } catch (err) {
+      if (err instanceof Error && (err.name === "NotAllowedError" || err.message.toLowerCase().includes("permission"))) {
+        let error3 = "permission_denied" /* PERMISSION_DENIED */, message3 = "Clipboard permission denied by user or browser";
+        return onError?.(error3, message3), { success: false, error: error3, errorMessage: message3 };
+      }
+      if (useFallback && availability.fallback && copyUsingFallback(formattedValue))
+        return onSuccess?.(), { success: true, usedFallback: true, copiedValue: formattedValue };
+      let error2 = "unknown" /* UNKNOWN */, message2 = err instanceof Error ? err.message : "Failed to copy to clipboard";
+      return onError?.(error2, message2), { success: false, error: error2, errorMessage: message2 };
+    }
+  if (useFallback && availability.fallback) {
+    if (copyUsingFallback(formattedValue))
+      return onSuccess?.(), { success: true, usedFallback: true, copiedValue: formattedValue };
+    let error2 = "unknown" /* UNKNOWN */, message2 = "Failed to copy using fallback method";
+    return onError?.(error2, message2), { success: false, error: error2, errorMessage: message2 };
+  }
+  let error = "not_supported" /* NOT_SUPPORTED */, message = "No clipboard method available";
+  return onError?.(error, message), { success: false, error, errorMessage: message };
+}
+async function copyAddressToClipboard(address, options) {
+  return copyToClipboard(address, {
+    ...options,
+    validateType: "address"
+  });
+}
+async function copySignatureToClipboard(signature, options) {
+  return copyToClipboard(signature, {
+    ...options,
+    validateType: "signature"
+  });
+}
+
+// src/lib/transaction/transaction-validator.ts
+var logger8 = createLogger("TransactionValidator"), MAX_TRANSACTION_SIZE = 1232, MIN_TRANSACTION_SIZE = 64, TransactionValidator = class {
+  /**
+   * Validate a transaction before signing
+   *
+   * @param transaction - The transaction to validate
+   * @param options - Validation options
+   * @returns Validation result with errors and warnings
+   */
+  static validate(transaction, options = {}) {
+    let {
+      maxSize = MAX_TRANSACTION_SIZE,
+      minSize = MIN_TRANSACTION_SIZE,
+      checkDuplicateSignatures = true,
+      strict = false
+    } = options, errors = [], warnings = [], size;
+    if (!transaction)
+      return errors.push("Transaction is null or undefined"), { valid: false, errors, warnings };
+    try {
+      let serialized;
+      if (typeof transaction.serialize == "function")
+        try {
+          serialized = transaction.serialize();
+        } catch (serializeError) {
+          logger8.debug("Transaction not yet serializable (may need signing)", {
+            error: serializeError instanceof Error ? serializeError.message : String(serializeError)
+          });
+        }
+      else if (transaction instanceof Uint8Array)
+        serialized = transaction;
+      else
+        return errors.push(
+          "Transaction type not recognized - must be a Transaction object with serialize() or Uint8Array"
+        ), { valid: false, errors, warnings };
+      serialized && (size = serialized.length, size > maxSize && (errors.push(`Transaction too large: ${size} bytes (max ${maxSize} bytes)`), logger8.warn("Transaction exceeds maximum size", { size, maxSize })), size < minSize && warnings.push(`Transaction is very small: ${size} bytes (min recommended ${minSize} bytes)`), size === 0 && errors.push("Transaction is empty (0 bytes)"), this.hasSuspiciousPattern(serialized) && warnings.push("Transaction contains unusual patterns - please review carefully"));
+    } catch (error) {
+      let errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Transaction validation failed: ${errorMessage}`), logger8.error("Validation error", { error: errorMessage });
+    }
+    if (checkDuplicateSignatures && typeof transaction == "object" && "signatures" in transaction) {
+      let signatures = transaction.signatures;
+      Array.isArray(signatures) && new Set(
+        signatures.map((sig) => {
+          let pubKey = sig?.publicKey;
+          return pubKey ? String(pubKey) : null;
+        }).filter(Boolean)
+      ).size < signatures.length && warnings.push("Transaction contains duplicate signers");
+    }
+    strict && warnings.length > 0 && (errors.push(...warnings.map((w) => `Strict mode: ${w}`)), warnings.length = 0);
+    let valid = errors.length === 0;
+    return valid ? warnings.length > 0 ? logger8.debug("Transaction validation passed with warnings", { warnings, size }) : logger8.debug("Transaction validation passed", { size }) : logger8.warn("Transaction validation failed", { errors, size }), {
+      valid,
+      errors,
+      warnings,
+      size
+    };
+  }
+  /**
+   * Check for suspicious patterns in serialized transaction
+   * This is a heuristic check to detect potentially malicious transactions
+   *
+   * @param serialized - Serialized transaction bytes
+   * @returns True if suspicious patterns detected
+   */
+  static hasSuspiciousPattern(serialized) {
+    if (serialized.every((byte) => byte === 0) || serialized.every((byte) => byte === 255)) return true;
+    let byteCounts = /* @__PURE__ */ new Map();
+    for (let byte of serialized)
+      byteCounts.set(byte, (byteCounts.get(byte) || 0) + 1);
+    return Math.max(...Array.from(byteCounts.values())) / serialized.length > 0.5;
+  }
+  /**
+   * Quick validation check - returns true if valid, throws on error
+   * Useful for inline validation
+   *
+   * @param transaction - Transaction to validate
+   * @param options - Validation options
+   * @throws Error if validation fails
+   *
+   * @example
+   * ```ts
+   * TransactionValidator.assertValid(transaction);
+   * // Continues if valid, throws if invalid
+   * await signer.signTransaction(transaction);
+   * ```
+   */
+  static assertValid(transaction, options) {
+    let result = this.validate(transaction, options);
+    if (!result.valid)
+      throw new Error(`Transaction validation failed: ${result.errors.join(", ")}`);
+    result.warnings.length > 0 && logger8.warn("Transaction validation warnings", { warnings: result.warnings });
+  }
+  /**
+   * Batch validate multiple transactions
+   * More efficient than validating one-by-one
+   *
+   * @param transactions - Array of transactions to validate
+   * @param options - Validation options
+   * @returns Array of validation results
+   */
+  static validateBatch(transactions, options) {
+    return transactions.map((tx, index) => (logger8.debug(`Validating transaction ${index + 1}/${transactions.length}`), this.validate(tx, options)));
+  }
+};
+
+// src/lib/transaction/transaction-signer.ts
+var logger9 = createLogger("TransactionSigner");
+function createTransactionSigner(config) {
+  let { wallet, account, cluster, eventEmitter } = config;
+  if (!wallet || !account)
+    return null;
+  let features = wallet.features, address = account.address, capabilities = {
+    canSign: !!features["solana:signTransaction"],
+    canSend: !!features["solana:signAndSendTransaction"],
+    canSignMessage: !!features["solana:signMessage"],
+    supportsBatchSigning: !!features["solana:signAllTransactions"]
+  }, signer = {
+    address,
+    async signTransaction(transaction) {
+      if (!capabilities.canSign)
+        throw Errors.featureNotSupported("transaction signing");
+      let validation = TransactionValidator.validate(transaction);
+      if (!validation.valid)
+        throw logger9.error("Transaction validation failed", { errors: validation.errors }), Errors.invalidTransaction(validation.errors.join(", "));
+      validation.warnings.length > 0 && logger9.warn("Transaction validation warnings", { warnings: validation.warnings });
+      try {
+        let signFeature = features["solana:signTransaction"], { serialized, wasWeb3js } = prepareTransactionForWallet(transaction);
+        logger9.debug("Signing transaction", {
+          wasWeb3js,
+          serializedLength: serialized.length,
+          serializedType: serialized.constructor.name,
+          accountAddress: account?.address,
+          hasAccount: !!account
+        });
+        let result, usedFormat = "";
+        try {
+          logger9.debug("Trying array format: transactions: [Uint8Array]"), result = await signFeature.signTransaction({
+            account,
+            transactions: [serialized],
+            ...cluster ? { chain: cluster.id } : {}
+          }), usedFormat = "array";
+        } catch (err1) {
+          let error1 = err1 instanceof Error ? err1 : new Error(String(err1));
+          logger9.debug("Array format failed, trying singular format", { error: error1.message });
+          try {
+            logger9.debug("Trying singular format: transaction: Uint8Array"), result = await signFeature.signTransaction({
+              account,
+              transaction: serialized,
+              ...cluster ? { chain: cluster.id } : {}
+            }), usedFormat = "singular";
+          } catch (err2) {
+            let error2 = err2 instanceof Error ? err2 : new Error(String(err2));
+            throw logger9.error("Both array and singular formats failed", { error: error2.message }), error2;
+          }
+        }
+        logger9.debug("Wallet signed successfully", { format: usedFormat });
+        let signedTx;
+        if (Array.isArray(result.signedTransactions) && result.signedTransactions[0])
+          signedTx = result.signedTransactions[0];
+        else if (result.signedTransaction)
+          signedTx = result.signedTransaction;
+        else if (Array.isArray(result) && result[0])
+          signedTx = result[0];
+        else if (result instanceof Uint8Array)
+          signedTx = result;
+        else
+          throw new Error(`Unexpected wallet response format: ${JSON.stringify(Object.keys(result))}`);
+        if (logger9.debug("Extracted signed transaction", {
+          hasSignedTx: !!signedTx,
+          signedTxType: signedTx?.constructor?.name,
+          signedTxLength: signedTx?.length,
+          isUint8Array: signedTx instanceof Uint8Array,
+          hasSerialize: typeof signedTx?.serialize == "function"
+        }), signedTx && typeof signedTx.serialize == "function")
+          return logger9.debug("Wallet returned web3.js object directly, no conversion needed"), signedTx;
+        if (signedTx && signedTx.signedTransaction) {
+          logger9.debug("Found signedTransaction property");
+          let bytes = signedTx.signedTransaction;
+          if (bytes instanceof Uint8Array)
+            return await convertSignedTransaction(bytes, wasWeb3js);
+        }
+        if (signedTx instanceof Uint8Array)
+          return await convertSignedTransaction(signedTx, wasWeb3js);
+        throw logger9.error("Unexpected wallet response format", {
+          type: typeof signedTx,
+          constructor: signedTx?.constructor?.name
+        }), new ValidationError(
+          "INVALID_FORMAT",
+          "Wallet returned unexpected format - not a Transaction or Uint8Array"
+        );
+      } catch (error) {
+        throw Errors.signingFailed(error);
+      }
+    },
+    async signAllTransactions(transactions) {
+      if (transactions.length === 0)
+        return [];
+      if (capabilities.supportsBatchSigning)
+        try {
+          let signFeature = features["solana:signAllTransactions"], prepared = transactions.map((tx) => 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) => convertSignedTransaction(signedBytes, wasWeb3js)
+            )
+          );
+        } catch (error) {
+          throw new TransactionError(
+            "SIGNING_FAILED",
+            "Failed to sign transactions in batch",
+            { count: transactions.length },
+            error
+          );
+        }
+      if (!capabilities.canSign)
+        throw 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(
+            "SIGNING_FAILED",
+            `Failed to sign transaction ${i + 1} of ${transactions.length}`,
+            { index: i, total: transactions.length },
+            error
+          );
+        }
+      return signed;
+    },
+    async signAndSendTransaction(transaction, options) {
+      if (!capabilities.canSend)
+        throw Errors.featureNotSupported("sending transactions");
+      try {
+        let sendFeature = features["solana:signAndSendTransaction"], { serialized } = prepareTransactionForWallet(transaction);
+        eventEmitter && eventEmitter.emit({
+          type: "transaction:preparing",
+          transaction: serialized,
+          size: serialized.length,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        let inputBase = {
+          account,
+          ...cluster ? { chain: cluster.id } : {},
+          ...options ? { options } : {}
+        };
+        eventEmitter && eventEmitter.emit({
+          type: "transaction:signing",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        let result;
+        try {
+          result = await sendFeature.signAndSendTransaction({
+            ...inputBase,
+            transactions: [serialized]
+          });
+        } catch {
+          result = await sendFeature.signAndSendTransaction({
+            ...inputBase,
+            transaction: serialized
+          });
+        }
+        let signature = typeof result == "object" && result.signature ? result.signature : String(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);
+      }
+    },
+    async signAndSendTransactions(transactions, options) {
+      if (transactions.length === 0)
+        return [];
+      if (!capabilities.canSend)
+        throw 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(
+            "SEND_FAILED",
+            `Failed to send transaction ${i + 1} of ${transactions.length}`,
+            { index: i, total: transactions.length },
+            error
+          );
+        }
+      return signatures;
+    },
+    ...capabilities.canSignMessage && {
+      async signMessage(message) {
+        try {
+          return (await features["solana:signMessage"].signMessage({
+            account,
+            message,
+            ...cluster ? { chain: cluster.id } : {}
+          })).signature;
+        } catch (error) {
+          throw new TransactionError("SIGNING_FAILED", "Failed to sign message", void 0, error);
+        }
+      }
+    },
+    getCapabilities() {
+      return { ...capabilities };
+    }
+  };
+  return signer;
+}
+var TransactionSignerError = class extends 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;
+}
+var logger10 = createLogger("GillTransactionSigner");
+function encodeShortVecLength(value) {
+  let bytes = [], remaining = value;
+  for (; remaining >= 128; )
+    bytes.push(remaining & 127 | 128), remaining >>= 7;
+  return bytes.push(remaining), new Uint8Array(bytes);
+}
+function decodeShortVecLength(data) {
+  let length = 0, size = 0;
+  for (; ; ) {
+    if (size >= data.length)
+      throw new Error("Invalid shortvec encoding: unexpected end of data");
+    let byte = data[size];
+    if (length |= (byte & 127) << size * 7, size += 1, (byte & 128) === 0)
+      break;
+    if (size > 10)
+      throw new Error("Invalid shortvec encoding: length prefix too long");
+  }
+  return { length, bytesConsumed: size };
+}
+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;
+}
+function extractSignature(signedTx) {
+  if (signedTx instanceof Uint8Array) {
+    let { length: numSignatures, bytesConsumed } = decodeShortVecLength(signedTx);
+    if (numSignatures === 0)
+      throw new Error("No signatures found in serialized transaction");
+    let signatureStart = bytesConsumed;
+    return signedTx.slice(signatureStart, signatureStart + 64);
+  }
+  if (isWeb3jsTransaction(signedTx)) {
+    let signatures = signedTx.signatures;
+    if (!signatures || signatures.length === 0)
+      throw new Error("No signatures found in web3.js transaction");
+    let firstSig = signatures[0];
+    if (firstSig instanceof Uint8Array)
+      return firstSig;
+    if (firstSig && typeof firstSig == "object" && "signature" in firstSig && firstSig.signature)
+      return firstSig.signature;
+    throw new Error("Could not extract signature from web3.js transaction");
+  }
+  throw new Error("Cannot extract signature from transaction format");
+}
+function createGillTransactionSigner(connectorSigner) {
+  let signerAddress = address(connectorSigner.address);
+  return {
+    address: signerAddress,
+    async modifyAndSignTransactions(transactions) {
+      let transactionData = transactions.map((tx) => {
+        let messageBytes = new Uint8Array(tx.messageBytes), numSigners = Object.keys(tx.signatures).length, wireFormat = createTransactionBytesForSigning(messageBytes, numSigners);
+        return logger10.debug("Preparing wire format for wallet", {
+          signerAddress,
+          messageBytesLength: messageBytes.length,
+          wireFormatLength: wireFormat.length,
+          structure: {
+            numSigsByte: wireFormat[0],
+            firstSigSlotPreview: Array.from(wireFormat.slice(1, 17)),
+            messageBytesStart: wireFormat.length - messageBytes.length
+          }
+        }), {
+          originalTransaction: tx,
+          messageBytes,
+          wireFormat
+        };
+      }), transactionsForWallet = transactionData.map((data) => data.wireFormat);
+      return (await connectorSigner.signAllTransactions(transactionsForWallet)).map((signedTx, index) => {
+        let { originalTransaction, wireFormat } = transactionData[index];
+        try {
+          let signedTxBytes;
+          if (signedTx instanceof Uint8Array)
+            signedTxBytes = signedTx;
+          else if (isWeb3jsTransaction(signedTx)) {
+            let txObj = signedTx;
+            if (typeof txObj.serialize == "function")
+              signedTxBytes = txObj.serialize();
+            else
+              throw new Error("Web3.js transaction without serialize method");
+          } else
+            throw new Error("Unknown signed transaction format");
+          if (logger10.debug("Wallet returned signed transaction", {
+            returnedLength: signedTxBytes.length,
+            sentLength: wireFormat.length,
+            lengthsMatch: signedTxBytes.length === wireFormat.length,
+            signedFirstBytes: Array.from(signedTxBytes.slice(0, 20)),
+            sentFirstBytes: Array.from(wireFormat.slice(0, 20))
+          }), signedTxBytes.length !== wireFormat.length) {
+            logger10.warn("Wallet modified transaction! Using wallet version", {
+              originalLength: wireFormat.length,
+              modifiedLength: signedTxBytes.length,
+              difference: signedTxBytes.length - wireFormat.length
+            });
+            let walletTransaction = getTransactionDecoder().decode(signedTxBytes), originalWithLifetime = originalTransaction, result = {
+              ...walletTransaction,
+              ...originalWithLifetime.lifetimeConstraint ? {
+                lifetimeConstraint: originalWithLifetime.lifetimeConstraint
+              } : {}
+            };
+            return logger10.debug("Using modified transaction from wallet", {
+              modifiedMessageBytesLength: walletTransaction.messageBytes.length,
+              signatures: Object.keys(walletTransaction.signatures)
+            }), result;
+          }
+          let signatureBytes = extractSignature(signedTxBytes), signatureBase58 = getSignatureFromBytes(signatureBytes);
+          return logger10.debug("Extracted signature from wallet (unmodified)", {
+            signerAddress,
+            signatureLength: signatureBytes.length,
+            signatureBase58
+            // Human-readable signature for debugging/logging
+          }), {
+            ...originalTransaction,
+            signatures: Object.freeze({
+              ...originalTransaction.signatures,
+              [signerAddress]: signatureBytes
+            })
+          };
+        } catch (error) {
+          return logger10.error("Failed to decode signed transaction", { error }), originalTransaction;
+        }
+      });
+    }
+  };
+}
+
+export { ClipboardErrorType, ConfigurationError, ConnectionError, ConnectorClient, ConnectorError, ConnectorErrorBoundary, DEFAULT_MAX_RETRIES, Errors, NetworkError, PUBLIC_RPC_ENDPOINTS, TransactionError, TransactionSignerError, ValidationError, WalletErrorType, copyAddressToClipboard, copySignatureToClipboard, copyToClipboard, createGillTransactionSigner, createTransactionSigner, formatAddress, formatNumber, formatSOL, formatTokenAmount, getAddressUrl, getBlockUrl, getClusterExplorerUrl, getClusterName, getClusterRpcUrl, getClusterType, getDefaultRpcUrl, getNetworkDisplayName, getPolyfillStatus, getTokenUrl, getTransactionUrl, getUserFriendlyMessage, getWalletsRegistry, installPolyfills, isClipboardAvailable, isConfigurationError, isConnectionError, isConnectorError, isCryptoAvailable, isDevnet, isDevnetCluster, isLocalCluster, isLocalnet, isMainnet, isMainnetCluster, isNetworkError, isPolyfillInstalled, isTestnet, isTestnetCluster, isTransactionError, isTransactionSignerError, isValidationError, normalizeNetwork, toClusterId, toConnectorError, truncate, withErrorBoundary };
+//# sourceMappingURL=chunk-52WUWW5R.mjs.map
+//# sourceMappingURL=chunk-52WUWW5R.mjs.map