@openfort/react 1.1.3 → 1.2.0

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,32 @@
+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 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 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).
+ */
+export declare function sendSolGasless({ from, to, amountSol, provider, cluster, publishableKey, }: SendSolGaslessParams): Promise<string>;
+export {};

package/build/solana/transfer.js

@@ -0,0 +1,125 @@
+/** 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://');
+}
+/**
+ * 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 = {
+        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 });
+        })),
+    };
+    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);
+}
+/** 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
+ * project. Returns the transaction signature (base58).
+ */
+async function sendSolGasless({ from, to, amountSol, provider, cluster, publishableKey, }) {
+    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.
+    const { instructions } = await client.transferTransaction({
+        amount: Number(solToLamports(amountSol)),
+        token: SYSTEM_PROGRAM_ID,
+        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');
+}
+
+export { sendSol, sendSolGasless };
+//# sourceMappingURL=transfer.js.map

package/build/solana/transfer.js.map

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

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.3";
+export declare const OPENFORT_VERSION = "1.2.0";

package/build/version.js

@@ -1,4 +1,4 @@
-const OPENFORT_VERSION = '1.1.3';
+const OPENFORT_VERSION = '1.2.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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/react",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "author": "Openfort (https://www.openfort.io)",
   "license": "BSD-2-Clause license",
   "description": "The easiest way to integrate Openfort to your project.",
@@ -65,7 +65,7 @@
     "react"
   ],
   "dependencies": {
-    "@openfort/openfort-js": "^1.3.6",
+    "@openfort/openfort-js": "^1.3.9",
     "buffer": "^6.0.3",
     "detect-browser": "^5.3.0",
     "fast-password-entropy": "^1.1.1",
@@ -83,7 +83,9 @@
     "@coinbase/wallet-sdk": "^4.3.6",
     "@safe-global/safe-apps-provider": "~0.18.6",
     "@safe-global/safe-apps-sdk": "^9.1.0",
+    "@solana-program/system": "^0.10.0",
     "@solana/kit": "^2.0.0 || ^5.0.0",
+    "@solana/kora": "^0.1.1",
     "@walletconnect/ethereum-provider": "^2.21.1",
     "react": "17.x || 18.x || 19.x",
     "react-dom": "17.x || 18.x || 19.x",
@@ -116,9 +118,15 @@
     "wagmi": "^3.6.16"
   },
   "peerDependenciesMeta": {
+    "@solana-program/system": {
+      "optional": true
+    },
     "@solana/kit": {
       "optional": true
     },
+    "@solana/kora": {
+      "optional": true
+    },
     "wagmi": {
       "optional": true
     },