@openfort/react 1.1.4 → 1.3.0

package/build/index.js

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

package/build/index.js.map

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

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

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

package/build/shared/hooks/useAsyncData.js

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

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

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

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

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

package/build/solana/hooks/useSolanaWalletAssets.js

@@ -0,0 +1,86 @@
+import { useEffect } from 'react';
+import { BALANCE_INVALIDATE_EVENT } from '../../hooks/useBalance.js';
+import { useAsyncData } from '../../shared/hooks/useAsyncData.js';
+import { useSolanaContext } from '../SolanaContext.js';
+import { useSolanaEmbeddedWallet } from './useSolanaEmbeddedWallet.js';
+
+/** SPL Token + Token-2022 program ids — token accounts live under one of these. */
+const TOKEN_PROGRAMS = ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA', 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb'];
+/**
+ * Known SPL mints → display metadata. An SPL token account carries only the mint
+ * and amount on-chain (no symbol/name), so common mints are mapped here; unknown
+ * mints fall back to a truncated mint address.
+ */
+const KNOWN_MINTS = {
+    EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v: { symbol: 'USDC', name: 'USD Coin' },
+    Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB: { symbol: 'USDT', name: 'Tether USD' },
+    // Circle's devnet USDC mint (same UI label).
+    '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU': { symbol: 'USDC', name: 'USD Coin' },
+};
+async function fetchSolanaAssets(addressStr, rpcUrl) {
+    var _a, _b;
+    const { address, createSolanaRpc } = await import('@solana/kit');
+    const rpc = createSolanaRpc(rpcUrl);
+    const owner = address(addressStr);
+    const out = [];
+    // Native SOL — always listed (even at zero) so it anchors the view.
+    const { value: lamports } = await rpc.getBalance(owner, { commitment: 'confirmed' }).send();
+    out.push({ mint: 'native', symbol: 'SOL', name: 'Solana', amount: BigInt(lamports), decimals: 9, isNative: true });
+    // SPL token balances across both token programs. The jsonParsed encoding yields
+    // a typed account whose `data.parsed.info` carries the mint and token amount.
+    for (const program of TOKEN_PROGRAMS) {
+        try {
+            const { value: accounts } = await rpc
+                .getTokenAccountsByOwner(owner, { programId: address(program) }, { encoding: 'jsonParsed', commitment: 'confirmed' })
+                .send();
+            for (const acc of accounts) {
+                const info = acc.account.data.parsed.info;
+                const amount = BigInt(info.tokenAmount.amount);
+                if (amount === BigInt(0))
+                    continue;
+                const mint = info.mint;
+                const known = KNOWN_MINTS[mint];
+                out.push({
+                    mint,
+                    symbol: (_a = known === null || known === void 0 ? void 0 : known.symbol) !== null && _a !== void 0 ? _a : `${mint.slice(0, 4)}…${mint.slice(-4)}`,
+                    name: (_b = known === null || known === void 0 ? void 0 : known.name) !== null && _b !== void 0 ? _b : 'SPL Token',
+                    amount,
+                    decimals: info.tokenAmount.decimals,
+                    isNative: false,
+                });
+            }
+        }
+        catch {
+            // Program absent or RPC hiccup — skip this program, keep what we have.
+        }
+    }
+    return out;
+}
+/**
+ * Returns the connected Solana wallet's balances: native SOL plus SPL token
+ * holdings, read directly from the cluster RPC. The SVM counterpart of
+ * {@link useEthereumWalletAssets}, feeding the Solana asset inventory. Refreshes
+ * on BALANCE_INVALIDATE_EVENT (e.g. after a deposit/send).
+ */
+function useSolanaWalletAssets() {
+    const wallet = useSolanaEmbeddedWallet();
+    const { rpcUrl } = useSolanaContext();
+    const address = wallet.status === 'connected' && wallet.address ? wallet.address : undefined;
+    const { data, error, isLoading, refetch } = useAsyncData({
+        queryKey: ['solana-assets', address, rpcUrl],
+        queryFn: () => (address && rpcUrl ? fetchSolanaAssets(address, rpcUrl) : Promise.resolve([])),
+        enabled: Boolean(address && rpcUrl),
+        staleTime: 30000,
+    });
+    useEffect(() => {
+        if (!address)
+            return;
+        const handler = () => refetch().catch(() => { });
+        window.addEventListener(BALANCE_INVALIDATE_EVENT, handler);
+        return () => window.removeEventListener(BALANCE_INVALIDATE_EVENT, handler);
+    }, [address, refetch]);
+    return { data: data !== null && data !== void 0 ? data : null, isLoading, isError: Boolean(error), refetch };
+}
+
+export { useSolanaWalletAssets };
+//# sourceMappingURL=useSolanaWalletAssets.js.map

