@solana/connector 0.1.6 → 0.1.7

package/dist/{chunk-3STZXVXD.mjs → chunk-JK47EFJT.mjs}

@@ -1,4 +1,4 @@
-import { installPolyfills, ConnectorErrorBoundary, isMainnetCluster, isDevnetCluster, isTestnetCluster, isLocalCluster, getClusterExplorerUrl, getClusterType, formatAddress, copyAddressToClipboard, createTransactionSigner, createKitTransactionSigner, NetworkError, getTransactionUrl, ConnectorClient } from './chunk-VMSZJPR5.mjs';
+import { installPolyfills, ConnectorErrorBoundary, isMainnetCluster, isDevnetCluster, isTestnetCluster, isLocalCluster, getClusterExplorerUrl, getClusterType, formatAddress, copyAddressToClipboard, createTransactionSigner, createKitTransactionSigner, NetworkError, formatLamportsToSolSafe, getTransactionUrl, ConnectorClient, formatBigIntBalance, formatBigIntUsd } from './chunk-APQGEW7S.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';
@@ -54,15 +54,15 @@ function ConnectorProviderInternal({
           "solana:mainnet",
           "solana:devnet",
           "solana:testnet"
-        ];
-        registerMwa({
+        ], mwaConfig = {
           appIdentity: mobile.appIdentity,
           authorizationCache: mobile.authorizationCache ?? createDefaultAuthorizationCache(),
           chains: mobile.chains ?? defaultChains,
           chainSelector: mobile.chainSelector ?? createDefaultChainSelector(),
           remoteHostAuthority: mobile.remoteHostAuthority,
           onWalletNotFound: mobile.onWalletNotFound ?? createDefaultWalletNotFoundHandler()
-        });
+        };
+        registerMwa(mwaConfig);
       } catch {
       }
     })(), () => {
@@ -299,73 +299,493 @@ function useTransactionPreparer() {
     [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;
+var DEFAULT_CACHE_TIME_MS = 300 * 1e3, MAX_STORE_SIZE = 100, store = /* @__PURE__ */ new Map();
+function evictStaleEntries() {
+  if (store.size <= MAX_STORE_SIZE) return;
+  let evictable = [];
+  for (let [key, entry] of store)
+    entry.subscribers.size === 0 && evictable.push([key, entry]);
+  evictable.sort((a, b) => a[1].lastAccessedAt - b[1].lastAccessedAt);
+  for (let [key, entry] of evictable) {
+    if (store.size <= MAX_STORE_SIZE) break;
+    entry.gcTimeoutId && clearTimeout(entry.gcTimeoutId), entry.intervalId && clearInterval(entry.intervalId), entry.abortController && entry.abortController.abort(), store.delete(key);
+  }
+}
+function getOrCreateEntry(key) {
+  let existing = store.get(key);
+  if (existing)
+    return existing.lastAccessedAt = Date.now(), existing;
+  let entry = {
+    snapshot: {
+      data: void 0,
+      error: null,
+      status: "idle",
+      updatedAt: null,
+      isFetching: false
+    },
+    subscribers: /* @__PURE__ */ new Set(),
+    promise: null,
+    abortController: null,
+    cacheTimeMs: DEFAULT_CACHE_TIME_MS,
+    gcTimeoutId: null,
+    queryFn: null,
+    intervalCounts: /* @__PURE__ */ new Map(),
+    activeIntervalMs: null,
+    intervalId: null,
+    lastAccessedAt: Date.now()
+  };
+  return store.set(key, entry), evictStaleEntries(), entry;
+}
+function emit(entry) {
+  for (let cb of entry.subscribers)
+    cb();
+}
+function setSnapshot(entry, next) {
+  let prev = entry.snapshot;
+  prev.status === next.status && prev.isFetching === next.isFetching && prev.updatedAt === next.updatedAt && prev.error === next.error && prev.data === next.data || (entry.snapshot = next, emit(entry));
+}
+function getMinIntervalMs(entry) {
+  let min = null;
+  for (let [ms, count] of entry.intervalCounts)
+    count <= 0 || (min === null || ms < min) && (min = ms);
+  return min;
+}
+function startOrRestartInterval(key, entry) {
+  let nextMs = getMinIntervalMs(entry);
+  if (nextMs === null) {
+    entry.intervalId && clearInterval(entry.intervalId), entry.intervalId = null, entry.activeIntervalMs = null;
+    return;
+  }
+  entry.activeIntervalMs === nextMs && entry.intervalId || (entry.intervalId && clearInterval(entry.intervalId), entry.activeIntervalMs = nextMs, entry.intervalId = setInterval(() => {
+    let fn = entry.queryFn;
+    fn && fetchSharedQuery(key, fn, { force: true });
+  }, nextMs));
+}
+function subscribeSharedQuery(key, onChange, cacheTimeMs) {
+  let entry = getOrCreateEntry(key);
+  return entry.subscribers.add(onChange), typeof cacheTimeMs == "number" && (entry.cacheTimeMs = Math.max(entry.cacheTimeMs, cacheTimeMs)), entry.gcTimeoutId && (clearTimeout(entry.gcTimeoutId), entry.gcTimeoutId = null), () => {
+    if (entry.subscribers.delete(onChange), entry.subscribers.size > 0) return;
+    entry.abortController && entry.abortController.abort(), entry.abortController = null, entry.promise = null, entry.intervalId && clearInterval(entry.intervalId), entry.intervalId = null, entry.activeIntervalMs = null, entry.intervalCounts.clear();
+    let gcDelayMs = entry.cacheTimeMs ?? DEFAULT_CACHE_TIME_MS;
+    entry.gcTimeoutId = setTimeout(() => {
+      entry.subscribers.size === 0 && store.delete(key);
+    }, gcDelayMs);
+  };
+}
+async function fetchSharedQuery(key, queryFn, options = {}) {
+  let entry = getOrCreateEntry(key);
+  entry.queryFn = queryFn;
+  let staleTimeMs = options.staleTimeMs ?? 0, now = Date.now();
+  if (options.force !== true && entry.snapshot.status === "success" && entry.snapshot.updatedAt !== null && now - entry.snapshot.updatedAt < staleTimeMs && entry.snapshot.data !== void 0)
+    return entry.snapshot.data;
+  if (entry.promise)
+    return entry.promise;
+  let controller = new AbortController();
+  entry.abortController = controller, options.signal && (options.signal.aborted ? controller.abort() : options.signal.addEventListener("abort", () => controller.abort(), { once: true }));
+  let isFirstLoad = entry.snapshot.status === "idle" && entry.snapshot.updatedAt === null;
+  setSnapshot(entry, {
+    ...entry.snapshot,
+    status: isFirstLoad ? "loading" : entry.snapshot.status,
+    isFetching: true,
+    error: null
+  });
+  let promise = (async () => {
+    try {
+      let data = await queryFn(controller.signal);
+      return setSnapshot(entry, {
+        data,
+        error: null,
+        status: "success",
+        updatedAt: Date.now(),
+        isFetching: false
+      }), data;
+    } catch (cause) {
+      if (controller.signal.aborted)
+        return setSnapshot(entry, {
+          data: entry.snapshot.data,
+          error: null,
+          status: entry.snapshot.status === "idle" ? "idle" : entry.snapshot.status,
+          updatedAt: entry.snapshot.updatedAt,
+          isFetching: false
+        }), entry.snapshot.data;
+      let error = cause instanceof Error ? cause : new Error(String(cause));
+      throw setSnapshot(entry, {
+        data: entry.snapshot.data,
+        error,
+        status: "error",
+        updatedAt: entry.snapshot.updatedAt,
+        isFetching: false
+      }), error;
+    } finally {
+      entry.promise = null, entry.abortController = null;
+    }
+  })();
+  return entry.promise = promise, promise;
+}
+function useSharedQuery(key, queryFn, options = {}) {
+  let {
+    enabled = true,
+    staleTimeMs = 0,
+    cacheTimeMs,
+    refetchOnMount = "stale",
+    refetchIntervalMs = false,
+    select
+  } = options, queryFnRef = useRef(queryFn);
+  queryFnRef.current = queryFn;
+  let stableQueryFn = useCallback((signal) => queryFnRef.current(signal), []), subscribe = useCallback(
+    (onChange) => key ? subscribeSharedQuery(key, onChange, cacheTimeMs) : () => {
+    },
+    [key, cacheTimeMs]
+  ), emptySnapshot = useMemo(
+    () => ({
+      data: void 0,
+      error: null,
+      status: "idle",
+      updatedAt: null,
+      isFetching: false
+    }),
+    []
+  ), getSnapshot = useCallback(() => key ? getOrCreateEntry(key).snapshot : emptySnapshot, [key, emptySnapshot]), snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot), selectedData = useMemo(() => select ? select(snapshot.data) : snapshot.data, [snapshot.data, select]), prevSelectedRef = useRef(selectedData), stableSelectedData = useMemo(() => Object.is(prevSelectedRef.current, selectedData) ? prevSelectedRef.current : (prevSelectedRef.current = selectedData, selectedData), [selectedData]), fetchedKeyRef = useRef(null);
+  useEffect(() => {
+    if (!key || !enabled) {
+      fetchedKeyRef.current = null;
       return;
     }
-    setIsLoading(true), setError(null);
+    let entry = getOrCreateEntry(key);
+    if (entry.queryFn = stableQueryFn, fetchedKeyRef.current === key && entry.snapshot.status === "success")
+      return;
+    let current = entry.snapshot, isStale = current.updatedAt === null || Date.now() - current.updatedAt >= staleTimeMs;
+    refetchOnMount === true || current.status === "idle" || refetchOnMount === "stale" && isStale ? (fetchedKeyRef.current = key, fetchSharedQuery(key, stableQueryFn, {
+      staleTimeMs,
+      force: refetchOnMount === true
+    }).catch(() => {
+    })) : fetchedKeyRef.current = key;
+  }, [key, enabled, staleTimeMs, refetchOnMount, stableQueryFn]), useEffect(() => {
+    if (!key || !enabled || refetchIntervalMs === false) return;
+    let entry = getOrCreateEntry(key);
+    entry.queryFn = stableQueryFn;
+    let prev = entry.intervalCounts.get(refetchIntervalMs) ?? 0;
+    return entry.intervalCounts.set(refetchIntervalMs, prev + 1), startOrRestartInterval(key, entry), () => {
+      let count = entry.intervalCounts.get(refetchIntervalMs) ?? 0;
+      count <= 1 ? entry.intervalCounts.delete(refetchIntervalMs) : entry.intervalCounts.set(refetchIntervalMs, count - 1), startOrRestartInterval(key, entry);
+    };
+  }, [key, enabled, refetchIntervalMs, stableQueryFn]);
+  let refetch = useCallback(
+    async (refetchOptions) => {
+      if (key)
+        return fetchSharedQuery(key, stableQueryFn, {
+          force: true,
+          signal: refetchOptions?.signal
+        });
+    },
+    [key, stableQueryFn]
+  ), abort = useCallback(() => {
+    if (!key) return;
+    let entry = store.get(key);
+    entry?.abortController && entry.abortController.abort();
+  }, [key]);
+  return useMemo(
+    () => ({
+      data: stableSelectedData,
+      error: snapshot.error,
+      status: snapshot.status,
+      updatedAt: snapshot.updatedAt,
+      isFetching: snapshot.isFetching,
+      refetch,
+      abort
+    }),
+    [stableSelectedData, snapshot.error, snapshot.status, snapshot.updatedAt, snapshot.isFetching, refetch, abort]
+  );
+}
+function invalidateSharedQuery(key) {
+  let entry = store.get(key);
+  entry && setSnapshot(entry, {
+    ...entry.snapshot,
+    updatedAt: null
+    // Mark as stale
+  });
+}
+function clearSharedQueryCache() {
+  for (let [, entry] of store)
+    entry.intervalId && clearInterval(entry.intervalId), entry.gcTimeoutId && clearTimeout(entry.gcTimeoutId), entry.abortController && entry.abortController.abort();
+  store.clear();
+}
+
+// src/hooks/_internal/use-wallet-assets.ts
+var TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb", NATIVE_SOL_MINT = "So11111111111111111111111111111111111111112";
+function isRecord(value) {
+  return typeof value == "object" && value !== null;
+}
+function parseBigInt(value) {
+  if (typeof value == "bigint") return value;
+  if (typeof value == "number" && Number.isSafeInteger(value)) return BigInt(value);
+  if (typeof value == "string")
     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([]);
+      return BigInt(value);
+    } catch {
+      return 0n;
+    }
+  return 0n;
+}
+function getParsedTokenAccountInfo(data) {
+  if (!isRecord(data)) return null;
+  let parsed = data.parsed;
+  if (!isRecord(parsed)) return null;
+  let info = parsed.info;
+  return isRecord(info) ? info : null;
+}
+function parseTokenAccount(account, programId) {
+  let info = getParsedTokenAccountInfo(account.account.data);
+  if (!info) return null;
+  let mint = typeof info.mint == "string" ? info.mint : null, owner = typeof info.owner == "string" ? info.owner : null;
+  if (!mint || !owner) return null;
+  let tokenAmount = isRecord(info.tokenAmount) ? info.tokenAmount : null, amount = parseBigInt(tokenAmount?.amount), decimals = typeof tokenAmount?.decimals == "number" ? tokenAmount.decimals : 0, state = typeof info.state == "string" ? info.state : void 0;
+  return {
+    pubkey: String(account.pubkey),
+    mint,
+    owner,
+    amount,
+    decimals,
+    isFrozen: state === "frozen",
+    programId
+  };
+}
+function useWalletAssets(options = {}) {
+  let {
+    enabled = true,
+    staleTimeMs = 0,
+    cacheTimeMs = 300 * 1e3,
+    // 5 minutes
+    refetchOnMount = "stale",
+    refetchIntervalMs = false,
+    client: clientOverride,
+    select
+  } = options, { address: address$1, connected } = useAccount(), { client: providerClient } = useSolanaClient(), rpcClient = clientOverride ?? providerClient, key = useMemo(() => {
+    if (!enabled || !connected || !address$1 || !rpcClient) return null;
+    let rpcUrl = rpcClient.urlOrMoniker instanceof URL ? rpcClient.urlOrMoniker.toString() : String(rpcClient.urlOrMoniker);
+    return JSON.stringify(["wallet-assets", rpcUrl, address$1]);
+  }, [enabled, connected, address$1, rpcClient]), queryFn = useCallback(
+    async (signal) => {
+      if (!connected || !address$1 || !rpcClient)
+        return { lamports: 0n, tokenAccounts: [] };
+      if (signal.aborted)
+        throw new DOMException("Query aborted", "AbortError");
+      let rpc = rpcClient.rpc, walletAddress = address(address$1), tokenProgramId = address(TOKEN_PROGRAM_ID), token2022ProgramId = address(TOKEN_2022_PROGRAM_ID), [balanceResult, tokenAccountsResult, token2022AccountsResult] = await Promise.all([
+        rpc.getBalance(walletAddress).send(),
+        rpc.getTokenAccountsByOwner(walletAddress, { programId: tokenProgramId }, { encoding: "jsonParsed" }).send(),
+        rpc.getTokenAccountsByOwner(
+          walletAddress,
+          { programId: token2022ProgramId },
+          { encoding: "jsonParsed" }
+        ).send()
+      ]);
+      if (signal.aborted)
+        throw new DOMException("Query aborted", "AbortError");
+      let tokenAccounts = [];
+      for (let account of tokenAccountsResult.value) {
+        let parsed = parseTokenAccount(account, "token");
+        parsed && tokenAccounts.push(parsed);
       }
-      hasDataRef.current = true, setLastUpdated(/* @__PURE__ */ new Date());
-    } catch (err) {
-      hasDataRef.current || (setError(err), console.error("Failed to fetch balance:", err));
-    } finally {
-      setIsLoading(false);
+      for (let account of token2022AccountsResult.value) {
+        let parsed = parseTokenAccount(account, "token-2022");
+        parsed && tokenAccounts.push(parsed);
+      }
+      return {
+        lamports: balanceResult.value,
+        tokenAccounts
+      };
+    },
+    [connected, address$1, rpcClient]
+  ), { data, error, status, updatedAt, isFetching, refetch, abort } = useSharedQuery(
+    key,
+    queryFn,
+    {
+      enabled,
+      staleTimeMs,
+      cacheTimeMs,
+      refetchOnMount,
+      refetchIntervalMs,
+      select
     }
-  }, [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]);
+  ), isLoading = status === "loading" || status === "idle";
+  return useMemo(
+    () => ({
+      data,
+      isLoading,
+      isFetching,
+      error,
+      refetch,
+      abort,
+      updatedAt
+    }),
+    [data, isLoading, isFetching, error, refetch, abort, updatedAt]
+  );
+}
+
+// src/hooks/use-balance.ts
+var LAMPORTS_PER_SOL2 = 1000000000n;
+function formatTokenAccount(account) {
+  let formatted = formatBigIntBalance(account.amount, account.decimals, {
+    maxDecimals: Math.min(account.decimals, 6)
+  });
+  return {
+    mint: account.mint,
+    amount: account.amount,
+    decimals: account.decimals,
+    formatted
+  };
+}
+function selectBalance(assets) {
+  if (!assets)
+    return { lamports: 0n, tokens: [] };
+  let tokens = assets.tokenAccounts.filter((account) => account.amount > 0n).map(formatTokenAccount);
+  return {
+    lamports: assets.lamports,
+    tokens
+  };
+}
+function useBalance(options = {}) {
+  let {
+    enabled = true,
+    autoRefresh = true,
+    refreshInterval = 3e4,
+    staleTimeMs = 0,
+    cacheTimeMs = 300 * 1e3,
+    // 5 minutes
+    refetchOnMount = "stale",
+    client: clientOverride
+  } = options, {
+    data,
+    error,
+    isFetching,
+    updatedAt,
+    refetch: sharedRefetch,
+    abort
+  } = useWalletAssets({
+    enabled,
+    staleTimeMs,
+    cacheTimeMs,
+    refetchOnMount,
+    refetchIntervalMs: autoRefresh ? refreshInterval : false,
+    client: clientOverride,
+    select: selectBalance
+  }), lamports = data?.lamports ?? 0n, tokens = data?.tokens ?? [], solBalance = useMemo(() => Number(lamports) / Number(LAMPORTS_PER_SOL2), [lamports]), formattedSol = useMemo(() => formatLamportsToSolSafe(lamports, { maxDecimals: 4, suffix: true }), [lamports]), visibleError = updatedAt ? null : error, refetch = useCallback(
+    async (opts) => {
+      await sharedRefetch(opts);
+    },
+    [sharedRefetch]
+  );
   return useMemo(
     () => ({
       solBalance,
       lamports,
       formattedSol,
       tokens,
-      isLoading,
-      error,
-      refetch: fetchBalance,
-      lastUpdated
+      isLoading: isFetching,
+      error: visibleError,
+      refetch,
+      abort,
+      lastUpdated: updatedAt ? new Date(updatedAt) : null
     }),
-    [solBalance, lamports, formattedSol, tokens, isLoading, error, fetchBalance, lastUpdated]
+    [solBalance, lamports, formattedSol, tokens, isFetching, visibleError, refetch, abort, updatedAt]
   );
 }
