@openfort/react 0.3.2 → 1.0.0

package/build/openfort/hooks/useAutoRecovery.js

@@ -0,0 +1,102 @@
+import { EmbeddedState, RecoveryMethod } from '@openfort/openfort-js';
+import { useRef, useEffect } from 'react';
+import { buildRecoveryParams } from '../../shared/utils/recovery.js';
+import { logger } from '../../utils/logger.js';
+
+/**
+ * Auto-recover: when the SDK reaches EMBEDDED_SIGNER_NOT_CONFIGURED with a known
+ * active address, attempts to configure the signer via recover() → READY.
+ *
+ * Reads embeddedAccounts imperatively from the store (not as a dep) so that
+ * fetchEmbeddedAccounts updating the store mid-recovery does not re-trigger the
+ * effect and cancel the closure before recover() runs.
+ *
+ * PASSWORD recovery is skipped — it requires explicit user input.
+ *
+ * On failure: surfaces recoveryError in the store. Does NOT auto-create a new wallet
+ * because silently replacing a wallet can strand the user's funds.
+ */
+function useAutoRecovery({ storeEmbeddedState, storeActiveEmbeddedAddress, openfort, walletConfig, store, }) {
+    const autoRecoverInProgressRef = useRef(false);
+    useEffect(() => {
+        if (storeEmbeddedState !== EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED)
+            return;
+        if (!storeActiveEmbeddedAddress)
+            return;
+        if (!openfort || !walletConfig)
+            return;
+        if (autoRecoverInProgressRef.current)
+            return;
+        const accounts = store.getState().embeddedAccounts;
+        if (!(accounts === null || accounts === void 0 ? void 0 : accounts.length))
+            return;
+        const normalizedTarget = storeActiveEmbeddedAddress.toLowerCase();
+        const account = accounts.find((a) => a.address.toLowerCase() === normalizedTarget);
+        if (!account)
+            return;
+        // PASSWORD recovery requires explicit user input — skip auto-recover.
+        if (account.recoveryMethod === RecoveryMethod.PASSWORD)
+            return;
+        // Reset any stale error from a previous attempt before starting fresh.
+        store.getState().setRecoveryError(null);
+        autoRecoverInProgressRef.current = true;
+        let cancelled = false;
+        logger.log('[auto-recover] starting', {
+            address: account.address,
+            method: account.recoveryMethod,
+        });
+        const run = async () => {
+            var _a;
+            // Stage 1: build recovery params (may trigger a passkey prompt for PASSKEY method).
+            logger.log('[auto-recover] building recovery params...');
+            let recoveryParams;
+            try {
+                recoveryParams = await buildRecoveryParams({
+                    recoveryMethod: account.recoveryMethod === RecoveryMethod.PASSKEY ? RecoveryMethod.PASSKEY : undefined,
+                    passkeyId: account.recoveryMethod === RecoveryMethod.PASSKEY ? (_a = account.recoveryMethodDetails) === null || _a === void 0 ? void 0 : _a.passkeyId : undefined,
+                }, {
+                    walletConfig,
+                    getAccessToken: () => openfort.getAccessToken(),
+                    getUserId: async () => { var _a; return (_a = (await openfort.user.get())) === null || _a === void 0 ? void 0 : _a.id; },
+                });
+            }
+            catch (err) {
+                if (cancelled)
+                    return;
+                const error = err instanceof Error ? err : new Error(String(err));
+                logger.error('[auto-recover] failed to build recovery params', error);
+                store.getState().setRecoveryError(error);
+                return;
+            }
+            if (cancelled)
+                return;
+            // Stage 2: configure the embedded signer.
+            logger.log('[auto-recover] configuring signer...');
+            try {
+                await openfort.embeddedWallet.recover({ account: account.id, recoveryParams });
+                if (cancelled)
+                    return;
+                logger.log('[auto-recover] succeeded — signer ready', { address: account.address });
+                // recoveryError clears automatically in the store subscriber when embeddedState → READY.
+            }
+            catch (err) {
+                if (cancelled)
+                    return;
+                const error = err instanceof Error ? err : new Error(String(err));
+                logger.error('[auto-recover] recover() failed — signer could not be configured. ' +
+                    'This typically happens on a new device or after local storage was cleared. ' +
+                    'Read `recoveryError` from useOpenfortCore() and prompt the user to create a new wallet.', error);
+                store.getState().setRecoveryError(error);
+            }
+        };
+        run().finally(() => {
+            autoRecoverInProgressRef.current = false;
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [storeEmbeddedState, storeActiveEmbeddedAddress, openfort, walletConfig, store]);
+}
+
+export { useAutoRecovery };
+//# sourceMappingURL=useAutoRecovery.js.map

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

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

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

@@ -0,0 +1,31 @@
+import { type EmbeddedAccount, type Openfort, type User } from '@openfort/openfort-js';
+import { type Dispatch, type MutableRefObject, type SetStateAction } from 'react';
+import type { StoreApi } from 'zustand/vanilla';
+import type { OpenfortStore } from '../store';
+type Params = {
+    openfort: Openfort;
+    storeEmbeddedState: OpenfortStore['embeddedState'];
+    storeUser: OpenfortStore['user'];
+    store: StoreApi<OpenfortStore>;
+    updateUserRef: MutableRefObject<(user?: User, logoutOnError?: boolean) => Promise<User | null>>;
+    fetchEmbeddedAccountsRef: MutableRefObject<(options?: {
+        silent?: boolean;
+    }) => Promise<EmbeddedAccount[]>>;
+};
+type Result = {
+    isConnectedWithEmbeddedSigner: boolean;
+    setIsConnectedWithEmbeddedSigner: Dispatch<SetStateAction<boolean>>;
+    connectingRef: MutableRefObject<boolean>;
+};
+/**
+ * Reacts to embedded state transitions and performs the appropriate side effects:
+ *
+ * - UNAUTHENTICATED → clears the store user
+ * - EMBEDDED_SIGNER_NOT_CONFIGURED → resets connect state, validates token, fetches accounts
+ * - READY → polls until user is confirmed in the store
+ *
+ * Returns `isConnectedWithEmbeddedSigner`, its setter, and `connectingRef` so that
+ * the bridge-connect effect and `logout` in CoreOpenfortProvider can share them.
+ */
+export declare function useEmbeddedStateMachine({ openfort, storeEmbeddedState, storeUser, store, updateUserRef, fetchEmbeddedAccountsRef, }: Params): Result;
+export {};

package/build/openfort/hooks/useEmbeddedStateMachine.js

@@ -0,0 +1,77 @@
+import { EmbeddedState } from '@openfort/openfort-js';
+import { useState, useRef, useLayoutEffect, useEffect } from 'react';
+import { logger } from '../../utils/logger.js';
+
+/**
+ * Reacts to embedded state transitions and performs the appropriate side effects:
+ *
+ * - UNAUTHENTICATED → clears the store user
+ * - EMBEDDED_SIGNER_NOT_CONFIGURED → resets connect state, validates token, fetches accounts
+ * - READY → polls until user is confirmed in the store
+ *
+ * Returns `isConnectedWithEmbeddedSigner`, its setter, and `connectingRef` so that
+ * the bridge-connect effect and `logout` in CoreOpenfortProvider can share them.
+ */
+function useEmbeddedStateMachine({ openfort, storeEmbeddedState, storeUser, store, updateUserRef, fetchEmbeddedAccountsRef, }) {
+    const [isConnectedWithEmbeddedSigner, setIsConnectedWithEmbeddedSigner] = useState(false);
+    const connectingRef = useRef(false);
+    const userRef = useRef(storeUser);
+    useLayoutEffect(() => {
+        userRef.current = storeUser;
+    }, [storeUser]);
+    useEffect(() => {
+        if (!openfort)
+            return;
+        let cancelled = false;
+        switch (storeEmbeddedState) {
+            case EmbeddedState.NONE:
+            case EmbeddedState.CREATING_ACCOUNT:
+                break;
+            case EmbeddedState.UNAUTHENTICATED:
+                store.getState().setUser(null);
+                break;
+            case EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED: {
+                connectingRef.current = false;
+                setIsConnectedWithEmbeddedSigner(false);
+                // Validate token and fetch accounts. Auto-recovery is handled by the
+                // dedicated useAutoRecovery hook (keyed on storeActiveEmbeddedAddress).
+                const doFetch = async () => {
+                    updateUserRef.current(undefined, !userRef.current);
+                    await fetchEmbeddedAccountsRef.current();
+                };
+                doFetch().catch((err) => {
+                    if (!cancelled) {
+                        logger.error('EMBEDDED_SIGNER_NOT_CONFIGURED flow failed', err);
+                    }
+                });
+                break;
+            }
+            case EmbeddedState.READY: {
+                const pollUserUntilReady = async () => {
+                    for (let i = 0; i < 5; i++) {
+                        if (cancelled)
+                            return;
+                        try {
+                            const user = await updateUserRef.current(undefined, true);
+                            if (user)
+                                break;
+                        }
+                        catch (_err) { }
+                        await new Promise((resolve) => setTimeout(resolve, 250));
+                    }
+                };
+                pollUserUntilReady();
+                break;
+            }
+            default:
+                throw new Error(`Unknown embedded state: ${storeEmbeddedState}`);
+        }
+        return () => {
+            cancelled = true;
+        };
+    }, [storeEmbeddedState, openfort, store]);
+    return { isConnectedWithEmbeddedSigner, setIsConnectedWithEmbeddedSigner, connectingRef };
+}
+
+export { useEmbeddedStateMachine };
+//# sourceMappingURL=useEmbeddedStateMachine.js.map

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

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

package/build/openfort/selectors.d.ts

@@ -0,0 +1,9 @@
+import { EmbeddedState } from '@openfort/openfort-js';
+import type { OpenfortStore } from './store';
+export declare const selectUser: (s: OpenfortStore) => import("@openfort/openfort-js").User | null;
+export declare const selectEmbeddedState: (s: OpenfortStore) => EmbeddedState;
+export declare const selectIsLoading: (s: OpenfortStore) => boolean;
+export declare const selectIsAuthenticated: (s: OpenfortStore) => boolean;
+export declare const selectWalletStatus: (s: OpenfortStore) => import("../hooks/openfort/walletTypes").WalletFlowStatus;
+export declare const selectActiveAddress: (s: OpenfortStore) => string | undefined;
+export declare const selectChainType: (s: OpenfortStore) => import("@openfort/openfort-js").ChainTypeEnum;

package/build/openfort/selectors.js

@@ -0,0 +1,15 @@
+import { EmbeddedState } from '@openfort/openfort-js';
+
+const selectUser = (s) => s.user;
+const selectEmbeddedState = (s) => s.embeddedState;
+const selectIsLoading = (s) => s.isLoading;
+const selectIsAuthenticated = (s) => {
+    const es = s.embeddedState;
+    return es === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED || es === EmbeddedState.READY;
+};
+const selectWalletStatus = (s) => s.walletStatus;
+const selectActiveAddress = (s) => s.activeEmbeddedAddress;
+const selectChainType = (s) => s.chainType;
+
+export { selectActiveAddress, selectChainType, selectEmbeddedState, selectIsAuthenticated, selectIsLoading, selectUser, selectWalletStatus };
+//# sourceMappingURL=selectors.js.map

package/build/openfort/selectors.js.map

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

package/build/openfort/store.d.ts

@@ -0,0 +1,46 @@
+import type { EmbeddedAccount, Openfort, User, UserAccount } from '@openfort/openfort-js';
+import { type ChainTypeEnum, EmbeddedState } from '@openfort/openfort-js';
+import { type StoreApi } from 'zustand/vanilla';
+import type { WalletFlowStatus } from '../hooks/openfort/walletTypes';
+export type OpenfortStoreState = {
+    user: User | null;
+    linkedAccounts: UserAccount[];
+    embeddedState: EmbeddedState;
+    embeddedAccounts: EmbeddedAccount[] | undefined;
+    isLoadingAccounts: boolean;
+    activeEmbeddedAddress: string | undefined;
+    walletStatus: WalletFlowStatus;
+    chainType: ChainTypeEnum;
+    isLoading: boolean;
+    needsRecovery: boolean;
+    /**
+     * Set when auto-recovery fails. Null on success or when cleared by a new auth session.
+     * Consumers can read this from `useOpenfortCore()` to show recovery error UI.
+     */
+    recoveryError: Error | null;
+};
+export type OpenfortStoreActions = {
+    setUser: (user: User | null) => void;
+    setLinkedAccounts: (accounts: UserAccount[]) => void;
+    setEmbeddedState: (state: EmbeddedState) => void;
+    setEmbeddedAccounts: (accounts: EmbeddedAccount[] | undefined) => void;
+    setIsLoadingAccounts: (loading: boolean) => void;
+    setActiveEmbeddedAddress: (address: string | undefined) => void;
+    setWalletStatus: (status: WalletFlowStatus) => void;
+    setChainType: (chainType: ChainTypeEnum) => void;
+    setRecoveryError: (error: Error | null) => void;
+    /** Force-recompute isLoading from current state + bridge info. */
+    recomputeIsLoading: () => void;
+    logout: () => Promise<void>;
+    signUpGuest: () => Promise<void>;
+    updateUser: (user?: User) => Promise<User | null>;
+    updateEmbeddedAccounts: (options?: {
+        silent?: boolean;
+    }) => Promise<EmbeddedAccount[] | undefined>;
+    client: Openfort;
+};
+export type OpenfortStore = OpenfortStoreState & OpenfortStoreActions;
+export declare function createOpenfortStore(initialChainType: ChainTypeEnum, client: Openfort, getBridgeInfo?: () => {
+    hasBridge: boolean;
+    address: string | undefined;
+}): StoreApi<OpenfortStore>;

package/build/openfort/store.js

@@ -0,0 +1,116 @@
+import { EmbeddedState } from '@openfort/openfort-js';
+import { createStore } from 'zustand/vanilla';
+
+function computeIsLoading(embeddedState, user, hasBridge, bridgeAddress) {
+    switch (embeddedState) {
+        case EmbeddedState.NONE:
+        case EmbeddedState.CREATING_ACCOUNT:
+            return true;
+        case EmbeddedState.UNAUTHENTICATED:
+            return !!user;
+        case EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED:
+            return !user;
+        case EmbeddedState.READY:
+            if (!user)
+                return true;
+            if (hasBridge && !bridgeAddress)
+                return true;
+            return false;
+        default:
+            return true;
+    }
+}
+function computeNeedsRecovery(embeddedState, embeddedAccounts) {
+    var _a;
+    return embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED && ((_a = embeddedAccounts === null || embeddedAccounts === void 0 ? void 0 : embeddedAccounts.length) !== null && _a !== void 0 ? _a : 0) > 0;
+}
+function createOpenfortStore(initialChainType, client, getBridgeInfo) {
+    const store = createStore((set) => ({
+        user: null,
+        linkedAccounts: [],
+        embeddedState: EmbeddedState.NONE,
+        embeddedAccounts: undefined,
+        isLoadingAccounts: false,
+        activeEmbeddedAddress: undefined,
+        walletStatus: { status: 'idle' },
+        chainType: initialChainType,
+        isLoading: true,
+        needsRecovery: false,
+        recoveryError: null,
+        setUser: (user) => {
+            set({ user });
+        },
+        setLinkedAccounts: (linkedAccounts) => {
+            set({ linkedAccounts });
+        },
+        setEmbeddedState: (embeddedState) => {
+            set({ embeddedState });
+        },
+        setEmbeddedAccounts: (embeddedAccounts) => {
+            set({ embeddedAccounts });
+        },
+        setIsLoadingAccounts: (isLoadingAccounts) => {
+            set({ isLoadingAccounts });
+        },
+        setActiveEmbeddedAddress: (activeEmbeddedAddress) => {
+            set({ activeEmbeddedAddress });
+        },
+        setWalletStatus: (walletStatus) => {
+            set({ walletStatus });
+        },
+        setRecoveryError: (recoveryError) => {
+            set({ recoveryError });
+        },
+        setChainType: (chainType) => {
+            set({ chainType });
+        },
+        recomputeIsLoading: () => {
+            var _a;
+            const state = store.getState();
+            const info = (_a = getBridgeInfo === null || getBridgeInfo === void 0 ? void 0 : getBridgeInfo()) !== null && _a !== void 0 ? _a : { hasBridge: false, address: undefined };
+            const loading = computeIsLoading(state.embeddedState, state.user, info.hasBridge, info.address);
+            if (loading !== state.isLoading) {
+                set({ isLoading: loading });
+            }
+        },
+        // Injected by CoreOpenfortProvider after mount (depend on bridge / external refs)
+        logout: async () => { },
+        signUpGuest: async () => { },
+        updateUser: async () => null,
+        updateEmbeddedAccounts: async () => undefined,
+        client,
+    }));
+    // Recompute derived state when dependencies change
+    store.subscribe((state, prev) => {
+        var _a;
+        const embeddedStateChanged = state.embeddedState !== prev.embeddedState;
+        const userChanged = state.user !== prev.user;
+        const embeddedAccountsChanged = state.embeddedAccounts !== prev.embeddedAccounts;
+        if (embeddedStateChanged || userChanged) {
+            const info = (_a = getBridgeInfo === null || getBridgeInfo === void 0 ? void 0 : getBridgeInfo()) !== null && _a !== void 0 ? _a : { hasBridge: false, address: undefined };
+            const isLoading = computeIsLoading(state.embeddedState, state.user, info.hasBridge, info.address);
+            if (isLoading !== state.isLoading) {
+                store.setState({ isLoading });
+            }
+        }
+        if (embeddedStateChanged || embeddedAccountsChanged) {
+            const needsRecovery = computeNeedsRecovery(state.embeddedState, state.embeddedAccounts);
+            if (needsRecovery !== state.needsRecovery) {
+                store.setState({ needsRecovery });
+            }
+        }
+        // Clear recoveryError when the session reaches a clean terminal state.
+        // Avoids stale errors from a previous recovery attempt being visible after
+        // the user has successfully recovered or logged out.
+        if (embeddedStateChanged && state.recoveryError !== null) {
+            const isClearState = state.embeddedState === EmbeddedState.READY || state.embeddedState === EmbeddedState.UNAUTHENTICATED;
+            if (isClearState) {
+                store.setState({ recoveryError: null });
+            }
+        }
+    });
+    return store;
+}
+
+export { createOpenfortStore };
+//# sourceMappingURL=store.js.map

package/build/openfort/store.js.map

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

package/build/openfort/useOpenfort.d.ts

@@ -1,3 +1,9 @@
-import type { WalletFlowStatus } from '../hooks/openfort/useWallets';
-export declare const useOpenfortCore: () => import("./CoreOpenfortProvider").ContextValue;
-export declare const useWalletStatus: () => [WalletFlowStatus, (status: WalletFlowStatus) => void];
+import type { OpenfortCoreContextValue } from './CoreOpenfortProvider';
+/**
+ * Access Openfort core context: user, embedded accounts, active chain, auth, and wallet operations.
+ * Must be used inside CoreOpenfortProvider (or OpenfortProvider which wraps it).
+ *
+ * @returns Core context with user, embeddedAccounts, activeChainId, logout, etc.
+ * @throws Error if used outside CoreOpenfortProvider
+ */
+export declare const useOpenfortCore: () => OpenfortCoreContextValue;

package/build/openfort/useOpenfort.js

@@ -0,0 +1,15 @@
+import { useOpenfortStore } from './useOpenfortStore.js';
+
+/**
+ * Access Openfort core context: user, embedded accounts, active chain, auth, and wallet operations.
+ * Must be used inside CoreOpenfortProvider (or OpenfortProvider which wraps it).
+ *
+ * @returns Core context with user, embeddedAccounts, activeChainId, logout, etc.
+ * @throws Error if used outside CoreOpenfortProvider
+ */
+const useOpenfortCore = () => {
+    return useOpenfortStore((s) => s);
+};
+
+export { useOpenfortCore };
+//# sourceMappingURL=useOpenfort.js.map

package/build/openfort/useOpenfort.js.map

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

package/build/openfort/useOpenfortStore.d.ts

@@ -0,0 +1,2 @@
+import type { OpenfortStore } from './store';
+export declare function useOpenfortStore<T>(selector: (state: OpenfortStore) => T): T;

package/build/openfort/useOpenfortStore.js

@@ -0,0 +1,13 @@
+import { useContext } from 'react';
+import { useStore } from 'zustand';
+import { StoreContext } from './context.js';
+
+function useOpenfortStore(selector) {
+    const store = useContext(StoreContext);
+    if (!store)
+        throw Error('useOpenfortStore must be inside CoreOpenfortProvider.');
+    return useStore(store, selector);
+}
+
+export { useOpenfortStore };
+//# sourceMappingURL=useOpenfortStore.js.map

package/build/openfort/useOpenfortStore.js.map

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

package/build/query/index.d.ts

@@ -0,0 +1,2 @@
+export { openfortKeys } from './queryKeys';
+export { getEmbeddedAccountsQueryOptions, getUserQueryOptions } from './queryOptions';

package/build/query/queryKeys.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Centralized query key factory for all TanStack Query operations.
+ *
+ * Using a factory ensures consistent key structures across the SDK,
+ * making cache invalidation predictable and type-safe.
+ */
+export declare const openfortKeys: {
+    all: readonly ["openfort"];
+    user: () => readonly ["openfort", "user"];
+    embeddedAccounts: () => readonly ["openfort", "embeddedAccounts"];
+    walletAssets: (chainId: number, customAssets: readonly string[], address: string | undefined) => readonly ["openfort", "walletAssets", number, readonly string[], string | undefined];
+};

package/build/query/queryKeys.js

@@ -0,0 +1,15 @@
+/**
+ * Centralized query key factory for all TanStack Query operations.
+ *
+ * Using a factory ensures consistent key structures across the SDK,
+ * making cache invalidation predictable and type-safe.
+ */
+const openfortKeys = {
+    all: ['openfort'],
+    user: () => [...openfortKeys.all, 'user'],
+    embeddedAccounts: () => [...openfortKeys.all, 'embeddedAccounts'],
+    walletAssets: (chainId, customAssets, address) => [...openfortKeys.all, 'walletAssets', chainId, customAssets, address],
+};
+
+export { openfortKeys };
+//# sourceMappingURL=queryKeys.js.map

package/build/query/queryKeys.js.map

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

package/build/query/queryOptions.d.ts

@@ -0,0 +1,23 @@
+import type { Openfort } from '@openfort/openfort-js';
+/**
+ * Query options factory for fetching the current user.
+ *
+ * Returns vanilla query options (framework-agnostic) that can be used with
+ * `useQuery`, `queryClient.ensureQueryData`, or `queryClient.fetchQuery`.
+ */
+export declare function getUserQueryOptions(client: Openfort): {
+    queryKey: readonly ["openfort", "user"];
+    queryFn: () => Promise<User$2>;
+    staleTime: number;
+    retry: false;
+};
+/**
+ * Query options factory for fetching embedded wallet accounts.
+ */
+export declare function getEmbeddedAccountsQueryOptions(client: Openfort): {
+    queryKey: readonly ["openfort", "embeddedAccounts"];
+    queryFn: () => Promise<import("@openfort/openfort-js").EmbeddedAccount[]>;
+    refetchOnMount: false;
+    refetchOnWindowFocus: false;
+    retry: false;
+};

package/build/query/queryOptions.js

@@ -0,0 +1,31 @@
+import { openfortKeys } from './queryKeys.js';
+
+/**
+ * Query options factory for fetching the current user.
+ *
+ * Returns vanilla query options (framework-agnostic) that can be used with
+ * `useQuery`, `queryClient.ensureQueryData`, or `queryClient.fetchQuery`.
+ */
+function getUserQueryOptions(client) {
+    return {
+        queryKey: openfortKeys.user(),
+        queryFn: () => client.user.get(),
+        staleTime: 30000,
+        retry: false,
+    };
+}
+/**
+ * Query options factory for fetching embedded wallet accounts.
+ */
+function getEmbeddedAccountsQueryOptions(client) {
+    return {
+        queryKey: openfortKeys.embeddedAccounts(),
+        queryFn: () => client.embeddedWallet.list({ limit: 100 }),
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+        retry: false,
+    };
+}
+
+export { getEmbeddedAccountsQueryOptions, getUserQueryOptions };
+//# sourceMappingURL=queryOptions.js.map

package/build/query/queryOptions.js.map

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

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

@@ -0,0 +1,19 @@
+type UseAsyncDataOptions<T> = {
+    queryFn: () => Promise<T>;
+    queryKey: readonly unknown[];
+    enabled?: boolean;
+    refetchInterval?: number;
+    staleTime?: number;
+};
+/**
+ * Simple fetch-with-cache hook. Replaces useQuery for internal SDK use.
+ * No external dependency on TanStack Query.
+ */
+export declare function useAsyncData<T>({ queryFn, queryKey, enabled, refetchInterval, staleTime, }: UseAsyncDataOptions<T>): {
+    data: T | undefined;
+    error: Error | null;
+    isLoading: boolean;
+    isPending: boolean;
+    refetch: () => Promise<T | undefined>;
+};
+export {};

package/build/shared/hooks/useAsyncData.js

@@ -0,0 +1,69 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+/**
+ * Simple fetch-with-cache hook. Replaces useQuery for internal SDK use.
+ * No external dependency on TanStack Query.
+ */
+function useAsyncData({ queryFn, queryKey, enabled = true, refetchInterval, staleTime = 0, }) {
+    const [data, setData] = useState(undefined);
+    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 () => {
+        if (!enabled)
+            return undefined;
+        setIsLoading(true);
+        setError(null);
+        try {
+            const result = await queryFnRef.current();
+            setData(result);
+            lastFetchRef.current = Date.now();
+            return result;
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            throw e;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [enabled]);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        fetchData().catch(() => { });
+    }, [enabled, queryKeyStr]);
+    useEffect(() => {
+        if (!enabled || !refetchInterval || refetchInterval <= 0)
+            return;
+        intervalRef.current = setInterval(() => {
+            const elapsed = Date.now() - lastFetchRef.current;
+            if (staleTime > 0 && elapsed < staleTime)
+                return;
+            fetchData().catch(() => { });
+        }, refetchInterval);
+        return () => {
+            if (intervalRef.current) {
+                clearInterval(intervalRef.current);
+                intervalRef.current = null;
+            }
+        };
+    }, [enabled, refetchInterval, staleTime, fetchData]);
+    return {
+        data,
+        error,
+        isLoading,
+        isPending: isLoading,
+        refetch: fetchData,
+    };
+}
+
+export { useAsyncData };
+//# sourceMappingURL=useAsyncData.js.map