@openfort/react 1.1.4 → 1.2.0

package/build/ethereum/hooks/useEthereumWalletAssets.js

@@ -1,11 +1,12 @@
 import { useCallback, useMemo } from 'react';
-import { numberToHex, custom, createWalletClient, formatUnits } from 'viem';
+import { numberToHex, custom, createWalletClient, formatUnits, createPublicClient, http, erc20Abi } from 'viem';
 import { erc7811Actions } from 'viem/experimental';
 import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
 import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
 import { useUser } from '../../hooks/openfort/useUser.js';
 import { openfortKeys } from '../../query/queryKeys.js';
 import { useAsyncData } from '../../shared/hooks/useAsyncData.js';
+import { getDefaultEthereumRpcUrl } from '../../utils/rpc.js';
 import { useEthereumEmbeddedWallet } from './useEthereumEmbeddedWallet.js';
 
 function getUsdValue(asset) {
@@ -17,6 +18,84 @@ function getUsdValue(asset) {
     const amount = Number.parseFloat(formatUnits(asset.balance, decimals));
     return Number.isFinite(amount) ? amount * fiat.value : 0;
 }
+/** Stablecoins approximated at $1 in fallback mode (no price feed available). */
+const STABLECOIN_SYMBOLS = new Set(['USDC', 'USDT', 'DAI']);
+/**
+ * Canonical Multicall3 address — same on every major chain. Passed explicitly so
+ * multicall works even when the SDK's chain config doesn't declare a multicall3.
+ */
+const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+/**
+ * Reads native + configured ERC-20 balances directly from the chain RPC.
+ *
+ * Fallback for when Openfort's ERC-7811 asset proxy is unavailable: the widget
+ * still shows on-chain balances (no fiat valuation — that comes from the proxy,
+ * except stablecoins which are approximated at $1). Tokens that don't exist on
+ * the chain are skipped.
+ */
+async function readEvmAssetsViaRpc(args) {
+    const { address, chain, rpcUrl, tokens } = args;
+    const client = createPublicClient({ chain, transport: http(rpcUrl) });
+    const out = [];
+    // Native balance — one call. Skipped silently if it fails (best-effort).
+    try {
+        const native = await client.getBalance({ address });
+        out.push({
+            type: 'native',
+            address: 'native',
+            balance: native,
+            metadata: {
+                symbol: chain.nativeCurrency.symbol,
+                decimals: chain.nativeCurrency.decimals,
+                fiat: { value: 0, currency: 'USD' },
+            },
+        });
+    }
+    catch {
+        // native read failed for this chain — skip it
+    }
+    if (tokens.length === 0)
+        return out;
+    // Batch every token's balanceOf/decimals/symbol/name into ONE multicall request
+    // (via Multicall3) instead of 4 calls per token — keeps us well under public-RPC
+    // rate limits (429s) that previously broke the fallback.
+    const contracts = tokens.flatMap((token) => [
+        { address: token, abi: erc20Abi, functionName: 'balanceOf', args: [address] },
+        { address: token, abi: erc20Abi, functionName: 'decimals' },
+        { address: token, abi: erc20Abi, functionName: 'symbol' },
+        { address: token, abi: erc20Abi, functionName: 'name' },
+    ]);
+    try {
+        const results = await client.multicall({ contracts, allowFailure: true, multicallAddress: MULTICALL3_ADDRESS });
+        tokens.forEach((token, i) => {
+            const balance = results[i * 4];
+            const decimals = results[i * 4 + 1];
+            const symbol = results[i * 4 + 2];
+            const name = results[i * 4 + 3];
+            if ((balance === null || balance === void 0 ? void 0 : balance.status) !== 'success' || (decimals === null || decimals === void 0 ? void 0 : decimals.status) !== 'success' || (symbol === null || symbol === void 0 ? void 0 : symbol.status) !== 'success')
+                return;
+            const sym = symbol.result;
+            out.push({
+                type: 'erc20',
+                address: token,
+                balance: balance.result,
+                metadata: {
+                    name: ((name === null || name === void 0 ? void 0 : name.status) === 'success' ? name.result : sym),
+                    symbol: sym,
+                    decimals: decimals.result,
+                    // No price feed in fallback mode; approximate stablecoins at $1 so the
+                    // USD total isn't blank. Other tokens show their amount without a value.
+                    fiat: STABLECOIN_SYMBOLS.has(sym.toUpperCase()) ? { value: 1, currency: 'USD' } : undefined,
+                },
+            });
+        });
+    }
+    catch {
+        // Multicall request itself failed (RPC throttled, or no Multicall3 on the chain).
+        // Return whatever we have (native) rather than throwing away the whole fetch.
+    }
+    return out;
+}
 /**
  * Returns wallet assets (tokens, NFTs) for the connected Ethereum address.
  * Uses ERC-7811 via Openfort's authenticated RPC proxy.
@@ -116,7 +195,7 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
             ? ['wallet-assets', 'multi', address, customAssetsMultiChain]
             : [...openfortKeys.walletAssets(chainId, customAssetsToFetch, address)],
         queryFn: async () => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
             if (multiChain) {
                 if (!address) {
                     throw new OpenfortError('No wallet address available', OpenfortReactErrorType.UNEXPECTED_ERROR);
@@ -146,7 +225,19 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                     : null;
                 const responses = await Promise.all([defaultRequest, customRequest].filter(Boolean));
                 const [defaultData, customData] = await Promise.all(responses.map((r) => r.json()));
-                const result = { ...((_a = defaultData.result) !== null && _a !== void 0 ? _a : {}) };
+                if (defaultData === null || defaultData === void 0 ? void 0 : defaultData.error) {
+                    // ERC-7811 asset proxy failed — fall back to per-chain RPC reads.
+                    const out = [];
+                    for (const c of chains) {
+                        const tokens = ((_c = (_b = (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.assets) === null || _b === void 0 ? void 0 : _b[c.id]) !== null && _c !== void 0 ? _c : []);
+                        const rpcUrl = (_f = (_e = (_d = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _d === void 0 ? void 0 : _d.rpcUrls) === null || _e === void 0 ? void 0 : _e[c.id]) !== null && _f !== void 0 ? _f : getDefaultEthereumRpcUrl(c.id);
+                        const rpcAssets = await readEvmAssetsViaRpc({ address: address, chain: c, rpcUrl, tokens });
+                        for (const a of rpcAssets)
+                            out.push({ ...a, chainId: c.id });
+                    }
+                    return out;
+                }
+                const result = { ...((_g = defaultData.result) !== null && _g !== void 0 ? _g : {}) };
                 if ((customData === null || customData === void 0 ? void 0 : customData.result) && typeof customData.result === 'object') {
                     for (const [chainKey, assets] of Object.entries(customData.result)) {
                         if (!Array.isArray(assets))
@@ -157,7 +248,7 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                         else {
                             const existing = new Map(result[chainKey].map((a) => { var _a; return [(_a = a.address) !== null && _a !== void 0 ? _a : '', a]; }));
                             for (const asset of assets) {
-                                existing.set((_b = asset.address) !== null && _b !== void 0 ? _b : '', asset);
+                                existing.set((_h = asset.address) !== null && _h !== void 0 ? _h : '', asset);
                             }
                             result[chainKey] = Array.from(existing.values());
                         }
@@ -172,28 +263,28 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                         if (a.type === 'erc20') {
                             const asset = {
                                 type: 'erc20',
-                                address: ((_c = a.address) !== null && _c !== void 0 ? _c : '0x0'),
-                                balance: BigInt((_d = a.balance) !== null && _d !== void 0 ? _d : 0),
+                                address: ((_j = a.address) !== null && _j !== void 0 ? _j : '0x0'),
+                                balance: BigInt((_k = a.balance) !== null && _k !== void 0 ? _k : 0),
                                 metadata: {
-                                    name: ((_e = a.metadata) === null || _e === void 0 ? void 0 : _e.name) || 'Unknown Token',
-                                    symbol: ((_f = a.metadata) === null || _f === void 0 ? void 0 : _f.symbol) || 'UNKNOWN',
-                                    decimals: (_g = a.metadata) === null || _g === void 0 ? void 0 : _g.decimals,
-                                    fiat: (_h = a.metadata) === null || _h === void 0 ? void 0 : _h.fiat,
+                                    name: ((_l = a.metadata) === null || _l === void 0 ? void 0 : _l.name) || 'Unknown Token',
+                                    symbol: ((_m = a.metadata) === null || _m === void 0 ? void 0 : _m.symbol) || 'UNKNOWN',
+                                    decimals: (_o = a.metadata) === null || _o === void 0 ? void 0 : _o.decimals,
+                                    fiat: (_p = a.metadata) === null || _p === void 0 ? void 0 : _p.fiat,
                                 },
                                 raw: a,
                             };
                             allAssets.push({ ...asset, chainId: cid });
                         }
                         else if (a.type === 'native') {
-                            const meta = ((_j = a.metadata) !== null && _j !== void 0 ? _j : {});
+                            const meta = ((_q = a.metadata) !== null && _q !== void 0 ? _q : {});
                             const asset = {
                                 type: 'native',
                                 address: 'native',
-                                balance: BigInt((_k = a.balance) !== null && _k !== void 0 ? _k : 0),
+                                balance: BigInt((_r = a.balance) !== null && _r !== void 0 ? _r : 0),
                                 metadata: {
                                     symbol: meta.symbol || 'ETH',
                                     decimals: meta.decimals,
-                                    fiat: (_l = meta.fiat) !== null && _l !== void 0 ? _l : { value: 0, currency: 'USD' },
+                                    fiat: (_s = meta.fiat) !== null && _s !== void 0 ? _s : { value: 0, currency: 'USD' },
                                 },
                                 raw: a,
                             };
@@ -210,92 +301,118 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                     error: new Error('Address, chainId, or chain not available'),
                 });
             }
-            const customClient = createWalletClient({
-                account: address,
-                chain,
-                transport: customTransport(),
-            });
-            const extendedClient = customClient.extend(erc7811Actions());
-            const defaultAssetsPromise = extendedClient.getAssets({
-                chainIds: [chainId],
-            });
-            const hexChainId = numberToHex(chainId);
-            const customAssetsPromise = customAssetsToFetch.length > 0
-                ? extendedClient.getAssets({
+            try {
+                const customClient = createWalletClient({
+                    account: address,
+                    chain,
+                    transport: customTransport(),
+                });
+                const extendedClient = customClient.extend(erc7811Actions());
+                const defaultAssetsPromise = extendedClient.getAssets({
                     chainIds: [chainId],
-                    assets: {
-                        [hexChainId]: customAssetsToFetch.map((a) => ({
-                            address: a,
+                });
+                const hexChainId = numberToHex(chainId);
+                const customAssetsPromise = customAssetsToFetch.length > 0
+                    ? extendedClient.getAssets({
+                        chainIds: [chainId],
+                        assets: {
+                            [hexChainId]: customAssetsToFetch.map((a) => ({
+                                address: a,
+                                type: 'erc20',
+                            })),
+                        },
+                    })
+                    : Promise.resolve({ [hexChainId]: [] });
+                const [defaultAssetsRaw, customAssets] = await Promise.all([defaultAssetsPromise, customAssetsPromise]);
+                // ERC-7811 response keys may be hex (e.g. "0x14a34") or numeric depending on the RPC
+                const rawByChain = defaultAssetsRaw;
+                const customByChain = customAssets;
+                const rawChainAssets = (_u = (_t = rawByChain[hexChainId]) !== null && _t !== void 0 ? _t : rawByChain[String(chainId)]) !== null && _u !== void 0 ? _u : [];
+                const customChainAssets = (_w = (_v = customByChain[hexChainId]) !== null && _v !== void 0 ? _v : customByChain[String(chainId)]) !== null && _w !== void 0 ? _w : [];
+                const defaultAssets = rawChainAssets.map((a) => {
+                    var _a;
+                    let asset;
+                    if (a.type === 'erc20') {
+                        const meta = a.metadata;
+                        asset = {
                             type: 'erc20',
-                        })),
-                    },
-                })
-                : Promise.resolve({ [hexChainId]: [] });
-            const [defaultAssetsRaw, customAssets] = await Promise.all([defaultAssetsPromise, customAssetsPromise]);
-            // ERC-7811 response keys may be hex (e.g. "0x14a34") or numeric depending on the RPC
-            const rawByChain = defaultAssetsRaw;
-            const customByChain = customAssets;
-            const rawChainAssets = (_o = (_m = rawByChain[hexChainId]) !== null && _m !== void 0 ? _m : rawByChain[String(chainId)]) !== null && _o !== void 0 ? _o : [];
-            const customChainAssets = (_q = (_p = customByChain[hexChainId]) !== null && _p !== void 0 ? _p : customByChain[String(chainId)]) !== null && _q !== void 0 ? _q : [];
-            const defaultAssets = rawChainAssets.map((a) => {
-                var _a;
-                let asset;
-                if (a.type === 'erc20') {
-                    const meta = a.metadata;
-                    asset = {
-                        type: 'erc20',
-                        address: a.address,
-                        balance: a.balance,
-                        metadata: {
-                            name: (meta === null || meta === void 0 ? void 0 : meta.name) || 'Unknown Token',
-                            symbol: (meta === null || meta === void 0 ? void 0 : meta.symbol) || 'UNKNOWN',
-                            decimals: meta === null || meta === void 0 ? void 0 : meta.decimals,
-                            fiat: meta === null || meta === void 0 ? void 0 : meta.fiat,
+                            address: a.address,
+                            balance: a.balance,
+                            metadata: {
+                                name: (meta === null || meta === void 0 ? void 0 : meta.name) || 'Unknown Token',
+                                symbol: (meta === null || meta === void 0 ? void 0 : meta.symbol) || 'UNKNOWN',
+                                decimals: meta === null || meta === void 0 ? void 0 : meta.decimals,
+                                fiat: meta === null || meta === void 0 ? void 0 : meta.fiat,
+                            },
+                            raw: a,
+                        };
+                    }
+                    else if (a.type === 'native') {
+                        const meta = a.metadata;
+                        asset = {
+                            type: 'native',
+                            address: 'native',
+                            balance: a.balance,
+                            metadata: (meta === null || meta === void 0 ? void 0 : meta.fiat)
+                                ? { symbol: (_a = meta.symbol) !== null && _a !== void 0 ? _a : '', decimals: meta.decimals, fiat: meta.fiat }
+                                : undefined,
+                            raw: a,
+                        };
+                    }
+                    else {
+                        throw new OpenfortError('Unsupported asset type', OpenfortReactErrorType.UNEXPECTED_ERROR, { error: a });
+                    }
+                    return asset;
+                });
+                const mergedAssets = [...defaultAssets];
+                const customAssetsForChain = customChainAssets.flatMap((asset) => {
+                    var _a, _b;
+                    if (asset.type !== 'erc20')
+                        return [];
+                    if (!((_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.assets))
+                        return [{ ...asset, raw: asset }];
+                    const configAsset = (_b = walletConfig.ethereum.assets[chainId]) === null || _b === void 0 ? void 0 : _b.find((a) => a.toLowerCase() === asset.address.toLowerCase());
+                    if (!configAsset)
+                        return [{ ...asset, raw: asset }];
+                    return [
+                        {
+                            type: 'erc20',
+                            address: asset.address,
+                            balance: asset.balance,
+                            metadata: asset.metadata,
+                            raw: asset,
                         },
-                        raw: a,
-                    };
-                }
-                else if (a.type === 'native') {
-                    const meta = a.metadata;
-                    asset = {
-                        type: 'native',
-                        address: 'native',
-                        balance: a.balance,
-                        metadata: (meta === null || meta === void 0 ? void 0 : meta.fiat) ? { symbol: (_a = meta.symbol) !== null && _a !== void 0 ? _a : '', decimals: meta.decimals, fiat: meta.fiat } : undefined,
-                        raw: a,
-                    };
-                }
-                else {
-                    throw new OpenfortError('Unsupported asset type', OpenfortReactErrorType.UNEXPECTED_ERROR, { error: a });
-                }
-                return asset;
-            });
-            const mergedAssets = [...defaultAssets];
-            const customAssetsForChain = customChainAssets.flatMap((asset) => {
-                var _a, _b;
-                if (asset.type !== 'erc20')
-                    return [];
-                if (!((_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.assets))
-                    return [{ ...asset, raw: asset }];
-                const configAsset = (_b = walletConfig.ethereum.assets[chainId]) === null || _b === void 0 ? void 0 : _b.find((a) => a.toLowerCase() === asset.address.toLowerCase());
-                if (!configAsset)
-                    return [{ ...asset, raw: asset }];
-                return [
-                    {
-                        type: 'erc20',
-                        address: asset.address,
-                        balance: asset.balance,
-                        metadata: asset.metadata,
-                        raw: asset,
-                    },
-                ];
-            });
-            customAssetsForChain.forEach((asset) => {
-                if (!mergedAssets.find((a) => a.address === asset.address)) {
-                    mergedAssets.push(asset);
+                    ];
+                });
+                customAssetsForChain.forEach((asset) => {
+                    if (!mergedAssets.find((a) => a.address === asset.address)) {
+                        mergedAssets.push(asset);
+                    }
+                });
+                if (mergedAssets.length === 0 && customAssetsToFetch.length > 0) {
+                    // Proxy succeeded but returned nothing while we expect tokens — read direct.
+                    const rpcUrl = (_z = (_y = (_x = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _x === void 0 ? void 0 : _x.rpcUrls) === null || _y === void 0 ? void 0 : _y[chainId]) !== null && _z !== void 0 ? _z : getDefaultEthereumRpcUrl(chainId);
+                    const fb = await readEvmAssetsViaRpc({
+                        address: address,
+                        chain,
+                        rpcUrl,
+                        tokens: customAssetsToFetch,
+                    });
+                    if (fb.length > 0)
+                        return fb;
                 }
-            });
-            return mergedAssets;
+                return mergedAssets;
+            }
+            catch {
+                // ERC-7811 asset proxy failed — fall back to direct chain-RPC balance reads.
+                const rpcUrl = (_2 = (_1 = (_0 = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _0 === void 0 ? void 0 : _0.rpcUrls) === null || _1 === void 0 ? void 0 : _1[chainId]) !== null && _2 !== void 0 ? _2 : getDefaultEthereumRpcUrl(chainId);
+                return (await readEvmAssetsViaRpc({
+                    address: address,
+                    chain,
+                    rpcUrl,
+                    tokens: customAssetsToFetch,
+                }));
+            }
         },
         enabled: multiChain ? isConnected && !!address : isConnected && !!chainId && !!chain && !!address,
         staleTime,

package/build/ethereum/hooks/useEthereumWalletAssets.js.map

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

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;