+
+// src/utils/abort.ts
+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)
+  };
+}
+
+// src/hooks/_internal/solana-token-list.ts
+var CLUSTER_CHAIN_IDS = {
+  mainnet: 101,
+  testnet: 102,
+  devnet: 103,
+  localnet: 103,
+  // Use devnet tokens for localnet
+  custom: 101
+  // Default to mainnet for custom clusters
+}, TOKEN_LIST_API_BASE_URL = "https://token-list-api.solana.cloud/v1/mints";
+function getTokenListApiUrl(cluster = "mainnet") {
+  let chainId = CLUSTER_CHAIN_IDS[cluster];
+  return `${TOKEN_LIST_API_BASE_URL}?chainId=${chainId}`;
+}
+var DEFAULT_TIMEOUT_MS = 1e4, TOKEN_LIST_CACHE_MAX_SIZE = 1500, MAX_ADDRESSES_PER_REQUEST = 100, tokenListCache = /* @__PURE__ */ new Map();
+function getCachedTokenListMetadata(mint) {
+  let value = tokenListCache.get(mint);
+  if (value)
+    return tokenListCache.delete(mint), tokenListCache.set(mint, value), value;
+}
+function setCachedTokenListMetadata(mint, value) {
+  if (tokenListCache.has(mint) && tokenListCache.delete(mint), tokenListCache.set(mint, value), tokenListCache.size > TOKEN_LIST_CACHE_MAX_SIZE) {
+    let oldestKey = tokenListCache.keys().next().value;
+    oldestKey && tokenListCache.delete(oldestKey);
+  }
+}
+function createLinkedSignal(externalSignal, timeoutMs) {
+  let controller = new AbortController(), onAbort = () => controller.abort();
+  externalSignal && (externalSignal.aborted ? controller.abort() : externalSignal.addEventListener("abort", onAbort, { once: true }));
+  let { signal: timeoutSignal, cleanup: cleanupTimeout } = createTimeoutSignal(timeoutMs), onTimeoutAbort = () => controller.abort();
+  return timeoutSignal.aborted ? controller.abort() : timeoutSignal.addEventListener("abort", onTimeoutAbort, { once: true }), {
+    signal: controller.signal,
+    cleanup: () => {
+      cleanupTimeout(), externalSignal && externalSignal.removeEventListener("abort", onAbort), timeoutSignal.removeEventListener("abort", onTimeoutAbort);
+    }
+  };
+}
+async function fetchSolanaTokenListMetadata(mints, options = {}) {
+  let results = /* @__PURE__ */ new Map();
+  if (!mints.length) return results;
+  let seen = /* @__PURE__ */ new Set(), uncached = [];
+  for (let mint of mints) {
+    let normalized = mint?.trim();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    let cached = getCachedTokenListMetadata(normalized);
+    cached ? results.set(normalized, cached) : uncached.push(normalized);
+  }
+  if (!uncached.length) return results;
+  let timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS, apiUrl = getTokenListApiUrl(options.cluster);
+  for (let i = 0; i < uncached.length && !options.signal?.aborted; i += MAX_ADDRESSES_PER_REQUEST) {
+    let batch = uncached.slice(i, i + MAX_ADDRESSES_PER_REQUEST), { signal, cleanup } = createLinkedSignal(options.signal, timeoutMs);
+    try {
+      let response = await fetch(apiUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ addresses: batch }),
+        signal
+      });
+      if (!response.ok) {
+        console.warn("[token-list] Solana Token List API error:", response.status, response.statusText);
+        continue;
+      }
+      let data = await response.json();
+      if (!data?.content?.length) continue;
+      for (let item of data.content)
+        item?.address && (results.set(item.address, item), setCachedTokenListMetadata(item.address, item));
+    } catch (error) {
+      console.warn("[token-list] Solana Token List API failed:", error);
+    } finally {
+      cleanup();
+    }
+  }
+  return results;
+}
+
+// src/utils/image.ts
+function transformImageUrl(url, imageProxy) {
+  if (url)
+    return imageProxy ? `${imageProxy}${encodeURIComponent(url)}` : url;
+}
+
+// src/hooks/use-transactions.ts
 function formatDate(timestamp) {
   if (!timestamp)
     return { date: "Unknown", time: "" };
@@ -377,6 +797,45 @@ function formatDate(timestamp) {
   });
   return { date: formattedDate, time: formattedTime };
 }