package/build/solana/hooks/useSolanaWalletAssets.js.map

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

package/build/solana/transfer.d.ts

@@ -0,0 +1,61 @@
+import type { OpenfortEmbeddedSolanaWalletProvider, SolanaCluster } from './types';
+type SendSolParams = {
+    from: string;
+    to: string;
+    amountSol: number;
+    provider: OpenfortEmbeddedSolanaWalletProvider;
+    rpcUrl: string;
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+};
+/**
+ * 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.
+ */
+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;
+    amountSol: number;
+    provider: OpenfortEmbeddedSolanaWalletProvider;
+    cluster: SolanaCluster;
+    /** 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 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

@@ -0,0 +1,219 @@
+/** The System program id — the "token" for a native SOL transfer through Kora. */
+const SYSTEM_PROGRAM_ID = '11111111111111111111111111111111';
+const SEND_TIMEOUT_MS = 60000;
+/** Decimal SOL → lamports, without floating-point loss. */
+function solToLamports(amountSol) {
+    const [whole, frac = ''] = amountSol.toString().split('.');
+    const padded = (frac + '0'.repeat(9)).slice(0, 9);
+    return BigInt(`${whole || '0'}${padded}`);
+}
+/** Ed25519 signatures are 64 bytes; trim a trailing recovery byte if one is present. */
+function toEd25519Signature(raw) {
+    const trimmed = raw.length === 65 ? raw.slice(0, 64) : raw;
+    if (trimmed.length !== 64) {
+        throw new Error(`Invalid Ed25519 signature: expected 64 bytes, got ${trimmed.length}`);
+    }
+    return trimmed;
+}
+/** Solana confirmation needs a wss endpoint; public cluster RPCs serve one at the same host. */
+function deriveWssUrl(rpcUrl) {
+    return rpcUrl.replace(/^https?:\/\//, 'wss://');
+}
+/**
+ * A `TransactionSigner` that signs message bytes through the embedded wallet
+ * provider (Ed25519). Shared by the native and SPL non-sponsored paths.
+ */
+function createEmbeddedSigner(kit, provider, fromAddress) {
+    return {
+        address: fromAddress,
+        signTransactions: async (transactions) => Promise.all(transactions.map(async (transaction) => {
+            const { signature } = await provider.signTransaction({
+                messageBytes: new Uint8Array(transaction.messageBytes),
+            });
+            const bytes = toEd25519Signature(new Uint8Array(kit.getBase58Encoder().encode(signature)));
+            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,
+        destination: kit.address(to),
+        amount: kit.lamports(solToLamports(amountSol)),
+    }), 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);
+}
+/**
+ * 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}`;
+}
+/**
+ * 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 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 transfer (native or SPL), with Kora as the fee payer.
+    const { instructions } = await client.transferTransaction({
+        amount: Number(amountBaseUnits),
+        token: tokenMint,
+        source: from,
+        destination: to,
+        signer_key: signer_address,
+    });
+    // 3. Build the message with Kora as fee payer.
+    const { blockhash } = await client.getBlockhash();
+    const message = kit.pipe(kit.createTransactionMessage({ version: 0 }), (tx) => kit.setTransactionMessageFeePayerSigner(feePayer, tx), (tx) => kit.setTransactionMessageLifetimeUsingBlockhash({
+        blockhash: blockhash,
+        lastValidBlockHeight: BigInt(0),
+    }, tx), (tx) => kit.appendTransactionMessageInstructions(instructions, tx));
+    // 4. Inject the user's Ed25519 signature alongside Kora's placeholder.
+    const partiallySigned = await kit.partiallySignTransactionMessageWithSigners(message);
+    const { signature } = await provider.signTransaction(new Uint8Array(partiallySigned.messageBytes));
+    const userSigned = {
+        ...partiallySigned,
+        signatures: {
+            ...partiallySigned.signatures,
+            [from]: toEd25519Signature(new Uint8Array(kit.getBase58Encoder().encode(signature))),
+        },
+    };
+    const wire = kit.getBase64EncodedWireTransaction(userSigned);
+    // 5. Kora co-signs (as fee payer) and broadcasts.
+    const response = (await client.signAndSendTransaction({
+        transaction: wire,
+        signer_key: signer_address,
+    }));
+    const direct = response.signature;
+    if (direct)
+        return direct;
+    const signedTxB64 = response.signed_transaction;
+    if (signedTxB64) {
+        // Wire format: [sigCount(1)][signature(64)]... — the first signature is the tx id.
+        const wireBytes = Uint8Array.from(atob(signedTxB64), (c) => c.charCodeAt(0));
+        return kit.getBase58Decoder().decode(wireBytes.slice(1, 65));
+    }
+    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, sendSplToken, sendSplTokenGasless };
+//# sourceMappingURL=transfer.js.map

package/build/solana/transfer.js.map

@@ -0,0 +1 @@
+{"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/index.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { truncateEthAddress, truncateSolanaAddress } from './format';
 declare const nFormatter: (num: number, digits?: number) => string;
 declare const detectBrowser: () => "" | import("detect-browser").Browser | "bot" | "node" | "react-native";
+declare const isIOS: () => boolean;
 declare const isAndroid: () => boolean;
 declare const isMobile: () => boolean;
 type ReactChildArray = ReturnType<typeof React.Children.toArray>;
@@ -9,4 +10,4 @@ declare function flattenChildren(children: React.ReactNode): ReactChildArray;
 export declare const isWalletConnectConnector: (connectorId?: string) => connectorId is "walletConnect";
 export declare const isCoinbaseWalletConnector: (connectorId?: string) => connectorId is "coinbaseWalletSDK";
 export declare const isInjectedConnector: (connectorId?: string) => connectorId is "injected";
-export { detectBrowser, flattenChildren, isAndroid, isMobile, nFormatter, truncateEthAddress, truncateSolanaAddress };
+export { detectBrowser, flattenChildren, isAndroid, isIOS, isMobile, nFormatter, truncateEthAddress, truncateSolanaAddress, };

package/build/utils/index.js

@@ -63,5 +63,5 @@ const isWalletConnectConnector = (connectorId) => connectorId === 'walletConnect
 const isCoinbaseWalletConnector = (connectorId) => connectorId === 'coinbaseWalletSDK';
 const isInjectedConnector = (connectorId) => connectorId === 'injected';
 
-export { detectBrowser, flattenChildren, isAndroid, isCoinbaseWalletConnector, isInjectedConnector, isMobile, isWalletConnectConnector, nFormatter };
+export { detectBrowser, flattenChildren, isAndroid, isCoinbaseWalletConnector, isIOS, isInjectedConnector, isMobile, isWalletConnectConnector, nFormatter };
 //# sourceMappingURL=index.js.map

package/build/version.d.ts

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

package/build/version.js

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

package/build/wagmi/defaultConnectors.js

@@ -1,4 +1,4 @@
-import { safe, coinbaseWallet, walletConnect } from '@wagmi/connectors';
+import { safe, injected, coinbaseWallet, walletConnect } from '@wagmi/connectors';
 import { embeddedWalletConnector } from './embeddedConnector.js';
 
 const defaultConnectors = ({ app, walletConnectProjectId, coinbaseWalletPreference, }) => {
@@ -10,6 +10,10 @@ const defaultConnectors = ({ app, walletConnectProjectId, coinbaseWalletPreferen
             allowedDomains: [/gnosis-safe.io$/, /app.safe.global$/],
         }));
     }
+    // Targeted injected connectors so the browser-extension wallets surface as
+    // their own entries (e.g. the deposit "transfer from wallet" list), instead of
+    // a single generic "Injected" provider.
+    connectors.push(injected({ target: 'metaMask' }), injected({ target: 'phantom' }));
     connectors.push(coinbaseWallet({
         appName: app.name,
         appLogoUrl: app.icon,

package/build/wagmi/defaultConnectors.js.map

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