@openfort/react 0.3.2 → 1.0.0

package/build/solana/SolanaContext.js

@@ -0,0 +1,87 @@
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useMemo, useContext } from 'react';
+import { OpenfortError, OpenfortReactErrorType } from '../types.js';
+
+const DEFAULT_RPC_URLS = {
+    devnet: 'https://api.devnet.solana.com',
+    testnet: 'https://api.testnet.solana.com',
+    'mainnet-beta': 'https://api.mainnet-beta.solana.com',
+};
+function getDefaultRpcUrl(cluster) {
+    const url = DEFAULT_RPC_URLS[cluster];
+    if (!url) {
+        throw new OpenfortError(`Unknown Solana cluster "${cluster}". Provide rpcUrls in walletConfig.solana.`, OpenfortReactErrorType.CONFIGURATION_ERROR);
+    }
+    return url;
+}
+const SolanaContext = createContext(null);
+/**
+ * Provides Solana configuration context to descendant components.
+ *
+ * This provider is automatically rendered by OpenfortProvider when
+ * `walletConfig.solana` is configured.
+ *
+ * @example
+ * ```tsx
+ * // Usually you don't use this directly, configure via OpenfortProvider:
+ * <OpenfortProvider
+ *   publishableKey="pk_..."
+ *   walletConfig={{
+ *     shieldPublishableKey: 'shield_pk_...',
+ *     solana: {
+ *       cluster: 'mainnet-beta',
+ *       commitment: 'confirmed'
+ *     }
+ *   }}
+ * >
+ *   <App />
+ * </OpenfortProvider>
+ * ```
+ */
+function resolveRpcUrl(cluster, config) {
+    var _a;
+    const url = (_a = config.rpcUrls) === null || _a === void 0 ? void 0 : _a[cluster];
+    if (url)
+        return url;
+    return getDefaultRpcUrl(cluster);
+}
+const DEFAULT_CLUSTER = 'devnet';
+function SolanaContextProvider({ config, children }) {
+    var _a;
+    const cluster = (_a = config.cluster) !== null && _a !== void 0 ? _a : DEFAULT_CLUSTER;
+    const rpcUrl = useMemo(() => resolveRpcUrl(cluster, config), [cluster, config]);
+    const value = useMemo(() => {
+        var _a;
+        return ({
+            cluster,
+            rpcUrl,
+            commitment: (_a = config.commitment) !== null && _a !== void 0 ? _a : 'confirmed',
+        });
+    }, [cluster, rpcUrl, config.commitment]);
+    return jsx(SolanaContext.Provider, { value: value, children: children });
+}
+/**
+ * Access the Solana context configuration.
+ *
+ * @throws Error if called outside of a SolanaContextProvider
+ * (i.e., when `walletConfig.solana` is not configured in OpenfortProvider)
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { cluster, rpcUrl, commitment } = useSolanaContext();
+ *   // Use Solana configuration...
+ * }
+ * ```
+ */
+function useSolanaContext() {
+    const context = useContext(SolanaContext);
+    if (!context) {
+        throw new Error('useSolanaContext must be used within a SolanaContextProvider. ' +
+            'Make sure walletConfig.solana is configured in OpenfortProvider.');
+    }
+    return context;
+}
+
+export { SolanaContext, SolanaContextProvider, useSolanaContext };
+//# sourceMappingURL=SolanaContext.js.map

package/build/solana/SolanaContext.js.map

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

package/build/solana/constants.d.ts

@@ -0,0 +1,21 @@
+/** System Program's Transfer instruction index (SystemInstruction enum variant 2). */
+export declare const TRANSFER_INSTRUCTION_INDEX = 2;
+export declare const LAMPORTS_PER_SOL: bigint;
+/**
+ * Solana System Program address.
+ * Not exported by @solana/kit v5 directly — defined here as a typed constant.
+ * Source: https://docs.solana.com/developing/runtime-facilities/programs#system-program
+ */
+export declare const SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+/**
+ * Base fee per signature (5,000 lamports). Does NOT include priority fees,
+ * which should be estimated dynamically via getPriorityFeeEstimate.
+ * See https://helius.dev/blog/solana-fees-in-theory-and-practice
+ */
+export declare const BASE_FEE_LAMPORTS: bigint;
+/**
+ * Rent-exempt minimum for a zero-data system account (0 bytes of data).
+ * Derived from (128 + 0) bytes * 3,480 lamports/byte-year * 2 years = 890,880 lamports.
+ * For accounts with data, use getMinimumBalanceForRentExemption RPC call instead.
+ */
+export declare const RENT_EXEMPT_MINIMUM_LAMPORTS: bigint;