+var KNOWN_PROGRAMS = {
+  "11111111111111111111111111111111": "System Program",
+  TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA: "Token Program",
+  ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL: "Associated Token",
+  JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4: "Jupiter",
+  whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc: "Orca Whirlpool",
+  "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8": "Raydium AMM",
+  Stake11111111111111111111111111111111111111: "Stake Program",
+  metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s: "Metaplex"
+}, DEFAULT_IGNORED_PROGRAM_IDS = /* @__PURE__ */ new Set([
+  "11111111111111111111111111111111",
+  // System Program
+  "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+  // Token Program
+  "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+  // Associated Token
+]);
+function resolveProgramName(programId, programLabels) {
+  return programLabels?.[programId] ?? KNOWN_PROGRAMS[programId];
+}
+function pickPrimaryProgramId(programIds) {
+  for (let id of programIds)
+    if (!DEFAULT_IGNORED_PROGRAM_IDS.has(id)) return id;
+  return programIds.values().next().value;
+}
+function getParsedInstructionTypes(message) {
+  if (!Array.isArray(message.instructions)) return;
+  let types = [];
+  for (let ix of message.instructions) {
+    if (!ix || typeof ix != "object") continue;
+    let parsed = ix.parsed;
+    if (!parsed || typeof parsed != "object" || !("type" in parsed)) continue;
+    let t = parsed.type;
+    if (typeof t == "string" && (types.push(t), types.length >= 10))
+      break;
+  }
+  let unique = [...new Set(types)];
+  return unique.length ? unique : void 0;
+}
 function isAccountKey(value) {
   return typeof value == "object" && value !== null && "pubkey" in value && typeof value.pubkey == "string";
 }
