@openfort/react 1.1.3 → 1.2.0

package/build/hooks/openfort/useFunding.js

@@ -0,0 +1,204 @@
+import { SDKConfiguration } from '@openfort/openfort-js';
+import { useMemo, useState, useRef, useEffect, useCallback } from 'react';
+import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { useOpenfortCore } from '../../openfort/useOpenfort.js';
+import { logger } from '../../utils/logger.js';
+import { createFetchFundingClient } from './fundingClient.js';
+
+/** Pay-links aren't exposed by the SDK funding namespace yet (CEX is API-deferred). */
+const sdkPayLinkUnavailable = async () => {
+    throw new Error('Exchange pay-links are not available through the SDK yet');
+};
+const TERMINAL = ['succeeded', 'bounced', 'expired'];
+const POLL_MS = 4000;
+/**
+ * Poll a session until it reaches a terminal state, pushing each update through
+ * `onUpdate`. Shared by `fund` (after a payment method is set) and `track` (the
+ * CEX rail, watching a hosted Coinbase deposit settle). `isCurrent` guards a
+ * stale loop from clobbering newer state after reset/unmount.
+ */
+async function pollUntilTerminal(client, onUpdate, start, isCurrent) {
+    var _a, _b, _c;
+    let current = start;
+    let prev = current.status;
+    while (!TERMINAL.includes(current.status)) {
+        await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+        if (!isCurrent())
+            return current;
+        current = await client.sessions.get(current.id, { clientSecret: current.clientSecret });
+        if (!isCurrent())
+            return current;
+        onUpdate(current);
+        if (current.status !== prev) {
+            logger.log('[funding] status', { sessionId: current.id, prev, status: current.status });
+            prev = current.status;
+        }
+    }
+    if (current.status === 'succeeded') {
+        logger.log('[funding] terminal: delivered', {
+            sessionId: current.id,
+            status: current.status,
+            txHash: (_c = (_b = (_a = current.metadata) === null || _a === void 0 ? void 0 : _a.txHash) !== null && _b !== void 0 ? _b : current.externalId) !== null && _c !== void 0 ? _c : null,
+        });
+    }
+    else {
+        // bounced = source delivered but Relay refunded; expired = nothing arrived in time.
+        logger.warn('[funding] terminal: failed', { sessionId: current.id, status: current.status });
+    }
+    return current;
+}
+/**
+ * React surface over the funding session API.
+ *
+ * @returns Session state plus `fund` (run the deposit flow) and `reset`.
+ */
+function useFunding(options) {
+    var _a, _b, _c;
+    const { uiConfig, publishableKey } = useOpenfort();
+    const { client: coreClient } = useOpenfortCore();
+    // The CEX rail (DepositCex) is served by the Openfort API; everything else uses
+    // the standalone funding service at uiConfig.fundingBaseUrl.
+    const baseUrl = (options === null || options === void 0 ? void 0 : options.useBackendUrl)
+        ? ((_a = SDKConfiguration.getInstance()) === null || _a === void 0 ? void 0 : _a.backendUrl) || 'https://api.openfort.io'
+        : ((_b = uiConfig.fundingBaseUrl) !== null && _b !== void 0 ? _b : '');
+    const injected = options === null || options === void 0 ? void 0 : options.client;
+    // Resolve the client, in order of preference:
+    //   1. an explicitly injected client (tests / custom backends),
+    //   2. the SDK's `openfort.funding` namespace once available,
+    //   3. the fetch adapter over uiConfig.fundingBaseUrl.
+    // The SDK namespace covers sessions; pay-links stay on the backend adapter
+    // until the API exposes them (CEX is deferred), so we compose the two.
+    const client = useMemo(() => {
+        var _a;
+        if (injected)
+            return injected;
+        const sdkFunding = coreClient === null || coreClient === void 0 ? void 0 : coreClient.funding;
+        const fetchClient = baseUrl ? createFetchFundingClient(baseUrl, publishableKey) : null;
+        if (sdkFunding) {
+            return { sessions: sdkFunding.sessions, payLink: (_a = fetchClient === null || fetchClient === void 0 ? void 0 : fetchClient.payLink) !== null && _a !== void 0 ? _a : sdkPayLinkUnavailable };
+        }
+        return fetchClient;
+    }, [injected, coreClient, baseUrl, publishableKey]);
+    const isAvailable = client != null;
+    const [session, setSession] = useState(null);
+    const [error, setError] = useState(null);
+    const [loading, setLoading] = useState(false);
+    // Generation guard: only the latest fund()/reset() updates state, so
+    // re-selecting a source mid-poll can't be clobbered by a stale request.
+    const generation = useRef(0);
+    // Stop any in-flight poll loop on unmount — without this the loop keeps
+    // hitting the network until the session turns terminal (up to its 24h TTL).
+    useEffect(() => {
+        return () => {
+            generation.current += 1;
+            logger.log('[funding] unmounted — poll loop stopped');
+        };
+    }, []);
+    const reset = useCallback(() => {
+        generation.current += 1;
+        logger.log('[funding] reset');
+        setSession(null);
+        setError(null);
+        setLoading(false);
+    }, []);
+    const fund = useCallback(async (target, paymentMethod) => {
+        var _a;
+        generation.current += 1;
+        const gen = generation.current;
+        const isCurrent = () => generation.current === gen;
+        setError(null);
+        setLoading(true);
+        logger.log('[funding] fund() start', {
+            chain: target.chain,
+            currency: target.currency,
+            address: target.address,
+            paymentMethod: paymentMethod.type,
+            sourceChain: paymentMethod.source.chain,
+            amount: paymentMethod.source.amount,
+        });
+        try {
+            if (!client) {
+                throw new Error('Funding is not configured (set uiConfig.fundingBaseUrl)');
+            }
+            const created = await client.sessions.create({ target });
+            logger.log('[funding] session created', { sessionId: created.id, status: created.status });
+            const current = await client.sessions.setPaymentMethod(created.id, {
+                clientSecret: created.clientSecret,
+                paymentMethod,
+            });
+            if (!isCurrent())
+                return current;
+            setSession(current);
+            setLoading(false);
+            logger.log('[funding] payment method set', {
+                sessionId: current.id,
+                status: current.status,
+                receiverAddress: (_a = current.paymentMethod) === null || _a === void 0 ? void 0 : _a.receiverAddress,
+            });
+            // The session status encodes both hops: waiting_payment (awaiting the source
+            // deposit, e.g. the Coinbase withdrawal) → processing (deposit arrived on-chain,
+            // Relay bridging) → succeeded / bounced (Relay refunded) / expired (no deposit).
+            return pollUntilTerminal(client, setSession, current, isCurrent);
+        }
+        catch (e) {
+            const err = e instanceof Error ? e : new Error(String(e));
+            if (isCurrent()) {
+                setError(err);
+                setLoading(false);
+                logger.error('[funding] fund() failed', err);
+            }
+            throw err;
+        }
+    }, [client]);
+    const createSession = useCallback(async (target) => {
+        if (!client)
+            throw new Error('Funding is not configured (set uiConfig.fundingBaseUrl)');
+        const created = await client.sessions.create({ target });
+        logger.log('[funding] session created (cex)', { sessionId: created.id, status: created.status });
+        return created;
+    }, [client]);
+    const track = useCallback(async (toTrack) => {
+        if (!client)
+            throw new Error('Funding is not configured (set uiConfig.fundingBaseUrl)');
+        generation.current += 1;
+        const gen = generation.current;
+        const isCurrent = () => generation.current === gen;
+        setError(null);
+        try {
+            const start = await client.sessions.get(toTrack.id, { clientSecret: toTrack.clientSecret });
+            if (!isCurrent())
+                return start;
+            setSession(start);
+            logger.log('[funding] track() start', { sessionId: start.id, status: start.status });
+            return await pollUntilTerminal(client, setSession, start, isCurrent);
+        }
+        catch (e) {
+            const err = e instanceof Error ? e : new Error(String(e));
+            if (isCurrent()) {
+                setError(err);
+                logger.error('[funding] track() failed', err);
+            }
+            throw err;
+        }
+    }, [client]);
+    const payLink = useCallback(async (params) => {
+        if (!client)
+            throw new Error('Funding is not configured (set uiConfig.fundingBaseUrl)');
+        return client.payLink(params);
+    }, [client]);
+    return {
+        session,
+        status: (_c = session === null || session === void 0 ? void 0 : session.status) !== null && _c !== void 0 ? _c : 'idle',
+        error,
+        loading,
+        isAvailable,
+        fund,
+        createSession,
+        track,
+        payLink,
+        reset,
+    };
+}
+
+export { useFunding };
+//# sourceMappingURL=useFunding.js.map