package/build/solana/constants.js

@@ -0,0 +1,24 @@
+/** System Program's Transfer instruction index (SystemInstruction enum variant 2). */
+const TRANSFER_INSTRUCTION_INDEX = 2;
+const LAMPORTS_PER_SOL = BigInt(1000000000);
+/**
+ * Solana System Program address.
+ * Not exported by @solana/kit v5 directly — defined here as a typed constant.
+ * Source: https://docs.solana.com/developing/runtime-facilities/programs#system-program
+ */
+const SYSTEM_PROGRAM_ADDRESS = '11111111111111111111111111111111';
+/**
+ * Base fee per signature (5,000 lamports). Does NOT include priority fees,
+ * which should be estimated dynamically via getPriorityFeeEstimate.
+ * See https://helius.dev/blog/solana-fees-in-theory-and-practice
+ */
+const BASE_FEE_LAMPORTS = BigInt(5000);
+/**
+ * Rent-exempt minimum for a zero-data system account (0 bytes of data).
+ * Derived from (128 + 0) bytes * 3,480 lamports/byte-year * 2 years = 890,880 lamports.
+ * For accounts with data, use getMinimumBalanceForRentExemption RPC call instead.
+ */
+const RENT_EXEMPT_MINIMUM_LAMPORTS = BigInt(890880);
+
+export { BASE_FEE_LAMPORTS, LAMPORTS_PER_SOL, RENT_EXEMPT_MINIMUM_LAMPORTS, SYSTEM_PROGRAM_ADDRESS, TRANSFER_INSTRUCTION_INDEX };
+//# sourceMappingURL=constants.js.map

package/build/solana/constants.js.map

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

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

@@ -0,0 +1,16 @@
+import { RecoveryMethod, type RecoveryParams } from '@openfort/openfort-js';
+import type { BuildRecoveryParamsConfig } from '../../shared/utils/recovery';
+import type { SetActiveSolanaWalletOptions } from '../types';
+type ResolveRecoveryResult = {
+    needsRecovery: true;
+} | {
+    needsRecovery: false;
+    recoveryParams: RecoveryParams;
+};
+export declare function resolveRecoveryForSetActive(account: {
+    recoveryMethod?: RecoveryMethod;
+    recoveryMethodDetails?: {
+        passkeyId?: string;
+    };
+}, activeOptions: SetActiveSolanaWalletOptions, config: BuildRecoveryParamsConfig): Promise<ResolveRecoveryResult>;
+export {};

package/build/solana/hooks/recoveryResolver.js

@@ -0,0 +1,39 @@
+import { RecoveryMethod } from '@openfort/openfort-js';
+import { buildRecoveryParams } from '../../shared/utils/recovery.js';
+
+async function resolveRecoveryForSetActive(account, activeOptions, config) {
+    var _a, _b, _c, _d, _e, _f;
+    const password = activeOptions.password;
+    const hasExplicitRecovery = activeOptions.recoveryParams != null || password != null || activeOptions.recoveryMethod !== undefined;
+    if (activeOptions.recoveryParams) {
+        return { needsRecovery: false, recoveryParams: activeOptions.recoveryParams };
+    }
+    if (!hasExplicitRecovery) {
+        const method = (_a = account.recoveryMethod) !== null && _a !== void 0 ? _a : RecoveryMethod.AUTOMATIC;
+        if (method === RecoveryMethod.PASSKEY) {
+            const passkeyId = (_b = activeOptions.passkeyId) !== null && _b !== void 0 ? _b : (_c = account.recoveryMethodDetails) === null || _c === void 0 ? void 0 : _c.passkeyId;
+            return {
+                needsRecovery: false,
+                recoveryParams: {
+                    recoveryMethod: RecoveryMethod.PASSKEY,
+                    ...(passkeyId && { passkeyInfo: { passkeyId } }),
+                },
+            };
+        }
+        if (method === RecoveryMethod.PASSWORD) {
+            return { needsRecovery: true };
+        }
+        const recoveryParams = await buildRecoveryParams({ recoveryMethod: undefined, otpCode: activeOptions.otpCode }, config);
+        return { needsRecovery: false, recoveryParams };
+    }
+    const recoveryParams = await buildRecoveryParams({
+        recoveryMethod: (_d = activeOptions.recoveryMethod) !== null && _d !== void 0 ? _d : (password != null ? RecoveryMethod.PASSWORD : undefined),
+        passkeyId: (_e = activeOptions.passkeyId) !== null && _e !== void 0 ? _e : (_f = account.recoveryMethodDetails) === null || _f === void 0 ? void 0 : _f.passkeyId,
+        password,
+        otpCode: activeOptions.otpCode,
+    }, config);
+    return { needsRecovery: false, recoveryParams };
+}
+
+export { resolveRecoveryForSetActive };
+//# sourceMappingURL=recoveryResolver.js.map

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

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

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

