@openfort/react 1.2.0 → 1.3.0

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

@@ -1,3 +1,4 @@
+import { SDKConfiguration } from '@openfort/openfort-js';
 import { useState, useEffect } from 'react';
 import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
 
@@ -32,15 +33,12 @@ 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 : '';
+    // 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 });
+    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`)

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/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/version.d.ts

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

package/build/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/react",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "author": "Openfort (https://www.openfort.io)",
   "license": "BSD-2-Clause license",
   "description": "The easiest way to integrate Openfort to your project.",
@@ -84,6 +84,7 @@
     "@safe-global/safe-apps-provider": "~0.18.6",
     "@safe-global/safe-apps-sdk": "^9.1.0",
     "@solana-program/system": "^0.10.0",
+    "@solana-program/token": "^0.9.0",
     "@solana/kit": "^2.0.0 || ^5.0.0",
     "@solana/kora": "^0.1.1",
     "@walletconnect/ethereum-provider": "^2.21.1",
@@ -121,6 +122,9 @@
     "@solana-program/system": {
       "optional": true
     },
+    "@solana-program/token": {
+      "optional": true
+    },
     "@solana/kit": {
       "optional": true
     },