@openfort/react 1.2.0 → 1.4.0

package/build/constants/logos.d.ts

@@ -1,2 +1,6 @@
 export declare const TOKEN_LOGO: Record<string, string>;
 export declare function symbolToColor(symbol: string): string;
+/** Network logo for a chain: the curated brand first (clean + testnet-aware), then the backend value. */
+export declare function chainLogoUrl(chainId?: number, apiLogo?: string | null): string | null;
+/** Token logo for a symbol: the backend value first, then the curated map (covers native ETH/SOL/… which the rail returns null for). */
+export declare function currencyLogoUrl(symbol?: string, apiLogo?: string | null): string | null;

package/build/constants/logos.js

@@ -54,6 +54,30 @@ function symbolToColor(symbol) {
     const h = ((hash % 360) + 360) % 360;
     return `hsl(${h}, 55%, 50%)`;
 }
+// EVM chain id -> network logo URL. Testnet ids reuse their mainnet brand. Used
+// instead of the funding rail's icon CDN, which serves a generic prism for
+// testnets and a blank square for some mainnets.
+const CHAIN_LOGO = {
+    1: `${TW}/ethereum/info/logo.png`,
+    11155111: `${TW}/ethereum/info/logo.png`, // Sepolia
+    8453: `${TW}/base/info/logo.png`,
+    84532: `${TW}/base/info/logo.png`, // Base Sepolia
+    10: `${TW}/optimism/info/logo.png`,
+    11155420: `${TW}/optimism/info/logo.png`, // OP Sepolia
+    42161: `${TW}/arbitrum/info/logo.png`,
+    421614: `${TW}/arbitrum/info/logo.png`, // Arbitrum Sepolia
+    137: `${TW}/polygon/info/logo.png`,
+    80002: `${TW}/polygon/info/logo.png`, // Polygon Amoy
+    56: `${TW}/smartchain/info/logo.png`,
+};
+/** Network logo for a chain: the curated brand first (clean + testnet-aware), then the backend value. */
+function chainLogoUrl(chainId, apiLogo) {
+    return (chainId !== undefined && CHAIN_LOGO[chainId]) || apiLogo || null;
+}
+/** Token logo for a symbol: the backend value first, then the curated map (covers native ETH/SOL/… which the rail returns null for). */
+function currencyLogoUrl(symbol, apiLogo) {
+    return apiLogo || (symbol && TOKEN_LOGO[symbol.toUpperCase()]) || null;
+}
 
-export { TOKEN_LOGO, symbolToColor };
+export { TOKEN_LOGO, chainLogoUrl, currencyLogoUrl, symbolToColor };
 //# sourceMappingURL=logos.js.map

package/build/constants/logos.js.map

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

package/build/ethereum/hooks/useEthereumWalletAssets.js

@@ -195,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, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
+            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, _3, _4, _5;
             if (multiChain) {
                 if (!address) {
                     throw new OpenfortError('No wallet address available', OpenfortReactErrorType.UNEXPECTED_ERROR);
@@ -292,6 +292,26 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                         }
                     }
                 }
+                // The ERC-7811 proxy indexes mainnet; testnet natives (e.g. Base Sepolia ETH)
+                // come back missing or stale. For configured testnet chains, read the native
+                // balance straight from RPC — the same source Rabby uses — and upsert it.
+                const testnetChains = chains.filter((c) => c.testnet === true);
+                const rpcNatives = await Promise.all(testnetChains.map(async (c) => {
+                    var _a, _b, _c;
+                    const rpcUrl = (_c = (_b = (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.rpcUrls) === null || _b === void 0 ? void 0 : _b[c.id]) !== null && _c !== void 0 ? _c : getDefaultEthereumRpcUrl(c.id);
+                    const read = await readEvmAssetsViaRpc({ address: address, chain: c, rpcUrl, tokens: [] });
+                    const native = read.find((a) => a.type === 'native');
+                    return native ? { ...native, chainId: c.id } : null;
+                }));
+                for (const native of rpcNatives) {
+                    if (!native)
+                        continue;
+                    const idx = allAssets.findIndex((a) => a.type === 'native' && a.chainId === native.chainId);
+                    if (idx >= 0)
+                        allAssets[idx] = native;
+                    else
+                        allAssets.push(native);
+                }
                 allAssets.sort((a, b) => getUsdValue(b) - getUsdValue(a));
                 return allAssets;
             }