@@ -401,6 +860,13 @@ function isTransactionWithMeta(value) {
 function isTransactionMessage(value) {
   return typeof value == "object" && value !== null && "accountKeys" in value && Array.isArray(value.accountKeys);
 }
+function coerceMaybeAddressString(value) {
+  if (typeof value == "string") return value;
+  if (value && typeof value == "object") {
+    let str = String(value);
+    if (str && str !== "[object Object]") return str;
+  }
+}
 function getAccountKeys(message) {
   return Array.isArray(message.accountKeys) ? message.accountKeys.map((key) => typeof key == "string" ? key : isAccountKey(key) ? key.pubkey : "").filter(Boolean) : [];
 }
@@ -432,12 +898,12 @@ function parseTokenTransfers(meta, accountKeys, walletAddress) {
     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();
+    let accountKey = accountKeys[balance.accountIndex], owner = coerceMaybeAddressString(balance.owner);
+    return accountKey && accountKey.trim() === walletAddress.trim() || owner && 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();
+    let accountKey = accountKeys[balance.accountIndex], owner = coerceMaybeAddressString(balance.owner);
+    return accountKey && accountKey.trim() === walletAddress.trim() || owner && owner.trim() === walletAddress.trim();
   }), allMints = /* @__PURE__ */ new Set();
   for (let token of ourPreTokens)
     isTokenBalance(token) && allMints.add(token.mint);
@@ -481,6 +947,52 @@ function parseTokenTransfers(meta, accountKeys, walletAddress) {
   }
   return null;
 }
