@solana/connector 0.1.3 → 0.1.5

package/dist/chunk-3STZXVXD.mjs

@@ -0,0 +1,2185 @@
+import { installPolyfills, ConnectorErrorBoundary, isMainnetCluster, isDevnetCluster, isTestnetCluster, isLocalCluster, getClusterExplorerUrl, getClusterType, formatAddress, copyAddressToClipboard, createTransactionSigner, createKitTransactionSigner, NetworkError, getTransactionUrl, ConnectorClient } from './chunk-VMSZJPR5.mjs';
+import { createLogger, __publicField, createSolanaClient, prepareTransaction } from './chunk-QL3IT3TS.mjs';
+import React, { createContext, useContext, useSyncExternalStore, useMemo, useState, useCallback, useRef, useEffect } from 'react';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { address } from '@solana/addresses';
+import { signature } from '@solana/keys';
+
+var logger = createLogger("ConnectorProvider");
+installPolyfills();
+var ConnectorContext = createContext(null);
+ConnectorContext.displayName = "ConnectorContext";
+function ConnectorProviderInternal({
+  children,
+  config,
+  mobile
+}) {
+  let clientRef = useRef(null), client = React.useCallback(() => {
+    if (!clientRef.current)
+      try {
+        clientRef.current = new ConnectorClient(config), typeof window < "u" && (window.__connectorClient = clientRef.current), config?.debug && logger.info("Client initialized successfully");
+      } catch (error) {
+        let err = error;
+        logger.error("Failed to initialize client", { error: err });
+        let extendedConfig = config;
+        return extendedConfig?.errorBoundary?.onError && extendedConfig.errorBoundary.onError(err, {
+          componentStack: "client-initialization",
+          digest: `constructor-${(/* @__PURE__ */ new Date()).toISOString()}`
+        }), null;
+      }
+    return clientRef.current;
+  }, [config])();
+  return React.useEffect(() => {
+    let currentClient = clientRef.current;
+    if (currentClient) {
+      let privateClient = currentClient;
+      privateClient.initialize && typeof privateClient.initialize == "function" && privateClient.initialize();
+    }
+    return () => {
+      typeof window < "u" && (window.__connectorClient = void 0), currentClient && typeof currentClient.destroy == "function" && currentClient.destroy();
+    };
+  }, []), React.useEffect(() => {
+    if (!mobile) return;
+    let cancelled = false;
+    return (async () => {
+      try {
+        let mod = await import('@solana-mobile/wallet-standard-mobile');
+        if (cancelled) return;
+        let {
+          registerMwa,
+          createDefaultAuthorizationCache,
+          createDefaultChainSelector,
+          createDefaultWalletNotFoundHandler
+        } = mod, defaultChains = [
+          "solana:mainnet",
+          "solana:devnet",
+          "solana:testnet"
+        ];
+        registerMwa({
+          appIdentity: mobile.appIdentity,
+          authorizationCache: mobile.authorizationCache ?? createDefaultAuthorizationCache(),
+          chains: mobile.chains ?? defaultChains,
+          chainSelector: mobile.chainSelector ?? createDefaultChainSelector(),
+          remoteHostAuthority: mobile.remoteHostAuthority,
+          onWalletNotFound: mobile.onWalletNotFound ?? createDefaultWalletNotFoundHandler()
+        });
+      } catch {
+      }
+    })(), () => {
+      cancelled = true;
+    };
+  }, [mobile]), /* @__PURE__ */ jsx(ConnectorContext.Provider, { value: client, children });
+}
+function ConnectorProvider({
+  children,
+  config,
+  mobile
+}) {
+  let errorBoundaryConfig = config?.errorBoundary;
+  return errorBoundaryConfig?.enabled ? /* @__PURE__ */ jsx(
+    ConnectorErrorBoundary,
+    {
+      maxRetries: errorBoundaryConfig.maxRetries ?? 3,
+      onError: errorBoundaryConfig.onError,
+      fallback: errorBoundaryConfig.fallback,
+      children: /* @__PURE__ */ jsx(ConnectorProviderInternal, { config, mobile, children })
+    }
+  ) : /* @__PURE__ */ jsx(ConnectorProviderInternal, { config, mobile, children });
+}
+function useConnector() {
+  let client = useContext(ConnectorContext);
+  if (!client)
+    throw new Error(
+      "useConnector must be used within ConnectorProvider. Wrap your app with <ConnectorProvider> or <UnifiedProvider> to use connector hooks."
+    );
+  let state = useSyncExternalStore(
+    React.useCallback((cb) => client.subscribe(cb), [client]),
+    React.useCallback(() => client.getSnapshot(), [client]),
+    React.useCallback(() => client.getSnapshot(), [client])
+  ), methods = useMemo(
+    () => ({
+      select: client.select.bind(client),
+      disconnect: client.disconnect.bind(client),
+      selectAccount: client.selectAccount.bind(client)
+    }),
+    [client]
+  );
+  return useMemo(
+    () => ({
+      ...state,
+      ...methods
+    }),
+    [state, methods]
+  );
+}
+function useConnectorClient() {
+  return useContext(ConnectorContext);
+}
+function UnifiedProvider({ children, config, connectorConfig, mobile, providers = [] }) {
+  let actualConnectorConfig = config?.connectorConfig ?? connectorConfig, actualMobile = config?.mobile ?? mobile, content = /* @__PURE__ */ jsx(ConnectorProvider, { config: actualConnectorConfig, mobile: actualMobile, children });
+  for (let i = providers.length - 1; i >= 0; i--) {
+    let { component: Provider, props = {} } = providers[i];
+    content = /* @__PURE__ */ jsx(Provider, { ...props, children: content });
+  }
+  return content;
+}
+function useCluster() {
+  let { cluster, clusters } = useConnector(), client = useConnectorClient();
+  if (!client)
+    throw new Error("useCluster must be used within ConnectorProvider");
+  let setCluster = useMemo(
+    () => async (id) => {
+      await client.setCluster(id);
+    },
+    [client]
+  );
+  return useMemo(() => {
+    let isMainnet = cluster ? isMainnetCluster(cluster) : false, isDevnet = cluster ? isDevnetCluster(cluster) : false, isTestnet = cluster ? isTestnetCluster(cluster) : false, isLocal = cluster ? isLocalCluster(cluster) : false, explorerUrl = cluster ? getClusterExplorerUrl(cluster) : "", type = cluster ? getClusterType(cluster) : null;
+    return {
+      cluster,
+      clusters,
+      setCluster,
+      isMainnet,
+      isDevnet,
+      isTestnet,
+      isLocal,
+      explorerUrl,
+      type
+    };
+  }, [cluster, clusters, setCluster]);
+}
+function useAccount() {
+  let { selectedAccount, accounts, connected, selectAccount } = useConnector(), [copied, setCopied] = useState(false), copyTimeoutRef = React.useRef(void 0), account = useMemo(
+    () => accounts.find((a) => a.address === selectedAccount) ?? null,
+    [accounts, selectedAccount]
+  ), formatted = useMemo(() => selectedAccount ? formatAddress(selectedAccount) : "", [selectedAccount]), copy = useCallback(async () => selectedAccount ? (copyTimeoutRef.current && clearTimeout(copyTimeoutRef.current), await copyAddressToClipboard(selectedAccount, {
+    onSuccess: () => {
+      setCopied(true), copyTimeoutRef.current = setTimeout(() => setCopied(false), 2e3);
+    }
+  })) : {
+    success: false,
+    error: "empty_value" /* EMPTY_VALUE */,
+    errorMessage: "No account selected"
+  }, [selectedAccount]);
+  return React.useEffect(() => () => {
+    copyTimeoutRef.current && clearTimeout(copyTimeoutRef.current);
+  }, []), useMemo(
+    () => ({
+      address: selectedAccount,
+      account,
+      connected,
+      formatted,
+      copy,
+      copied,
+      accounts,
+      selectAccount
+    }),
+    [selectedAccount, account, connected, formatted, copy, copied, accounts, selectAccount]
+  );
+}
+function useWalletInfo() {
+  let { selectedWallet, wallets, connected, connecting } = useConnector(), mappedWallets = useMemo(
+    () => wallets.map(
+      (walletInfo) => ({
+        name: walletInfo.wallet.name,
+        icon: walletInfo.wallet.icon,
+        installed: walletInfo.installed,
+        connectable: walletInfo.connectable
+      })
+    ),
+    [wallets]
+  ), selectedWalletInfo = useMemo(() => {
+    if (!selectedWallet)
+      return {
+        name: null,
+        icon: null,
+        installed: false,
+        connectable: false
+      };
+    let walletInfo = wallets.find((w) => w.wallet.name === selectedWallet.name);
+    return {
+      name: selectedWallet.name,
+      icon: selectedWallet.icon ?? null,
+      installed: walletInfo?.installed ?? false,
+      connectable: walletInfo?.connectable ?? false
+    };
+  }, [selectedWallet, wallets]);
+  return useMemo(
+    () => ({
+      ...selectedWalletInfo,
+      connected,
+      connecting,
+      wallets: mappedWallets
+    }),
+    [selectedWalletInfo, connected, connecting, mappedWallets]
+  );
+}
+function useTransactionSigner() {
+  let { selectedWallet, selectedAccount, accounts, cluster, connected } = useConnector(), client = useConnectorClient(), account = useMemo(
+    () => accounts.find((a) => a.address === selectedAccount)?.raw ?? null,
+    [accounts, selectedAccount]
+  ), signer = useMemo(() => !connected || !selectedWallet || !account ? null : createTransactionSigner({
+    wallet: selectedWallet,
+    account,
+    cluster: cluster ?? void 0,
+    eventEmitter: client ? {
+      emit: (event) => {
+        client.emitEvent(event);
+      }
+    } : void 0
+  }), [connected, selectedWallet, account, cluster, client]), capabilities = useMemo(
+    () => signer?.getCapabilities() ?? {
+      canSign: false,
+      canSend: false,
+      canSignMessage: false,
+      supportsBatchSigning: false
+    },
+    [signer]
+  );
+  return {
+    signer,
+    ready: !!signer,
+    address: selectedAccount,
+    capabilities
+  };
+}
+function useKitTransactionSigner() {
+  let { signer: connectorSigner, ready } = useTransactionSigner();
+  return {
+    signer: useMemo(() => connectorSigner ? createKitTransactionSigner(connectorSigner) : null, [connectorSigner]),
+    ready
+  };
+}
+var useGillTransactionSigner = useKitTransactionSigner;
+var logger2 = createLogger("useSolanaClient");
+function useSolanaClient() {
+  let { type } = useCluster(), connectorClient = useConnectorClient(), client = useMemo(() => {
+    if (!type || !connectorClient) return null;
+    try {
+      let rpcUrl = connectorClient.getRpcUrl();
+      return rpcUrl ? createSolanaClient({
+        urlOrMoniker: rpcUrl
+      }) : type !== "custom" ? createSolanaClient({
+        urlOrMoniker: type
+      }) : null;
+    } catch (error) {
+      return logger2.error("Failed to create Solana client", { error }), null;
+    }
+  }, [type, connectorClient]);
+  return useMemo(
+    () => ({
+      client,
+      ready: !!client,
+      clusterType: type
+    }),
+    [client, type]
+  );
+}
+var useGillSolanaClient = useSolanaClient;
+function useTransactionPreparer() {
+  let { client, ready } = useSolanaClient(), prepare = useCallback(
+    async (transaction, options = {}) => {
+      if (!client)
+        throw new NetworkError("RPC_ERROR", "Solana client not available. Cannot prepare transaction.");
+      return prepareTransaction({
+        transaction,
+        rpc: client.rpc,
+        computeUnitLimitMultiplier: options.computeUnitLimitMultiplier,
+        computeUnitLimitReset: options.computeUnitLimitReset,
+        blockhashReset: options.blockhashReset
+      });
+    },
+    [client]
+  );
+  return useMemo(
+    () => ({
+      prepare,
+      ready
+    }),
+    [prepare, ready]
+  );
+}
+var LAMPORTS_PER_SOL2 = 1000000000n;
+function formatSol(lamports, decimals = 4) {
+  return (Number(lamports) / Number(LAMPORTS_PER_SOL2)).toLocaleString(void 0, {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: decimals
+  }) + " SOL";
+}
+function useBalance() {
+  let { address: address$1, connected } = useAccount(); useCluster(); let client = useSolanaClient(), [lamports, setLamports] = useState(0n), [tokens, setTokens] = useState([]), [isLoading, setIsLoading] = useState(false), [error, setError] = useState(null), [lastUpdated, setLastUpdated] = useState(null), hasDataRef = useRef(false), rpcClient = client?.client ?? null, fetchBalance = useCallback(async () => {
+    if (!connected || !address$1 || !rpcClient) {
+      setLamports(0n), setTokens([]), hasDataRef.current = false;
+      return;
+    }
+    setIsLoading(true), setError(null);
+    try {
+      let rpc = rpcClient.rpc, walletAddress = address(address$1), balanceResult = await rpc.getBalance(walletAddress).send();
+      setLamports(balanceResult.value);
+      try {
+        let tokenProgramId = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), tokenAccountsResult = await rpc.getTokenAccountsByOwner(walletAddress, { programId: tokenProgramId }, { encoding: "jsonParsed" }).send(), tokenBalances = [];
+        for (let account of tokenAccountsResult.value) {
+          let parsed = account.account.data;
+          if (parsed?.parsed?.info) {
+            let info = parsed.parsed.info, amount = BigInt(info.tokenAmount?.amount || "0"), decimals = info.tokenAmount?.decimals || 0, formatted = (Number(amount) / Math.pow(10, decimals)).toLocaleString(void 0, {
+              minimumFractionDigits: 0,
+              maximumFractionDigits: Math.min(decimals, 6)
+            });
+            amount > 0n && tokenBalances.push({
+              mint: info.mint,
+              amount,
+              decimals,
+              formatted
+            });
+          }
+        }
+        setTokens(tokenBalances);
+      } catch (tokenError) {
+        console.warn("Failed to fetch token balances:", tokenError), setTokens([]);
+      }
+      hasDataRef.current = true, setLastUpdated(/* @__PURE__ */ new Date());
+    } catch (err) {
+      hasDataRef.current || (setError(err), console.error("Failed to fetch balance:", err));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [connected, address$1, rpcClient]);
+  useEffect(() => {
+    fetchBalance();
+  }, [fetchBalance]), useEffect(() => {
+    if (!connected) return;
+    let interval = setInterval(fetchBalance, 3e4);
+    return () => clearInterval(interval);
+  }, [connected, fetchBalance]);
+  let solBalance = useMemo(() => Number(lamports) / Number(LAMPORTS_PER_SOL2), [lamports]), formattedSol = useMemo(() => formatSol(lamports), [lamports]);
+  return useMemo(
+    () => ({
+      solBalance,
+      lamports,
+      formattedSol,
+      tokens,
+      isLoading,
+      error,
+      refetch: fetchBalance,
+      lastUpdated
+    }),
+    [solBalance, lamports, formattedSol, tokens, isLoading, error, fetchBalance, lastUpdated]
+  );
+}
+function formatDate(timestamp) {
+  if (!timestamp)
+    return { date: "Unknown", time: "" };
+  let date = new Date(timestamp * 1e3), diffDays = Math.floor(((/* @__PURE__ */ new Date()).getTime() - date.getTime()) / (1e3 * 60 * 60 * 24)), formattedDate;
+  diffDays === 0 ? formattedDate = "Today" : diffDays === 1 ? formattedDate = "Yesterday" : diffDays < 7 ? formattedDate = `${diffDays} days ago` : formattedDate = date.toLocaleDateString();
+  let formattedTime = date.toLocaleTimeString(void 0, {
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+  return { date: formattedDate, time: formattedTime };
+}
+function isAccountKey(value) {
+  return typeof value == "object" && value !== null && "pubkey" in value && typeof value.pubkey == "string";
+}
+function isTransactionMeta(value) {
+  if (typeof value != "object" || value === null || !("preBalances" in value) || !("postBalances" in value))
+    return false;
+  let meta = value;
+  if (!Array.isArray(meta.preBalances) || !Array.isArray(meta.postBalances))
+    return false;
+  let isValidBalance = (b) => typeof b == "number" || typeof b == "bigint";
+  return meta.preBalances.every(isValidBalance) && meta.postBalances.every(isValidBalance);
+}
+function isTokenBalance(value) {
+  return typeof value == "object" && value !== null && "accountIndex" in value && "mint" in value && "uiTokenAmount" in value && typeof value.accountIndex == "number" && typeof value.mint == "string" && typeof value.uiTokenAmount == "object" && value.uiTokenAmount !== null;
+}
+function isUiTokenAmount(value) {
+  return typeof value == "object" && value !== null && "amount" in value && "decimals" in value && typeof value.amount == "string" && typeof value.decimals == "number";
+}
+function isTransactionWithMeta(value) {
+  return typeof value == "object" && value !== null && "meta" in value && "transaction" in value && value.meta !== null && typeof value.transaction == "object" && value.transaction !== null && "message" in value.transaction;
+}
+function isTransactionMessage(value) {
+  return typeof value == "object" && value !== null && "accountKeys" in value && Array.isArray(value.accountKeys);
+}
+function getAccountKeys(message) {
+  return Array.isArray(message.accountKeys) ? message.accountKeys.map((key) => typeof key == "string" ? key : isAccountKey(key) ? key.pubkey : "").filter(Boolean) : [];
+}
+function detectProgramIds(message, accountKeys) {
+  let programIds = /* @__PURE__ */ new Set();
+  if (!Array.isArray(message.instructions))
+    return programIds;
+  for (let instruction of message.instructions)
+    if (typeof instruction == "object" && instruction !== null) {
+      if (typeof instruction.programIdIndex == "number" && accountKeys[instruction.programIdIndex])
+        programIds.add(accountKeys[instruction.programIdIndex]);
+      else if (typeof instruction.programId == "string")
+        programIds.add(instruction.programId);
+      else if (instruction.programId && typeof instruction.programId == "object") {
+        let programIdStr = String(instruction.programId);
+        programIdStr && programIdStr !== "[object Object]" && programIds.add(programIdStr);
+      }
+    }
+  return programIds;
+}
+function parseSolChange(meta, walletIndex) {
+  if (!isTransactionMeta(meta) || !Array.isArray(meta.preBalances) || !Array.isArray(meta.postBalances))
+    return { balanceChange: 0, solChange: 0 };
+  let preBalanceRaw = meta.preBalances[walletIndex], postBalanceRaw = meta.postBalances[walletIndex], preBalance = typeof preBalanceRaw == "number" ? preBalanceRaw : typeof preBalanceRaw == "bigint" ? Number(preBalanceRaw) : 0, balanceChange = (typeof postBalanceRaw == "number" ? postBalanceRaw : typeof postBalanceRaw == "bigint" ? Number(postBalanceRaw) : 0) - preBalance, solChange = balanceChange / 1e9;
+  return { balanceChange, solChange };
+}
+function parseTokenTransfers(meta, accountKeys, walletAddress) {
+  if (!isTransactionMeta(meta))
+    return null;
+  let preTokenBalances = Array.isArray(meta.preTokenBalances) ? meta.preTokenBalances : [], postTokenBalances = Array.isArray(meta.postTokenBalances) ? meta.postTokenBalances : [], ourPreTokens = preTokenBalances.filter((balance) => {
+    if (!isTokenBalance(balance)) return false;
+    let accountKey = accountKeys[balance.accountIndex];
+    return accountKey && accountKey.trim() === walletAddress.trim() || balance.owner && balance.owner.trim() === walletAddress.trim();
+  }), ourPostTokens = postTokenBalances.filter((balance) => {
+    if (!isTokenBalance(balance)) return false;
+    let accountKey = accountKeys[balance.accountIndex];
+    return accountKey && accountKey.trim() === walletAddress.trim() || balance.owner && balance.owner.trim() === walletAddress.trim();
+  }), allMints = /* @__PURE__ */ new Set();
+  for (let token of ourPreTokens)
+    isTokenBalance(token) && allMints.add(token.mint);
+  for (let token of ourPostTokens)
+    isTokenBalance(token) && allMints.add(token.mint);
+  for (let mint of allMints) {
+    let preBal = ourPreTokens.find((b) => isTokenBalance(b) && b.mint === mint), postBal = ourPostTokens.find((b) => isTokenBalance(b) && b.mint === mint);
+    if (!isTokenBalance(preBal) && !isTokenBalance(postBal))
+      continue;
+    let preAmount = isTokenBalance(preBal) && isUiTokenAmount(preBal.uiTokenAmount) ? Number(preBal.uiTokenAmount.amount) : 0, change = (isTokenBalance(postBal) && isUiTokenAmount(postBal.uiTokenAmount) ? Number(postBal.uiTokenAmount.amount) : 0) - preAmount;
+    if (change !== 0) {
+      let decimals = isTokenBalance(postBal) && isUiTokenAmount(postBal.uiTokenAmount) ? postBal.uiTokenAmount.decimals : isTokenBalance(preBal) && isUiTokenAmount(preBal.uiTokenAmount) ? preBal.uiTokenAmount.decimals : 0;
+      if (typeof decimals != "number" || decimals < 0)
+        continue;
+      return {
+        tokenMint: mint,
+        tokenAmount: Math.abs(change) / Math.pow(10, decimals),
+        tokenDecimals: decimals,
+        direction: change > 0 ? "in" : "out",
+        type: change > 0 ? "received" : "sent"
+      };
+    }
+  }
+  if (ourPostTokens.length > ourPreTokens.length) {
+    let newToken = ourPostTokens.find(
+      (b) => isTokenBalance(b) && !ourPreTokens.some((p) => isTokenBalance(p) && p.mint === b.mint)
+    );
+    if (isTokenBalance(newToken) && isUiTokenAmount(newToken.uiTokenAmount)) {
+      let decimals = newToken.uiTokenAmount.decimals;
+      if (typeof decimals == "number" && decimals >= 0) {
+        let amount = Number(newToken.uiTokenAmount.amount) / Math.pow(10, decimals);
+        return {
+          tokenMint: newToken.mint,
+          tokenAmount: amount,
+          tokenDecimals: decimals,
+          direction: "in",
+          type: "received"
+        };
+      }
+    }
+  }
+  return null;
+}
+function formatAmount(tokenAmount, tokenDecimals, direction, solChange) {
+  if (tokenAmount !== void 0 && tokenDecimals !== void 0 && direction !== void 0) {
+    let sign = direction === "in" ? "+" : "-", maxDecimals = Math.min(tokenDecimals, 6);
+    return `${sign}${tokenAmount.toLocaleString(void 0, { maximumFractionDigits: maxDecimals })}`;
+  }
+  if (solChange !== 0)
+    return `${solChange > 0 ? "+" : ""}${solChange.toFixed(4)} SOL`;
+}
+var tokenMetadataCache = /* @__PURE__ */ new Map();
+function transformImageUrl(url, imageProxy) {
+  if (url)
+    return imageProxy ? `${imageProxy}${encodeURIComponent(url)}` : url;
+}
+async function fetchTokenMetadata(mints) {
+  let results = /* @__PURE__ */ new Map();
+  if (mints.length === 0) return results;
+  let uncachedMints = [];
+  for (let mint of mints) {
+    let cached = tokenMetadataCache.get(mint);
+    cached ? results.set(mint, cached) : uncachedMints.push(mint);
+  }
+  if (uncachedMints.length === 0) return results;
+  try {
+    let response = await fetch("https://token-list-api.solana.cloud/v1/mints?chainId=101", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ addresses: uncachedMints }),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) return results;
+    let data = await response.json();
+    for (let item of data.content) {
+      let metadata = { symbol: item.symbol, icon: item.logoURI };
+      results.set(item.address, metadata), tokenMetadataCache.set(item.address, metadata);
+    }
+  } catch (error) {
+    console.warn("[useTransactions] Failed to fetch token metadata:", error);
+  }
+  return results;
+}
+function useTransactions(options = {}) {
+  let { limit = 10, autoRefresh = false, refreshInterval = 6e4, fetchDetails = true } = options, { address: address$1, connected } = useAccount(), { cluster } = useCluster(), client = useSolanaClient(), connectorClient = useConnectorClient(), [transactions, setTransactions] = useState([]), [isLoading, setIsLoading] = useState(false), [error, setError] = useState(null), [hasMore, setHasMore] = useState(true), [lastUpdated, setLastUpdated] = useState(null), beforeSignatureRef = useRef(void 0), prevDepsRef = useRef(
+    null
+  ), rpcClient = client?.client ?? null, imageProxy = connectorClient?.getConfig().imageProxy, parseTransaction = useCallback(
+    (tx, walletAddress, sig, blockTime, slot, err, explorerUrl) => {
+      let { date, time } = formatDate(blockTime), baseInfo = {
+        signature: sig,
+        blockTime,
+        slot,
+        status: err ? "failed" : "success",
+        error: err ? JSON.stringify(
+          err,
+          (_key, value) => typeof value == "bigint" ? value.toString() : value
+        ) : void 0,
+        type: "unknown",
+        formattedDate: date,
+        formattedTime: time,
+        explorerUrl
+      };
+      if (!isTransactionWithMeta(tx))
+        return baseInfo;
+      try {
+        let { meta, transaction } = tx;
+        if (!isTransactionMeta(meta))
+          return baseInfo;
+        let { message } = transaction;
+        if (!isTransactionMessage(message))
+          return baseInfo;
+        let accountKeys = getAccountKeys(message), walletIndex = accountKeys.findIndex((key) => key.trim() === walletAddress.trim());
+        if (walletIndex === -1)
+          return baseInfo;
+        let { balanceChange, solChange } = parseSolChange(meta, walletIndex), programIds = detectProgramIds(message, accountKeys), hasJupiter = programIds.has("JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"), hasOrca = programIds.has("whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"), hasRaydium = programIds.has("675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"), hasStake = programIds.has("Stake11111111111111111111111111111111111111"), hasMetaplex = programIds.has("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"), hasSystemProgram = programIds.has("11111111111111111111111111111111"), hasTokenProgram = programIds.has("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), type = "unknown", direction, counterparty, tokenMint, tokenAmount, tokenDecimals;
+        if (hasJupiter || hasOrca || hasRaydium)
+          type = "swap";
+        else if (hasStake)
+          type = "stake";
+        else if (hasMetaplex)
+          type = "nft";
+        else if (hasSystemProgram && Math.abs(balanceChange) > 0)
+          type = balanceChange > 0 ? "received" : "sent", direction = balanceChange > 0 ? "in" : "out", tokenMint = "So11111111111111111111111111111111111111112", accountKeys.length >= 2 && (counterparty = accountKeys.find(
+            (key, idx) => idx !== walletIndex && key !== "11111111111111111111111111111111"
+          ));
+        else if (hasTokenProgram) {
+          let tokenTransfer = parseTokenTransfers(meta, accountKeys, walletAddress);
+          tokenTransfer && (type = tokenTransfer.type, direction = tokenTransfer.direction, tokenMint = tokenTransfer.tokenMint, tokenAmount = tokenTransfer.tokenAmount, tokenDecimals = tokenTransfer.tokenDecimals);
+        } else programIds.size > 0 && (type = "program");
+        let formattedAmount = formatAmount(tokenAmount, tokenDecimals, direction, solChange);
+        return {
+          ...baseInfo,
+          type,
+          direction,
+          amount: tokenAmount ?? Math.abs(solChange),
+          formattedAmount,
+          tokenMint,
+          counterparty: counterparty ? `${counterparty.slice(0, 4)}...${counterparty.slice(-4)}` : void 0
+        };
+      } catch (parseError) {
+        return console.warn("Failed to parse transaction:", parseError), baseInfo;
+      }
+    },
+    []
+  ), fetchTransactions = useCallback(
+    async (loadMore = false) => {
+      if (!connected || !address$1 || !rpcClient || !cluster) {
+        setTransactions([]);
+        return;
+      }
+      setIsLoading(true), setError(null);
+      try {
+        let rpc = rpcClient.rpc, walletAddress = address(address$1), signaturesResult = await rpc.getSignaturesForAddress(walletAddress, {
+          limit,
+          ...loadMore && beforeSignatureRef.current ? { before: signature(beforeSignatureRef.current) } : {}
+        }).send(), newTransactions;
+        if (fetchDetails && signaturesResult.length > 0) {
+          let txPromises = signaturesResult.map(
+            (s) => rpc.getTransaction(signature(String(s.signature)), {
+              encoding: "jsonParsed",
+              maxSupportedTransactionVersion: 0
+            }).send().catch(() => null)
+          ), txDetails = await Promise.all(txPromises);
+          newTransactions = signaturesResult.map((sig, idx) => {
+            let blockTimeNum = sig.blockTime ? Number(sig.blockTime) : null, tx = txDetails[idx];
+            return parseTransaction(
+              tx,
+              address$1,
+              String(sig.signature),
+              blockTimeNum,
+              Number(sig.slot),
+              sig.err,
+              getTransactionUrl(String(sig.signature), cluster)
+            );
+          });
+        } else
+          newTransactions = signaturesResult.map((sig) => {
+            let blockTimeNum = sig.blockTime ? Number(sig.blockTime) : null, { date, time } = formatDate(blockTimeNum);
+            return {
+              signature: String(sig.signature),
+              blockTime: blockTimeNum,
+              slot: Number(sig.slot),
+              status: sig.err ? "failed" : "success",
+              error: sig.err ? JSON.stringify(sig.err) : void 0,
+              type: "unknown",
+              formattedDate: date,
+              formattedTime: time,
+              explorerUrl: getTransactionUrl(String(sig.signature), cluster)
+            };
+          });
+        setTransactions(loadMore ? (prev) => [...prev, ...newTransactions] : newTransactions);
+        let mintsToFetch = [...new Set(newTransactions.filter((tx) => tx.tokenMint).map((tx) => tx.tokenMint))];
+        if (mintsToFetch.length > 0) {
+          let tokenMetadata = await fetchTokenMetadata(mintsToFetch);
+          if (tokenMetadata.size > 0) {
+            let enrichedTransactions = newTransactions.map((tx) => {
+              if (tx.tokenMint && tokenMetadata.has(tx.tokenMint)) {
+                let meta = tokenMetadata.get(tx.tokenMint);
+                return {
+                  ...tx,
+                  tokenSymbol: meta.symbol,
+                  tokenIcon: transformImageUrl(meta.icon, imageProxy),
+                  // Update formatted amount with symbol
+                  formattedAmount: tx.formattedAmount ? `${tx.formattedAmount} ${meta.symbol}` : tx.formattedAmount
+                };
+              }
+              return tx;
+            });
+            setTransactions(loadMore ? (prev) => [...prev.slice(0, -newTransactions.length), ...enrichedTransactions] : enrichedTransactions);
+          }
+        }
+        if (typeof newTransactions < "u" && Array.isArray(newTransactions)) {
+          if (newTransactions.length > 0) {
+            let newBeforeSignature = newTransactions[newTransactions.length - 1].signature;
+            beforeSignatureRef.current = newBeforeSignature;
+          }
+          setHasMore(newTransactions.length === limit);
+        }
+        setLastUpdated(/* @__PURE__ */ new Date());
+      } catch (err) {
+        setError(err), console.error("Failed to fetch transactions:", err);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [connected, address$1, rpcClient, cluster, limit, fetchDetails, parseTransaction, imageProxy]
+  ), refetch = useCallback(async () => {
+    beforeSignatureRef.current = void 0, await fetchTransactions(false);
+  }, [fetchTransactions]), loadMoreFn = useCallback(async () => {
+    hasMore && !isLoading && await fetchTransactions(true);
+  }, [hasMore, isLoading, fetchTransactions]);
+  return useEffect(() => {
+    let prevDeps = prevDepsRef.current, currentDeps = { connected, address: address$1, cluster };
+    (!prevDeps || prevDeps.connected !== connected || prevDeps.address !== address$1 || prevDeps.cluster !== cluster) && (prevDepsRef.current = currentDeps, beforeSignatureRef.current = void 0, fetchTransactions(false));
+  }, [connected, address$1, cluster, fetchTransactions]), useEffect(() => {
+    if (!connected || !autoRefresh) return;
+    let interval = setInterval(refetch, refreshInterval);
+    return () => clearInterval(interval);
+  }, [connected, autoRefresh, refreshInterval, refetch]), useMemo(
+    () => ({
+      transactions,
+      isLoading,
+      error,
+      hasMore,
+      loadMore: loadMoreFn,
+      refetch,
+      lastUpdated
+    }),
+    [transactions, isLoading, error, hasMore, loadMoreFn, refetch, lastUpdated]
+  );
+}
+function createTimeoutSignal(ms) {
+  if (typeof AbortSignal.timeout == "function")
+    return { signal: AbortSignal.timeout(ms), cleanup: () => {
+    } };
+  let controller = new AbortController(), timeoutId = setTimeout(() => controller.abort(), ms);
+  return {
+    signal: controller.signal,
+    cleanup: () => clearTimeout(timeoutId)
+  };
+}
+var NATIVE_MINT = "So11111111111111111111111111111111111111112", CACHE_MAX_SIZE = 500, PRICE_CACHE_TTL = 6e4, STALE_CLEANUP_INTERVAL = 12e4, COINGECKO_DEFAULT_MAX_RETRIES = 3, COINGECKO_DEFAULT_BASE_DELAY = 1e3, COINGECKO_DEFAULT_MAX_TIMEOUT = 3e4, COINGECKO_API_BASE_URL = "https://api.coingecko.com/api/v3", LRUCache = class {
+  constructor(maxSize, options) {
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
+    __publicField(this, "maxSize");
+    __publicField(this, "getTtl");
+    __publicField(this, "getTimestamp");
+    this.maxSize = maxSize, this.getTtl = options?.getTtl, this.getTimestamp = options?.getTimestamp;
+  }
+  get(key) {
+    let value = this.cache.get(key);
+    if (value !== void 0) {
+      if (this.getTtl && this.getTimestamp) {
+        let ttl = this.getTtl(value), timestamp = this.getTimestamp(value);
+        if (ttl !== void 0 && timestamp !== void 0 && Date.now() - timestamp >= ttl) {
+          this.cache.delete(key);
+          return;
+        }
+      }
+      return this.cache.delete(key), this.cache.set(key, value), value;
+    }
+  }
+  set(key, value) {
+    if (this.cache.has(key) && this.cache.delete(key), this.cache.size >= this.maxSize) {
+      let oldestKey = this.cache.keys().next().value;
+      oldestKey !== void 0 && this.cache.delete(oldestKey);
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Prune stale entries based on TTL.
+   * Only works if getTtl and getTimestamp are provided.
+   */
+  pruneStale() {
+    if (!this.getTtl || !this.getTimestamp) return 0;
+    let now = Date.now(), pruned = 0;
+    for (let [key, value] of this.cache) {
+      let ttl = this.getTtl(value), timestamp = this.getTimestamp(value);
+      ttl !== void 0 && timestamp !== void 0 && now - timestamp >= ttl && (this.cache.delete(key), pruned++);
+    }
+    return pruned;
+  }
+}, metadataCache = new LRUCache(CACHE_MAX_SIZE), priceCache = new LRUCache(CACHE_MAX_SIZE, {
+  getTtl: () => PRICE_CACHE_TTL,
+  getTimestamp: (entry) => entry.timestamp
+}), cleanupIntervalId = null, cleanupRefCount = 0;
+function startCacheCleanup() {
+  cleanupRefCount++, cleanupIntervalId === null && (cleanupIntervalId = setInterval(() => {
+    priceCache.pruneStale();
+  }, STALE_CLEANUP_INTERVAL));
+}
+function stopCacheCleanup() {
+  cleanupRefCount = Math.max(0, cleanupRefCount - 1), cleanupRefCount === 0 && cleanupIntervalId !== null && (clearInterval(cleanupIntervalId), cleanupIntervalId = null);
+}
+function clearTokenCaches() {
+  metadataCache.clear(), priceCache.clear();
+}
+async function fetchSolanaTokenMetadata(mints) {
+  let results = /* @__PURE__ */ new Map();
+  if (mints.length === 0) return results;
+  let { signal, cleanup } = createTimeoutSignal(1e4);
+  try {
+    let response = await fetch("https://token-list-api.solana.cloud/v1/mints?chainId=101", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ addresses: mints }),
+      signal
+    });
+    if (cleanup(), !response.ok)
+      throw new Error(`Solana Token List API error: ${response.status}`);
+    let data = await response.json();
+    for (let item of data.content)
+      results.set(item.address, item);
+  } catch (error) {
+    cleanup(), console.warn("[useTokens] Solana Token List API failed:", error);
+  }
+  return results;
+}
+function calculateBackoffDelay(attempt, baseDelay, retryAfter) {
+  if (retryAfter !== void 0 && retryAfter > 0) {
+    let jitter2 = Math.random() * 500;
+    return retryAfter * 1e3 + jitter2;
+  }
+  let exponentialDelay = baseDelay * Math.pow(2, attempt), jitter = Math.random() * 500;
+  return exponentialDelay + jitter;
+}
+function parseRetryAfter(retryAfterHeader) {
+  if (!retryAfterHeader) return;
+  let seconds = parseInt(retryAfterHeader, 10);
+  if (!isNaN(seconds) && seconds >= 0)
+    return seconds;
+  let date = Date.parse(retryAfterHeader);
+  if (!isNaN(date)) {
+    let waitMs = date - Date.now();
+    return waitMs > 0 ? Math.ceil(waitMs / 1e3) : 0;
+  }
+}
+async function fetchCoinGeckoPrices(coingeckoIds, config) {
+  let results = /* @__PURE__ */ new Map();
+  if (coingeckoIds.length === 0) return results;
+  let now = Date.now(), uncachedIds = [];
+  for (let id of coingeckoIds) {
+    let cached = priceCache.get(id);
+    cached && now - cached.timestamp < PRICE_CACHE_TTL ? results.set(id, cached.price) : uncachedIds.push(id);
+  }
+  if (uncachedIds.length === 0) return results;
+  let maxRetries = config?.maxRetries ?? COINGECKO_DEFAULT_MAX_RETRIES, baseDelay = config?.baseDelay ?? COINGECKO_DEFAULT_BASE_DELAY, maxTimeout = config?.maxTimeout ?? COINGECKO_DEFAULT_MAX_TIMEOUT, apiKey = config?.apiKey, isPro = config?.isPro ?? false, url = `${COINGECKO_API_BASE_URL}/simple/price?ids=${uncachedIds.join(",")}&vs_currencies=usd`, headers = {};
+  apiKey && (headers[isPro ? "x-cg-pro-api-key" : "x-cg-demo-api-key"] = apiKey);
+  let startTime = Date.now(), attempt = 0, lastError = null;
+  for (; attempt <= maxRetries; ) {
+    let elapsedTime = Date.now() - startTime;
+    if (elapsedTime >= maxTimeout) {
+      console.warn(
+        `[useTokens] CoinGecko API: Total timeout (${maxTimeout}ms) exceeded after ${attempt} attempts. Returning cached/partial results.`
+      );
+      break;
+    }
+    let remainingTimeout = maxTimeout - elapsedTime, requestTimeout = Math.min(1e4, remainingTimeout), { signal, cleanup } = createTimeoutSignal(requestTimeout);
+    try {
+      let response = await fetch(url, {
+        headers,
+        signal
+      });
+      if (cleanup(), response.status === 429) {
+        let retryAfter = parseRetryAfter(response.headers.get("Retry-After")), delay = calculateBackoffDelay(attempt, baseDelay, retryAfter);
+        if (console.warn(
+          `[useTokens] CoinGecko API rate limited (429). Attempt ${attempt + 1}/${maxRetries + 1}. Retry-After: ${retryAfter ?? "not specified"}s. Waiting ${Math.round(delay)}ms before retry. Consider adding an API key for higher limits: https://www.coingecko.com/en/api/pricing`
+        ), Date.now() - startTime + delay >= maxTimeout) {
+          console.warn(
+            `[useTokens] CoinGecko API: Skipping retry - would exceed total timeout (${maxTimeout}ms). Returning cached/partial results.`
+          );
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay)), attempt++;
+        continue;
+      }
+      if (!response.ok)
+        throw new Error(`CoinGecko API error: ${response.status} ${response.statusText}`);
+      let data = await response.json(), fetchTime = Date.now();
+      for (let [id, priceData] of Object.entries(data))
+        priceData?.usd !== void 0 && (results.set(id, priceData.usd), priceCache.set(id, { price: priceData.usd, timestamp: fetchTime }));
+      return results;
+    } catch (error) {
+      if (cleanup(), lastError = error, error instanceof DOMException && error.name === "AbortError" ? console.warn(
+        `[useTokens] CoinGecko API request timed out. Attempt ${attempt + 1}/${maxRetries + 1}.`
+      ) : console.warn(
+        `[useTokens] CoinGecko API request failed. Attempt ${attempt + 1}/${maxRetries + 1}:`,
+        error
+      ), attempt < maxRetries) {
+        let delay = calculateBackoffDelay(attempt, baseDelay);
+        Date.now() - startTime + delay < maxTimeout && await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+      attempt++;
+    }
+  }
+  return attempt > maxRetries && console.warn(
+    `[useTokens] CoinGecko API: All ${maxRetries + 1} attempts failed. Returning cached/partial results. Last error: ${lastError?.message ?? "Unknown error"}. If you are frequently rate limited, consider adding an API key: https://www.coingecko.com/en/api/pricing`
+  ), results;
+}
+async function fetchTokenMetadataHybrid(mints, coingeckoConfig) {
+  let results = /* @__PURE__ */ new Map();
+  if (mints.length === 0) return results;
+  let uncachedMints = [], now = Date.now();
+  for (let mint of mints) {
+    let cached = metadataCache.get(mint);
+    cached ? (cached.coingeckoId && (!priceCache.get(cached.coingeckoId) || now - (priceCache.get(cached.coingeckoId)?.timestamp ?? 0) >= PRICE_CACHE_TTL) && cached.coingeckoId && uncachedMints.push(mint), results.set(mint, cached)) : uncachedMints.push(mint);
+  }
+  if (uncachedMints.length === 0) return results;
+  let solanaMetadata = await fetchSolanaTokenMetadata(uncachedMints), coingeckoIdToMint = /* @__PURE__ */ new Map();
+  for (let [mint, meta] of solanaMetadata)
+    meta.extensions?.coingeckoId && coingeckoIdToMint.set(meta.extensions.coingeckoId, mint);
+  for (let mint of mints) {
+    let cached = metadataCache.get(mint);
+    cached?.coingeckoId && !coingeckoIdToMint.has(cached.coingeckoId) && coingeckoIdToMint.set(cached.coingeckoId, mint);
+  }
+  let prices = await fetchCoinGeckoPrices([...coingeckoIdToMint.keys()], coingeckoConfig);
+  for (let [mint, meta] of solanaMetadata) {
+    let coingeckoId = meta.extensions?.coingeckoId, usdPrice = coingeckoId ? prices.get(coingeckoId) : void 0, combined = {
+      address: meta.address,
+      name: meta.address === NATIVE_MINT ? "Solana" : meta.name,
+      symbol: meta.symbol,
+      decimals: meta.decimals,
+      logoURI: meta.logoURI,
+      coingeckoId,
+      usdPrice
+    };
+    results.set(mint, combined), metadataCache.set(mint, combined);
+  }
+  for (let [coingeckoId, mint] of coingeckoIdToMint) {
+    let cached = results.get(mint) ?? metadataCache.get(mint);
+    if (cached) {
+      let usdPrice = prices.get(coingeckoId);
+      usdPrice !== void 0 && (cached.usdPrice = usdPrice, results.set(mint, cached), metadataCache.set(mint, cached));
+    }
+  }
+  return results;
+}
+function formatBalance(amount, decimals) {
+  return (Number(amount) / Math.pow(10, decimals)).toLocaleString(void 0, {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: Math.min(decimals, 6)
+  });
+}
+function formatUsd(amount, decimals, usdPrice) {
+  return (Number(amount) / Math.pow(10, decimals) * usdPrice).toLocaleString(void 0, {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+}
+function transformImageUrl2(url, imageProxy) {
+  if (!url) return;
+  if (!imageProxy) return url;
+  let encodedUrl = encodeURIComponent(url);
+  return imageProxy.endsWith("/") ? imageProxy + encodedUrl : imageProxy + "/" + encodedUrl;
+}
+function useTokens(options = {}) {
+  let {
+    includeZeroBalance = false,
+    autoRefresh = false,
+    refreshInterval = 6e4,
+    fetchMetadata = true,
+    includeNativeSol = true
+  } = options, { address: address$1, connected } = useAccount(), client = useSolanaClient(), connectorClient = useConnectorClient(), [tokens, setTokens] = useState([]), [isLoading, setIsLoading] = useState(false), [error, setError] = useState(null), [lastUpdated, setLastUpdated] = useState(null), [totalAccounts, setTotalAccounts] = useState(0), rpcClient = client?.client ?? null, connectorConfig = connectorClient?.getConfig(), imageProxy = connectorConfig?.imageProxy, coingeckoConfig = connectorConfig?.coingecko, fetchTokens = useCallback(async () => {
+    if (!connected || !address$1 || !rpcClient) {
+      setTokens([]), setTotalAccounts(0);
+      return;
+    }
+    setIsLoading(true), setError(null);
+    try {
+      let rpc = rpcClient.rpc, walletAddress = address(address$1), tokenProgramId = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), [balanceResult, tokenAccountsResult] = await Promise.all([
+        includeNativeSol ? rpc.getBalance(walletAddress).send() : Promise.resolve(null),
+        rpc.getTokenAccountsByOwner(walletAddress, { programId: tokenProgramId }, { encoding: "jsonParsed" }).send()
+      ]), tokenList = [], mints = [];
+      if (includeNativeSol && balanceResult !== null) {
+        let solBalance = balanceResult.value;
+        (includeZeroBalance || solBalance > 0n) && (tokenList.push({
+          mint: NATIVE_MINT,
+          tokenAccount: address$1,
+          // SOL uses wallet address
+          amount: solBalance,
+          decimals: 9,
+          formatted: formatBalance(solBalance, 9),
+          isFrozen: false,
+          owner: address$1
+        }), mints.push(NATIVE_MINT));
+      }
+      for (let account of tokenAccountsResult.value) {
+        let parsed = account.account.data;
+        if (parsed?.parsed?.info) {
+          let info = parsed.parsed.info, amount = BigInt(info.tokenAmount?.amount || "0"), decimals = info.tokenAmount?.decimals || 0;
+          if (!includeZeroBalance && amount === 0n)
+            continue;
+          tokenList.push({
+            mint: info.mint,
+            tokenAccount: account.pubkey,
+            amount,
+            decimals,
+            formatted: formatBalance(amount, decimals),
+            isFrozen: info.state === "frozen",
+            owner: info.owner
+          }), mints.push(info.mint);
+        }
+      }
+      if (setTokens([...tokenList]), setTotalAccounts(tokenAccountsResult.value.length + (includeNativeSol ? 1 : 0)), setLastUpdated(/* @__PURE__ */ new Date()), fetchMetadata && mints.length > 0) {
+        let metadata = await fetchTokenMetadataHybrid(mints, coingeckoConfig);
+        for (let i = 0; i < tokenList.length; i++) {
+          let meta = metadata.get(tokenList[i].mint);
+          meta && (tokenList[i] = {
+            ...tokenList[i],
+            name: meta.name,
+            symbol: meta.symbol,
+            logo: transformImageUrl2(meta.logoURI, imageProxy),
+            usdPrice: meta.usdPrice,
+            formattedUsd: meta.usdPrice ? formatUsd(tokenList[i].amount, tokenList[i].decimals, meta.usdPrice) : void 0
+          });
+        }
+        tokenList.sort((a, b) => {
+          let metadataSort = (b.logo ? 1 : 0) - (a.logo ? 1 : 0);
+          if (metadataSort !== 0) return metadataSort;
+          let aValue = Number(a.amount) / Math.pow(10, a.decimals) * (a.usdPrice ?? 0);
+          return Number(b.amount) / Math.pow(10, b.decimals) * (b.usdPrice ?? 0) - aValue;
+        }), setTokens([...tokenList]);
+      }
+    } catch (err) {
+      setError(err), console.error("[useTokens] Failed to fetch tokens:", err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [connected, address$1, rpcClient, includeZeroBalance, fetchMetadata, includeNativeSol, imageProxy, coingeckoConfig]);
+  useEffect(() => {
+    fetchTokens();
+  }, [fetchTokens]), useEffect(() => {
+    if (!connected || !autoRefresh) return;
+    let interval = setInterval(fetchTokens, refreshInterval);
+    return () => clearInterval(interval);
+  }, [connected, autoRefresh, refreshInterval, fetchTokens]), useEffect(() => (startCacheCleanup(), () => stopCacheCleanup()), []);
+  let wasConnectedRef = useRef(connected);
+  return useEffect(() => {
+    wasConnectedRef.current && !connected && clearTokenCaches(), wasConnectedRef.current = connected;
+  }, [connected]), useMemo(
+    () => ({
+      tokens,
+      isLoading,
+      error,
+      refetch: fetchTokens,
+      lastUpdated,
+      totalAccounts
+    }),
+    [tokens, isLoading, error, fetchTokens, lastUpdated, totalAccounts]
+  );
+}
+function DisconnectElement({
+  variant = "menuitem",
+  className,
+  label = "Disconnect",
+  icon,
+  showIcon = true,
+  onDisconnect,
+  render
+}) {
+  let { disconnect, connecting } = useConnector(), [disconnecting, setDisconnecting] = React.useState(false), handleDisconnect = async () => {
+    setDisconnecting(true);
+    try {
+      await disconnect(), onDisconnect?.();
+    } finally {
+      setDisconnecting(false);
+    }
+  };
+  if (render)
+    return /* @__PURE__ */ jsx(Fragment, { children: render({ disconnect: handleDisconnect, disconnecting }) });
+  let isDisabled = connecting || disconnecting, content = /* @__PURE__ */ jsxs(Fragment, { children: [
+    showIcon && (icon || showIcon && !icon && /* @__PURE__ */ jsxs(
+      "svg",
+      {
+        width: "16",
+        height: "16",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        className: "ck-block-icon",
+        "data-slot": "disconnect-element-icon",
+        children: [
+          /* @__PURE__ */ jsx("path", { d: "M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4" }),
+          /* @__PURE__ */ jsx("polyline", { points: "16 17 21 12 16 7" }),
+          /* @__PURE__ */ jsx("line", { x1: "21", y1: "12", x2: "9", y2: "12" })
+        ]
+      }
+    )),
+    /* @__PURE__ */ jsx("span", { "data-slot": "disconnect-element-label", children: label })
+  ] });
+  return variant === "button" ? /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      className: `ck-disconnect-block ck-disconnect-block--button ${className || ""}`,
+      onClick: handleDisconnect,
+      disabled: isDisabled,
+      "data-slot": "disconnect-element",
+      "data-variant": "button",
+      "data-disconnecting": disconnecting,
+      children: content
+    }
+  ) : variant === "link" ? /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      className: `ck-disconnect-block ck-disconnect-block--link ${className || ""}`,
+      onClick: handleDisconnect,
+      disabled: isDisabled,
+      "data-slot": "disconnect-element",
+      "data-variant": "link",
+      "data-disconnecting": disconnecting,
+      children: content
+    }
+  ) : /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      role: "menuitem",
+      className: `ck-disconnect-block ck-disconnect-block--menuitem ${className || ""}`,
+      onClick: handleDisconnect,
+      disabled: isDisabled,
+      "data-slot": "disconnect-element",
+      "data-variant": "menuitem",
+      "data-disconnecting": disconnecting,
+      children: content
+    }
+  );
+}
+DisconnectElement.displayName = "DisconnectElement";
+function AccountElement({
+  showAvatar = true,
+  showCopy = true,
+  showFullAddress = false,
+  className,
+  avatarSize = 32,
+  variant = "compact",
+  render
+}) {
+  let { address, formatted, copy, copied } = useAccount(), { name: walletName, icon: walletIcon } = useWalletInfo();
+  if (render)
+    return /* @__PURE__ */ jsx(Fragment, { children: render({ address, formatted, walletName, walletIcon, copy, copied }) });
+  if (!address) return null;
+  let displayAddress = showFullAddress ? address : formatted, handleCopy = async (e) => {
+    e.stopPropagation(), await copy();
+  }, copyIcon = /* @__PURE__ */ jsx(
+    "svg",
+    {
+      width: "14",
+      height: "14",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      className: "ck-block-icon",
+      "data-slot": "account-element-copy-icon",
+      children: copied ? /* @__PURE__ */ jsx("polyline", { points: "20 6 9 17 4 12" }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx("rect", { x: "9", y: "9", width: "13", height: "13", rx: "2", ry: "2" }),
+        /* @__PURE__ */ jsx("path", { d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" })
+      ] })
+    }
+  );
+  return variant === "inline" ? /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-account-block ck-account-block--inline ${className || ""}`,
+      "data-slot": "account-element",
+      "data-variant": "inline",
+      children: [
+        showAvatar && walletIcon && /* @__PURE__ */ jsx(
+          "img",
+          {
+            src: walletIcon,
+            alt: walletName || "Wallet",
+            className: "ck-account-block-avatar",
+            style: { width: avatarSize, height: avatarSize },
+            "data-slot": "account-element-avatar"
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { className: "ck-account-block-address", "data-slot": "account-element-address", children: displayAddress }),
+        showCopy && /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "ck-account-block-copy",
+            onClick: handleCopy,
+            title: copied ? "Copied!" : "Copy address",
+            "data-slot": "account-element-copy",
+            "data-copied": copied,
+            children: copyIcon
+          }
+        )
+      ]
+    }
+  ) : variant === "expanded" ? /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-account-block ck-account-block--expanded ${className || ""}`,
+      "data-slot": "account-element",
+      "data-variant": "expanded",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "ck-account-block-header", "data-slot": "account-element-header", children: [
+          showAvatar && walletIcon && /* @__PURE__ */ jsx(
+            "img",
+            {
+              src: walletIcon,
+              alt: walletName || "Wallet",
+              className: "ck-account-block-avatar",
+              style: { width: avatarSize, height: avatarSize },
+              "data-slot": "account-element-avatar"
+            }
+          ),
+          /* @__PURE__ */ jsxs("div", { className: "ck-account-block-info", "data-slot": "account-element-info", children: [
+            walletName && /* @__PURE__ */ jsx("span", { className: "ck-account-block-wallet-name", "data-slot": "account-element-wallet-name", children: walletName }),
+            /* @__PURE__ */ jsx("span", { className: "ck-account-block-address", "data-slot": "account-element-address", children: displayAddress })
+          ] })
+        ] }),
+        showCopy && /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            className: "ck-account-block-copy",
+            onClick: handleCopy,
+            "data-slot": "account-element-copy",
+            "data-copied": copied,
+            children: [
+              copyIcon,
+              /* @__PURE__ */ jsx("span", { children: copied ? "Copied!" : "Copy" })
+            ]
+          }
+        )
+      ]
+    }
+  ) : /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-account-block ck-account-block--compact ${className || ""}`,
+      "data-slot": "account-element",
+      "data-variant": "compact",
+      children: [
+        showAvatar && walletIcon && /* @__PURE__ */ jsx(
+          "img",
+          {
+            src: walletIcon,
+            alt: walletName || "Wallet",
+            className: "ck-account-block-avatar",
+            style: { width: avatarSize, height: avatarSize },
+            "data-slot": "account-element-avatar"
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "ck-account-block-content", "data-slot": "account-element-content", children: [
+          walletName && /* @__PURE__ */ jsx("span", { className: "ck-account-block-wallet-name", "data-slot": "account-element-wallet-name", children: walletName }),
+          /* @__PURE__ */ jsx("span", { className: "ck-account-block-address", "data-slot": "account-element-address", children: displayAddress })
+        ] }),
+        showCopy && /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "ck-account-block-copy",
+            onClick: handleCopy,
+            title: copied ? "Copied!" : "Copy address",
+            "data-slot": "account-element-copy",
+            "data-copied": copied,
+            children: copyIcon
+          }
+        )
+      ]
+    }
+  );
+}
+AccountElement.displayName = "AccountElement";
+var DEFAULT_LABELS = {
+  "mainnet-beta": "Mainnet",
+  devnet: "Devnet",
+  testnet: "Testnet",
+  localnet: "Localnet"
+};
+function getClusterColor(clusterId) {
+  switch (clusterId) {
+    case "mainnet-beta":
+      return "var(--ck-cluster-mainnet, #22c55e)";
+    case "devnet":
+      return "var(--ck-cluster-devnet, #3b82f6)";
+    case "testnet":
+      return "var(--ck-cluster-testnet, #eab308)";
+    case "localnet":
+      return "var(--ck-cluster-localnet, #ef4444)";
+    default:
+      return "var(--ck-cluster-custom, #8b5cf6)";
+  }
+}
+function ClusterElement({
+  variant = "badge",
+  className,
+  allowChange = false,
+  showIndicator = true,
+  labels = {},
+  render
+}) {
+  let { cluster, clusters, setCluster, isMainnet, isDevnet, isTestnet, isLocal } = useCluster(), [isOpen, setIsOpen] = React.useState(false);
+  if (render)
+    return /* @__PURE__ */ jsx(Fragment, { children: render({ cluster, clusters, setCluster, isMainnet, isDevnet, isTestnet, isLocal }) });
+  if (!cluster) return null;
+  let allLabels = { ...DEFAULT_LABELS, ...labels }, displayLabel = allLabels[cluster.id] || cluster.label || cluster.id, color = getClusterColor(cluster.id), indicator = showIndicator && /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: "ck-cluster-indicator",
+      style: { backgroundColor: color },
+      "data-slot": "cluster-element-indicator",
+      "aria-hidden": "true"
+    }
+  );
+  return variant === "badge" ? /* @__PURE__ */ jsxs(
+    "span",
+    {
+      className: `ck-cluster-block ck-cluster-block--badge ${className || ""}`,
+      "data-slot": "cluster-element",
+      "data-variant": "badge",
+      "data-cluster": cluster.id,
+      children: [
+        indicator,
+        /* @__PURE__ */ jsx("span", { "data-slot": "cluster-element-label", children: displayLabel })
+      ]
+    }
+  ) : variant === "menuitem" ? allowChange ? /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-cluster-block ck-cluster-block--menuitem ${className || ""}`,
+      "data-slot": "cluster-element",
+      "data-variant": "menuitem",
+      "data-cluster": cluster.id,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            className: "ck-cluster-block-trigger",
+            onClick: () => setIsOpen(!isOpen),
+            "data-slot": "cluster-element-trigger",
+            children: [
+              indicator,
+              /* @__PURE__ */ jsx("span", { "data-slot": "cluster-element-label", children: displayLabel }),
+              /* @__PURE__ */ jsx(
+                "svg",
+                {
+                  width: "12",
+                  height: "12",
+                  viewBox: "0 0 24 24",
+                  fill: "none",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  className: `ck-cluster-block-chevron ${isOpen ? "ck-cluster-block-chevron--open" : ""}`,
+                  "data-slot": "cluster-element-chevron",
+                  children: /* @__PURE__ */ jsx("polyline", { points: "6 9 12 15 18 9" })
+                }
+              )
+            ]
+          }
+        ),
+        isOpen && /* @__PURE__ */ jsx("div", { className: "ck-cluster-block-options", "data-slot": "cluster-element-options", children: clusters.map((c) => {
+          let cLabel = allLabels[c.id] || c.label || c.id, cColor = getClusterColor(c.id), isSelected = c.id === cluster.id;
+          return /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              className: `ck-cluster-block-option ${isSelected ? "ck-cluster-block-option--selected" : ""}`,
+              onClick: () => {
+                setCluster(c.id), setIsOpen(false);
+              },
+              "data-slot": "cluster-element-option",
+              "data-selected": isSelected,
+              children: [
+                /* @__PURE__ */ jsx(
+                  "span",
+                  {
+                    className: "ck-cluster-indicator",
+                    style: { backgroundColor: cColor },
+                    "data-slot": "cluster-element-indicator"
+                  }
+                ),
+                /* @__PURE__ */ jsx("span", { children: cLabel }),
+                isSelected && /* @__PURE__ */ jsx(
+                  "svg",
+                  {
+                    width: "12",
+                    height: "12",
+                    viewBox: "0 0 24 24",
+                    fill: "none",
+                    stroke: "currentColor",
+                    strokeWidth: "3",
+                    className: "ck-cluster-block-check",
+                    "data-slot": "cluster-element-check",
+                    children: /* @__PURE__ */ jsx("polyline", { points: "20 6 9 17 4 12" })
+                  }
+                )
+              ]
+            },
+            c.id
+          );
+        }) })
+      ]
+    }
+  ) : /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-cluster-block ck-cluster-block--menuitem ${className || ""}`,
+      role: "menuitem",
+      "data-slot": "cluster-element",
+      "data-variant": "menuitem",
+      "data-cluster": cluster.id,
+      children: [
+        indicator,
+        /* @__PURE__ */ jsx("span", { "data-slot": "cluster-element-label", children: displayLabel })
+      ]
+    }
+  ) : /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-cluster-block ck-cluster-block--select ${className || ""}`,
+      "data-slot": "cluster-element",
+      "data-variant": "select",
+      "data-cluster": cluster.id,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            className: "ck-cluster-block-trigger",
+            onClick: () => setIsOpen(!isOpen),
+            disabled: !allowChange,
+            "data-slot": "cluster-element-trigger",
+            children: [
+              indicator,
+              /* @__PURE__ */ jsx("span", { "data-slot": "cluster-element-label", children: displayLabel }),
+              allowChange && /* @__PURE__ */ jsx(
+                "svg",
+                {
+                  width: "12",
+                  height: "12",
+                  viewBox: "0 0 24 24",
+                  fill: "none",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  className: `ck-cluster-block-chevron ${isOpen ? "ck-cluster-block-chevron--open" : ""}`,
+                  "data-slot": "cluster-element-chevron",
+                  children: /* @__PURE__ */ jsx("polyline", { points: "6 9 12 15 18 9" })
+                }
+              )
+            ]
+          }
+        ),
+        isOpen && allowChange && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx("div", { className: "ck-cluster-block-backdrop", onClick: () => setIsOpen(false), "aria-hidden": "true" }),
+          /* @__PURE__ */ jsx("div", { className: "ck-cluster-block-options", "data-slot": "cluster-element-options", children: clusters.map((c) => {
+            let cLabel = allLabels[c.id] || c.label || c.id, cColor = getClusterColor(c.id), isSelected = c.id === cluster.id;
+            return /* @__PURE__ */ jsxs(
+              "button",
+              {
+                type: "button",
+                className: `ck-cluster-block-option ${isSelected ? "ck-cluster-block-option--selected" : ""}`,
+                onClick: () => {
+                  setCluster(c.id), setIsOpen(false);
+                },
+                "data-slot": "cluster-element-option",
+                "data-selected": isSelected,
+                children: [
+                  /* @__PURE__ */ jsx(
+                    "span",
+                    {
+                      className: "ck-cluster-indicator",
+                      style: { backgroundColor: cColor },
+                      "data-slot": "cluster-element-indicator"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx("span", { children: cLabel }),
+                  isSelected && /* @__PURE__ */ jsx(
+                    "svg",
+                    {
+                      width: "12",
+                      height: "12",
+                      viewBox: "0 0 24 24",
+                      fill: "none",
+                      stroke: "currentColor",
+                      strokeWidth: "3",
+                      className: "ck-cluster-block-check",
+                      "data-slot": "cluster-element-check",
+                      children: /* @__PURE__ */ jsx("polyline", { points: "20 6 9 17 4 12" })
+                    }
+                  )
+                ]
+              },
+              c.id
+            );
+          }) })
+        ] })
+      ]
+    }
+  );
+}
+ClusterElement.displayName = "ClusterElement";
+function WalletListElement({
+  installedOnly = false,
+  className,
+  variant = "list",
+  showStatus = true,
+  onSelect,
+  render,
+  renderWallet
+}) {
+  let { wallets, connecting } = useWalletInfo(), { select } = useConnector(), installedWallets = wallets.filter((w) => w.installed), displayWallets = installedOnly ? installedWallets : wallets, handleSelect = async (walletName) => {
+    await select(walletName), onSelect?.(walletName);
+  };
+  if (render)
+    return /* @__PURE__ */ jsx(Fragment, { children: render({ wallets, installedWallets, select: handleSelect, connecting }) });
+  if (displayWallets.length === 0)
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: `ck-wallet-list-block ck-wallet-list-block--empty ${className || ""}`,
+        "data-slot": "wallet-list-element",
+        "data-empty": "true",
+        children: /* @__PURE__ */ jsxs("div", { className: "ck-wallet-list-empty", "data-slot": "wallet-list-empty", children: [
+          /* @__PURE__ */ jsxs(
+            "svg",
+            {
+              width: "48",
+              height: "48",
+              viewBox: "0 0 24 24",
+              fill: "none",
+              stroke: "currentColor",
+              strokeWidth: "1.5",
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              className: "ck-wallet-list-empty-icon",
+              "data-slot": "wallet-list-empty-icon",
+              children: [
+                /* @__PURE__ */ jsx("path", { d: "M19 7V4a1 1 0 0 0-1-1H5a2 2 0 0 0 0 4h15a1 1 0 0 1 1 1v4h-3a2 2 0 0 0 0 4h3a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1" }),
+                /* @__PURE__ */ jsx("path", { d: "M3 5v14a2 2 0 0 0 2 2h15a1 1 0 0 0 1-1v-4" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx("p", { className: "ck-wallet-list-empty-text", "data-slot": "wallet-list-empty-text", children: installedOnly ? "No wallets detected" : "No wallets available" }),
+          /* @__PURE__ */ jsx("p", { className: "ck-wallet-list-empty-hint", "data-slot": "wallet-list-empty-hint", children: "Install a Solana wallet extension to continue" })
+        ] })
+      }
+    );
+  let walletIcon = /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      className: "ck-wallet-list-item-fallback-icon",
+      "data-slot": "wallet-list-item-fallback-icon",
+      children: [
+        /* @__PURE__ */ jsx("path", { d: "M19 7V4a1 1 0 0 0-1-1H5a2 2 0 0 0 0 4h15a1 1 0 0 1 1 1v4h-3a2 2 0 0 0 0 4h3a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1" }),
+        /* @__PURE__ */ jsx("path", { d: "M3 5v14a2 2 0 0 0 2 2h15a1 1 0 0 0 1-1v-4" })
+      ]
+    }
+  );
+  return variant === "grid" ? /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `ck-wallet-list-block ck-wallet-list-block--grid ${className || ""}`,
+      "data-slot": "wallet-list-element",
+      "data-variant": "grid",
+      children: displayWallets.map((wallet) => renderWallet ? /* @__PURE__ */ jsx(React.Fragment, { children: renderWallet({
+        wallet,
+        select: () => handleSelect(wallet.name),
+        connecting
+      }) }, wallet.name) : /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          className: "ck-wallet-list-item ck-wallet-list-item--grid",
+          onClick: () => handleSelect(wallet.name),
+          disabled: connecting || !wallet.installed && installedOnly,
+          "data-slot": "wallet-list-item",
+          "data-wallet": wallet.name,
+          "data-installed": wallet.installed,
+          children: [
+            /* @__PURE__ */ jsx("div", { className: "ck-wallet-list-item-icon", "data-slot": "wallet-list-item-icon", children: wallet.icon ? /* @__PURE__ */ jsx("img", { src: wallet.icon, alt: wallet.name }) : walletIcon }),
+            /* @__PURE__ */ jsx("span", { className: "ck-wallet-list-item-name", "data-slot": "wallet-list-item-name", children: wallet.name }),
+            showStatus && !wallet.installed && /* @__PURE__ */ jsx("span", { className: "ck-wallet-list-item-status", "data-slot": "wallet-list-item-status", children: "Not installed" })
+          ]
+        },
+        wallet.name
+      ))
+    }
+  ) : variant === "compact" ? /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `ck-wallet-list-block ck-wallet-list-block--compact ${className || ""}`,
+      "data-slot": "wallet-list-element",
+      "data-variant": "compact",
+      children: displayWallets.map((wallet) => renderWallet ? /* @__PURE__ */ jsx(React.Fragment, { children: renderWallet({
+        wallet,
+        select: () => handleSelect(wallet.name),
+        connecting
+      }) }, wallet.name) : /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          className: "ck-wallet-list-item ck-wallet-list-item--compact",
+          onClick: () => handleSelect(wallet.name),
+          disabled: connecting || !wallet.installed && installedOnly,
+          "data-slot": "wallet-list-item",
+          "data-wallet": wallet.name,
+          "data-installed": wallet.installed,
+          children: [
+            /* @__PURE__ */ jsx("div", { className: "ck-wallet-list-item-icon", "data-slot": "wallet-list-item-icon", children: wallet.icon ? /* @__PURE__ */ jsx("img", { src: wallet.icon, alt: wallet.name }) : walletIcon }),
+            /* @__PURE__ */ jsx("span", { className: "ck-wallet-list-item-name", "data-slot": "wallet-list-item-name", children: wallet.name })
+          ]
+        },
+        wallet.name
+      ))
+    }
+  ) : /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `ck-wallet-list-block ck-wallet-list-block--list ${className || ""}`,
+      "data-slot": "wallet-list-element",
+      "data-variant": "list",
+      children: displayWallets.map((wallet) => renderWallet ? /* @__PURE__ */ jsx(React.Fragment, { children: renderWallet({
+        wallet,
+        select: () => handleSelect(wallet.name),
+        connecting
+      }) }, wallet.name) : /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          className: "ck-wallet-list-item ck-wallet-list-item--list",
+          onClick: () => handleSelect(wallet.name),
+          disabled: connecting || !wallet.installed && installedOnly,
+          "data-slot": "wallet-list-item",
+          "data-wallet": wallet.name,
+          "data-installed": wallet.installed,
+          children: [
+            /* @__PURE__ */ jsx("div", { className: "ck-wallet-list-item-icon", "data-slot": "wallet-list-item-icon", children: wallet.icon ? /* @__PURE__ */ jsx("img", { src: wallet.icon, alt: wallet.name }) : walletIcon }),
+            /* @__PURE__ */ jsxs("div", { className: "ck-wallet-list-item-info", "data-slot": "wallet-list-item-info", children: [
+              /* @__PURE__ */ jsx("span", { className: "ck-wallet-list-item-name", "data-slot": "wallet-list-item-name", children: wallet.name }),
+              showStatus && /* @__PURE__ */ jsx(
+                "span",
+                {
+                  className: "ck-wallet-list-item-status",
+                  "data-slot": "wallet-list-item-status",
+                  "data-installed": wallet.installed,
+                  children: wallet.installed ? "Detected" : "Not installed"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsx(
+              "svg",
+              {
+                width: "16",
+                height: "16",
+                viewBox: "0 0 24 24",
+                fill: "none",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                className: "ck-wallet-list-item-arrow",
+                "data-slot": "wallet-list-item-arrow",
+                children: /* @__PURE__ */ jsx("polyline", { points: "9 18 15 12 9 6" })
+              }
+            )
+          ]
+        },
+        wallet.name
+      ))
+    }
+  );
+}
+WalletListElement.displayName = "WalletListElement";
+function BalanceElement({
+  showSol = true,
+  showTokens = false,
+  tokenCount = 3,
+  className,
+  variant = "compact",
+  showRefresh = false,
+  showSkeleton = true,
+  render
+}) {
+  let { solBalance, formattedSol, tokens, isLoading, error, refetch } = useBalance();
+  if (render)
+    return /* @__PURE__ */ jsx(Fragment, { children: render({ solBalance, formattedSol, tokens, isLoading, error, refetch }) });
+  let displayTokens = tokens.slice(0, tokenCount), refreshIcon = /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "14",
+      height: "14",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      className: `ck-block-icon ${isLoading ? "ck-block-icon--spinning" : ""}`,
+      "data-slot": "balance-element-refresh-icon",
+      children: [
+        /* @__PURE__ */ jsx("path", { d: "M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8" }),
+        /* @__PURE__ */ jsx("path", { d: "M3 3v5h5" }),
+        /* @__PURE__ */ jsx("path", { d: "M3 12a9 9 0 0 0 9 9 9.75 9.75 0 0 0 6.74-2.74L21 16" }),
+        /* @__PURE__ */ jsx("path", { d: "M16 16h5v5" })
+      ]
+    }
+  );
+  return isLoading && showSkeleton && solBalance === 0 ? /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `ck-balance-block ck-balance-block--${variant} ck-balance-block--loading ${className || ""}`,
+      "data-slot": "balance-element",
+      "data-variant": variant,
+      "data-loading": "true",
+      children: /* @__PURE__ */ jsxs("div", { className: "ck-balance-block-skeleton", "data-slot": "balance-element-skeleton", children: [
+        /* @__PURE__ */ jsx("div", { className: "ck-skeleton ck-skeleton--text" }),
+        showTokens && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx("div", { className: "ck-skeleton ck-skeleton--text ck-skeleton--short" }),
+          /* @__PURE__ */ jsx("div", { className: "ck-skeleton ck-skeleton--text ck-skeleton--short" })
+        ] })
+      ] })
+    }
+  ) : error ? /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-balance-block ck-balance-block--${variant} ck-balance-block--error ${className || ""}`,
+      "data-slot": "balance-element",
+      "data-variant": variant,
+      "data-error": "true",
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "ck-balance-block-error", "data-slot": "balance-element-error", children: "Failed to load balance" }),
+        showRefresh && /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "ck-balance-block-refresh",
+            onClick: () => refetch(),
+            "data-slot": "balance-element-refresh",
+            children: refreshIcon
+          }
+        )
+      ]
+    }
+  ) : variant === "inline" ? /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-balance-block ck-balance-block--inline ${className || ""}`,
+      "data-slot": "balance-element",
+      "data-variant": "inline",
+      children: [
+        showSol && /* @__PURE__ */ jsx("span", { className: "ck-balance-block-sol", "data-slot": "balance-element-sol", children: formattedSol }),
+        showRefresh && /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "ck-balance-block-refresh",
+            onClick: () => refetch(),
+            disabled: isLoading,
+            "data-slot": "balance-element-refresh",
+            children: refreshIcon
+          }
+        )
+      ]
+    }
+  ) : variant === "expanded" ? /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-balance-block ck-balance-block--expanded ${className || ""}`,
+      "data-slot": "balance-element",
+      "data-variant": "expanded",
+      children: [
+        showSol && /* @__PURE__ */ jsxs("div", { className: "ck-balance-block-sol-section", "data-slot": "balance-element-sol-section", children: [
+          /* @__PURE__ */ jsx("span", { className: "ck-balance-block-label", "data-slot": "balance-element-label", children: "SOL Balance" }),
+          /* @__PURE__ */ jsx("span", { className: "ck-balance-block-sol", "data-slot": "balance-element-sol", children: formattedSol })
+        ] }),
+        showTokens && displayTokens.length > 0 && /* @__PURE__ */ jsxs("div", { className: "ck-balance-block-tokens-section", "data-slot": "balance-element-tokens-section", children: [
+          /* @__PURE__ */ jsxs("span", { className: "ck-balance-block-label", "data-slot": "balance-element-label", children: [
+            "Tokens (",
+            tokens.length,
+            ")"
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "ck-balance-block-tokens", "data-slot": "balance-element-tokens", children: [
+            displayTokens.map((token) => /* @__PURE__ */ jsxs(
+              "div",
+              {
+                className: "ck-balance-block-token",
+                "data-slot": "balance-element-token",
+                children: [
+                  token.logo && /* @__PURE__ */ jsx(
+                    "img",
+                    {
+                      src: token.logo,
+                      alt: token.symbol || "Token",
+                      className: "ck-balance-block-token-logo",
+                      "data-slot": "balance-element-token-logo"
+                    }
+                  ),
+                  /* @__PURE__ */ jsxs(
+                    "span",
+                    {
+                      className: "ck-balance-block-token-info",
+                      "data-slot": "balance-element-token-info",
+                      children: [
+                        /* @__PURE__ */ jsx(
+                          "span",
+                          {
+                            className: "ck-balance-block-token-symbol",
+                            "data-slot": "balance-element-token-symbol",
+                            children: token.symbol || token.mint.slice(0, 4) + "..." + token.mint.slice(-4)
+                          }
+                        ),
+                        /* @__PURE__ */ jsx(
+                          "span",
+                          {
+                            className: "ck-balance-block-token-amount",
+                            "data-slot": "balance-element-token-amount",
+                            children: token.formatted
+                          }
+                        )
+                      ]
+                    }
+                  )
+                ]
+              },
+              token.mint
+            )),
+            tokens.length > tokenCount && /* @__PURE__ */ jsxs("div", { className: "ck-balance-block-more", "data-slot": "balance-element-more", children: [
+              "+",
+              tokens.length - tokenCount,
+              " more"
+            ] })
+          ] })
+        ] }),
+        showRefresh && /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            className: "ck-balance-block-refresh",
+            onClick: () => refetch(),
+            disabled: isLoading,
+            "data-slot": "balance-element-refresh",
+            children: [
+              refreshIcon,
+              /* @__PURE__ */ jsx("span", { children: "Refresh" })
+            ]
+          }
+        )
+      ]
+    }
+  ) : /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-balance-block ck-balance-block--compact ${className || ""}`,
+      "data-slot": "balance-element",
+      "data-variant": "compact",
+      children: [
+        showSol && /* @__PURE__ */ jsx("span", { className: "ck-balance-block-sol", "data-slot": "balance-element-sol", children: formattedSol }),
+        showTokens && displayTokens.length > 0 && /* @__PURE__ */ jsxs("span", { className: "ck-balance-block-token-count", "data-slot": "balance-element-token-count", children: [
+          "+",
+          tokens.length,
+          " tokens"
+        ] }),
+        showRefresh && /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "ck-balance-block-refresh",
+            onClick: () => refetch(),
+            disabled: isLoading,
+            "data-slot": "balance-element-refresh",
+            children: refreshIcon
+          }
+        )
+      ]
+    }
+  );
+}
+BalanceElement.displayName = "BalanceElement";
+function TransactionHistoryElement({
+  limit = 5,
+  showStatus = true,
+  showTime = true,
+  className,
+  variant = "list",
+  showLoadMore = false,
+  showSkeleton = true,
+  render,
+  renderItem
+}) {
+  let { transactions, isLoading, error, hasMore, loadMore, refetch } = useTransactions({ limit });
+  if (render)
+    return /* @__PURE__ */ jsx(Fragment, { children: render({ transactions, isLoading, error, hasMore, loadMore, refetch }) });
+  let statusIcon = (status) => /* @__PURE__ */ jsx(
+    "svg",
+    {
+      width: "12",
+      height: "12",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      className: `ck-tx-status-icon ck-tx-status-icon--${status}`,
+      "data-slot": "tx-status-icon",
+      "data-status": status,
+      children: status === "success" ? /* @__PURE__ */ jsx("polyline", { points: "20 6 9 17 4 12" }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+        /* @__PURE__ */ jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+      ] })
+    }
+  ), externalLinkIcon = /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "12",
+      height: "12",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      className: "ck-block-icon",
+      "data-slot": "tx-external-link-icon",
+      children: [
+        /* @__PURE__ */ jsx("path", { d: "M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6" }),
+        /* @__PURE__ */ jsx("polyline", { points: "15 3 21 3 21 9" }),
+        /* @__PURE__ */ jsx("line", { x1: "10", y1: "14", x2: "21", y2: "3" })
+      ]
+    }
+  );
+  if (isLoading && showSkeleton && transactions.length === 0)
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: `ck-tx-history-block ck-tx-history-block--${variant} ck-tx-history-block--loading ${className || ""}`,
+        "data-slot": "tx-history-element",
+        "data-variant": variant,
+        "data-loading": "true",
+        children: /* @__PURE__ */ jsx("div", { className: "ck-tx-history-skeleton", "data-slot": "tx-history-skeleton", children: Array.from({ length: Math.min(limit, 3) }).map((_, i) => /* @__PURE__ */ jsx("div", { className: "ck-skeleton ck-skeleton--tx" }, i)) })
+      }
+    );
+  if (error)
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: `ck-tx-history-block ck-tx-history-block--${variant} ck-tx-history-block--error ${className || ""}`,
+        "data-slot": "tx-history-element",
+        "data-variant": variant,
+        "data-error": "true",
+        children: [
+          /* @__PURE__ */ jsx("span", { className: "ck-tx-history-error", "data-slot": "tx-history-error", children: "Failed to load transactions" }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: "ck-tx-history-retry",
+              onClick: () => refetch(),
+              "data-slot": "tx-history-retry",
+              children: "Retry"
+            }
+          )
+        ]
+      }
+    );
+  if (transactions.length === 0)
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: `ck-tx-history-block ck-tx-history-block--${variant} ck-tx-history-block--empty ${className || ""}`,
+        "data-slot": "tx-history-element",
+        "data-variant": variant,
+        "data-empty": "true",
+        children: /* @__PURE__ */ jsx("span", { className: "ck-tx-history-empty", "data-slot": "tx-history-empty", children: "No transactions yet" })
+      }
+    );
+  let itemRenderer = renderItem || ((tx) => /* @__PURE__ */ jsxs(
+    "a",
+    {
+      href: tx.explorerUrl,
+      target: "_blank",
+      rel: "noopener noreferrer",
+      className: "ck-tx-item",
+      "data-slot": "tx-item",
+      "data-status": tx.status,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "ck-tx-item-main", "data-slot": "tx-item-main", children: [
+          showStatus && /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: `ck-tx-status ck-tx-status--${tx.status}`,
+              "data-slot": "tx-status",
+              "data-status": tx.status,
+              children: statusIcon(tx.status)
+            }
+          ),
+          /* @__PURE__ */ jsxs("span", { className: "ck-tx-signature", "data-slot": "tx-signature", children: [
+            tx.signature.slice(0, 8),
+            "...",
+            tx.signature.slice(-8)
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "ck-tx-item-meta", "data-slot": "tx-item-meta", children: [
+          showTime && /* @__PURE__ */ jsxs("span", { className: "ck-tx-time", "data-slot": "tx-time", children: [
+            tx.formattedDate,
+            " ",
+            tx.formattedTime
+          ] }),
+          externalLinkIcon
+        ] })
+      ]
+    },
+    tx.signature
+  ));
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-tx-history-block ck-tx-history-block--${variant} ${className || ""}`,
+      "data-slot": "tx-history-element",
+      "data-variant": variant,
+      children: [
+        variant === "expanded" && /* @__PURE__ */ jsxs("div", { className: "ck-tx-history-header", "data-slot": "tx-history-header", children: [
+          /* @__PURE__ */ jsx("span", { className: "ck-tx-history-title", "data-slot": "tx-history-title", children: "Recent Transactions" }),
+          /* @__PURE__ */ jsx("span", { className: "ck-tx-history-count", "data-slot": "tx-history-count", children: transactions.length })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "ck-tx-history-list", "data-slot": "tx-history-list", children: transactions.map(itemRenderer) }),
+        showLoadMore && hasMore && /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "ck-tx-history-load-more",
+            onClick: () => loadMore(),
+            disabled: isLoading,
+            "data-slot": "tx-history-load-more",
+            children: isLoading ? "Loading..." : "Load more"
+          }
+        )
+      ]
+    }
+  );
+}
+TransactionHistoryElement.displayName = "TransactionHistoryElement";
+function TokenListElement({
+  limit = 10,
+  showValue = false,
+  className,
+  variant = "compact",
+  showRefresh = false,
+  showSkeleton = true,
+  render,
+  renderItem
+}) {
+  let { tokens, isLoading, error, refetch, totalAccounts } = useTokens();
+  if (render)
+    return /* @__PURE__ */ jsx(Fragment, { children: render({ tokens, isLoading, error, refetch, totalAccounts }) });
+  let displayTokens = tokens.slice(0, limit), refreshIcon = /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "14",
+      height: "14",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      className: `ck-block-icon ${isLoading ? "ck-block-icon--spinning" : ""}`,
+      "data-slot": "token-list-refresh-icon",
+      children: [
+        /* @__PURE__ */ jsx("path", { d: "M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8" }),
+        /* @__PURE__ */ jsx("path", { d: "M3 3v5h5" }),
+        /* @__PURE__ */ jsx("path", { d: "M3 12a9 9 0 0 0 9 9 9.75 9.75 0 0 0 6.74-2.74L21 16" }),
+        /* @__PURE__ */ jsx("path", { d: "M16 16h5v5" })
+      ]
+    }
+  ), tokenIcon = /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      className: "ck-token-placeholder-icon",
+      "data-slot": "token-placeholder-icon",
+      children: [
+        /* @__PURE__ */ jsx("circle", { cx: "12", cy: "12", r: "10" }),
+        /* @__PURE__ */ jsx("path", { d: "M12 6v12" }),
+        /* @__PURE__ */ jsx("path", { d: "M6 12h12" })
+      ]
+    }
+  );
+  if (isLoading && showSkeleton && tokens.length === 0)
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: `ck-token-list-block ck-token-list-block--${variant} ck-token-list-block--loading ${className || ""}`,
+        "data-slot": "token-list-element",
+        "data-variant": variant,
+        "data-loading": "true",
+        children: /* @__PURE__ */ jsx("div", { className: "ck-token-list-skeleton", "data-slot": "token-list-skeleton", children: Array.from({ length: Math.min(limit, 3) }).map((_, i) => /* @__PURE__ */ jsx("div", { className: "ck-skeleton ck-skeleton--token" }, i)) })
+      }
+    );
+  if (error)
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: `ck-token-list-block ck-token-list-block--${variant} ck-token-list-block--error ${className || ""}`,
+        "data-slot": "token-list-element",
+        "data-variant": variant,
+        "data-error": "true",
+        children: [
+          /* @__PURE__ */ jsx("span", { className: "ck-token-list-error", "data-slot": "token-list-error", children: "Failed to load tokens" }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: "ck-token-list-retry",
+              onClick: () => refetch(),
+              "data-slot": "token-list-retry",
+              children: "Retry"
+            }
+          )
+        ]
+      }
+    );
+  if (tokens.length === 0)
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: `ck-token-list-block ck-token-list-block--${variant} ck-token-list-block--empty ${className || ""}`,
+        "data-slot": "token-list-element",
+        "data-variant": variant,
+        "data-empty": "true",
+        children: /* @__PURE__ */ jsx("span", { className: "ck-token-list-empty", "data-slot": "token-list-empty", children: "No tokens found" })
+      }
+    );
+  let itemRenderer = renderItem || ((token) => /* @__PURE__ */ jsxs("div", { className: "ck-token-item", "data-slot": "token-item", children: [
+    /* @__PURE__ */ jsx("div", { className: "ck-token-item-icon", "data-slot": "token-item-icon", children: token.logo ? /* @__PURE__ */ jsx(
+      "img",
+      {
+        src: token.logo,
+        alt: token.symbol || "Token",
+        className: "ck-token-logo",
+        "data-slot": "token-logo",
+        onError: (e) => {
+          e.currentTarget.style.display = "none";
+        }
+      }
+    ) : tokenIcon }),
+    /* @__PURE__ */ jsxs("div", { className: "ck-token-item-info", "data-slot": "token-item-info", children: [
+      /* @__PURE__ */ jsx("span", { className: "ck-token-symbol", "data-slot": "token-symbol", children: token.symbol || token.mint.slice(0, 4) + "..." + token.mint.slice(-4) }),
+      token.name && /* @__PURE__ */ jsx("span", { className: "ck-token-name", "data-slot": "token-name", children: token.name })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "ck-token-item-balance", "data-slot": "token-item-balance", children: [
+      /* @__PURE__ */ jsx("span", { className: "ck-token-amount", "data-slot": "token-amount", children: token.formatted }),
+      showValue && /* @__PURE__ */ jsx("span", { className: "ck-token-value", "data-slot": "token-value", children: "-" })
+    ] })
+  ] }, token.mint));
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `ck-token-list-block ck-token-list-block--${variant} ${className || ""}`,
+      "data-slot": "token-list-element",
+      "data-variant": variant,
+      children: [
+        variant === "expanded" && /* @__PURE__ */ jsxs("div", { className: "ck-token-list-header", "data-slot": "token-list-header", children: [
+          /* @__PURE__ */ jsx("span", { className: "ck-token-list-title", "data-slot": "token-list-title", children: "Tokens" }),
+          /* @__PURE__ */ jsx("span", { className: "ck-token-list-count", "data-slot": "token-list-count", children: totalAccounts }),
+          showRefresh && /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: "ck-token-list-refresh",
+              onClick: () => refetch(),
+              disabled: isLoading,
+              "data-slot": "token-list-refresh",
+              children: refreshIcon
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: `ck-token-list ${variant === "grid" ? "ck-token-list--grid" : ""}`, "data-slot": "token-list", children: displayTokens.map(itemRenderer) }),
+        tokens.length > limit && /* @__PURE__ */ jsxs("div", { className: "ck-token-list-more", "data-slot": "token-list-more", children: [
+          "+",
+          tokens.length - limit,
+          " more tokens"
+        ] })
+      ]
+    }
+  );
+}
+TokenListElement.displayName = "TokenListElement";
+
+export { AccountElement, BalanceElement, ClusterElement, ConnectorProvider, DisconnectElement, TokenListElement, TransactionHistoryElement, UnifiedProvider, WalletListElement, useAccount, useBalance, useCluster, useConnector, useConnectorClient, useGillSolanaClient, useGillTransactionSigner, useKitTransactionSigner, useSolanaClient, useTokens, useTransactionPreparer, useTransactionSigner, useTransactions, useWalletInfo };
+//# sourceMappingURL=chunk-3STZXVXD.mjs.map
+//# sourceMappingURL=chunk-3STZXVXD.mjs.map