@@ -389,9 +409,25 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
                         mergedAssets.push(asset);
                     }
                 });
+                // The ERC-7811 proxy indexes mainnet; a testnet native (e.g. Base Sepolia
+                // ETH) comes back missing or stale, so the single-chain path would report
+                // "no assets" while the multi-chain inventory shows the balance. Read the
+                // native straight from RPC and upsert it to keep the two consistent.
+                if (chain.testnet === true) {
+                    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 read = await readEvmAssetsViaRpc({ address: address, chain, rpcUrl, tokens: [] });
+                    const native = read.find((a) => a.type === 'native');
+                    if (native) {
+                        const idx = mergedAssets.findIndex((a) => a.type === 'native');
+                        if (idx >= 0)
+                            mergedAssets[idx] = native;
+                        else
+                            mergedAssets.unshift(native);
+                    }
+                }
                 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 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);
                     const fb = await readEvmAssetsViaRpc({
                         address: address,
                         chain,
@@ -405,7 +441,7 @@ const useEthereumWalletAssets = ({ assets: hookCustomAssets, multiChain = false,
             }
             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);
+                const rpcUrl = (_5 = (_4 = (_3 = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _3 === void 0 ? void 0 : _3.rpcUrls) === null || _4 === void 0 ? void 0 : _4[chainId]) !== null && _5 !== void 0 ? _5 : getDefaultEthereumRpcUrl(chainId);
                 return (await readEvmAssetsViaRpc({
                     address: address,
                     chain,

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/useFunding.js

@@ -53,14 +53,14 @@ async function pollUntilTerminal(client, onUpdate, start, isCurrent) {
  * @returns Session state plus `fund` (run the deposit flow) and `reset`.
  */
 function useFunding(options) {
-    var _a, _b, _c;
+    var _a, _b;
     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 : '');
+    // 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),
@@ -188,7 +188,7 @@ function useFunding(options) {
     }, [client]);
     return {
         session,
-        status: (_c = session === null || session === void 0 ? void 0 : session.status) !== null && _c !== void 0 ? _c : 'idle',
+        status: (_b = session === null || session === void 0 ? void 0 : session.status) !== null && _b !== void 0 ? _b : 'idle',
         error,
         loading,
         isAvailable,

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

@@ -20,6 +20,12 @@ export type FundingChain = {
 };
 type UseFundingChains = {
     chains: FundingChain[];
+    /**
+     * The rail's full deliverable chain list (uncurated). Used to check whether a
+     * funding TARGET chain is supported, independent of the source allowlist that
+     * narrows {@link chains}.
+     */
+    railChains: FundingChain[];
     loading: boolean;
     error: Error | null;
 };

package/build/hooks/openfort/useFundingChains.js

@@ -1,5 +1,7 @@
+import { SDKConfiguration } from '@openfort/openfort-js';
 import { useState, useEffect } from 'react';
 import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { getPublishableKeyEnvironment } from '../../utils/validation.js';
 
 /**
  * Sensible default source chains — the common funding origins. Override with
@@ -31,19 +33,24 @@ const DEFAULT_SOURCE_CURRENCIES = ['native', 'USDC', 'USDT'];
  */
 function useFundingChains() {
     var _a, _b, _c, _d, _e;
-    const { uiConfig } = useOpenfort();
-    const baseUrl = (_a = uiConfig.fundingBaseUrl) !== null && _a !== void 0 ? _a : '';
+    const { uiConfig, publishableKey } = 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: Boolean(baseUrl), error: null });
+    // Match the rail host to the key environment: test keys (`pk_test_…`) list the
+    // testnet rail, everything else the mainnet rail. The backend picks the same
+    // host from the request livemode for the authenticated session endpoints.
+    const livemode = getPublishableKeyEnvironment(publishableKey) !== 'test';
+    const [state, setState] = useState({
+        chains: [],
+        loading: true,
+        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`)
+        fetch(`${baseUrl}/v2/funding/chains?livemode=${livemode}`)
             .then((r) => {
             if (!r.ok)
                 throw new Error(`Failed to load chains (${r.status})`);
@@ -61,9 +68,14 @@ function useFundingChains() {
         return () => {
             cancelled = true;
         };
-    }, [baseUrl]);
+    }, [baseUrl, livemode]);
     // Narrow the provider dictionary to the selected subset (cheap, O(chains)).
-    return { ...state, chains: curateChains(state.chains, sourceChains, sourceCurrencies) };
+    return {
+        chains: curateChains(state.chains, sourceChains, sourceCurrencies),
+        railChains: state.chains,
+        loading: state.loading,
+        error: state.error,
+    };
 }
 /**
  * Narrow the fetched chains to a selection. `sourceChains` is a CAIP-2 allowlist

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

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

package/build/shared/hooks/useAsyncData.js

@@ -2,6 +2,19 @@ import { useState, useRef, useCallback, useEffect } from 'react';
 
 /** Module-level cache shared across hook instances, so revisiting a view paints instantly. */
 const dataCache = new Map();
+/**
+ * Serialize a queryKey to a stable cache string.
+ *
+ * `JSON.stringify` throws `TypeError: Do not know how to serialize a BigInt`,
+ * and queryKeys legitimately carry bigints (token amounts, balances, gas
+ * values — e.g. a native ETH send keys its gas estimate on the bigint amount).
+ * Without this replacer such a key crashes the whole modal render. A bigint is
+ * encoded as its decimal digits with an `n` suffix so distinct values stay
+ * distinct keys.
+ */
+function serializeQueryKey(queryKey) {
+    return JSON.stringify(queryKey, (_key, value) => (typeof value === 'bigint' ? `${value}n` : value));
+}
 /**
  * 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
@@ -40,8 +53,8 @@ function isEmptyResult(result) {
  */
 function useAsyncData({ queryFn, queryKey, enabled = true, refetchInterval, staleTime = 0, }) {
     // 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);
+    // not when array/object references change. Bigint-safe (see serializeQueryKey).
+    const queryKeyStr = serializeQueryKey(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);

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/shared/utils/explorer.js

@@ -29,15 +29,17 @@ function appendPath(base, options, queryParams) {
 const explorerRegistry = {
     [ChainTypeEnum.EVM]: (options) => {
         var _a;
+        // Never fall back to an unrelated chain's explorer — a valid hash on the wrong
+        // explorer reads as "transaction not found". Return '' so callers hide the link.
         if (!options.chainId) {
-            logger.warn('No chain ID provided. Configure explorerUrls in OpenfortProvider for better reliability and rate limits.');
-            return polygonAmoy.blockExplorers.default.url;
+            logger.warn('No chain ID provided; cannot build an explorer URL for this transaction.');
+            return '';
         }
         const chain = EVM_CHAINS_BY_ID[options.chainId];
         const explorerUrl = (_a = chain === null || chain === void 0 ? void 0 : chain.blockExplorers) === null || _a === void 0 ? void 0 : _a.default.url;
         if (!explorerUrl) {
-            logger.warn(`No explorer URL found for chain ${options.chainId}. Configure explorerUrls in OpenfortProvider for better reliability and rate limits.`);
-            return polygonAmoy.blockExplorers.default.url;
+            logger.warn(`No explorer URL known for chain ${options.chainId}. Configure explorerUrls in OpenfortProvider to enable the link.`);
+            return '';
         }
         return appendPath(explorerUrl, options);
     },

package/build/shared/utils/explorer.js.map

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

package/build/solana/transfer.d.ts

@@ -13,6 +13,26 @@ type SendSolParams = {
  * to sponsor it.
  */
 export declare function sendSol({ from, to, amountSol, provider, rpcUrl, commitment, }: SendSolParams): Promise<string>;
+type SendSplTokenParams = {
+    from: string;
+    to: string;
+    /** SPL mint address (base58). */
+    mint: string;
+    /** Amount in token base units (already scaled by `decimals`). */
+    amount: bigint;
+    decimals: number;
+    provider: OpenfortEmbeddedSolanaWalletProvider;
+    rpcUrl: string;
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+};
+/**
+ * Build, sign, and broadcast an SPL token transfer. Creates the recipient's
+ * associated token account if it doesn't exist yet (idempotent — a no-op when it
+ * already holds the token; the sender pays the small rent). The wallet pays the
+ * network fee — use {@link sendSplTokenGasless} to sponsor it. Returns the
+ * transaction signature (base58).
+ */
+export declare function sendSplToken({ from, to, mint, amount, decimals, provider, rpcUrl, commitment, }: SendSplTokenParams): Promise<string>;
 type SendSolGaslessParams = {
     from: string;
     to: string;
@@ -22,11 +42,20 @@ type SendSolGaslessParams = {
     /** Project publishable key; sent to the Openfort Solana paymaster (Kora) as a Bearer token. */
     publishableKey: string;
 };
-/**
- * Send a native SOL transfer with fees sponsored by the Openfort Solana paymaster
- * (Kora): Kora is the fee payer, the user signs their part with the embedded wallet,
- * and Kora co-signs + broadcasts. Requires a `sponsorSolTransaction` policy on the
- * project. Returns the transaction signature (base58).
- */
+/** Send a native SOL transfer with fees sponsored by the Openfort paymaster (Kora). */
 export declare function sendSolGasless({ from, to, amountSol, provider, cluster, publishableKey, }: SendSolGaslessParams): Promise<string>;
+type SendSplTokenGaslessParams = {
+    from: string;
+    to: string;
+    /** SPL mint address (base58). */
+    mint: string;
+    /** Amount in token base units (already scaled by `decimals`). */
+    amount: bigint;
+    provider: OpenfortEmbeddedSolanaWalletProvider;
+    cluster: SolanaCluster;
+    /** Project publishable key; sent to the Openfort Solana paymaster (Kora) as a Bearer token. */
+    publishableKey: string;
+};
+/** Send an SPL token transfer with fees sponsored by the Openfort paymaster (Kora). */
+export declare function sendSplTokenGasless({ from, to, mint, amount, provider, cluster, publishableKey, }: SendSplTokenGaslessParams): Promise<string>;
 export {};

package/build/solana/transfer.js

@@ -20,17 +20,11 @@ function deriveWssUrl(rpcUrl) {
     return rpcUrl.replace(/^https?:\/\//, 'wss://');
 }
 /**
- * Build, sign, and broadcast a native SOL transfer. Returns the transaction
- * signature (base58). The wallet pays the network fee — use {@link sendSolGasless}
- * to sponsor it.
+ * A `TransactionSigner` that signs message bytes through the embedded wallet
+ * provider (Ed25519). Shared by the native and SPL non-sponsored paths.
  */
-async function sendSol({ from, to, amountSol, provider, rpcUrl, commitment = 'confirmed', }) {
-    const kit = await import('@solana/kit');
-    const { getTransferSolInstruction } = await import('@solana-program/system');
-    const fromAddress = kit.address(from);
-    const rpc = kit.createSolanaRpc(rpcUrl);
-    const rpcSubscriptions = kit.createSolanaRpcSubscriptions(deriveWssUrl(rpcUrl));
-    const signer = {
+function createEmbeddedSigner(kit, provider, fromAddress) {
+    return {
         address: fromAddress,
         signTransactions: async (transactions) => Promise.all(transactions.map(async (transaction) => {
             const { signature } = await provider.signTransaction({
@@ -40,6 +34,19 @@ async function sendSol({ from, to, amountSol, provider, rpcUrl, commitment = 'co
             return Object.freeze({ [fromAddress]: bytes });
         })),
     };
+}
+/**
+ * Build, sign, and broadcast a native SOL transfer. Returns the transaction
+ * signature (base58). The wallet pays the network fee — use {@link sendSolGasless}
+ * to sponsor it.
+ */
+async function sendSol({ from, to, amountSol, provider, rpcUrl, commitment = 'confirmed', }) {
+    const kit = await import('@solana/kit');
+    const { getTransferSolInstruction } = await import('@solana-program/system');
+    const fromAddress = kit.address(from);
+    const rpc = kit.createSolanaRpc(rpcUrl);
+    const rpcSubscriptions = kit.createSolanaRpcSubscriptions(deriveWssUrl(rpcUrl));
+    const signer = createEmbeddedSigner(kit, provider, fromAddress);
     const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
     const message = kit.pipe(kit.createTransactionMessage({ version: 0 }), (tx) => kit.setTransactionMessageFeePayer(fromAddress, tx), (tx) => kit.setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => kit.appendTransactionMessageInstruction(getTransferSolInstruction({
         source: signer,
@@ -61,28 +68,91 @@ async function sendSol({ from, to, amountSol, provider, rpcUrl, commitment = 'co
     }
     return kit.getSignatureFromTransaction(signedTransaction);
 }
+/**
+ * Build, sign, and broadcast an SPL token transfer. Creates the recipient's
+ * associated token account if it doesn't exist yet (idempotent — a no-op when it
+ * already holds the token; the sender pays the small rent). The wallet pays the
+ * network fee — use {@link sendSplTokenGasless} to sponsor it. Returns the
+ * transaction signature (base58).
+ */
+async function sendSplToken({ from, to, mint, amount, decimals, provider, rpcUrl, commitment = 'confirmed', }) {
+    const kit = await import('@solana/kit');
+    const token = await import('@solana-program/token');
+    const fromAddress = kit.address(from);
+    const toAddress = kit.address(to);
+    const mintAddress = kit.address(mint);
+    const rpc = kit.createSolanaRpc(rpcUrl);
+    const rpcSubscriptions = kit.createSolanaRpcSubscriptions(deriveWssUrl(rpcUrl));
+    const signer = createEmbeddedSigner(kit, provider, fromAddress);
+    const [sourceAta] = await token.findAssociatedTokenPda({
+        owner: fromAddress,
+        tokenProgram: token.TOKEN_PROGRAM_ADDRESS,
+        mint: mintAddress,
+    });
+    const [destinationAta] = await token.findAssociatedTokenPda({
+        owner: toAddress,
+        tokenProgram: token.TOKEN_PROGRAM_ADDRESS,
+        mint: mintAddress,
+    });
+    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+    const message = kit.pipe(kit.createTransactionMessage({ version: 0 }), (tx) => kit.setTransactionMessageFeePayer(fromAddress, tx), (tx) => kit.setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => kit.appendTransactionMessageInstructions([
+        token.getCreateAssociatedTokenIdempotentInstruction({
+            payer: signer,
+            ata: destinationAta,
+            owner: toAddress,
+            mint: mintAddress,
+        }),
+        token.getTransferCheckedInstruction({
+            source: sourceAta,
+            mint: mintAddress,
+            destination: destinationAta,
+            authority: signer,
+            amount,
+            decimals,
+        }),
+    ], tx));
+    const signedTransaction = await kit.signTransactionMessageWithSigners(message);
+    const sendAndConfirm = kit.sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), SEND_TIMEOUT_MS);
+    try {
+        await sendAndConfirm(signedTransaction, {
+            commitment,
+            abortSignal: abortController.signal,
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    return kit.getSignatureFromTransaction(signedTransaction);
+}
 /** The Openfort Solana paymaster (Kora) endpoint for a cluster. */
 function koraRpcUrl(cluster) {
     const segment = cluster === 'mainnet-beta' ? 'mainnet' : cluster;
     return `https://api.openfort.io/rpc/solana/${segment}`;
 }
 /**
- * Send a native SOL transfer with fees sponsored by the Openfort Solana paymaster
- * (Kora): Kora is the fee payer, the user signs their part with the embedded wallet,
- * and Kora co-signs + broadcasts. Requires a `sponsorSolTransaction` policy on the
+ * Sponsor a transfer through the Openfort Solana paymaster (Kora): Kora is the
+ * fee payer, the user signs their part with the embedded wallet, and Kora
+ * co-signs + broadcasts. Requires a `sponsorSolTransaction` policy on the
  * project. Returns the transaction signature (base58).
  */
-async function sendSolGasless({ from, to, amountSol, provider, cluster, publishableKey, }) {
+async function sendViaKora({ from, to, amountBaseUnits, tokenMint, provider, cluster, publishableKey, }) {
+    // Kora's request takes a JS number; fail loudly rather than silently corrupt
+    // an amount that can't be represented exactly.
+    if (amountBaseUnits > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error('Amount is too large to sponsor through the paymaster.');
+    }
     const kit = await import('@solana/kit');
     const { KoraClient } = await import('@solana/kora');
     const client = new KoraClient({ rpcUrl: koraRpcUrl(cluster), apiKey: `Bearer ${publishableKey}` });
     // 1. Kora's fee-payer signer.
     const { signer_address } = await client.getPayerSigner();
     const feePayer = kit.createNoopSigner(signer_address);
-    // 2. A sponsored native SOL transfer, with Kora as the fee payer.
+    // 2. A sponsored transfer (native or SPL), with Kora as the fee payer.
     const { instructions } = await client.transferTransaction({
-        amount: Number(solToLamports(amountSol)),
-        token: SYSTEM_PROGRAM_ID,
+        amount: Number(amountBaseUnits),
+        token: tokenMint,
         source: from,
         destination: to,
         signer_key: signer_address,
@@ -120,6 +190,30 @@ async function sendSolGasless({ from, to, amountSol, provider, cluster, publisha
     }
     throw new Error('Failed to extract transaction signature from the Kora response');
 }
+/** Send a native SOL transfer with fees sponsored by the Openfort paymaster (Kora). */
+async function sendSolGasless({ from, to, amountSol, provider, cluster, publishableKey, }) {
+    return sendViaKora({
+        from,
+        to,
+        amountBaseUnits: solToLamports(amountSol),
+        tokenMint: SYSTEM_PROGRAM_ID,
+        provider,
+        cluster,
+        publishableKey,
+    });
+}
+/** Send an SPL token transfer with fees sponsored by the Openfort paymaster (Kora). */
+async function sendSplTokenGasless({ from, to, mint, amount, provider, cluster, publishableKey, }) {
+    return sendViaKora({
+        from,
+        to,
+        amountBaseUnits: amount,
+        tokenMint: mint,
+        provider,
+        cluster,
+        publishableKey,
+    });
+}
 
-export { sendSol, sendSolGasless };
+export { sendSol, sendSolGasless, sendSplToken, sendSplTokenGasless };
 //# sourceMappingURL=transfer.js.map

package/build/solana/transfer.js.map

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

package/build/solana/types.d.ts

@@ -47,6 +47,14 @@ export type SolanaConfig = {
     rpcUrls?: Partial<Record<'mainnet-beta' | 'devnet' | 'testnet', string>>;
     /** Commitment level for transactions (default: 'confirmed') */
     commitment?: SolanaCommitment;
+    /**
+     * Sponsor network fees for Solana sends through the Openfort paymaster (Kora).
+     * The SVM counterpart of `ethereum.ethereumFeeSponsorshipId`: when `true`, sends
+     * are routed gaslessly and the confirm screen marks the network fee as sponsored.
+     * Requires a `sponsorSolTransaction` policy on the project (resolved server-side
+     * from the publishable key). Defaults to `false` (user pays the fee).
+     */
+    sponsorFees?: boolean;
     /** UI options for Solana-connected screens */
     ui?: SolanaUIOptions;
 };

package/build/utils/validation.d.ts

@@ -1 +1,10 @@
 export declare const isValidEmail: (email: string) => boolean;
+type PublishableKeyEnvironment = 'test' | 'live';
+/**
+ * Derive the environment from an Openfort publishable key.
+ *
+ * Keys are formatted `pk_test_<uuid>` or `pk_live_<uuid>`. Returns `null` when
+ * the prefix is unrecognized so callers can fall back to default behavior.
+ */
+export declare const getPublishableKeyEnvironment: (publishableKey: string | undefined | null) => PublishableKeyEnvironment | null;
+export {};

package/build/utils/validation.js

@@ -2,6 +2,19 @@ const isValidEmail = (email) => {
     const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
     return emailRegex.test(email);
 };
+/**
+ * Derive the environment from an Openfort publishable key.
+ *
+ * Keys are formatted `pk_test_<uuid>` or `pk_live_<uuid>`. Returns `null` when
+ * the prefix is unrecognized so callers can fall back to default behavior.
+ */
+const getPublishableKeyEnvironment = (publishableKey) => {
+    if (publishableKey === null || publishableKey === void 0 ? void 0 : publishableKey.startsWith('pk_test_'))
+        return 'test';
+    if (publishableKey === null || publishableKey === void 0 ? void 0 : publishableKey.startsWith('pk_live_'))
+        return 'live';
+    return null;
+};
 
-export { isValidEmail };
+export { getPublishableKeyEnvironment, isValidEmail };
 //# sourceMappingURL=validation.js.map

package/build/utils/validation.js.map

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

package/build/version.d.ts

@@ -1 +1 @@
-export declare const OPENFORT_VERSION = "1.2.0";
+export declare const OPENFORT_VERSION = "1.4.0";

package/build/version.js

@@ -1,4 +1,4 @@
-const OPENFORT_VERSION = '1.2.0';
+const OPENFORT_VERSION = '1.4.0';
 
 export { OPENFORT_VERSION };
 //# sourceMappingURL=version.js.map

package/build/wagmi/components/ChainSelect/index.js

@@ -2,7 +2,7 @@ import { jsx, jsxs } from 'react/jsx-runtime';
 import { motion } from 'framer-motion';
 import { useState, useEffect } from 'react';
 import { css } from 'styled-components';
-import { useChainId, useSwitchChain } from 'wagmi';
+import { useChainId } from 'wagmi';
 import Chain from '../../../components/Common/Chain/index.js';
 import Tooltip from '../../../components/Common/Tooltip/index.js';
 import { routes } from '../../../components/Openfort/types.js';
@@ -11,6 +11,7 @@ import defaultTheme from '../../../constants/defaultTheme.js';
 import useLocales from '../../../hooks/useLocales.js';
 import styled from '../../../styles/styled/index.js';
 import { isMobile, flattenChildren } from '../../../utils/index.js';
+import { useSwitchChainFiltered } from '../../useSwitchChainFiltered.js';
 import ChainSelectDropdown from '../ChainSelectDropdown/index.js';
 
 const Container = styled(motion.div) ``;
@@ -112,7 +113,7 @@ const ChainSelector = () => {
     const { open, triggerResize, setRoute } = useOpenfort();
     const [isOpen, setIsOpen] = useState(false);
     const chainId = useChainId();
-    const { chains } = useSwitchChain();
+    const { chains } = useSwitchChainFiltered();
     const chain = chains.find((c) => c.id === chainId);
     const locales = useLocales({
         CHAIN: (_a = chain === null || chain === void 0 ? void 0 : chain.name) !== null && _a !== void 0 ? _a : 'UNKNOWN',

package/build/wagmi/components/ChainSelect/index.js.map

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