+function parseTokenAccountClosure(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], owner = coerceMaybeAddressString(balance.owner);
+    return accountKey && accountKey.trim() === walletAddress.trim() || owner && owner.trim() === walletAddress.trim();
+  }), ourPostTokens = postTokenBalances.filter((balance) => {
+    if (!isTokenBalance(balance)) return false;
+    let accountKey = accountKeys[balance.accountIndex], owner = coerceMaybeAddressString(balance.owner);
+    return accountKey && accountKey.trim() === walletAddress.trim() || owner && owner.trim() === walletAddress.trim();
+  }), postKeys = /* @__PURE__ */ new Set();
+  for (let token of ourPostTokens)
+    isTokenBalance(token) && postKeys.add(`${token.accountIndex}:${token.mint}`);
+  for (let token of ourPreTokens) {
+    if (!isTokenBalance(token)) continue;
+    let key = `${token.accountIndex}:${token.mint}`;
+    if (!postKeys.has(key))
+      return { tokenMint: token.mint };
+  }
+  return null;
+}
+function parseSwapTokens(meta, accountKeys, walletAddress, solChange) {
+  if (!isTransactionMeta(meta))
+    return {};
+  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], owner = coerceMaybeAddressString(balance.owner);
+    return accountKey && accountKey.trim() === walletAddress.trim() || owner && owner.trim() === walletAddress.trim();
+  }), ourPostTokens = postTokenBalances.filter((balance) => {
+    if (!isTokenBalance(balance)) return false;
+    let accountKey = accountKeys[balance.accountIndex], owner = coerceMaybeAddressString(balance.owner);
+    return accountKey && accountKey.trim() === walletAddress.trim() || owner && 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);
+  let fromToken, toToken;
+  for (let mint of allMints) {
+    let preBal = ourPreTokens.find((b) => isTokenBalance(b) && b.mint === mint), postBal = ourPostTokens.find((b) => isTokenBalance(b) && b.mint === mint), preAmount = isTokenBalance(preBal) && isUiTokenAmount(preBal.uiTokenAmount) ? Number(preBal.uiTokenAmount.amount) : 0, change = (isTokenBalance(postBal) && isUiTokenAmount(postBal.uiTokenAmount) ? Number(postBal.uiTokenAmount.amount) : 0) - preAmount;
+    change < 0 && !fromToken ? fromToken = { mint } : change > 0 && !toToken && (toToken = { mint });
+  }
+  let WRAPPED_SOL_MINT = "So11111111111111111111111111111111111111112";
+  return solChange < -1e-3 && !fromToken ? fromToken = { mint: WRAPPED_SOL_MINT } : solChange > 1e-3 && !toToken && (toToken = { mint: WRAPPED_SOL_MINT }), { fromToken, toToken };
+}
 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);
@@ -489,52 +1001,59 @@ function formatAmount(tokenAmount, tokenDecimals, direction, solChange) {
   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;
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw new DOMException("Query aborted", "AbortError");
 }