package/build/hooks/openfort/useFunding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFunding.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/useFundingChains.d.ts

@@ -0,0 +1,49 @@
+/** A source currency available on a chain (sourced live from Relay via the backend). */
+export type FundingCurrency = {
+    symbol: string;
+    /** Contract address, or the zero address for the chain's native asset. */
+    address: string;
+    decimals: number;
+    logo: string | null;
+    /** True for the chain's native currency (ETH, SOL, POL, BNB, …). */
+    native: boolean;
+};
+/** A source chain the funding backend (Relay) can route from. */
+export type FundingChain = {
+    /** CAIP-2 chain id, e.g. "eip155:8453". */
+    id: string;
+    name: string;
+    logo: string | null;
+    /** "evm" | "svm" — used to gate Solana sources and the CEX tab. */
+    vmType: string;
+    currencies: FundingCurrency[];
+};
+type UseFundingChains = {
+    chains: FundingChain[];
+    loading: boolean;
+    error: Error | null;
+};
+/**
+ * The chains/currencies the funding backend supports, fetched from
+ * `GET /v2/funding/chains` (a live passthrough of Relay's `/chains`), then
+ * narrowed to a curated subset. The provider dictionary is dynamic; the client
+ * just selects from it via `uiConfig.funding.{sourceChains,sourceCurrencies}`,
+ * defaulting to {@link DEFAULT_SOURCE_CHAINS} / {@link DEFAULT_SOURCE_CURRENCIES}.
+ *
+ * Reads the base URL from `uiConfig.fundingBaseUrl`, mirroring `useFunding`.
+ * Returns an empty list when funding isn't configured.
+ */
+export declare function useFundingChains(): UseFundingChains;
+/**
+ * Narrow the fetched chains to a selection. `sourceChains` is a CAIP-2 allowlist
+ * (also defines order); `sourceCurrencies` is a symbol allowlist where the
+ * sentinel `'native'` matches each chain's native currency. Chains left with no
+ * currency are dropped, and selected chains the rail doesn't support are skipped.
+ */
+export declare function curateChains(chains: FundingChain[], sourceChains: string[] | undefined, sourceCurrencies: string[] | undefined): FundingChain[];
+/** Nominal source amount (in base units) used only to mint an open, route-bound deposit address.
+ * The open address accepts any amount >= the route minimum afterward, so this is just a quote seed.
+ * Stablecoins use 1 whole unit (~$1, clears mainnet route minimums); native tokens are far pricier
+ * per unit (1 ETH ≈ thousands), so they use 0.01 of a unit to avoid minting/QR-prefilling 1 whole ETH. */
+export declare function nominalUnits(decimals: number, native?: boolean): string;
+export {};

