@solana/connector 0.1.4 → 0.1.6

package/dist/{chunk-LUZWUZ5N.js → chunk-ULUYX23Q.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkCLXM6UEE_js = require('./chunk-CLXM6UEE.js');
-var chunkRIQH5W7D_js = require('./chunk-RIQH5W7D.js');
+var chunkJUZVCBAI_js = require('./chunk-JUZVCBAI.js');
+var chunkI64FD2EH_js = require('./chunk-I64FD2EH.js');
 var React = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var addresses = require('@solana/addresses');
@@ -11,8 +11,8 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var React__default = /*#__PURE__*/_interopDefault(React);
 
-var logger = chunkRIQH5W7D_js.createLogger("ConnectorProvider");
-chunkCLXM6UEE_js.installPolyfills();
+var logger = chunkI64FD2EH_js.createLogger("ConnectorProvider");
+chunkJUZVCBAI_js.installPolyfills();
 var ConnectorContext = React.createContext(null);
 ConnectorContext.displayName = "ConnectorContext";
 function ConnectorProviderInternal({
@@ -23,7 +23,7 @@ function ConnectorProviderInternal({
   let clientRef = React.useRef(null), client = React__default.default.useCallback(() => {
     if (!clientRef.current)
       try {
-        clientRef.current = new chunkCLXM6UEE_js.ConnectorClient(config), typeof window < "u" && (window.__connectorClient = clientRef.current), config?.debug && logger.info("Client initialized successfully");
+        clientRef.current = new chunkJUZVCBAI_js.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 });
@@ -83,7 +83,7 @@ function ConnectorProvider({
 }) {
   let errorBoundaryConfig = config?.errorBoundary;
   return errorBoundaryConfig?.enabled ? /* @__PURE__ */ jsxRuntime.jsx(
-    chunkCLXM6UEE_js.ConnectorErrorBoundary,
+    chunkJUZVCBAI_js.ConnectorErrorBoundary,
     {
       maxRetries: errorBoundaryConfig.maxRetries ?? 3,
       onError: errorBoundaryConfig.onError,
@@ -140,7 +140,7 @@ function useCluster() {
     [client]
   );
   return React.useMemo(() => {
-    let isMainnet = cluster ? chunkCLXM6UEE_js.isMainnetCluster(cluster) : false, isDevnet = cluster ? chunkCLXM6UEE_js.isDevnetCluster(cluster) : false, isTestnet = cluster ? chunkCLXM6UEE_js.isTestnetCluster(cluster) : false, isLocal = cluster ? chunkCLXM6UEE_js.isLocalCluster(cluster) : false, explorerUrl = cluster ? chunkCLXM6UEE_js.getClusterExplorerUrl(cluster) : "", type = cluster ? chunkCLXM6UEE_js.getClusterType(cluster) : null;
+    let isMainnet = cluster ? chunkJUZVCBAI_js.isMainnetCluster(cluster) : false, isDevnet = cluster ? chunkJUZVCBAI_js.isDevnetCluster(cluster) : false, isTestnet = cluster ? chunkJUZVCBAI_js.isTestnetCluster(cluster) : false, isLocal = cluster ? chunkJUZVCBAI_js.isLocalCluster(cluster) : false, explorerUrl = cluster ? chunkJUZVCBAI_js.getClusterExplorerUrl(cluster) : "", type = cluster ? chunkJUZVCBAI_js.getClusterType(cluster) : null;
     return {
       cluster,
       clusters,
@@ -158,7 +158,7 @@ function useAccount() {
   let { selectedAccount, accounts, connected, selectAccount } = useConnector(), [copied, setCopied] = React.useState(false), copyTimeoutRef = React__default.default.useRef(void 0), account = React.useMemo(
     () => accounts.find((a) => a.address === selectedAccount) ?? null,
     [accounts, selectedAccount]
-  ), formatted = React.useMemo(() => selectedAccount ? chunkCLXM6UEE_js.formatAddress(selectedAccount) : "", [selectedAccount]), copy = React.useCallback(async () => selectedAccount ? (copyTimeoutRef.current && clearTimeout(copyTimeoutRef.current), await chunkCLXM6UEE_js.copyAddressToClipboard(selectedAccount, {
+  ), formatted = React.useMemo(() => selectedAccount ? chunkJUZVCBAI_js.formatAddress(selectedAccount) : "", [selectedAccount]), copy = React.useCallback(async () => selectedAccount ? (copyTimeoutRef.current && clearTimeout(copyTimeoutRef.current), await chunkJUZVCBAI_js.copyAddressToClipboard(selectedAccount, {
     onSuccess: () => {
       setCopied(true), copyTimeoutRef.current = setTimeout(() => setCopied(false), 2e3);
     }
@@ -224,7 +224,7 @@ function useTransactionSigner() {
   let { selectedWallet, selectedAccount, accounts, cluster, connected } = useConnector(), client = useConnectorClient(), account = React.useMemo(
     () => accounts.find((a) => a.address === selectedAccount)?.raw ?? null,
     [accounts, selectedAccount]
-  ), signer = React.useMemo(() => !connected || !selectedWallet || !account ? null : chunkCLXM6UEE_js.createTransactionSigner({
+  ), signer = React.useMemo(() => !connected || !selectedWallet || !account ? null : chunkJUZVCBAI_js.createTransactionSigner({
     wallet: selectedWallet,
     account,
     cluster: cluster ?? void 0,
@@ -252,20 +252,20 @@ function useTransactionSigner() {
 function useKitTransactionSigner() {
   let { signer: connectorSigner, ready } = useTransactionSigner();
   return {
-    signer: React.useMemo(() => connectorSigner ? chunkCLXM6UEE_js.createKitTransactionSigner(connectorSigner) : null, [connectorSigner]),
+    signer: React.useMemo(() => connectorSigner ? chunkJUZVCBAI_js.createKitTransactionSigner(connectorSigner) : null, [connectorSigner]),
     ready
   };
 }
 var useGillTransactionSigner = useKitTransactionSigner;
-var logger2 = chunkRIQH5W7D_js.createLogger("useSolanaClient");
+var logger2 = chunkI64FD2EH_js.createLogger("useSolanaClient");
 function useSolanaClient() {
   let { type } = useCluster(), connectorClient = useConnectorClient(), client = React.useMemo(() => {
     if (!type || !connectorClient) return null;
     try {
       let rpcUrl = connectorClient.getRpcUrl();
-      return rpcUrl ? chunkRIQH5W7D_js.createSolanaClient({
+      return rpcUrl ? chunkI64FD2EH_js.createSolanaClient({
         urlOrMoniker: rpcUrl
-      }) : type !== "custom" ? chunkRIQH5W7D_js.createSolanaClient({
+      }) : type !== "custom" ? chunkI64FD2EH_js.createSolanaClient({
         urlOrMoniker: type
       }) : null;
     } catch (error) {
@@ -286,8 +286,8 @@ function useTransactionPreparer() {
   let { client, ready } = useSolanaClient(), prepare = React.useCallback(
     async (transaction, options = {}) => {
       if (!client)
-        throw new chunkCLXM6UEE_js.NetworkError("RPC_ERROR", "Solana client not available. Cannot prepare transaction.");
-      return chunkRIQH5W7D_js.prepareTransaction({
+        throw new chunkJUZVCBAI_js.NetworkError("RPC_ERROR", "Solana client not available. Cannot prepare transaction.");
+      return chunkI64FD2EH_js.prepareTransaction({
         transaction,
         rpc: client.rpc,
         computeUnitLimitMultiplier: options.computeUnitLimitMultiplier,
@@ -313,9 +313,9 @@ function formatSol(lamports, decimals = 4) {
   }) + " SOL";
 }
 function useBalance() {
-  let { address, connected } = useAccount(); useCluster(); let client = useSolanaClient(), [lamports, setLamports] = React.useState(0n), [tokens, setTokens] = React.useState([]), [isLoading, setIsLoading] = React.useState(false), [error, setError] = React.useState(null), [lastUpdated, setLastUpdated] = React.useState(null), rpcClient = client?.client ?? null, fetchBalance = React.useCallback(async () => {
+  let { address, connected } = useAccount(); useCluster(); let client = useSolanaClient(), [lamports, setLamports] = React.useState(0n), [tokens, setTokens] = React.useState([]), [isLoading, setIsLoading] = React.useState(false), [error, setError] = React.useState(null), [lastUpdated, setLastUpdated] = React.useState(null), hasDataRef = React.useRef(false), rpcClient = client?.client ?? null, fetchBalance = React.useCallback(async () => {
     if (!connected || !address || !rpcClient) {
-      setLamports(0n), setTokens([]);
+      setLamports(0n), setTokens([]), hasDataRef.current = false;
       return;
     }
     setIsLoading(true), setError(null);
@@ -343,9 +343,9 @@ function useBalance() {
       } catch (tokenError) {
         console.warn("Failed to fetch token balances:", tokenError), setTokens([]);
       }
-      setLastUpdated(/* @__PURE__ */ new Date());
+      hasDataRef.current = true, setLastUpdated(/* @__PURE__ */ new Date());
     } catch (err) {
-      setError(err), console.error("Failed to fetch balance:", err);
+      hasDataRef.current || (setError(err), console.error("Failed to fetch balance:", err));
     } finally {
       setIsLoading(false);
     }
@@ -496,6 +496,10 @@ function formatAmount(tokenAmount, tokenDecimals, direction, solChange) {
     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;
@@ -506,16 +510,17 @@ async function fetchTokenMetadata(mints) {
   }
   if (uncachedMints.length === 0) return results;
   try {
-    let url = new URL("https://lite-api.jup.ag/tokens/v2/search");
-    url.searchParams.append("query", uncachedMints.join(","));
-    let response = await fetch(url.toString(), {
+    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 items = await response.json();
-    for (let item of items) {
-      let metadata = { symbol: item.symbol, icon: item.icon };
-      results.set(item.id, metadata), tokenMetadataCache.set(item.id, metadata);
+    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);
@@ -523,16 +528,19 @@ async function fetchTokenMetadata(mints) {
   return results;
 }
 function useTransactions(options = {}) {
-  let { limit = 10, autoRefresh = false, refreshInterval = 6e4, fetchDetails = true } = options, { address, connected } = useAccount(), { cluster } = useCluster(), client = useSolanaClient(), [transactions, setTransactions] = React.useState([]), [isLoading, setIsLoading] = React.useState(false), [error, setError] = React.useState(null), [hasMore, setHasMore] = React.useState(true), [lastUpdated, setLastUpdated] = React.useState(null), beforeSignatureRef = React.useRef(void 0), prevDepsRef = React.useRef(
+  let { limit = 10, autoRefresh = false, refreshInterval = 6e4, fetchDetails = true } = options, { address, connected } = useAccount(), { cluster } = useCluster(), client = useSolanaClient(), connectorClient = useConnectorClient(), [transactions, setTransactions] = React.useState([]), [isLoading, setIsLoading] = React.useState(false), [error, setError] = React.useState(null), [hasMore, setHasMore] = React.useState(true), [lastUpdated, setLastUpdated] = React.useState(null), beforeSignatureRef = React.useRef(void 0), prevDepsRef = React.useRef(
     null
-  ), rpcClient = client?.client ?? null, parseTransaction = React.useCallback(
+  ), rpcClient = client?.client ?? null, imageProxy = connectorClient?.getConfig().imageProxy, parseTransaction = React.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) : void 0,
+        error: err ? JSON.stringify(
+          err,
+          (_key, value) => typeof value == "bigint" ? value.toString() : value
+        ) : void 0,
         type: "unknown",
         formattedDate: date,
         formattedTime: time,
@@ -608,7 +616,7 @@ function useTransactions(options = {}) {
               blockTimeNum,
               Number(sig.slot),
               sig.err,
-              chunkCLXM6UEE_js.getTransactionUrl(String(sig.signature), cluster)
+              chunkJUZVCBAI_js.getTransactionUrl(String(sig.signature), cluster)
             );
           });
         } else
@@ -623,7 +631,7 @@ function useTransactions(options = {}) {
               type: "unknown",
               formattedDate: date,
               formattedTime: time,
-              explorerUrl: chunkCLXM6UEE_js.getTransactionUrl(String(sig.signature), cluster)
+              explorerUrl: chunkJUZVCBAI_js.getTransactionUrl(String(sig.signature), cluster)
             };
           });
         setTransactions(loadMore ? (prev) => [...prev, ...newTransactions] : newTransactions);
@@ -637,7 +645,7 @@ function useTransactions(options = {}) {
                 return {
                   ...tx,
                   tokenSymbol: meta.symbol,
-                  tokenIcon: meta.icon,
+                  tokenIcon: transformImageUrl(meta.icon, imageProxy),
                   // Update formatted amount with symbol
                   formattedAmount: tx.formattedAmount ? `${tx.formattedAmount} ${meta.symbol}` : tx.formattedAmount
                 };
@@ -661,7 +669,7 @@ function useTransactions(options = {}) {
         setIsLoading(false);
       }
     },
-    [connected, address, rpcClient, cluster, limit, fetchDetails, parseTransaction]
+    [connected, address, rpcClient, cluster, limit, fetchDetails, parseTransaction, imageProxy]
   ), refetch = React.useCallback(async () => {
     beforeSignatureRef.current = void 0, await fetchTransactions(false);
   }, [fetchTransactions]), loadMoreFn = React.useCallback(async () => {
@@ -687,38 +695,221 @@ function useTransactions(options = {}) {
     [transactions, isLoading, error, hasMore, loadMoreFn, refetch, lastUpdated]
   );
 }
-var NATIVE_MINT = "So11111111111111111111111111111111111111112", metadataCache = /* @__PURE__ */ new Map();
-async function fetchJupiterMetadata(mints) {
+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) {
+    chunkI64FD2EH_js.__publicField(this, "cache", /* @__PURE__ */ new Map());
+    chunkI64FD2EH_js.__publicField(this, "maxSize");
+    chunkI64FD2EH_js.__publicField(this, "getTtl");
+    chunkI64FD2EH_js.__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 uncachedMints = [];
+  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 ? results.set(mint, cached) : uncachedMints.push(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;
-  try {
-    let url = new URL("https://lite-api.jup.ag/tokens/v2/search");
-    url.searchParams.append("query", uncachedMints.join(","));
-    let response = await fetch(url.toString(), {
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (!response.ok)
-      throw new Error(`Jupiter API error: ${response.status}`);
-    let items = await response.json();
-    for (let item of items) {
-      let metadata = {
-        id: item.id,
-        name: item.id === NATIVE_MINT ? "Solana" : item.name,
-        symbol: item.symbol,
-        decimals: item.decimals,
-        icon: item.icon,
-        usdPrice: item.usdPrice
-      };
-      results.set(item.id, metadata), metadataCache.set(item.id, metadata);
+  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));
     }
-  } catch (error) {
-    console.warn("[useTokens] Jupiter API failed:", error);
   }
   return results;
 }
@@ -736,6 +927,12 @@ function formatUsd(amount, decimals, usdPrice) {
     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,
@@ -743,7 +940,7 @@ function useTokens(options = {}) {
     refreshInterval = 6e4,
     fetchMetadata = true,
     includeNativeSol = true
-  } = options, { address, connected } = useAccount(), client = useSolanaClient(), [tokens, setTokens] = React.useState([]), [isLoading, setIsLoading] = React.useState(false), [error, setError] = React.useState(null), [lastUpdated, setLastUpdated] = React.useState(null), [totalAccounts, setTotalAccounts] = React.useState(0), rpcClient = client?.client ?? null, fetchTokens = React.useCallback(async () => {
+  } = options, { address, connected } = useAccount(), client = useSolanaClient(), connectorClient = useConnectorClient(), [tokens, setTokens] = React.useState([]), [isLoading, setIsLoading] = React.useState(false), [error, setError] = React.useState(null), [lastUpdated, setLastUpdated] = React.useState(null), [totalAccounts, setTotalAccounts] = React.useState(0), rpcClient = client?.client ?? null, connectorConfig = connectorClient?.getConfig(), imageProxy = connectorConfig?.imageProxy, coingeckoConfig = connectorConfig?.coingecko, fetchTokens = React.useCallback(async () => {
     if (!connected || !address || !rpcClient) {
       setTokens([]), setTotalAccounts(0);
       return;
@@ -785,16 +982,16 @@ function useTokens(options = {}) {
         }
       }
       if (setTokens([...tokenList]), setTotalAccounts(tokenAccountsResult.value.length + (includeNativeSol ? 1 : 0)), setLastUpdated(/* @__PURE__ */ new Date()), fetchMetadata && mints.length > 0) {
-        let metadata = await fetchJupiterMetadata(mints);
+        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: meta.icon,
+            logo: transformImageUrl2(meta.logoURI, imageProxy),
             usdPrice: meta.usdPrice,
-            formattedUsd: formatUsd(tokenList[i].amount, tokenList[i].decimals, meta.usdPrice)
+            formattedUsd: meta.usdPrice ? formatUsd(tokenList[i].amount, tokenList[i].decimals, meta.usdPrice) : void 0
           });
         }
         tokenList.sort((a, b) => {
@@ -809,14 +1006,18 @@ function useTokens(options = {}) {
     } finally {
       setIsLoading(false);
     }
-  }, [connected, address, rpcClient, includeZeroBalance, fetchMetadata, includeNativeSol]);
-  return React.useEffect(() => {
+  }, [connected, address, rpcClient, includeZeroBalance, fetchMetadata, includeNativeSol, imageProxy, coingeckoConfig]);
+  React.useEffect(() => {
     fetchTokens();
   }, [fetchTokens]), React.useEffect(() => {
     if (!connected || !autoRefresh) return;
     let interval = setInterval(fetchTokens, refreshInterval);
     return () => clearInterval(interval);
-  }, [connected, autoRefresh, refreshInterval, fetchTokens]), React.useMemo(
+  }, [connected, autoRefresh, refreshInterval, fetchTokens]), React.useEffect(() => (startCacheCleanup(), () => stopCacheCleanup()), []);
+  let wasConnectedRef = React.useRef(connected);
+  return React.useEffect(() => {
+    wasConnectedRef.current && !connected && clearTokenCaches(), wasConnectedRef.current = connected;
+  }, [connected]), React.useMemo(
     () => ({
       tokens,
       isLoading,
@@ -2008,5 +2209,5 @@ exports.useTransactionPreparer = useTransactionPreparer;
 exports.useTransactionSigner = useTransactionSigner;
 exports.useTransactions = useTransactions;
 exports.useWalletInfo = useWalletInfo;
-//# sourceMappingURL=chunk-LUZWUZ5N.js.map
-//# sourceMappingURL=chunk-LUZWUZ5N.js.map
+//# sourceMappingURL=chunk-ULUYX23Q.js.map
+//# sourceMappingURL=chunk-ULUYX23Q.js.map