@@ -0,0 +1,17 @@
+import type { SolanaWalletState, UseEmbeddedSolanaWalletOptions } from '../types';
+/**
+ * Returns state for Solana embedded wallets: create, recover, list, active wallet, and provider.
+ * Use for creating accounts, recovering existing ones, and signing transactions.
+ *
+ * @param options - Optional cluster override (like chainId on Ethereum) and recoveryParams
+ * @returns State with status, wallets, activeWallet, create, recover, setActive, provider, cluster, rpcUrl
+ *
+ * @example
+ * ```tsx
+ * const solana = useSolanaEmbeddedWallet()
+ * if (solana.status === 'connected' && solana.provider) {
+ *   const sig = await solana.provider.signTransaction(tx)
+ * }
+ * ```
+ */
+export declare function useSolanaEmbeddedWallet(options?: UseEmbeddedSolanaWalletOptions): SolanaWalletState;

package/build/solana/hooks/useSolanaEmbeddedWallet.js

@@ -0,0 +1,389 @@
+import { ChainTypeEnum, AccountTypeEnum, EmbeddedState } from '@openfort/openfort-js';
+import { useRef, useState, useMemo, useCallback, useEffect, useContext } from 'react';
+import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
+import { useOpenfortCore } from '../../openfort/useOpenfort.js';
+import { buildEmbeddedWalletStatusResult } from '../../shared/utils/embeddedWalletStatusMapper.js';
+import { buildRecoveryParams } from '../../shared/utils/recovery.js';
+import { toConnectedStateProperties } from '../../shared/utils/walletStatusProps.js';
+import { formatAddress } from '../../utils/format.js';
+import { getDefaultSolanaRpcUrl } from '../../utils/rpc.js';
+import { getTransactionBytes } from '../operations.js';
+import { createSolanaProvider } from '../provider.js';
+import { SolanaContext } from '../SolanaContext.js';
+import { resolveRecoveryForSetActive } from './recoveryResolver.js';
+
+/**
+ * Returns state for Solana embedded wallets: create, recover, list, active wallet, and provider.
+ * Use for creating accounts, recovering existing ones, and signing transactions.
+ *
+ * @param options - Optional cluster override (like chainId on Ethereum) and recoveryParams
+ * @returns State with status, wallets, activeWallet, create, recover, setActive, provider, cluster, rpcUrl
+ *
+ * @example
+ * ```tsx
+ * const solana = useSolanaEmbeddedWallet()
+ * if (solana.status === 'connected' && solana.provider) {
+ *   const sig = await solana.provider.signTransaction(tx)
+ * }
+ * ```
+ */
+function useSolanaEmbeddedWallet(options) {
+    var _a, _b, _c, _d, _e;
+    const { client, embeddedAccounts, embeddedState, isLoadingAccounts, activeEmbeddedAddress, updateEmbeddedAccounts, setActiveEmbeddedAddress, setWalletStatus, } = useOpenfortCore();
+    const { walletConfig, chainType } = useOpenfort();
+    const setActiveInProgressRef = useRef(null);
+    const solanaAccountsRef = useRef([]);
+    const [state, setState] = useState({
+        status: 'disconnected',
+        activeWallet: null,
+        provider: null,
+        error: null,
+    });
+    const solanaAccounts = useMemo(() => {
+        if (!embeddedAccounts)
+            return [];
+        return embeddedAccounts.filter((acc) => acc.chainType === ChainTypeEnum.SVM);
+    }, [embeddedAccounts]);
+    solanaAccountsRef.current = solanaAccounts;
+    const createProviderForAccount = useCallback((account) => {
+        return createSolanaProvider({
+            account,
+            signMessage: async (message) => {
+                const signature = await client.embeddedWallet.signMessage(message, {
+                    hashMessage: false, // Ed25519 - no keccak256
+                });
+                return signature;
+            },
+            signTransaction: async (transaction) => {
+                const messageBytes = getTransactionBytes(transaction);
+                const signature = await client.embeddedWallet.signMessage(new Uint8Array(messageBytes), {
+                    hashMessage: false, // Ed25519 - no keccak256
+                });
+                return {
+                    signature: signature,
+                    publicKey: account.address,
+                };
+            },
+            signAllTransactions: async (transactions) => {
+                const results = await Promise.all(transactions.map(async (tx) => {
+                    const messageBytes = getTransactionBytes(tx);
+                    const signature = await client.embeddedWallet.signMessage(new Uint8Array(messageBytes), {
+                        hashMessage: false, // Ed25519 - no keccak256
+                    });
+                    return {
+                        signature: signature,
+                        publicKey: account.address,
+                    };
+                }));
+                return results;
+            },
+        });
+    }, [client]);
+    const wallets = useMemo(() => {
+        return solanaAccounts.map((acc, index) => ({
+            id: acc.id,
+            address: acc.address,
+            chainType: ChainTypeEnum.SVM,
+            walletIndex: index,
+            recoveryMethod: acc.recoveryMethod,
+            getProvider: async () => createProviderForAccount(acc),
+        }));
+    }, [solanaAccounts, createProviderForAccount]);
+    useEffect(() => {
+        if (state.status === 'creating') {
+            setWalletStatus({ status: 'creating' });
+        }
+        else if (state.status === 'connecting' && state.activeWallet) {
+            setWalletStatus({ status: 'connecting' });
+        }
+        else {
+            setWalletStatus({ status: 'idle' });
+        }
+    }, [state.status, (_a = state.activeWallet) === null || _a === void 0 ? void 0 : _a.address, setWalletStatus]);
+    const create = useCallback(async (createOptions) => {
+        var _a, _b;
+        setState((s) => ({ ...s, status: 'creating', error: null }));
+        try {
+            if (!walletConfig) {
+                throw new OpenfortError('Wallet config not found', OpenfortReactErrorType.CONFIGURATION_ERROR);
+            }
+            const recoveryParams = await buildRecoveryParams({
+                recoveryMethod: createOptions === null || createOptions === void 0 ? void 0 : createOptions.recoveryMethod,
+                passkeyId: createOptions === null || createOptions === void 0 ? void 0 : createOptions.passkeyId,
+                password: createOptions === null || createOptions === void 0 ? void 0 : createOptions.password,
+                otpCode: createOptions === null || createOptions === void 0 ? void 0 : createOptions.otpCode,
+            }, {
+                walletConfig,
+                getAccessToken: () => client.getAccessToken(),
+                getUserId: () => client.user.get().then((u) => u === null || u === void 0 ? void 0 : u.id),
+            });
+            const account = await client.embeddedWallet.create({
+                chainType: ChainTypeEnum.SVM,
+                accountType: AccountTypeEnum.EOA,
+                recoveryParams,
+            });
+            await updateEmbeddedAccounts({ silent: true });
+            const provider = createProviderForAccount(account);
+            const connectedWallet = {
+                id: account.id,
+                address: account.address,
+                chainType: ChainTypeEnum.SVM,
+                walletIndex: 0,
+                recoveryMethod: account.recoveryMethod,
+                getProvider: async () => provider,
+            };
+            setState({
+                status: 'connected',
+                activeWallet: connectedWallet,
+                provider,
+                error: null,
+            });
+            setActiveEmbeddedAddress(account.address);
+            (_a = createOptions === null || createOptions === void 0 ? void 0 : createOptions.onSuccess) === null || _a === void 0 ? void 0 : _a.call(createOptions, { account });
+            return account;
+        }
+        catch (err) {
+            const error = err instanceof OpenfortError
+                ? err
+                : new OpenfortError('Failed to create Solana wallet', OpenfortReactErrorType.WALLET_ERROR, { error: err });
+            setState((s) => ({
+                ...s,
+                status: 'error',
+                error: error.message,
+            }));
+            (_b = createOptions === null || createOptions === void 0 ? void 0 : createOptions.onError) === null || _b === void 0 ? void 0 : _b.call(createOptions, error);
+            throw error;
+        }
+    }, [client, walletConfig, createProviderForAccount, updateEmbeddedAccounts, setActiveEmbeddedAddress]);
+    const setActive = useCallback(async (activeOptions) => {
+        const run = async () => {
+            const accounts = solanaAccountsRef.current;
+            const account = accounts.find((acc) => acc.address === activeOptions.address);
+            if (!account) {
+                throw new OpenfortError('Embedded wallet not found', OpenfortReactErrorType.WALLET_ERROR, {
+                    address: activeOptions.address,
+                });
+            }
+            const connectingStub = {
+                id: account.id,
+                address: account.address,
+                chainType: ChainTypeEnum.SVM,
+                walletIndex: accounts.indexOf(account),
+                recoveryMethod: account.recoveryMethod,
+                getProvider: async () => {
+                    throw new OpenfortError('Provider not ready yet', OpenfortReactErrorType.WALLET_ERROR);
+                },
+            };
+            setState((s) => ({ ...s, status: 'connecting', activeWallet: connectingStub, error: null }));
+            try {
+                const config = {
+                    walletConfig,
+                    getAccessToken: () => client.getAccessToken(),
+                    getUserId: () => client.user.get().then((u) => u === null || u === void 0 ? void 0 : u.id),
+                };
+                const resolved = await resolveRecoveryForSetActive(account, activeOptions, config);
+                if (resolved.needsRecovery) {
+                    setState((s) => ({ ...s, status: 'needs-recovery', error: null }));
+                    return;
+                }
+                const recoveryParams = resolved.recoveryParams;
+                if (recoveryParams) {
+                    await client.embeddedWallet.recover({
+                        account: account.id,
+                        recoveryParams,
+                    });
+                }
+                const provider = createProviderForAccount(account);
+                const connectedWallet = {
+                    id: account.id,
+                    address: account.address,
+                    chainType: ChainTypeEnum.SVM,
+                    walletIndex: accounts.indexOf(account),
+                    recoveryMethod: account.recoveryMethod,
+                    getProvider: async () => provider,
+                };
+                setState({
+                    status: 'connected',
+                    activeWallet: connectedWallet,
+                    provider,
+                    error: null,
+                });
+                setActiveEmbeddedAddress(account.address);
+            }
+            catch (err) {
+                const error = err instanceof OpenfortError
+                    ? err
+                    : new OpenfortError('Failed to set active Solana wallet', OpenfortReactErrorType.WALLET_ERROR, {
+                        error: err,
+                    });
+                setState((s) => ({
+                    ...s,
+                    status: 'error',
+                    error: error.message,
+                }));
+                throw error;
+            }
+        };
+        const prev = setActiveInProgressRef.current;
+        if (prev) {
+            try {
+                await prev;
+            }
+            catch {
+                /* ignore previous operation's error */
+            }
+        }
+        const promise = run();
+        setActiveInProgressRef.current = promise;
+        try {
+            await promise;
+        }
+        finally {
+            if (setActiveInProgressRef.current === promise)
+                setActiveInProgressRef.current = null;
+        }
+    }, [client, walletConfig, createProviderForAccount, setActiveEmbeddedAddress]);
+    const setRecovery = useCallback(async (recoveryOptions) => {
+        try {
+            await client.embeddedWallet.setRecoveryMethod(recoveryOptions.previousRecovery, recoveryOptions.newRecovery);
+            await updateEmbeddedAccounts({ silent: true });
+        }
+        catch (err) {
+            const error = err instanceof OpenfortError
+                ? err
+                : new OpenfortError('Failed to set recovery method', OpenfortReactErrorType.WALLET_ERROR, { error: err });
+            throw error;
+        }
+    }, [client, updateEmbeddedAccounts]);
+    const exportPrivateKey = useCallback(async () => {
+        return await client.embeddedWallet.exportPrivateKey();
+    }, [client]);
+    const actions = useMemo(() => ({
+        create,
+        wallets,
+        setActive,
+        setRecovery,
+        exportPrivateKey,
+    }), [create, wallets, setActive, setRecovery, exportPrivateKey]);
+    // Clear local state when core clears activeEmbeddedAddress (e.g. logout).
+    useEffect(() => {
+        if (!activeEmbeddedAddress && (state.status === 'connected' || state.status === 'needs-recovery')) {
+            setState({ status: 'disconnected', activeWallet: null, provider: null, error: null });
+        }
+    }, [activeEmbeddedAddress, state.status]);
+    // Sync local state from core's activeEmbeddedAddress (single source of truth).
+    useEffect(() => {
+        var _a;
+        if (isLoadingAccounts ||
+            solanaAccounts.length === 0 ||
+            embeddedState !== EmbeddedState.READY ||
+            state.status === 'connecting' ||
+            state.status === 'reconnecting' ||
+            state.status === 'creating'
+        // NOTE: 'error' is intentionally NOT blocked here — mirrors EVM hook behaviour.
+        // If setActive failed but embeddedState is READY, the sync can self-heal by
+        // rebuilding the provider directly (no recover() call needed).
+        ) {
+            return;
+        }
+        const accountByAddress = activeEmbeddedAddress
+            ? solanaAccounts.find((acc) => acc.address === activeEmbeddedAddress)
+            : undefined;
+        const currentMatches = state.status === 'connected' && ((_a = state.activeWallet) === null || _a === void 0 ? void 0 : _a.address) === activeEmbeddedAddress;
+        if (!activeEmbeddedAddress && state.status === 'connected') {
+            setState({ status: 'disconnected', activeWallet: null, provider: null, error: null });
+            return;
+        }
+        if (accountByAddress && !currentMatches) {
+            const provider = createProviderForAccount(accountByAddress);
+            const connectedWallet = {
+                id: accountByAddress.id,
+                address: accountByAddress.address,
+                chainType: ChainTypeEnum.SVM,
+                walletIndex: solanaAccounts.indexOf(accountByAddress),
+                recoveryMethod: accountByAddress.recoveryMethod,
+                getProvider: async () => provider,
+            };
+            setState({
+                status: 'connected',
+                activeWallet: connectedWallet,
+                provider,
+                error: null,
+            });
+        }
+        // activeEmbeddedAddress is from other chain (e.g. EVM); auto-activate first SVM wallet.
+        // Only when on SVM view to prevent ping-pong with Ethereum hook.
+        // Also runs from 'error' state: if setActive failed (e.g. recover() threw) but the
+        // address still points to an EVM wallet, we need to re-point to the SVM wallet so
+        // the sync effect above can self-heal via createProviderForAccount.
+        if (chainType === ChainTypeEnum.SVM &&
+            !accountByAddress &&
+            activeEmbeddedAddress &&
+            solanaAccounts.length > 0 &&
+            (state.status === 'disconnected' || state.status === 'error')) {
+            setActiveEmbeddedAddress(solanaAccounts[0].address);
+        }
+    }, [
+        isLoadingAccounts,
+        state.status,
+        (_b = state.activeWallet) === null || _b === void 0 ? void 0 : _b.address,
+        solanaAccounts,
+        embeddedState,
+        activeEmbeddedAddress,
+        chainType,
+        createProviderForAccount,
+        setActiveEmbeddedAddress,
+    ]);
+    const derived = useMemo(() => ({
+        isLoading: state.status === 'fetching-wallets' ||
+            state.status === 'connecting' ||
+            state.status === 'creating' ||
+            state.status === 'reconnecting',
+        isError: state.status === 'error',
+        isSuccess: state.status === 'connected',
+    }), [state.status]);
+    // Cluster: option override (parity with Ethereum chainId) or Solana context
+    const solanaContext = useContext(SolanaContext);
+    const cluster = ((_c = options === null || options === void 0 ? void 0 : options.cluster) !== null && _c !== void 0 ? _c : solanaContext === null || solanaContext === void 0 ? void 0 : solanaContext.cluster);
+    const rpcUrl = solanaContext && solanaContext.cluster === cluster
+        ? solanaContext.rpcUrl
+        : cluster
+            ? getDefaultSolanaRpcUrl(cluster)
+            : solanaContext === null || solanaContext === void 0 ? void 0 : solanaContext.rpcUrl;
+    const connectedStateProps = useMemo(() => toConnectedStateProperties(state.status, state.activeWallet), [state.status, state.activeWallet]);
+    // Compute displayAddress when connected
+    const displayAddress = useMemo(() => {
+        var _a;
+        return ((_a = state.activeWallet) === null || _a === void 0 ? void 0 : _a.address) && (state.status === 'connected' || state.status === 'connecting')
+            ? formatAddress(state.activeWallet.address, ChainTypeEnum.SVM)
+            : undefined;
+    }, [(_d = state.activeWallet) === null || _d === void 0 ? void 0 : _d.address, state.status]);
+    if (isLoadingAccounts) {
+        return {
+            ...actions,
+            status: 'fetching-wallets',
+            activeWallet: null,
+            isLoading: true,
+            isError: false,
+            isSuccess: false,
+            embeddedWalletId: undefined,
+            isConnected: false,
+            isConnecting: true,
+            isDisconnected: false,
+            isReconnecting: false,
+        };
+    }
+    return {
+        ...buildEmbeddedWalletStatusResult(state, actions),
+        ...derived,
+        ...connectedStateProps,
+        ...(displayAddress && { displayAddress }),
+        ...(((_e = state.activeWallet) === null || _e === void 0 ? void 0 : _e.address) && { address: state.activeWallet.address }),
+        ...(cluster && { cluster }),
+        ...(rpcUrl && { rpcUrl }),
+    };
+}
+
+export { useSolanaEmbeddedWallet };
+//# sourceMappingURL=useSolanaEmbeddedWallet.js.map

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

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

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

