@openfort/react 1.1.4 → 1.3.0

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

@@ -0,0 +1,34 @@
+import type { FundingSession, FundingTarget, PayLinkParams, PaymentMethodInput } from './useFunding';
+/**
+ * The funding client surface, mirroring the planned `openfort.funding.*`
+ * namespace in `@openfort/openfort-js`:
+ *
+ *   openfort.funding.sessions.create({ target })
+ *   openfort.funding.sessions.setPaymentMethod(id, { clientSecret, paymentMethod })
+ *   openfort.funding.sessions.get(id, { clientSecret? })
+ *   openfort.funding.payLink(params)
+ *
+ * `useFunding` depends only on this interface. Today it's backed by the
+ * fetch adapter below (the standalone funding service); once the SDK ships the
+ * namespace, the adapter is swapped for `coreClient.funding` with no hook change.
+ */
+export type FundingClient = {
+    sessions: {
+        create(params: {
+            target: FundingTarget;
+        }): Promise<FundingSession>;
+        setPaymentMethod(id: string, params: {
+            clientSecret: string;
+            paymentMethod: PaymentMethodInput;
+        }): Promise<FundingSession>;
+        get(id: string, params?: {
+            clientSecret?: string;
+        }): Promise<FundingSession>;
+    };
+    payLink(params: PayLinkParams): Promise<string>;
+};
+/**
+ * Fetch-backed funding client against the standalone funding service at
+ * `baseUrl`. Temporary: replaced by the SDK's `funding` namespace at cutover.
+ */
+export declare function createFetchFundingClient(baseUrl: string, publishableKey?: string): FundingClient;

package/build/hooks/openfort/fundingClient.js

@@ -0,0 +1,60 @@
+import { logger } from '../../utils/logger.js';
+
+async function readJson(res) {
+    var _a;
+    if (!res.ok) {
+        // The API returns { error: { type, message } }; the standalone prototype
+        // returned a flat { error: string }. Handle both so the real rail message
+        // surfaces instead of "[object Object]".
+        const body = (await res.json().catch(() => ({})));
+        const message = typeof body.error === 'string' ? body.error : (_a = body.error) === null || _a === void 0 ? void 0 : _a.message;
+        logger.error('[funding:client] request failed', { status: res.status, message });
+        throw new Error(message !== null && message !== void 0 ? message : `Funding request failed (${res.status})`);
+    }
+    return res.json();
+}
+/**
+ * Fetch-backed funding client against the standalone funding service at
+ * `baseUrl`. Temporary: replaced by the SDK's `funding` namespace at cutover.
+ */
+function createFetchFundingClient(baseUrl, publishableKey) {
+    // The /v2/funding session API is publishable-key authenticated. The standalone
+    // prototype accepted no auth, so the key is optional and only attached when set.
+    const authHeaders = () => publishableKey ? { authorization: `Bearer ${publishableKey}` } : {};
+    return {
+        sessions: {
+            async create({ target }) {
+                const res = await fetch(`${baseUrl}/v2/funding/sessions`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json', ...authHeaders() },
+                    body: JSON.stringify({ target }),
+                });
+                return readJson(res);
+            },
+            async setPaymentMethod(id, { clientSecret, paymentMethod }) {
+                const res = await fetch(`${baseUrl}/v2/funding/sessions/${encodeURIComponent(id)}/payment_methods`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json', ...authHeaders() },
+                    body: JSON.stringify({ clientSecret, paymentMethod }),
+                });
+                return readJson(res);
+            },
+            async get(id, params) {
+                const query = (params === null || params === void 0 ? void 0 : params.clientSecret) ? `?clientSecret=${encodeURIComponent(params.clientSecret)}` : '';
+                return readJson(await fetch(`${baseUrl}/v2/funding/sessions/${encodeURIComponent(id)}${query}`, { headers: authHeaders() }));
+            },
+        },
+        async payLink(params) {
+            const res = await fetch(`${baseUrl}/v2/funding/pay_link`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', ...authHeaders() },
+                body: JSON.stringify(params),
+            });
+            const data = await readJson(res);
+            return data.url;
+        },
+    };
+}
+
+export { createFetchFundingClient };
+//# sourceMappingURL=fundingClient.js.map

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

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

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