-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);
+function clampInt(value, min, max) {
+  return Number.isFinite(value) ? Math.min(max, Math.max(min, Math.floor(value))) : min;
+}
+async function mapWithConcurrency(inputs, worker, options) {
+  let concurrency = clampInt(options.concurrency, 1, 32), results = new Array(inputs.length), nextIndex = 0;
+  async function run() {
+    for (; ; ) {
+      throwIfAborted(options.signal);
+      let index = nextIndex;
+      if (nextIndex += 1, index >= inputs.length) return;
+      results[index] = await worker(inputs[index], index);
     }
-  } catch (error) {
-    console.warn("[useTransactions] Failed to fetch token metadata:", error);
   }
+  let runners = Array.from({ length: Math.min(concurrency, inputs.length) }, () => run());
+  return await Promise.all(runners), results;
+}
+async function fetchTransactionTokenMetadata(mints, options = {}) {
+  let results = /* @__PURE__ */ new Map();
+  if (!mints.length) return results;
+  let tokenList = await fetchSolanaTokenListMetadata(mints, {
+    timeoutMs: 5e3,
+    signal: options.signal,
+    cluster: options.cluster
+  });
+  for (let [mint, meta] of tokenList)
+    results.set(mint, { symbol: meta.symbol, icon: meta.logoURI });
   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(
+  let {
+    enabled = true,
+    limit = 10,
+    autoRefresh = false,
+    refreshInterval = 6e4,
+    fetchDetails = true,
+    detailsConcurrency = 6,
+    staleTimeMs = 0,
+    cacheTimeMs = 300 * 1e3,
+    // 5 minutes
+    refetchOnMount = "stale",
+    client: clientOverride
+  } = options, { address: address$1, connected } = useAccount(), { cluster } = useCluster(), { client: providerClient } = useSolanaClient(), connectorClient = useConnectorClient(), [paginatedTransactions, setPaginatedTransactions] = useState([]), [isPaginationLoading, setIsPaginationLoading] = useState(false), [hasMore, setHasMore] = useState(true), beforeSignatureRef = useRef(void 0), rpcClient = clientOverride ?? providerClient, connectorConfig = connectorClient?.getConfig(), imageProxy = connectorConfig?.imageProxy, programLabels = connectorConfig?.programLabels, 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,
+        error: err ? JSON.stringify(err, (_key, value) => typeof value == "bigint" ? value.toString() : value) : void 0,
         type: "unknown",
         formattedDate: date,
         formattedTime: time,
@@ -549,24 +1068,13 @@ function useTransactions(options = {}) {
         let { message } = transaction;
         if (!isTransactionMessage(message))
           return baseInfo;
-        let accountKeys = getAccountKeys(message), walletIndex = accountKeys.findIndex((key) => key.trim() === walletAddress.trim());
+        let accountKeys = getAccountKeys(message), walletIndex = accountKeys.findIndex((key2) => key2.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 { 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"), tokenTransfer = hasTokenProgram ? parseTokenTransfers(meta, accountKeys, walletAddress) : null, tokenAccountClosure = hasTokenProgram ? parseTokenAccountClosure(meta, accountKeys, walletAddress) : null, inferredSwapTokens = parseSwapTokens(meta, accountKeys, walletAddress, solChange), inferredSwapFromMint = inferredSwapTokens.fromToken?.mint, inferredSwapToMint = inferredSwapTokens.toToken?.mint, hasNonTrivialProgram = [...programIds].some((id) => !DEFAULT_IGNORED_PROGRAM_IDS.has(id)), hasInferredSwap = !!(inferredSwapFromMint && inferredSwapToMint) && inferredSwapFromMint !== inferredSwapToMint && hasNonTrivialProgram && !tokenAccountClosure, programId = pickPrimaryProgramId(programIds), programName = programId ? resolveProgramName(programId, programLabels) : void 0, programIdsArray = [...programIds], instructionTypes = getParsedInstructionTypes(message), instructionCount = Array.isArray(message.instructions) ? message.instructions.length : void 0, type = "unknown", direction, counterparty, tokenMint, tokenAmount, tokenDecimals, swapFromToken, swapToToken;
+        hasJupiter || hasOrca || hasRaydium ? (type = "swap", inferredSwapTokens.fromToken && (swapFromToken = { mint: inferredSwapTokens.fromToken.mint }), inferredSwapTokens.toToken && (swapToToken = { mint: inferredSwapTokens.toToken.mint })) : hasStake ? type = "stake" : hasMetaplex ? type = "nft" : hasInferredSwap ? (type = "swap", swapFromToken = { mint: inferredSwapFromMint }, swapToToken = { mint: inferredSwapToMint }) : tokenTransfer ? (type = tokenTransfer.type, direction = tokenTransfer.direction, tokenMint = tokenTransfer.tokenMint, tokenAmount = tokenTransfer.tokenAmount, tokenDecimals = tokenTransfer.tokenDecimals) : tokenAccountClosure ? (type = "tokenAccountClosed", tokenMint = tokenAccountClosure.tokenMint, direction = solChange > 0 ? "in" : void 0) : hasSystemProgram && Math.abs(balanceChange) > 0 ? (type = balanceChange > 0 ? "received" : "sent", direction = balanceChange > 0 ? "in" : "out", tokenMint = "So11111111111111111111111111111111111111112", accountKeys.length >= 2 && (counterparty = accountKeys.find(
+          (key2, idx) => idx !== walletIndex && key2 !== "11111111111111111111111111111111"
+        ))) : programIds.size > 0 && (type = "program");
         let formattedAmount = formatAmount(tokenAmount, tokenDecimals, direction, solChange);
         return {
           ...baseInfo,
@@ -575,131 +1083,189 @@ function useTransactions(options = {}) {
           amount: tokenAmount ?? Math.abs(solChange),
           formattedAmount,
           tokenMint,
-          counterparty: counterparty ? `${counterparty.slice(0, 4)}...${counterparty.slice(-4)}` : void 0
+          counterparty: counterparty ? `${counterparty.slice(0, 4)}...${counterparty.slice(-4)}` : void 0,
+          swapFromToken,
+          swapToToken,
+          programId,
+          programName,
+          programIds: programIdsArray.length ? programIdsArray : void 0,
+          instructionTypes,
+          instructionCount
         };
       } 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)
+    [programLabels]
+  ), key = useMemo(() => {
+    if (!enabled || !connected || !address$1 || !rpcClient || !cluster) return null;
+    let rpcUrl = rpcClient.urlOrMoniker instanceof URL ? rpcClient.urlOrMoniker.toString() : String(rpcClient.urlOrMoniker);
+    return JSON.stringify(["wallet-transactions", rpcUrl, address$1, cluster.id, limit, fetchDetails]);
+  }, [enabled, connected, address$1, rpcClient, cluster, limit, fetchDetails]);
+  useEffect(() => {
+    beforeSignatureRef.current = void 0, setPaginatedTransactions([]), setIsPaginationLoading(false), setHasMore(true);
+  }, [key]);
+  let fetchAndEnrichTransactions = useCallback(
+    async (beforeSignature, currentCluster, signal) => {
+      if (!rpcClient || !address$1)
+        return { transactions: [], hasMore: false };
+      throwIfAborted(signal);
+      let rpc = rpcClient.rpc, walletAddress = address(address$1), signaturesResult = await rpc.getSignaturesForAddress(walletAddress, {
+        limit,
+        ...beforeSignature ? { before: signature(beforeSignature) } : {}
+      }).send();
+      throwIfAborted(signal);
+      let newTransactions;
+      if (fetchDetails && signaturesResult.length > 0) {
+        let txDetails = await mapWithConcurrency(
+          signaturesResult,
+          async (sig) => rpc.getTransaction(signature(String(sig.signature)), {
+            encoding: "jsonParsed",
+            maxSupportedTransactionVersion: 0
+          }).send().catch(() => null),
+          { concurrency: detailsConcurrency, signal }
+        );
+        throwIfAborted(signal), 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), currentCluster)
+          );
+        });
+      } 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), currentCluster)
+          };
+        });
+      let mintsToFetch = [
+        .../* @__PURE__ */ new Set([
+          ...newTransactions.filter((tx) => tx.tokenMint).map((tx) => tx.tokenMint),
+          ...newTransactions.filter((tx) => tx.swapFromToken?.mint).map((tx) => tx.swapFromToken.mint),
+          ...newTransactions.filter((tx) => tx.swapToToken?.mint).map((tx) => tx.swapToToken.mint)
+        ])
+      ];
+      if (mintsToFetch.length > 0) {
+        throwIfAborted(signal);
+        let tokenMetadata = await fetchTransactionTokenMetadata(mintsToFetch, {
+          signal,
+          cluster: getClusterType(currentCluster)
+        });
+        tokenMetadata.size > 0 && (newTransactions = newTransactions.map((tx) => {
+          let enrichedTx = { ...tx };
+          if (tx.tokenMint && tokenMetadata.has(tx.tokenMint)) {
+            let meta = tokenMetadata.get(tx.tokenMint);
+            enrichedTx = {
+              ...enrichedTx,
+              tokenSymbol: meta.symbol,
+              tokenIcon: transformImageUrl(meta.icon, imageProxy),
+              formattedAmount: tx.formattedAmount ? `${tx.formattedAmount} ${meta.symbol}` : tx.formattedAmount
             };
-          });
-        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
-                };
+          }
+          if (tx.swapFromToken?.mint && tokenMetadata.has(tx.swapFromToken.mint)) {
+            let meta = tokenMetadata.get(tx.swapFromToken.mint);
+            enrichedTx = {
+              ...enrichedTx,
+              swapFromToken: {
+                ...tx.swapFromToken,
+                symbol: meta.symbol,
+                icon: transformImageUrl(meta.icon, imageProxy)
               }
-              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;
+          if (tx.swapToToken?.mint && tokenMetadata.has(tx.swapToToken.mint)) {
+            let meta = tokenMetadata.get(tx.swapToToken.mint);
+            enrichedTx = {
+              ...enrichedTx,
+              swapToToken: {
+                ...tx.swapToToken,
+                symbol: meta.symbol,
+                icon: transformImageUrl(meta.icon, imageProxy)
+              }
+            };
           }
-          setHasMore(newTransactions.length === limit);
-        }
-        setLastUpdated(/* @__PURE__ */ new Date());
+          return enrichedTx;
+        }));
+      }
+      return {
+        transactions: newTransactions,
+        hasMore: newTransactions.length === limit
+      };
+    },
+    [rpcClient, address$1, limit, fetchDetails, detailsConcurrency, parseTransaction, imageProxy]
+  ), queryFn = useCallback(
+    async (signal) => {
+      if (!connected || !address$1 || !rpcClient || !cluster)
+        return [];
+      throwIfAborted(signal);
+      let result = await fetchAndEnrichTransactions(void 0, cluster, signal);
+      return throwIfAborted(signal), result.transactions;
+    },
+    [connected, address$1, rpcClient, cluster, fetchAndEnrichTransactions]
+  ), {
+    data: initialTransactions,
+    error,
+    isFetching: isInitialLoading,
+    updatedAt,
+    refetch: sharedRefetch,
+    abort
+  } = useSharedQuery(key, queryFn, {
+    enabled,
+    staleTimeMs,
+    cacheTimeMs,
+    refetchOnMount,
+    refetchIntervalMs: autoRefresh ? refreshInterval : false
+  });
+  useEffect(() => {
+    initialTransactions && (beforeSignatureRef.current = initialTransactions.length ? initialTransactions[initialTransactions.length - 1].signature : void 0, setHasMore(initialTransactions.length === limit), setPaginatedTransactions((prev) => prev.length ? [] : prev));
+  }, [initialTransactions, limit]);
+  let loadMoreFn = useCallback(async () => {
+    if (!(!hasMore || isPaginationLoading || !cluster)) {
+      setIsPaginationLoading(true);
+      try {
+        let result = await fetchAndEnrichTransactions(beforeSignatureRef.current, cluster);
+        result.transactions.length > 0 && (beforeSignatureRef.current = result.transactions[result.transactions.length - 1].signature, setPaginatedTransactions((prev) => [...prev, ...result.transactions])), setHasMore(result.hasMore);
       } catch (err) {
-        setError(err), console.error("Failed to fetch transactions:", err);
+        console.error("Failed to load more transactions:", err);
       } finally {
-        setIsLoading(false);
+        setIsPaginationLoading(false);
       }
+    }
+  }, [hasMore, isPaginationLoading, cluster, fetchAndEnrichTransactions]), refetch = useCallback(
+    async (opts) => {
+      beforeSignatureRef.current = void 0, setPaginatedTransactions([]), setHasMore(true), await sharedRefetch(opts);
     },
-    [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(
+    [sharedRefetch]
+  ), transactions = useMemo(() => [...initialTransactions ?? [], ...paginatedTransactions], [initialTransactions, paginatedTransactions]), isLoading = isInitialLoading || isPaginationLoading, visibleError = updatedAt ? null : error;
+  return useMemo(
     () => ({
       transactions,
       isLoading,
-      error,
+      error: visibleError,
       hasMore,
       loadMore: loadMoreFn,
       refetch,
-      lastUpdated
+      abort,
+      lastUpdated: updatedAt ? new Date(updatedAt) : null
     }),
-    [transactions, isLoading, error, hasMore, loadMoreFn, refetch, lastUpdated]
+    [transactions, isLoading, visibleError, hasMore, loadMoreFn, refetch, abort, updatedAt]
   );
 }
-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 {
+var 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");
@@ -739,10 +1305,6 @@ var NATIVE_MINT = "So11111111111111111111111111111111111111112", CACHE_MAX_SIZE
   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;
@@ -767,27 +1329,6 @@ function stopCacheCleanup() {
 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;
@@ -823,26 +1364,17 @@ async function fetchCoinGeckoPrices(coingeckoIds, config) {
     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.`
+        `[useTokens] CoinGecko API: Total timeout (${maxTimeout}ms) exceeded after ${attempt} attempts.`
       );
       break;
     }
     let remainingTimeout = maxTimeout - elapsedTime, requestTimeout = Math.min(1e4, remainingTimeout), { signal, cleanup } = createTimeoutSignal(requestTimeout);
     try {
-      let response = await fetch(url, {
-        headers,
-        signal
-      });
+      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.`
-          );
+        if (console.warn(`[useTokens] CoinGecko API rate limited (429). Waiting ${Math.round(delay)}ms.`), Date.now() - startTime + delay >= maxTimeout)
           break;
-        }
         await new Promise((resolve) => setTimeout(resolve, delay)), attempt++;
         continue;
       }
@@ -853,174 +1385,195 @@ async function fetchCoinGeckoPrices(coingeckoIds, config) {
         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) {
+      if (cleanup(), lastError = 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;
+  return attempt > maxRetries && lastError && console.warn(`[useTokens] CoinGecko API: All attempts failed. Last error: ${lastError.message}`), 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);
+async function fetchTokenMetadataHybrid(mints, coingeckoConfig, options) {
+  if (mints.length === 0) return false;
+  let now = Date.now(), mintsNeedingTokenList = [], staleCoingeckoIdToMint = /* @__PURE__ */ new Map();
   for (let mint of mints) {
     let cached = metadataCache.get(mint);
-    cached?.coingeckoId && !coingeckoIdToMint.has(cached.coingeckoId) && coingeckoIdToMint.set(cached.coingeckoId, mint);
+    if (!cached) {
+      mintsNeedingTokenList.push(mint);
+      continue;
+    }
+    if (!cached.coingeckoId) continue;
+    let priceEntry = priceCache.get(cached.coingeckoId);
+    !!(priceEntry && now - priceEntry.timestamp < PRICE_CACHE_TTL) || staleCoingeckoIdToMint.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 = {
+  let didUpdate = false, tokenListMetadata = await fetchSolanaTokenListMetadata(mintsNeedingTokenList, {
+    timeoutMs: 1e4,
+    cluster: options?.cluster
+  });
+  for (let [mint, meta] of tokenListMetadata) {
+    let coingeckoId = meta.extensions?.coingeckoId, usdPrice = (coingeckoId ? priceCache.get(coingeckoId) : void 0)?.price, combined = {
       address: meta.address,
-      name: meta.address === NATIVE_MINT ? "Solana" : meta.name,
+      name: meta.address === NATIVE_SOL_MINT ? "Solana" : meta.name,
       symbol: meta.symbol,
       decimals: meta.decimals,
       logoURI: meta.logoURI,
       coingeckoId,
       usdPrice
-    };
-    results.set(mint, combined), metadataCache.set(mint, combined);
+    }, existing = metadataCache.get(mint);
+    (!existing || existing.name !== combined.name || existing.symbol !== combined.symbol || existing.decimals !== combined.decimals || existing.logoURI !== combined.logoURI || existing.coingeckoId !== combined.coingeckoId || existing.usdPrice !== combined.usdPrice) && (didUpdate = true, metadataCache.set(mint, combined));
   }
+  didUpdate && options?.onUpdate?.();
+  let coingeckoIdToMint = new Map(staleCoingeckoIdToMint);
+  for (let [mint, meta] of tokenListMetadata)
+    meta.extensions?.coingeckoId && coingeckoIdToMint.set(meta.extensions.coingeckoId, mint);
+  if (coingeckoIdToMint.size === 0)
+    return didUpdate;
+  let prices = await fetchCoinGeckoPrices([...coingeckoIdToMint.keys()], coingeckoConfig), didUpdatePrices = false;
   for (let [coingeckoId, mint] of coingeckoIdToMint) {
-    let cached = results.get(mint) ?? metadataCache.get(mint);
+    let cached = metadataCache.get(mint);
     if (cached) {
       let usdPrice = prices.get(coingeckoId);
-      usdPrice !== void 0 && (cached.usdPrice = usdPrice, results.set(mint, cached), metadataCache.set(mint, cached));
+      usdPrice !== void 0 && cached.usdPrice !== usdPrice && (didUpdate = true, didUpdatePrices = true, cached.usdPrice = usdPrice, metadataCache.set(mint, cached));
     }
   }
-  return results;
+  return didUpdatePrices && options?.onUpdate?.(), didUpdate;
 }
 function formatBalance(amount, decimals) {
-  return (Number(amount) / Math.pow(10, decimals)).toLocaleString(void 0, {
-    minimumFractionDigits: 0,
-    maximumFractionDigits: Math.min(decimals, 6)
+  return formatBigIntBalance(amount, decimals, {
+    maxDecimals: 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
-  });
+  return formatBigIntUsd(amount, decimals, usdPrice);
+}
+function selectTokens(assets, address) {
+  return {
+    lamports: assets?.lamports ?? 0n,
+    tokenAccounts: assets?.tokenAccounts ?? [],
+    address
+  };
 }
-function transformImageUrl2(url, imageProxy) {
-  if (!url) return;
-  if (!imageProxy) return url;
-  let encodedUrl = encodeURIComponent(url);
-  return imageProxy.endsWith("/") ? imageProxy + encodedUrl : imageProxy + "/" + encodedUrl;
+function sortByValueDesc(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;
 }
 function useTokens(options = {}) {
   let {
+    enabled = true,
     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]);
+    includeNativeSol = true,
+    staleTimeMs = 0,
+    cacheTimeMs = 300 * 1e3,
+    // 5 minutes
+    refetchOnMount = "stale",
+    client: clientOverride
+  } = options, { address, connected } = useAccount(), { type: clusterType } = useCluster(), connectorConfig = useConnectorClient()?.getConfig(), imageProxy = connectorConfig?.imageProxy, coingeckoConfig = connectorConfig?.coingecko, selectFn = useCallback(
+    (assets) => selectTokens(assets, address ?? ""),
+    [address]
+  ), {
+    data: selection,
+    error,
+    isFetching,
+    updatedAt,
+    refetch: sharedRefetch,
+    abort
+  } = useWalletAssets({
+    enabled,
+    staleTimeMs,
+    cacheTimeMs,
+    refetchOnMount,
+    refetchIntervalMs: autoRefresh ? refreshInterval : false,
+    client: clientOverride,
+    select: selectFn
+  }), lamports = selection?.lamports ?? 0n, tokenAccounts = selection?.tokenAccounts ?? [], walletAddress = selection?.address ?? "", baseTokens = useMemo(() => {
+    let result = [];
+    includeNativeSol && walletAddress && (includeZeroBalance || lamports > 0n) && result.push({
+      mint: NATIVE_SOL_MINT,
+      tokenAccount: walletAddress,
+      amount: lamports,
+      decimals: 9,
+      formatted: formatBalance(lamports, 9),
+      isFrozen: false,
+      owner: walletAddress
+    });
+    for (let account of tokenAccounts)
+      !includeZeroBalance && account.amount === 0n || result.push({
+        mint: account.mint,
+        tokenAccount: account.pubkey,
+        amount: account.amount,
+        decimals: account.decimals,
+        formatted: formatBalance(account.amount, account.decimals),
+        isFrozen: account.isFrozen,
+        owner: account.owner,
+        programId: account.programId
+      });
+    return result;
+  }, [lamports, tokenAccounts, walletAddress, includeNativeSol, includeZeroBalance]), mints = useMemo(() => {
+    let unique = /* @__PURE__ */ new Set();
+    for (let token of baseTokens)
+      unique.add(token.mint);
+    return [...unique].sort();
+  }, [baseTokens]), mintsKey = useMemo(() => mints.join(","), [mints]), [metadataVersion, setMetadataVersion] = useState(0);
   useEffect(() => {
-    fetchTokens();
-  }, [fetchTokens]), useEffect(() => {
-    if (!connected || !autoRefresh) return;
-    let interval = setInterval(fetchTokens, refreshInterval);
-    return () => clearInterval(interval);
-  }, [connected, autoRefresh, refreshInterval, fetchTokens]), useEffect(() => (startCacheCleanup(), () => stopCacheCleanup()), []);
+    if (!fetchMetadata || !mintsKey) return;
+    let isMounted = true;
+    return (async () => {
+      try {
+        let mintList = mintsKey.split(",");
+        await fetchTokenMetadataHybrid(mintList, coingeckoConfig, {
+          onUpdate: () => {
+            isMounted && setMetadataVersion((v) => v + 1);
+          },
+          cluster: clusterType ?? void 0
+        }), isMounted && setMetadataVersion((v) => v + 1);
+      } catch (err) {
+        console.error("[useTokens] Failed to fetch metadata:", err);
+      }
+    })(), () => {
+      isMounted = false;
+    };
+  }, [mintsKey, fetchMetadata, coingeckoConfig, clusterType]);
+  let tokens = useMemo(() => fetchMetadata ? baseTokens.map((token) => {
+    let meta = metadataCache.get(token.mint);
+    if (!meta) return token;
+    let usdPrice = (meta.coingeckoId ? priceCache.get(meta.coingeckoId) : void 0)?.price ?? meta.usdPrice;
+    return {
+      ...token,
+      name: meta.name,
+      symbol: meta.symbol,
+      logo: transformImageUrl(meta.logoURI, imageProxy),
+      usdPrice,
+      formattedUsd: usdPrice ? formatUsd(token.amount, token.decimals, usdPrice) : void 0
+    };
+  }).sort(sortByValueDesc) : baseTokens.slice().sort(sortByValueDesc), [baseTokens, fetchMetadata, imageProxy, metadataVersion]), totalAccounts = tokenAccounts.length + (includeNativeSol ? 1 : 0);
+  useEffect(() => (startCacheCleanup(), () => stopCacheCleanup()), []);
   let wasConnectedRef = useRef(connected);
-  return useEffect(() => {
+  useEffect(() => {
     wasConnectedRef.current && !connected && clearTokenCaches(), wasConnectedRef.current = connected;
-  }, [connected]), useMemo(
+  }, [connected]);
+  let visibleError = updatedAt ? null : error, refetch = useCallback(
+    async (opts) => {
+      await sharedRefetch(opts);
+    },
+    [sharedRefetch]
+  );
+  return useMemo(
     () => ({
       tokens,
-      isLoading,
-      error,
-      refetch: fetchTokens,
-      lastUpdated,
+      isLoading: isFetching,
+      error: visibleError,
+      refetch,
+      abort,
+      lastUpdated: updatedAt ? new Date(updatedAt) : null,
       totalAccounts
     }),
-    [tokens, isLoading, error, fetchTokens, lastUpdated, totalAccounts]
+    [tokens, isFetching, visibleError, refetch, abort, updatedAt, totalAccounts]
   );
 }
 function DisconnectElement({
@@ -1864,6 +2417,8 @@ function BalanceElement({
 BalanceElement.displayName = "BalanceElement";
 function TransactionHistoryElement({
   limit = 5,
+  fetchDetails = true,
+  detailsConcurrency,
   showStatus = true,
   showTime = true,
   className,
@@ -1873,7 +2428,11 @@ function TransactionHistoryElement({
   render,
   renderItem
 }) {
-  let { transactions, isLoading, error, hasMore, loadMore, refetch } = useTransactions({ limit });
+  let { transactions, isLoading, error, hasMore, loadMore, refetch } = useTransactions({
+    limit,
+    fetchDetails,
+    detailsConcurrency
+  });
   if (render)
     return /* @__PURE__ */ jsx(Fragment, { children: render({ transactions, isLoading, error, hasMore, loadMore, refetch }) });
   let statusIcon = (status) => /* @__PURE__ */ jsx(
@@ -2180,6 +2739,6 @@ function TokenListElement({
 }
 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
+export { AccountElement, BalanceElement, ClusterElement, ConnectorProvider, DisconnectElement, TokenListElement, TransactionHistoryElement, UnifiedProvider, WalletListElement, clearSharedQueryCache, invalidateSharedQuery, useAccount, useBalance, useCluster, useConnector, useConnectorClient, useGillSolanaClient, useGillTransactionSigner, useKitTransactionSigner, useSolanaClient, useTokens, useTransactionPreparer, useTransactionSigner, useTransactions, useWalletInfo };
+//# sourceMappingURL=chunk-JK47EFJT.mjs.map
+//# sourceMappingURL=chunk-JK47EFJT.mjs.map