@@ -0,0 +1,2 @@
+export declare function solToLamports(sol: number): bigint;
+export declare function formatSol(lamports: bigint, decimals?: number): string;

package/build/solana/hooks/utils.js

@@ -0,0 +1,18 @@
+import { LAMPORTS_PER_SOL } from '../constants.js';
+
+function solToLamports(sol) {
+    // Use toFixed(9) to avoid scientific notation (e.g. 1e-9) for small values
+    const str = sol.toFixed(9);
+    const [whole = '0', frac = ''] = str.split('.');
+    const padded = frac.slice(0, 9);
+    return BigInt(whole) * LAMPORTS_PER_SOL + BigInt(padded);
+}
+function formatSol(lamports, decimals = 4) {
+    const whole = lamports / LAMPORTS_PER_SOL;
+    const remainder = lamports % LAMPORTS_PER_SOL;
+    const fracStr = remainder.toString().padStart(9, '0');
+    return `${whole}.${fracStr}`.replace(new RegExp(`(\\d*\\.\\d{${decimals}})\\d*`), '$1');
+}
+
+export { formatSol, solToLamports };
+//# sourceMappingURL=utils.js.map

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

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

package/build/solana/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Solana-specific exports for @openfort/react/solana
+ *
+ * Import from '@openfort/react/solana' for Solana-only features.
+ * Tree-shakeable: only imported Solana code will be bundled.
+ *
+ * @packageDocumentation
+ */
+export type { SolanaUserWallet } from '../hooks/openfort/walletTypes';
+export type { CreateEmbeddedWalletOptions, CreateEmbeddedWalletResult, } from '../shared/types';
+export { useSolanaEmbeddedWallet } from './hooks/useSolanaEmbeddedWallet';
+export type { ConnectedEmbeddedSolanaWallet, OpenfortEmbeddedSolanaWalletProvider, SetActiveSolanaWalletOptions, SignedSolanaTransaction, SolanaCluster, SolanaCommitment, SolanaConfig, SolanaSignAllTransactionsRequest, SolanaSignMessageRequest, SolanaSignTransactionRequest, SolanaTransaction, SolanaWalletActions, SolanaWalletState, UseEmbeddedSolanaWalletOptions, } from './types';

package/build/solana/index.js

@@ -0,0 +1,2 @@
+export { useSolanaEmbeddedWallet } from './hooks/useSolanaEmbeddedWallet.js';
+//# sourceMappingURL=index.js.map

package/build/solana/index.js.map

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