@@ -0,0 +1,159 @@
+import { type FundingClient } from './fundingClient';
+/**
+ * Funding session client — adapted from the openfort-funding prototype.
+ *
+ * A session is one deposit attempt against a destination. The client creates a
+ * session, sets one payment method (a source the user commits to sending from),
+ * then polls until the session reaches a terminal state. The response carries
+ * everything the UI (or an agent) needs: a receiver address, a scannable URI,
+ * prefilled wallet deeplinks, and CEX guidance.
+ *
+ * The hook depends on a {@link FundingClient}, not on `fetch` directly. Today the
+ * default client is the fetch adapter over `uiConfig.fundingBaseUrl`; once
+ * `@openfort/openfort-js` ships the `funding` namespace, the resolution below
+ * swaps to `coreClient.funding` with no change to this hook.
+ */
+/** Where funds should land. CAIP-2 chain + token contract (or native) + wallet. */
+export type FundingTarget = {
+    /** CAIP-2 chain id, e.g. "eip155:8453" for Base. */
+    chain: string;
+    /** Token contract address, or the zero address for the chain's native asset. */
+    currency: string;
+    /** Destination wallet that receives the bridged funds. */
+    address: string;
+};
+/** The route the user commits to sending from. */
+export type FundingSource = {
+    /** CAIP-2 chain id the user sends from, e.g. "eip155:137". */
+    chain: string;
+    /** Token contract the user sends, or the zero address for native. */
+    currency: string;
+    /** Amount in the source token's smallest unit (wei, lamports, base units). */
+    amount: string;
+};
+/** Session lifecycle, mirroring the prototype's vocabulary. */
+export type SessionStatus = 'requires_payment_method' | 'waiting_payment' | 'processing' | 'succeeded' | 'bounced' | 'expired';
+export type FundingFee = {
+    kind: 'gas' | 'relayerGas' | 'relayerService' | 'app';
+    amount: string;
+    currency: string;
+};
+/**
+ * Payment-method-per-source input. `evm` and `solana` are self-custody wallet
+ * sends (they get wallet deeplinks); `cex` is an exchange withdrawal (no
+ * deeplink — exchanges can't be deeplinked into).
+ */
+export type PaymentMethodInput = {
+    type: 'evm';
+    source: FundingSource;
+} | {
+    type: 'solana';
+    source: FundingSource;
+} | {
+    type: 'cex';
+    cex: string;
+    source: FundingSource;
+};
+export type PaymentMethodType = PaymentMethodInput['type'];
+/** A prefilled deeplink into a source wallet app (e.g. Trust Wallet). */
+export type WalletDeeplink = {
+    app: string;
+    label: string;
+    url: string;
+};
+/** Per-exchange guidance for the guided CEX flow. */
+export type CexGuidance = {
+    exchange: string;
+    network: string;
+    minWithdrawal: string | null;
+    requiresMemo: boolean;
+};
+/** A resolved payment method — what the UI renders and the agent reads. */
+export type PaymentMethod = {
+    type: PaymentMethodType;
+    source: FundingSource;
+    /** Address the user (or their CEX/wallet) sends to. */
+    receiverAddress: string;
+    /** Provider-side id used to track settlement. */
+    providerRequestId: string;
+    /** BIP-21 / EIP-681 URI for QR. Scanner support for amount/token varies. */
+    addressUri: string;
+    /** Prefilled deeplinks for source wallet apps, when available. */
+    deeplinks: WalletDeeplink[];
+    /** Guidance for the "cex" type; null otherwise. */
+    cex: CexGuidance | null;
+    fees: FundingFee[];
+    /** Minimum to send for this route (source base units), or null. */
+    minAmount: string | null;
+};
+/** A single deposit attempt. */
+export type FundingSession = {
+    id: string;
+    clientSecret: string;
+    target: FundingTarget;
+    status: SessionStatus;
+    amountUnits: string | null;
+    metadata: Record<string, string> | null;
+    externalId: string | null;
+    createdAt: number;
+    expiresAt: number;
+    paymentMethod: PaymentMethod | null;
+};
+export type UseFunding = {
+    session: FundingSession | null;
+    status: SessionStatus | 'idle';
+    error: Error | null;
+    /** True while a session is being created and its deposit address fetched. */
+    loading: boolean;
+    /** True when a funding client is resolved (injected, or uiConfig.fundingBaseUrl set). */
+    isAvailable: boolean;
+    /** Create a session, set a payment method, and poll until terminal. */
+    fund: (target: FundingTarget, paymentMethod: PaymentMethodInput) => Promise<FundingSession>;
+    /** Create a bare session for a target (no payment method, no polling). Used by
+     * the Coinbase CEX rail, which only needs the session id + secret to mint a
+     * pay-link; the destination is bound to the session so the client can't redirect funds. */
+    createSession: (target: FundingTarget) => Promise<FundingSession>;
+    /** Poll an already-created session (id + clientSecret) until it reaches a
+     * terminal state, surfacing `status`/`session` updates as it goes. Used by the
+     * CEX rail, which hands off to a hosted Coinbase flow and then watches the
+     * bound session settle to drive the success/failed screen. */
+    track: (session: {
+        id: string;
+        clientSecret: string;
+    }) => Promise<FundingSession>;
+    /** Resolve a hosted Coinbase pay URL for an existing session. Coinbase delivers
+     * to the session's bound destination, so only the amount (and optional asset) is client-supplied. */
+    payLink: (params: PayLinkParams) => Promise<string>;
+    /** Reset to the idle state (e.g. when leaving the Deposit flow). */
+    reset: () => void;
+};
+/** Parameters for a Coinbase pay-link request. The destination (chain, currency,
+ * address) is bound to the session server-side; the client only chooses how much. */
+export type PayLinkParams = {
+    /** Session the pay-link settles into — pins the destination so it can't be redirected. */
+    sessionId: string;
+    /** Secret returned when the session was created; authorizes this pay-link. */
+    clientSecret: string;
+    /** Amount in the destination asset's units (≈ USD for USDC). Coinbase enforces its own minimum. */
+    amount: string;
+    /** Destination asset ticker. Optional — the backend defaults to USDC. */
+    asset?: string;
+};
+/** Options for {@link useFunding}. */
+export type UseFundingOptions = {
+    /** Inject a funding client (tests, or a custom backend). Defaults to the
+     * fetch adapter over `uiConfig.fundingBaseUrl`. */
+    client?: FundingClient;
+    /**
+     * Resolve the base URL from the Openfort API backend (`SDKConfiguration.backendUrl`)
+     * instead of `uiConfig.fundingBaseUrl`. The CEX (Coinbase pay-link) rail is served
+     * by the API, not the standalone funding service — `DepositCex` opts in.
+     */
+    useBackendUrl?: boolean;
+};
+/**
+ * React surface over the funding session API.
+ *
+ * @returns Session state plus `fund` (run the deposit flow) and `reset`.
+ */
+export declare function useFunding(options?: UseFundingOptions): UseFunding;

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;
+    const { uiConfig, publishableKey } = useOpenfort();
+    const { client: coreClient } = useOpenfortCore();
+    // The funding JSON API defaults to the Openfort backend (api.openfort.io);
+    // integrators can point the crypto rails at a custom service via
+    // uiConfig.fundingBaseUrl. The CEX rail always uses the backend (Coinbase pay-link).
+    const backendUrl = ((_a = SDKConfiguration.getInstance()) === null || _a === void 0 ? void 0 : _a.backendUrl) || 'https://api.openfort.io';
+    const baseUrl = (options === null || options === void 0 ? void 0 : options.useBackendUrl) ? backendUrl : uiConfig.fundingBaseUrl || backendUrl;
+    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: (_b = session === null || session === void 0 ? void 0 : session.status) !== null && _b !== void 0 ? _b : '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,100 @@
+import { SDKConfiguration } from '@openfort/openfort-js';
+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();
+    // Defaults to the SDK backend (api.openfort.io); override for a custom funding service.
+    const baseUrl = uiConfig.fundingBaseUrl || ((_a = SDKConfiguration.getInstance()) === null || _a === void 0 ? void 0 : _a.backendUrl) || 'https://api.openfort.io';
+    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: true, error: null });
+    useEffect(() => {
+        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';