package/build/hooks/openfort/useFundingChains.js

@@ -0,0 +1,102 @@
+import { useState, useEffect } from 'react';
+import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+
+/**
+ * Sensible default source chains — the common funding origins. Override with
+ * `uiConfig.funding.sourceChains`. Intersected with what the rail supports.
+ */
+const DEFAULT_SOURCE_CHAINS = [
+    'eip155:42161', // Arbitrum
+    'eip155:8453', // Base
+    'eip155:56', // BNB Chain
+    'eip155:1', // Ethereum
+    'eip155:10', // Optimism
+    'eip155:137', // Polygon
+    'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp', // Solana
+];
+/**
+ * Default source currencies: the chain's `'native'` currency plus the major
+ * stablecoins. Override with `uiConfig.funding.sourceCurrencies`.
+ */
+const DEFAULT_SOURCE_CURRENCIES = ['native', 'USDC', 'USDT'];
+/**
+ * The chains/currencies the funding backend supports, fetched from
+ * `GET /v2/funding/chains` (a live passthrough of Relay's `/chains`), then
+ * narrowed to a curated subset. The provider dictionary is dynamic; the client
+ * just selects from it via `uiConfig.funding.{sourceChains,sourceCurrencies}`,
+ * defaulting to {@link DEFAULT_SOURCE_CHAINS} / {@link DEFAULT_SOURCE_CURRENCIES}.
+ *
+ * Reads the base URL from `uiConfig.fundingBaseUrl`, mirroring `useFunding`.
+ * Returns an empty list when funding isn't configured.
+ */
+function useFundingChains() {
+    var _a, _b, _c, _d, _e;
+    const { uiConfig } = useOpenfort();
+    const baseUrl = (_a = uiConfig.fundingBaseUrl) !== null && _a !== void 0 ? _a : '';
+    const sourceChains = (_c = (_b = uiConfig.funding) === null || _b === void 0 ? void 0 : _b.sourceChains) !== null && _c !== void 0 ? _c : DEFAULT_SOURCE_CHAINS;
+    const sourceCurrencies = (_e = (_d = uiConfig.funding) === null || _d === void 0 ? void 0 : _d.sourceCurrencies) !== null && _e !== void 0 ? _e : DEFAULT_SOURCE_CURRENCIES;
+    const [state, setState] = useState({ chains: [], loading: Boolean(baseUrl), error: null });
+    useEffect(() => {
+        if (!baseUrl) {
+            setState({ chains: [], loading: false, error: null });
+            return;
+        }
+        let cancelled = false;
+        setState((s) => ({ ...s, loading: true }));
+        fetch(`${baseUrl}/v2/funding/chains`)
+            .then((r) => {
+            if (!r.ok)
+                throw new Error(`Failed to load chains (${r.status})`);
+            return r.json();
+        })
+            .then((d) => {
+            var _a;
+            if (!cancelled)
+                setState({ chains: (_a = d.chains) !== null && _a !== void 0 ? _a : [], loading: false, error: null });
+        })
+            .catch((e) => {
+            if (!cancelled)
+                setState({ chains: [], loading: false, error: e instanceof Error ? e : new Error(String(e)) });
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [baseUrl]);
+    // Narrow the provider dictionary to the selected subset (cheap, O(chains)).
+    return { ...state, chains: curateChains(state.chains, sourceChains, sourceCurrencies) };
+}
+/**
+ * Narrow the fetched chains to a selection. `sourceChains` is a CAIP-2 allowlist
+ * (also defines order); `sourceCurrencies` is a symbol allowlist where the
+ * sentinel `'native'` matches each chain's native currency. Chains left with no
+ * currency are dropped, and selected chains the rail doesn't support are skipped.
+ */
+function curateChains(chains, sourceChains, sourceCurrencies) {
+    let out = chains;
+    if (sourceCurrencies && sourceCurrencies.length > 0) {
+        const allow = new Set(sourceCurrencies.map((s) => s.toLowerCase()));
+        const allowNative = allow.has('native');
+        out = out
+            .map((c) => ({
+            ...c,
+            currencies: c.currencies.filter((cur) => (allowNative && cur.native) || allow.has(cur.symbol.toLowerCase())),
+        }))
+            .filter((c) => c.currencies.length > 0);
+    }
+    if (sourceChains && sourceChains.length > 0) {
+        const byId = new Map(out.map((c) => [c.id, c]));
+        out = sourceChains.map((id) => byId.get(id)).filter((c) => c !== undefined);
+    }
+    return out;
+}
+/** Nominal source amount (in base units) used only to mint an open, route-bound deposit address.
+ * The open address accepts any amount >= the route minimum afterward, so this is just a quote seed.
+ * Stablecoins use 1 whole unit (~$1, clears mainnet route minimums); native tokens are far pricier
+ * per unit (1 ETH ≈ thousands), so they use 0.01 of a unit to avoid minting/QR-prefilling 1 whole ETH. */
+function nominalUnits(decimals, native = false) {
+    const zeros = native ? Math.max(0, decimals - 2) : decimals;
+    return `1${'0'.repeat(zeros)}`;
+}
+
+export { curateChains, nominalUnits, useFundingChains };
+//# sourceMappingURL=useFundingChains.js.map

package/build/hooks/openfort/useFundingChains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFundingChains.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/useBalance.js

@@ -3,7 +3,7 @@ import { useEffect } from 'react';
 import { createPublicClient, http, formatEther } from 'viem';
 import { useOpenfort } from '../components/Openfort/useOpenfort.js';
 import { DEFAULT_TESTNET_CHAIN_ID } from '../core/ConnectionStrategy.js';
-import { useAsyncData } from '../shared/hooks/useAsyncData.js';
+import { invalidateAsyncData, useAsyncData } from '../shared/hooks/useAsyncData.js';
 import { formatSol } from '../solana/hooks/utils.js';
 import { getDefaultEthereumRpcUrl, getDefaultSolanaRpcUrl, getNativeCurrency } from '../utils/rpc.js';
 
@@ -11,6 +11,11 @@ import { getDefaultEthereumRpcUrl, getDefaultSolanaRpcUrl, getNativeCurrency } f
 const BALANCE_INVALIDATE_EVENT = 'openfort:balance-invalidate';
 /** Dispatches balance invalidation so all useBalance instances refetch. Call after mint/send. */
 function invalidateBalance() {
+    // Token/asset balances come from useEthereumWalletAssets → useAsyncData, which
+    // doesn't listen to the event below. Drop their cache too so the next render
+    // (e.g. landing on the asset inventory after a deposit) refetches fresh.
+    invalidateAsyncData('walletAssets');
+    invalidateAsyncData('wallet-assets');
     if (typeof window !== 'undefined') {
         window.dispatchEvent(new CustomEvent(BALANCE_INVALIDATE_EVENT));
     }

package/build/hooks/useBalance.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBalance.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useBalance.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/index.d.ts

@@ -45,7 +45,7 @@ export { default as ChainIcon } from './components/Common/Chain';
 export { OpenfortButton } from './components/ConnectButton';
 export { OpenfortProvider } from './components/Openfort/OpenfortProvider';
 export type { CustomizableRoutes, MultiChainAsset } from './components/Openfort/types';
-export { LinkWalletOnSignUpOption, UIAuthProvider as AuthProvider } from './components/Openfort/types';
+export { FundingMethod, LinkWalletOnSignUpOption, UIAuthProvider as AuthProvider } from './components/Openfort/types';
 export { embeddedWalletId } from './constants/openfort';
 export { OpenfortError, OpenfortReactErrorType, OpenfortReactErrorType as OpenfortErrorType, } from './core/errors';
 export type { ConnectedEmbeddedEthereumWallet, EthereumWalletState, SetActiveEthereumWalletOptions, UseEmbeddedEthereumWalletOptions, } from './ethereum/types';
@@ -58,7 +58,10 @@ export type { StoreCredentialsResult } from './hooks/openfort/auth/useOAuth';
 export { useOAuth } from './hooks/openfort/auth/useOAuth';
 export { usePhoneOtpAuth } from './hooks/openfort/auth/usePhoneOtpAuth';
 export { useSignOut } from './hooks/openfort/auth/useSignOut';
+export type { FundingClient } from './hooks/openfort/fundingClient';
 export { type SignAuthorizationParameters, type SignAuthorizationReturnType, use7702Authorization, } from './hooks/openfort/use7702Authorization';
+export type { FundingSession, FundingTarget, PaymentMethod, PaymentMethodInput, UseFunding, UseFundingOptions, } from './hooks/openfort/useFunding';
+export { useFunding } from './hooks/openfort/useFunding';
 export { useGrantPermissions } from './hooks/openfort/useGrantPermissions';
 export { useRevokePermissions } from './hooks/openfort/useRevokePermissions';
 export { useUI } from './hooks/openfort/useUI';

package/build/index.js

@@ -3,7 +3,7 @@ export { default as Avatar } from './components/Common/Avatar/index.js';
 export { default as ChainIcon } from './components/Common/Chain/index.js';
 export { OpenfortButton } from './components/ConnectButton/index.js';
 export { OpenfortProvider } from './components/Openfort/OpenfortProvider.js';
-export { UIAuthProvider as AuthProvider, LinkWalletOnSignUpOption } from './components/Openfort/types.js';
+export { UIAuthProvider as AuthProvider, FundingMethod, LinkWalletOnSignUpOption } from './components/Openfort/types.js';
 export { embeddedWalletId } from './constants/openfort.js';
 export { OpenfortError, OpenfortReactErrorType as OpenfortErrorType, OpenfortReactErrorType } from './types.js';
 export { useAuthCallback } from './hooks/openfort/auth/useAuthCallback.js';
@@ -14,6 +14,7 @@ export { useOAuth } from './hooks/openfort/auth/useOAuth.js';
 export { usePhoneOtpAuth } from './hooks/openfort/auth/usePhoneOtpAuth.js';
 export { useSignOut } from './hooks/openfort/auth/useSignOut.js';
 export { use7702Authorization } from './hooks/openfort/use7702Authorization.js';
+export { useFunding } from './hooks/openfort/useFunding.js';
 export { useGrantPermissions } from './hooks/openfort/useGrantPermissions.js';
 export { useRevokePermissions } from './hooks/openfort/useRevokePermissions.js';
 export { useUI } from './hooks/openfort/useUI.js';

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/shared/hooks/useAsyncData.d.ts

@@ -5,9 +5,20 @@ type UseAsyncDataOptions<T> = {
     refetchInterval?: number;
     staleTime?: number;
 };
+/**
+ * Drop cached entries so the next mount (or refetch) hits the network instead of
+ * painting stale data. Pass a substring matched against the serialized queryKey
+ * to target specific queries (e.g. `'walletAssets'`), or omit to clear everything.
+ * Used by balance-changing flows (deposit/mint/send) to force fresh balances.
+ */
+export declare function invalidateAsyncData(keyMatch?: string): void;
 /**
  * Simple fetch-with-cache hook. Replaces useQuery for internal SDK use.
  * No external dependency on TanStack Query.
+ *
+ * Stale-while-revalidate: a cached (non-empty) result for the same `queryKey` is
+ * painted synchronously on (re)mount — so navigating away and back is instant —
+ * then refreshed in the background (skipped while younger than `staleTime`).
  */
 export declare function useAsyncData<T>({ queryFn, queryKey, enabled, refetchInterval, staleTime, }: UseAsyncDataOptions<T>): {
     data: T | undefined;

package/build/shared/hooks/useAsyncData.js

@@ -1,29 +1,66 @@
 import { useState, useRef, useCallback, useEffect } from 'react';
 
+/** Module-level cache shared across hook instances, so revisiting a view paints instantly. */
+const dataCache = new Map();
+/**
+ * Drop cached entries so the next mount (or refetch) hits the network instead of
+ * painting stale data. Pass a substring matched against the serialized queryKey
+ * to target specific queries (e.g. `'walletAssets'`), or omit to clear everything.
+ * Used by balance-changing flows (deposit/mint/send) to force fresh balances.
+ */
+function invalidateAsyncData(keyMatch) {
+    if (!keyMatch) {
+        dataCache.clear();
+        return;
+    }
+    for (const key of Array.from(dataCache.keys())) {
+        if (key.includes(keyMatch))
+            dataCache.delete(key);
+    }
+}
+/**
+ * Empty/absent results are NOT cached — only meaningful data is. This prevents a
+ * transient empty response (e.g. a cold/erroring asset call) from being pinned
+ * and shown as "no balance" on later mounts.
+ */
+function isEmptyResult(result) {
+    if (result == null)
+        return true;
+    if (Array.isArray(result))
+        return result.length === 0;
+    return false;
+}
 /**
  * Simple fetch-with-cache hook. Replaces useQuery for internal SDK use.
  * No external dependency on TanStack Query.
+ *
+ * Stale-while-revalidate: a cached (non-empty) result for the same `queryKey` is
+ * painted synchronously on (re)mount — so navigating away and back is instant —
+ * then refreshed in the background (skipped while younger than `staleTime`).
  */
 function useAsyncData({ queryFn, queryKey, enabled = true, refetchInterval, staleTime = 0, }) {
-    const [data, setData] = useState(undefined);
+    // Serialize queryKey to a stable string so the effect only re-runs when values change,
+    // not when array/object references change.
+    const queryKeyStr = JSON.stringify(queryKey);
+    const [data, setData] = useState(() => { var _a; return (_a = dataCache.get(queryKeyStr)) === null || _a === void 0 ? void 0 : _a.data; });
     const [error, setError] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
     const lastFetchRef = useRef(0);
     const intervalRef = useRef(null);
     const queryFnRef = useRef(queryFn);
     queryFnRef.current = queryFn;
-    // Serialize queryKey to a stable string so the effect only re-runs when values change,
-    // not when array/object references change.
-    const queryKeyStr = JSON.stringify(queryKey);
-    const fetchData = useCallback(async () => {
+    const fetchData = useCallback(async (showLoading = true) => {
         if (!enabled)
             return undefined;
-        setIsLoading(true);
+        if (showLoading)
+            setIsLoading(true);
         setError(null);
         try {
             const result = await queryFnRef.current();
-            setData(result);
+            if (!isEmptyResult(result))
+                dataCache.set(queryKeyStr, { data: result, timestamp: Date.now() });
             lastFetchRef.current = Date.now();
+            setData(result);
             return result;
         }
         catch (err) {
@@ -34,12 +71,22 @@ function useAsyncData({ queryFn, queryKey, enabled = true, refetchInterval, stal
         finally {
             setIsLoading(false);
         }
-    }, [enabled]);
+    }, [enabled, queryKeyStr]);
     useEffect(() => {
         if (!enabled)
             return;
-        fetchData().catch(() => { });
-    }, [enabled, queryKeyStr]);
+        const cached = dataCache.get(queryKeyStr);
+        if (cached) {
+            // Paint cached data immediately; revalidate in the background unless still fresh.
+            setData(cached.data);
+            const fresh = staleTime > 0 && Date.now() - cached.timestamp < staleTime;
+            if (!fresh)
+                fetchData(false).catch(() => { });
+        }
+        else {
+            fetchData(true).catch(() => { });
+        }
+    }, [enabled, queryKeyStr, staleTime, fetchData]);
     useEffect(() => {
         if (!enabled || !refetchInterval || refetchInterval <= 0)
             return;
@@ -47,7 +94,7 @@ function useAsyncData({ queryFn, queryKey, enabled = true, refetchInterval, stal
             const elapsed = Date.now() - lastFetchRef.current;
             if (staleTime > 0 && elapsed < staleTime)
                 return;
-            fetchData().catch(() => { });
+            fetchData(false).catch(() => { });
         }, refetchInterval);
         return () => {
             if (intervalRef.current) {
@@ -61,9 +108,9 @@ function useAsyncData({ queryFn, queryKey, enabled = true, refetchInterval, stal
         error,
         isLoading,
         isPending: isLoading,
-        refetch: fetchData,
+        refetch: useCallback(() => fetchData(true), [fetchData]),
     };
 }
 
-export { useAsyncData };
+export { invalidateAsyncData, useAsyncData };
 //# sourceMappingURL=useAsyncData.js.map

package/build/shared/hooks/useAsyncData.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAsyncData.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useAsyncData.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/solana/hooks/useSolanaWalletAssets.d.ts

@@ -0,0 +1,24 @@
+/** A holding in the connected Solana wallet: native SOL or an SPL token. */
+type SolanaAsset = {
+    /** Mint address, or 'native' for SOL. */
+    mint: string;
+    symbol: string;
+    name: string;
+    /** Raw balance in base units (lamports for SOL, token base units otherwise). */
+    amount: bigint;
+    decimals: number;
+    isNative: boolean;
+};
+/**
+ * Returns the connected Solana wallet's balances: native SOL plus SPL token
+ * holdings, read directly from the cluster RPC. The SVM counterpart of
+ * {@link useEthereumWalletAssets}, feeding the Solana asset inventory. Refreshes
+ * on BALANCE_INVALIDATE_EVENT (e.g. after a deposit/send).
+ */
+export declare function useSolanaWalletAssets(): {
+    data: SolanaAsset[] | null;
+    isLoading: boolean;
+    isError: boolean;
+    refetch: () => Promise<unknown>;
+};
+export {};