@0xkey-io/react-native-wallet-kit 0.1.0

package/dist/providers/ZeroXKeyProvider.js

@@ -0,0 +1,1846 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var utils = require('../utils/utils.js');
+var timers = require('../utils/timers.js');
+var oauth = require('../utils/oauth.js');
+var core = require('@0xkey-io/core');
+var react = require('react');
+var reactNative = require('react-native');
+var DeviceInfo = require('react-native-device-info');
+var reactNativeInappbrowserReborn = require('react-native-inappbrowser-reborn');
+var sha2 = require('@noble/hashes/sha2');
+var utils$1 = require('@noble/hashes/utils');
+var sdkTypes = require('@0xkey-io/sdk-types');
+var base = require('../types/base.js');
+var Types = require('./Types.js');
+var crypto = require('@0xkey-io/crypto');
+
+/**
+ * Provides ZeroXKey client authentication, session management, wallet operations, and user profile management
+ * for the React Native Wallet Kit SDK. This context provider encapsulates all core authentication flows (Passkey, OTP, OAuth),
+ * session lifecycle (creation, expiration, refresh), wallet import/export, and user profile updates (email, phone, name).
+ *
+ * The provider automatically initializes the ZeroXKey client, fetches configuration (including proxy auth config if needed),
+ * and synchronizes session and authentication state. It exposes a comprehensive set of methods for authentication flows,
+ * wallet management, and user profile operations, as well as UI handlers for modal-driven flows.
+ *
+ * Features:
+ * - Passkey, OTP (Email/SMS), and OAuth (Google, Apple, Facebook, Discord, X) authentication and sign-up flows.
+ * - React Native-specific OAuth: opens an in-app browser (Custom Tabs/Safari View Controller) and deep-links back via the configured app scheme.
+ * - Session management: creation, expiration scheduling, refresh, and clearing.
+ * - Wallet management: fetch, import, export, account management.
+ * - User profile management: email, phone, name, OAuth provider, and passkey linking/removal.
+ * - Error handling and callback integration for custom error and event responses.
+ *
+ * Usage:
+ * Wrap your application with `ZeroXKeyProvider` to enable authentication and wallet features via context.
+ *
+ * @param config - The ZeroXKey provider configuration object.
+ * @param children - React children to be rendered within the provider.
+ * @param callbacks - Optional callbacks for error handling and session events.
+ *
+ * @returns A React context provider exposing authentication, wallet, and user management methods and state.
+ */
+const ZeroXKeyProvider = ({ config, children, callbacks, }) => {
+    const [client, setClient] = react.useState(undefined);
+    const [session, setSession] = react.useState(undefined);
+    const [masterConfig, setMasterConfig] = react.useState(undefined);
+    const [wallets, setWallets] = react.useState([]);
+    const [user, setUser] = react.useState(undefined);
+    const [clientState, setClientState] = react.useState();
+    const [authState, setAuthState] = react.useState(base.AuthState.Unauthenticated);
+    const expiryTimeoutsRef = react.useRef({});
+    const proxyAuthConfigRef = react.useRef(null);
+    const [allSessions, setAllSessions] = react.useState(undefined);
+    // if there is no authProxyConfigId or if autoFetchWalletKitConfig is specifically
+    // set to false, we don't need to fetch the config
+    const shouldFetchWalletKitConfig = config.authProxyConfigId != null &&
+        config.authProxyConfigId !== "" &&
+        config.autoFetchWalletKitConfig !== false;
+    const buildConfig = (proxyAuthConfig) => {
+        // Juggle the local overrides with the values set in the dashboard (proxyAuthConfig).
+        // Normalize potentially empty string values coming from the app-level config
+        const sanitizedAuthProxyUrl = config.authProxyUrl && config.authProxyUrl.trim()
+            ? config.authProxyUrl
+            : undefined;
+        // Resolve OTP enablement
+        const emailOtpEnabled = config.auth?.otp?.email ??
+            proxyAuthConfig?.enabledProviders.includes("email") ??
+            false;
+        const smsOtpEnabled = config.auth?.otp?.sms ??
+            proxyAuthConfig?.enabledProviders.includes("sms") ??
+            false;
+        // Resolve shared redirect; do NOT attach scheme here. We'll attach in handler on demand.
+        const appScheme = config.auth?.oauth?.appScheme ?? undefined;
+        const redirectUrl = config.auth?.oauth?.redirectUri ??
+            proxyAuthConfig?.oauthRedirectUrl ??
+            oauth.ZEROXKEY_OAUTH_REDIRECT_URL;
+        // Warn if they are trying to set auth proxy only settings directly
+        if (proxyAuthConfig) {
+            if (config.auth?.sessionExpirationSeconds) {
+                console.warn("ZeroXKey SDK warning. You have set sessionExpirationSeconds directly in the ZeroXKeyProvider. This setting will be ignored because you are using an auth proxy. Please configure session expiration in the ZeroXKey dashboard.");
+            }
+            if (config.auth?.otp?.alphanumeric !== undefined &&
+                shouldFetchWalletKitConfig) {
+                console.warn("ZeroXKey SDK warning. You have set otpAlphanumeric directly in the ZeroXKeyProvider. This setting will be ignored because you are using an auth proxy. Please configure OTP settings in the ZeroXKey dashboard.");
+            }
+            if (config.auth?.otp?.length && shouldFetchWalletKitConfig) {
+                console.warn("ZeroXKey SDK warning. You have set otpLength directly in the ZeroXKeyProvider. This setting will be ignored because you are using an auth proxy. Please configure OTP settings in the ZeroXKey dashboard.");
+            }
+        }
+        // These are settings that can only be set via the auth proxy config
+        const authProxyPrioSettings = {
+            sessionExpirationSeconds: proxyAuthConfig?.sessionExpirationSeconds ??
+                config.auth?.sessionExpirationSeconds,
+            otp: {
+                alphanumeric: proxyAuthConfig?.otpAlphanumeric ??
+                    config.auth?.otp?.alphanumeric ??
+                    true,
+                length: proxyAuthConfig?.otpLength ?? config.auth?.otp?.length ?? "6",
+            },
+        };
+        return {
+            ...config,
+            // Ensure empty strings are not forwarded as URLs
+            authProxyUrl: sanitizedAuthProxyUrl,
+            // Overrides:
+            auth: {
+                ...config.auth,
+                // Proxy-controlled settings
+                sessionExpirationSeconds: authProxyPrioSettings.sessionExpirationSeconds,
+                otp: {
+                    ...config.auth?.otp,
+                    // Enablement flags
+                    email: emailOtpEnabled,
+                    sms: smsOtpEnabled,
+                    // Proxy-only settings
+                    alphanumeric: authProxyPrioSettings.otp.alphanumeric,
+                    length: authProxyPrioSettings.otp.length,
+                },
+                // OAuth shared settings
+                oauth: {
+                    ...config.auth?.oauth,
+                    ...(appScheme && { appScheme }),
+                    redirectUri: redirectUrl,
+                },
+                autoRefreshSession: config.auth?.autoRefreshSession ?? true,
+            },
+            autoRefreshManagedState: config.autoRefreshManagedState ?? true,
+        };
+    };
+    const getOauthProviderSettings = (provider) => {
+        const oauth$1 = masterConfig?.auth?.oauth;
+        const providerConfig = oauth$1 ? oauth$1[provider] : undefined;
+        const providerObjectConfig = providerConfig && typeof providerConfig === "object"
+            ? providerConfig
+            : undefined;
+        const proxyClientIds = proxyAuthConfigRef.current?.oauthClientIds;
+        const clientId = providerObjectConfig?.clientId ??
+            (proxyClientIds ? proxyClientIds[provider] : undefined);
+        const appScheme = oauth$1?.appScheme;
+        // For Discord and X, default to scheme-based deep link if not explicitly provided.
+        const redirectUri = providerObjectConfig?.redirectUri ??
+            ((provider === "discord" || provider === "x") && appScheme
+                ? `${appScheme}://`
+                : (oauth$1?.redirectUri ??
+                    proxyAuthConfigRef.current?.oauthRedirectUrl ??
+                    oauth.ZEROXKEY_OAUTH_REDIRECT_URL));
+        return { clientId, redirectUri, appScheme };
+    };
+    /**
+     * Initializes the ZeroXKey client with the provided configuration.
+     * This function sets up the client, fetches the proxy auth config if needed,
+     * and prepares the client for use in authentication and wallet operations.
+     *
+     * @internal
+     */
+    const initializeClient = async () => {
+        if (!masterConfig || client || clientState == base.ClientState.Loading)
+            return;
+        try {
+            setClientState(base.ClientState.Loading);
+            const zeroXKeyClient = new core.ZeroXKeyClient({
+                apiBaseUrl: masterConfig.apiBaseUrl,
+                authProxyUrl: masterConfig.authProxyUrl,
+                authProxyConfigId: masterConfig.authProxyConfigId,
+                organizationId: masterConfig.organizationId,
+                defaultStamperType: masterConfig.defaultStamperType,
+                // Define passkey and wallet config here. If we don't pass it into the client, Mr. Client will assume that we don't want to use passkeys/wallets and not create the stamper!
+                passkeyConfig: {
+                    rpId: masterConfig.passkeyConfig?.rpId,
+                    timeout: masterConfig.passkeyConfig?.timeout || 60000, // 60 seconds
+                    userVerification: masterConfig.passkeyConfig?.userVerification || "preferred",
+                    allowCredentials: masterConfig.passkeyConfig?.allowCredentials || [],
+                },
+            });
+            await zeroXKeyClient.init();
+            setClient(zeroXKeyClient);
+            // Don't set clientState to ready until we fetch the proxy auth config (See other fetchProxyAuthConfig useEffect)
+        }
+        catch (error) {
+            setClientState(base.ClientState.Error);
+            if (error instanceof sdkTypes.ZeroXKeyError ||
+                error instanceof sdkTypes.ZeroXKeyNetworkError) {
+                callbacks?.onError?.(error);
+            }
+            else {
+                callbacks?.onError?.(new sdkTypes.ZeroXKeyError(`Failed to initialize ZeroXKey client`, sdkTypes.ZeroXKeyErrorCodes.INITIALIZE_CLIENT_ERROR, error));
+            }
+        }
+    };
+    /**
+     * @internal
+     * Schedules a session expiration and warning timer for the given session key.
+     *
+     * - Sets up two timers: one for warning before expiry and one for actual expiry.
+     * - Uses capped timeouts under the hood so delays > 24.8 days are safe (see utils/timers.ts).
+     *
+     * @param params.sessionKey - The key of the session to schedule expiration for.
+     * @param params.expiry - The expiration time in seconds since epoch.
+     * @throws {ZeroXKeyError} If an error occurs while scheduling the session expiration.
+     */
+    async function scheduleSessionExpiration(params) {
+        const { sessionKey, expiry } = params;
+        try {
+            const warnKey = `${sessionKey}-warning`;
+            // Replace any prior timers for this session
+            timers.clearKey(expiryTimeoutsRef.current, sessionKey);
+            timers.clearKey(expiryTimeoutsRef.current, warnKey);
+            const now = Date.now();
+            const expiryMs = expiry * 1000;
+            const timeUntilExpiry = expiryMs - now;
+            const beforeExpiry = async () => {
+                const activeSession = await getSession();
+                if (!activeSession && expiryTimeoutsRef.current[warnKey]) {
+                    // Keep nudging until session materializes (short 10s timer is fine)
+                    timers.setTimeoutInMap(expiryTimeoutsRef.current, warnKey, beforeExpiry, 10_000);
+                    return;
+                }
+                const session = await getSession({ sessionKey });
+                if (!session)
+                    return;
+                callbacks?.beforeSessionExpiry?.({ sessionKey });
+                if (masterConfig?.auth?.autoRefreshSession) {
+                    await refreshSession({
+                        expirationSeconds: session.expirationSeconds,
+                        sessionKey,
+                    });
+                }
+            };
+            const expireSession = async () => {
+                const expiredSession = await getSession({ sessionKey });
+                if (!expiredSession)
+                    return;
+                callbacks?.onSessionExpired?.({ sessionKey });
+                if ((await getActiveSessionKey()) === sessionKey) {
+                    setSession(undefined);
+                }
+                setAllSessions((prev) => {
+                    if (!prev)
+                        return prev;
+                    const next = { ...prev };
+                    delete next[sessionKey];
+                    return next;
+                });
+                await clearSession({ sessionKey });
+                // Remove timers for this session
+                timers.clearKey(expiryTimeoutsRef.current, sessionKey);
+                timers.clearKey(expiryTimeoutsRef.current, warnKey);
+                await logout();
+            };
+            // Already expired → expire immediately
+            if (timeUntilExpiry <= 0) {
+                await expireSession();
+                return;
+            }
+            // Warning timer (if threshold is in the future)
+            const warnAt = expiryMs - utils.SESSION_WARNING_THRESHOLD_MS;
+            if (warnAt <= now) {
+                void beforeExpiry(); // fire-and-forget is fine
+            }
+            else {
+                timers.setCappedTimeoutInMap(expiryTimeoutsRef.current, warnKey, beforeExpiry, warnAt - now);
+            }
+            // Actual expiry timer (safe for long delays)
+            timers.setCappedTimeoutInMap(expiryTimeoutsRef.current, sessionKey, expireSession, timeUntilExpiry);
+        }
+        catch (error) {
+            if (error instanceof sdkTypes.ZeroXKeyError ||
+                error instanceof sdkTypes.ZeroXKeyNetworkError) {
+                callbacks?.onError?.(error);
+            }
+            else {
+                callbacks?.onError?.(new sdkTypes.ZeroXKeyError(`Failed to schedule session expiration for ${sessionKey}`, sdkTypes.ZeroXKeyErrorCodes.SCHEDULE_SESSION_EXPIRY_ERROR, error));
+            }
+        }
+    }
+    /**
+     * Clears all scheduled session timers (warning + expiry).
+     *
+     * - Removes all active timers managed by this client.
+     * - Useful on re-init or logout to avoid stale timers.
+     *
+     * @throws {ZeroXKeyError} If an error occurs while clearing the timers.
+     */
+    function clearSessionTimeouts(sessionKeys) {
+        try {
+            if (sessionKeys) {
+                timers.clearKeys(expiryTimeoutsRef.current, sessionKeys);
+            }
+            else {
+                timers.clearAll(expiryTimeoutsRef.current); // clears & deletes everything
+            }
+        }
+        catch (error) {
+            if (error instanceof sdkTypes.ZeroXKeyError ||
+                error instanceof sdkTypes.ZeroXKeyNetworkError) {
+                callbacks?.onError?.(error);
+            }
+            else {
+                callbacks?.onError?.(new sdkTypes.ZeroXKeyError("Failed to clear session timeouts", sdkTypes.ZeroXKeyErrorCodes.CLEAR_SESSION_TIMEOUTS_ERROR, error));
+            }
+        }
+    }
+    /**
+     * Initializes the user sessions by fetching all active sessions and setting up their state.
+     * @internal
+     */
+    const initializeSessions = async () => {
+        setSession(undefined);
+        setAllSessions(undefined);
+        try {
+            const allLocalStorageSessions = await getAllSessions();
+            if (!allLocalStorageSessions)
+                return;
+            await Promise.all(Object.keys(allLocalStorageSessions).map(async (sessionKey) => {
+                const s = allLocalStorageSessions?.[sessionKey];
+                if (!utils.isValidSession(s)) {
+                    await clearSession({ sessionKey });
+                    if (sessionKey === (await getActiveSessionKey())) {
+                        setSession(undefined);
+                    }
+                    delete allLocalStorageSessions[sessionKey];
+                    return;
+                }
+                await scheduleSessionExpiration({
+                    sessionKey,
+                    expiry: s.expiry,
+                });
+            }));
+            setAllSessions(allLocalStorageSessions || undefined);
+            const activeSessionKey = await client?.getActiveSessionKey();
+            if (activeSessionKey) {
+                if (!allLocalStorageSessions[activeSessionKey]) {
+                    return;
+                }
+                setSession(allLocalStorageSessions[activeSessionKey]);
+                await maybeRefreshUser();
+                await maybeRefreshWallets();
+                return;
+            }
+        }
+        catch (error) {
+            if (error instanceof sdkTypes.ZeroXKeyError ||
+                error instanceof sdkTypes.ZeroXKeyNetworkError) {
+                callbacks?.onError?.(error);
+            }
+            else {
+                callbacks?.onError?.(new sdkTypes.ZeroXKeyError(`Failed to initialize sessions`, sdkTypes.ZeroXKeyErrorCodes.INITIALIZE_SESSION_ERROR, error));
+            }
+        }
+    };
+    /**
+     * @internal
+     * Handles the post-authentication flow.
+     *
+     * - This function is called after a successful authentication (login or sign-up) via any supported method (Passkey, Wallet, OTP, OAuth).
+     * - It fetches the active session and all sessions, updates the session state, and schedules session expiration and warning timeouts.
+     * - It also refreshes the user's wallets and profile information to ensure the provider state is up to date.
+     * - This function is used internally after all authentication flows to synchronize state and trigger any necessary callbacks.
+     *
+     * @returns A void promise.
+     * @throws {ZeroXKeyError} If the client is not initialized or if there is an error during the process.
+     */
+    const handlePostAuth = async (params) => {
+        const { method, action, identifier } = params;
+        try {
+            const sessionKey = await getActiveSessionKey();
+            const session = await getSession({
+                ...(sessionKey && { sessionKey }),
+            });
+            if (session && sessionKey)
+                await scheduleSessionExpiration({
+                    sessionKey,
+                    expiry: session.expiry,
+                });
+            const allSessions = await client.getAllSessions();
+            setSession(session);
+            setAllSessions(allSessions);
+            await maybeRefreshWallets();
+            await maybeRefreshUser();
+            callbacks?.onAuthenticationSuccess?.({
+                session,
+                method,
+                action,
+                identifier,
+            });
+        }
+        catch (error) {
+            if (error instanceof sdkTypes.ZeroXKeyError ||
+                error instanceof sdkTypes.ZeroXKeyNetworkError) {
+                callbacks?.onError?.(error);
+            }
+            else {
+                callbacks?.onError?.(new sdkTypes.ZeroXKeyError(`Failed to handle post-authentication`, sdkTypes.ZeroXKeyErrorCodes.HANDLE_POST_AUTH_ERROR, error));
+            }
+        }
+    };
+    /**
+     * @internal
+     * Handles the post-logout flow.
+     *
+     * - This function is called after a successful logout or session clear.
+     * - It clears all scheduled session expiration and warning timeouts associated to the session key to prevent memory leaks.
+     * - It resets the session state, removes user data from memory, the logged out session from all sessions state, and clears the wallets list.
+     * - This ensures that all sensitive information is removed from the provider state after logout.
+     * - Called internally after logout or when all sessions are cleared.
+     *
+     * @returns void
+     * @throws {ZeroXKeyError} If there is an error during the post-logout process.
+     */
+    const handlePostLogout = (sessionKey) => {
+        try {
+            clearSessionTimeouts(sessionKey ? [sessionKey, `${sessionKey}-warning`] : undefined);
+            setAllSessions((prev) => {
+                if (!prev)
+                    return prev;
+                if (sessionKey) {
+                    const next = { ...prev };
+                    delete next[sessionKey];
+                    return next;
+                }
+                return {};
+            });
+            setSession(undefined);
+            setUser(undefined);
+            setWallets([]);
+        }
+        catch (error) {
+            callbacks?.onError?.(new sdkTypes.ZeroXKeyError(`Failed to initialize sessions`, sdkTypes.ZeroXKeyErrorCodes.HANDLE_POST_LOGOUT_ERROR, error));
+        }
+    };
+    const createPasskey = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        return utils.withZeroXKeyErrorHandling(() => client.createPasskey({ ...params }), () => logout(), callbacks, "Failed to create passkey");
+    }, [client, callbacks]);
+    const createHttpClient = react.useCallback((params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        return client.createHttpClient(params);
+    }, [client]);
+    const logout = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        await utils.withZeroXKeyErrorHandling(async () => {
+            // If no sessionKey is provided, we try to get the active one.
+            let sessionKey = params?.sessionKey;
+            if (!sessionKey)
+                sessionKey = await getActiveSessionKey();
+            await client.logout(params);
+            // We only handle post logout if the sessionKey is defined since that means we actually logged out of a session.
+            if (sessionKey)
+                handlePostLogout(sessionKey);
+        }, () => logout(), callbacks, "Failed to logout");
+        return;
+    }, [client, callbacks]);
+    const loginWithPasskey = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        const expirationSeconds = params?.expirationSeconds ??
+            masterConfig?.auth?.sessionExpirationSeconds ??
+            core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+        const res = await utils.withZeroXKeyErrorHandling(() => client.loginWithPasskey({ ...params, expirationSeconds }), () => logout(), callbacks, "Failed to login with passkey");
+        if (res) {
+            await handlePostAuth({
+                method: base.AuthMethod.Passkey,
+                action: sdkTypes.AuthAction.LOGIN,
+                identifier: res.credentialId,
+            });
+        }
+        return res;
+    }, [client, callbacks]);
+    const signUpWithPasskey = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        if (!masterConfig) {
+            throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+        }
+        // If createSubOrgParams is not provided, use the default from masterConfig
+        let createSubOrgParams = params?.createSubOrgParams ??
+            masterConfig.auth?.createSuborgParams?.passkeyAuth;
+        params =
+            createSubOrgParams !== undefined
+                ? { ...params, createSubOrgParams }
+                : { ...params };
+        const expirationSeconds = params.expirationSeconds ??
+            masterConfig?.auth?.sessionExpirationSeconds ??
+            core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+        const websiteName = reactNative.Platform.OS === "web" && typeof window !== "undefined"
+            ? window.location.hostname
+            : DeviceInfo.getApplicationName() ||
+                DeviceInfo.getBundleId() ||
+                "mobile-app";
+        const timestamp = new Date().toLocaleDateString() +
+            "-" +
+            new Date().toLocaleTimeString([], {
+                hour: "2-digit",
+                minute: "2-digit",
+            });
+        // We allow passkeyName to be passed in thru the provider or thru the params of this function directly.
+        // This is because signUpWithPasskey will create a new passkey using that name.
+        // Any extra authenticators will be created after the first one. (see core implementation)
+        const passkeyName = params?.passkeyDisplayName ??
+            masterConfig.auth?.createSuborgParams?.passkeyAuth?.passkeyName ??
+            `${websiteName}-${timestamp}`;
+        const res = await utils.withZeroXKeyErrorHandling(() => client.signUpWithPasskey({
+            ...params,
+            passkeyDisplayName: passkeyName,
+            expirationSeconds,
+        }), () => logout(), callbacks, "Failed to sign up with passkey");
+        if (res) {
+            await handlePostAuth({
+                method: base.AuthMethod.Passkey,
+                action: sdkTypes.AuthAction.SIGNUP,
+                identifier: res.credentialId,
+            });
+        }
+        return res;
+    }, [client, callbacks]);
+    const initOtp = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        return utils.withZeroXKeyErrorHandling(() => client.initOtp(params), () => logout(), callbacks, "Failed to initialize OTP");
+    }, [client, callbacks]);
+    const verifyOtp = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        return utils.withZeroXKeyErrorHandling(() => client.verifyOtp(params), () => logout(), callbacks, "Failed to verify OTP");
+    }, [client, callbacks]);
+    const loginWithOtp = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        const res = await utils.withZeroXKeyErrorHandling(() => client.loginWithOtp(params), () => logout(), callbacks, "Failed to login with OTP");
+        if (res) {
+            await handlePostAuth({
+                method: base.AuthMethod.Otp,
+                action: sdkTypes.AuthAction.LOGIN,
+                identifier: params.verificationToken,
+            });
+        }
+        return res;
+    }, [client, callbacks]);
+    const signUpWithOtp = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        if (!masterConfig) {
+            throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+        }
+        // If createSubOrgParams is not provided, use the default from masterConfig
+        let createSubOrgParams = params.createSubOrgParams;
+        if (!createSubOrgParams && masterConfig?.auth?.createSuborgParams) {
+            if (params.otpType === core.OtpType.Email) {
+                createSubOrgParams =
+                    masterConfig.auth.createSuborgParams.emailOtpAuth;
+            }
+            else if (params.otpType === core.OtpType.Sms) {
+                createSubOrgParams = masterConfig.auth.createSuborgParams.smsOtpAuth;
+            }
+        }
+        params =
+            createSubOrgParams !== undefined
+                ? { ...params, createSubOrgParams }
+                : { ...params };
+        const res = await utils.withZeroXKeyErrorHandling(() => client.signUpWithOtp(params), () => logout(), callbacks, "Failed to sign up with OTP");
+        if (res) {
+            await handlePostAuth({
+                method: base.AuthMethod.Otp,
+                action: sdkTypes.AuthAction.SIGNUP,
+                identifier: params.verificationToken,
+            });
+        }
+        return res;
+    }, [client, callbacks, masterConfig]);
+    const completeOtp = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        if (!masterConfig) {
+            throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+        }
+        // If createSubOrgParams is not provided, use the default from masterConfig
+        let createSubOrgParams = params.createSubOrgParams;
+        if (!createSubOrgParams && masterConfig?.auth?.createSuborgParams) {
+            if (params.otpType === core.OtpType.Email) {
+                createSubOrgParams =
+                    masterConfig.auth.createSuborgParams.emailOtpAuth;
+            }
+            else if (params.otpType === core.OtpType.Sms) {
+                createSubOrgParams = masterConfig.auth.createSuborgParams.smsOtpAuth;
+            }
+        }
+        params =
+            createSubOrgParams !== undefined
+                ? { ...params, createSubOrgParams }
+                : { ...params };
+        const res = await utils.withZeroXKeyErrorHandling(() => client.completeOtp(params), () => logout(), callbacks, "Failed to complete OTP");
+        if (res) {
+            await handlePostAuth({
+                method: base.AuthMethod.Otp,
+                action: res.action,
+                identifier: res.verificationToken,
+            });
+        }
+        return res;
+    }, [client, callbacks, masterConfig]);
+    const loginWithOauth = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        const res = await utils.withZeroXKeyErrorHandling(() => client.loginWithOauth(params), () => logout(), callbacks, "Failed to login with OAuth");
+        if (res) {
+            await handlePostAuth({
+                method: base.AuthMethod.Oauth,
+                action: sdkTypes.AuthAction.LOGIN,
+                identifier: params.oidcToken,
+            });
+        }
+        return res;
+    }, [client, callbacks]);
+    const signUpWithOauth = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        if (!masterConfig) {
+            throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+        }
+        // If createSubOrgParams is not provided, use the default from masterConfig
+        let createSubOrgParams = params.createSubOrgParams ??
+            masterConfig.auth?.createSuborgParams?.oauth;
+        params =
+            createSubOrgParams !== undefined
+                ? { ...params, createSubOrgParams }
+                : { ...params };
+        const res = await utils.withZeroXKeyErrorHandling(() => client.signUpWithOauth(params), () => logout(), callbacks, "Failed to sign up with OAuth");
+        if (res) {
+            await handlePostAuth({
+                method: base.AuthMethod.Oauth,
+                action: sdkTypes.AuthAction.SIGNUP,
+                identifier: params.oidcToken,
+            });
+        }
+        return res;
+    }, [client, callbacks, masterConfig]);
+    const completeOauth = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        if (!masterConfig) {
+            throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+        }
+        // If createSubOrgParams is not provided, use the default from masterConfig
+        const createSubOrgParams = params.createSubOrgParams ??
+            masterConfig.auth?.createSuborgParams?.oauth;
+        params =
+            createSubOrgParams !== undefined
+                ? { ...params, createSubOrgParams }
+                : { ...params };
+        const res = await utils.withZeroXKeyErrorHandling(() => client.completeOauth(params), () => logout(), callbacks, "Failed to complete OAuth");
+        if (res) {
+            await handlePostAuth({
+                method: base.AuthMethod.Oauth,
+                action: res.action,
+                identifier: params.oidcToken,
+            });
+        }
+        return res;
+    }, [client, callbacks, masterConfig]);
+    const fetchWallets = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        return utils.withZeroXKeyErrorHandling(() => client.fetchWallets(params), () => logout(), callbacks, "Failed to fetch wallets");
+    }, [client, callbacks]);
+    const fetchWalletAccounts = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        return utils.withZeroXKeyErrorHandling(() => client.fetchWalletAccounts(params), () => logout(), callbacks, "Failed to fetch wallet accounts");
+    }, [client, callbacks]);
+    const fetchPrivateKeys = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        return utils.withZeroXKeyErrorHandling(() => client.fetchPrivateKeys(params), () => logout(), callbacks, "Failed to fetch private keys");
+    }, [client, callbacks]);
+    const fetchBootProofForAppProof = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.fetchBootProofForAppProof(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
+    }, [client, callbacks]);
+    const signMessage = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.signMessage(params), () => logout(), callbacks, "Failed to sign message");
+    }, [client, callbacks]);
+    const signTransaction = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.signTransaction(params), () => logout(), callbacks, "Failed to sign transaction");
+    }, [client, callbacks]);
+    const solSendTransaction = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.solSendTransaction(params), () => logout(), callbacks, "Failed to send sol transaction");
+    }, [client, callbacks]);
+    const ethSendTransaction = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.ethSendTransaction(params), () => logout(), callbacks, "Failed to send eth transaction");
+    }, [client, callbacks]);
+    const ethSendErc20Transfer = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.ethSendErc20Transfer(params), () => logout(), callbacks, "Failed to send ERC20 transfer");
+    }, [client, callbacks]);
+    const signAndSendTransaction = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.signAndSendTransaction(params), () => logout(), callbacks, "Failed to sign and send raw transaction");
+    }, [client, callbacks, logout]);
+    const pollTransactionStatus = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.pollTransactionStatus(params), () => logout(), callbacks, "Failed to poll transaction status");
+    }, [client, callbacks]);
+    const fetchUser = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.fetchUser(params), () => logout(), callbacks, "Failed to fetch user");
+    }, [client, callbacks]);
+    const fetchOrCreateP256ApiKeyUser = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.fetchOrCreateP256ApiKeyUser(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
+    }, [client, callbacks]);
+    const fetchOrCreatePolicies = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.fetchOrCreatePolicies(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
+    }, [client, callbacks]);
+    const updateUserEmail = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const res = await utils.withZeroXKeyErrorHandling(() => client.updateUserEmail(params), () => logout(), callbacks, "Failed to update user email");
+        if (res)
+            await maybeRefreshUser({
+                stampWith: params?.stampWith,
+                ...(params?.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params?.userId && { userId: params.userId }),
+            });
+        return res;
+    }, [client, callbacks]);
+    const removeUserEmail = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const res = await utils.withZeroXKeyErrorHandling(() => client.removeUserEmail(params), () => logout(), callbacks, "Failed to remove user email");
+        if (res)
+            await maybeRefreshUser({
+                stampWith: params?.stampWith,
+                ...(params?.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params?.userId && { userId: params.userId }),
+            });
+        return res;
+    }, [client, callbacks]);
+    const updateUserPhoneNumber = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const res = await utils.withZeroXKeyErrorHandling(() => client.updateUserPhoneNumber(params), () => logout(), callbacks, "Failed to update user phone number");
+        if (res)
+            await maybeRefreshUser({
+                stampWith: params?.stampWith,
+                ...(params?.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params?.userId && { userId: params.userId }),
+            });
+        return res;
+    }, [client, callbacks]);
+    const removeUserPhoneNumber = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const res = await utils.withZeroXKeyErrorHandling(() => client.removeUserPhoneNumber(params), () => logout(), callbacks, "Failed to remove user phone number");
+        if (res)
+            await maybeRefreshUser({
+                stampWith: params?.stampWith,
+                ...(params?.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params?.userId && { userId: params.userId }),
+            });
+        return res;
+    }, [client, callbacks]);
+    const updateUserName = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const res = await utils.withZeroXKeyErrorHandling(() => client.updateUserName(params), () => logout(), callbacks, "Failed to update user name");
+        if (res)
+            await maybeRefreshUser({
+                stampWith: params?.stampWith,
+                ...(params?.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params?.userId && { userId: params.userId }),
+            });
+        return res;
+    }, [client, callbacks]);
+    const addOauthProvider = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const res = await utils.withZeroXKeyErrorHandling(() => client.addOauthProvider(params), () => logout(), callbacks, "Failed to add OAuth provider");
+        if (res)
+            await maybeRefreshUser({
+                stampWith: params?.stampWith,
+                ...(params?.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params?.userId && { userId: params.userId }),
+            });
+        return res;
+    }, [client, callbacks]);
+    const removeOauthProviders = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const res = await utils.withZeroXKeyErrorHandling(() => client.removeOauthProviders(params), () => logout(), callbacks, "Failed to remove OAuth providers");
+        if (res)
+            await maybeRefreshUser({
+                stampWith: params?.stampWith,
+                ...(params?.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params?.userId && { userId: params.userId }),
+            });
+        return res;
+    }, [client, callbacks]);
+    const addPasskey = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const res = await utils.withZeroXKeyErrorHandling(() => client.addPasskey(params), () => logout(), callbacks, "Failed to add passkey");
+        if (res)
+            await maybeRefreshUser({
+                stampWith: params?.stampWith,
+                ...(params?.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params?.userId && { userId: params.userId }),
+            });
+        return res;
+    }, [client, callbacks]);
+    const removePasskeys = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const res = await utils.withZeroXKeyErrorHandling(() => client.removePasskeys(params), () => logout(), callbacks, "Failed to remove passkeys");
+        if (res)
+            await maybeRefreshUser({
+                stampWith: params?.stampWith,
+                ...(params?.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params?.userId && { userId: params.userId }),
+            });
+        return res;
+    }, [client, callbacks]);
+    const createWallet = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const res = await utils.withZeroXKeyErrorHandling(() => client.createWallet(params), () => logout(), callbacks, "Failed to create wallet");
+        const s = await getSession();
+        if (res && s)
+            await maybeRefreshWallets({
+                stampWith: params?.stampWith,
+                ...(params?.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+            });
+        return res;
+    }, [client, session, callbacks]);
+    const createWalletAccounts = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const res = await utils.withZeroXKeyErrorHandling(() => client.createWalletAccounts(params), () => logout(), callbacks, "Failed to create wallet accounts");
+        const s = await getSession();
+        if (res && s)
+            await maybeRefreshWallets({
+                stampWith: params?.stampWith,
+                ...(params?.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+            });
+        return res;
+    }, [client, session, callbacks]);
+    const exportWallet = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        // Default: decrypt unless explicitly disabled
+        const shouldDecrypt = params?.decrypt !== false;
+        if (!shouldDecrypt) {
+            const res = await utils.withZeroXKeyErrorHandling(() => client.exportWallet({
+                walletId: params.walletId,
+                targetPublicKey: params.targetPublicKey,
+                ...(params.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params.stampWith && { stampWith: params.stampWith }),
+            }), () => logout(), callbacks, "Failed to export wallet");
+            const s = await getSession();
+            if (res && s)
+                await maybeRefreshWallets({
+                    stampWith: params?.stampWith,
+                    ...(params?.organizationId && {
+                        organizationId: params.organizationId,
+                    }),
+                });
+            return res;
+        }
+        // Decrypting path: generate P-256 keypair, export, then decrypt to mnemonic
+        try {
+            const { privateKey, publicKeyUncompressed } = crypto.generateP256KeyPair();
+            const targetPublicKey = publicKeyUncompressed;
+            const exportParams = {
+                walletId: params.walletId,
+                targetPublicKey,
+                ...(params.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params.stampWith && { stampWith: params.stampWith }),
+            };
+            const bundle = await utils.withZeroXKeyErrorHandling(() => client.exportWallet(exportParams), () => logout(), callbacks, "Failed to export wallet");
+            const session = await getSession();
+            const orgId = session?.organizationId;
+            if (!orgId) {
+                throw new sdkTypes.ZeroXKeyError("Missing organizationId in session for decryption", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+            }
+            const mnemonic = await crypto.decryptExportBundle({
+                exportBundle: bundle,
+                embeddedKey: privateKey,
+                organizationId: orgId,
+                returnMnemonic: true,
+                keyFormat: "HEXADECIMAL",
+            });
+            return mnemonic;
+        }
+        catch (error) {
+            throw error;
+        }
+    }, [client, session, callbacks]);
+    const exportPrivateKey = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const shouldDecrypt = params?.decrypt !== false;
+        if (!shouldDecrypt) {
+            const res = await utils.withZeroXKeyErrorHandling(() => client.exportPrivateKey({
+                privateKeyId: params.privateKeyId,
+                targetPublicKey: params.targetPublicKey,
+                ...(params.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params.stampWith && { stampWith: params.stampWith }),
+            }), () => logout(), callbacks, "Failed to export private key");
+            return res;
+        }
+        try {
+            const { privateKey, publicKeyUncompressed } = crypto.generateP256KeyPair();
+            const targetPublicKey = publicKeyUncompressed;
+            const exportParams = {
+                privateKeyId: params.privateKeyId,
+                targetPublicKey,
+                ...(params.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params.stampWith && { stampWith: params.stampWith }),
+            };
+            const bundle = await utils.withZeroXKeyErrorHandling(() => client.exportPrivateKey(exportParams), () => logout(), callbacks, "Failed to export private key");
+            const session = await getSession();
+            const orgId = session?.organizationId;
+            if (!orgId) {
+                throw new sdkTypes.ZeroXKeyError("Missing organizationId in session for decryption", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+            }
+            const rawPrivateKey = await crypto.decryptExportBundle({
+                exportBundle: bundle,
+                embeddedKey: privateKey,
+                organizationId: orgId,
+                returnMnemonic: false,
+                keyFormat: "HEXADECIMAL",
+            });
+            return rawPrivateKey;
+        }
+        catch (error) {
+            throw error;
+        }
+    }, [client, callbacks]);
+    const exportWalletAccount = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const shouldDecrypt = params?.decrypt !== false;
+        if (!shouldDecrypt) {
+            const res = await utils.withZeroXKeyErrorHandling(() => client.exportWalletAccount({
+                address: params.address,
+                targetPublicKey: params.targetPublicKey,
+                ...(params.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params.stampWith && { stampWith: params.stampWith }),
+            }), () => logout(), callbacks, "Failed to export wallet accounts");
+            return res;
+        }
+        try {
+            const { privateKey, publicKeyUncompressed } = crypto.generateP256KeyPair();
+            const targetPublicKey = publicKeyUncompressed;
+            const exportParams = {
+                address: params.address,
+                targetPublicKey,
+                ...(params.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params.stampWith && { stampWith: params.stampWith }),
+            };
+            const bundle = await utils.withZeroXKeyErrorHandling(() => client.exportWalletAccount(exportParams), () => logout(), callbacks, "Failed to export wallet accounts");
+            const session = await getSession();
+            const orgId = session?.organizationId;
+            if (!orgId) {
+                throw new sdkTypes.ZeroXKeyError("Missing organizationId in session for decryption", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+            }
+            const decryptedKey = await crypto.decryptExportBundle({
+                exportBundle: bundle,
+                embeddedKey: privateKey,
+                organizationId: orgId,
+                returnMnemonic: false,
+                keyFormat: "HEXADECIMAL",
+            });
+            return decryptedKey;
+        }
+        catch (error) {
+            throw error;
+        }
+    }, [client, callbacks, masterConfig, session, user]);
+    const importWallet = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const { mnemonic, walletName, accounts, organizationId, userId, stampWith, } = params;
+        // Resolve org/user from params or current session
+        const currentSession = await getSession();
+        const effectiveOrgId = organizationId ?? currentSession?.organizationId;
+        const effectiveUserId = userId ?? currentSession?.userId;
+        if (!effectiveOrgId || !effectiveUserId) {
+            throw new sdkTypes.ZeroXKeyError("Missing organizationId or userId for wallet import", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+        }
+        // Step 1: init import to obtain importBundle
+        const initRes = await utils.withZeroXKeyErrorHandling(() => client.httpClient?.initImportWallet({
+            organizationId: effectiveOrgId,
+            userId: effectiveUserId,
+        }, stampWith), () => logout(), callbacks, "Failed to init wallet import");
+        const importBundle = initRes?.importBundle;
+        if (!importBundle) {
+            throw new sdkTypes.ZeroXKeyError("Failed to retrieve import bundle", sdkTypes.ZeroXKeyErrorCodes.IMPORT_WALLET_ERROR);
+        }
+        // Step 2: encrypt mnemonic to encryptedBundle
+        const encryptedBundle = await crypto.encryptWalletToBundle({
+            mnemonic,
+            importBundle,
+            userId: effectiveUserId,
+            organizationId: effectiveOrgId,
+        });
+        // Step 3: call importWallet with encrypted bundle
+        const res = await utils.withZeroXKeyErrorHandling(() => client.importWallet({
+            encryptedBundle,
+            walletName,
+            ...(accounts && { accounts }),
+            organizationId: effectiveOrgId,
+            userId: effectiveUserId,
+            ...(stampWith && { stampWith }),
+        }), () => logout(), callbacks, "Failed to import wallet");
+        // Refresh state after import
+        if (res)
+            await maybeRefreshWallets({
+                ...(stampWith && { stampWith }),
+                organizationId: effectiveOrgId,
+                userId: effectiveUserId,
+            });
+        return res;
+    }, [client, callbacks, masterConfig, session, user]);
+    const importPrivateKey = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const { privateKey, privateKeyName, addressFormats, curve, keyFormat = "HEXADECIMAL", organizationId, userId, stampWith, } = params;
+        // Resolve org/user
+        const currentSession = await getSession();
+        const effectiveOrgId = organizationId ?? currentSession?.organizationId;
+        const effectiveUserId = userId ?? currentSession?.userId;
+        if (!effectiveOrgId || !effectiveUserId) {
+            throw new sdkTypes.ZeroXKeyError("Missing organizationId or userId for private key import", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+        }
+        // Init import to get bundle
+        const initRes = await utils.withZeroXKeyErrorHandling(() => client.httpClient?.initImportPrivateKey({
+            organizationId: effectiveOrgId,
+            userId: effectiveUserId,
+        }, stampWith), () => logout(), callbacks, "Failed to init private key import");
+        const importBundle = initRes?.importBundle;
+        if (!importBundle) {
+            throw new sdkTypes.ZeroXKeyError("Failed to retrieve import bundle", sdkTypes.ZeroXKeyErrorCodes.IMPORT_WALLET_ERROR);
+        }
+        // Encrypt provided private key to bundle
+        const encryptedBundle = await crypto.encryptPrivateKeyToBundle({
+            privateKey,
+            keyFormat,
+            importBundle,
+            userId: effectiveUserId,
+            organizationId: effectiveOrgId,
+        });
+        // Import
+        const res = await utils.withZeroXKeyErrorHandling(() => client.importPrivateKey({
+            encryptedBundle,
+            privateKeyName,
+            addressFormats,
+            curve: curve ?? "CURVE_SECP256K1",
+            organizationId: effectiveOrgId,
+            userId: effectiveUserId,
+            ...(stampWith && { stampWith }),
+        }), () => logout(), callbacks, "Failed to import private key");
+        return res;
+    }, [client, callbacks, masterConfig, session, user]);
+    const deleteSubOrganization = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.deleteSubOrganization(params), () => logout(), callbacks, "Failed to delete sub-organization");
+    }, [client, callbacks, masterConfig, session, user]);
+    const storeSession = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        await utils.withZeroXKeyErrorHandling(() => client.storeSession(params), () => logout(), callbacks, "Failed to store session");
+        const sessionKey = await getActiveSessionKey();
+        const session = await getSession({
+            ...(sessionKey && { sessionKey }),
+        });
+        if (session && sessionKey)
+            await scheduleSessionExpiration({ sessionKey, expiry: session.expiry });
+        const allSessions = await getAllSessions();
+        setSession(session);
+        setAllSessions(allSessions);
+        await maybeRefreshWallets();
+        await maybeRefreshUser();
+    }, [client, callbacks, masterConfig, session, user]);
+    const clearSession = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        await utils.withZeroXKeyErrorHandling(async () => client.clearSession(params), () => logout(), callbacks, "Failed to clear session");
+        const sessionKey = params?.sessionKey ?? (await getActiveSessionKey());
+        if (!sessionKey)
+            return;
+        if (!params?.sessionKey) {
+            setSession(undefined);
+        }
+        clearSessionTimeouts([sessionKey]);
+        // clear only the cleared session from allSessions
+        const newAllSessions = { ...allSessions };
+        if (newAllSessions) {
+            delete newAllSessions[sessionKey];
+        }
+        setAllSessions(newAllSessions);
+        return;
+    }, [client, callbacks, session, user, masterConfig]);
+    const clearAllSessions = react.useCallback(async () => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        setSession(undefined);
+        setAllSessions(undefined);
+        clearSessionTimeouts();
+        return await utils.withZeroXKeyErrorHandling(() => client.clearAllSessions(), () => logout(), callbacks, "Failed to clear all sessions");
+    }, [client, callbacks, session, user, masterConfig]);
+    const refreshSession = react.useCallback(async (params) => {
+        if (!client) {
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        }
+        const activeSessionKey = await client.getActiveSessionKey();
+        if (!activeSessionKey) {
+            throw new sdkTypes.ZeroXKeyError("No active session found.", sdkTypes.ZeroXKeyErrorCodes.NO_SESSION_FOUND);
+        }
+        const sessionKey = params?.sessionKey ?? activeSessionKey;
+        const res = await utils.withZeroXKeyErrorHandling(() => client.refreshSession({ ...params }), () => logout(), callbacks, "Failed to refresh session");
+        const session = await getSession({ sessionKey });
+        if (session && sessionKey) {
+            await scheduleSessionExpiration({
+                sessionKey,
+                expiry: session.expiry,
+                ...(params?.expirationSeconds && {
+                    expirationSeconds: params?.expirationSeconds,
+                }),
+            });
+        }
+        const allSessions = await getAllSessions();
+        setSession(session);
+        setAllSessions(allSessions);
+        return res;
+    }, [client, callbacks, scheduleSessionExpiration, session, user, masterConfig]);
+    const getSession = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.getSession(params), () => logout(), callbacks, "Failed to get session");
+    }, [client, callbacks, masterConfig, session, user]);
+    const getAllSessions = react.useCallback(async () => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.getAllSessions(), () => logout(), callbacks, "Failed to get all sessions");
+    }, [client, callbacks, masterConfig, session, user]);
+    const setActiveSession = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const session = await utils.withZeroXKeyErrorHandling(() => client.getSession({ sessionKey: params.sessionKey }), () => logout(), callbacks, "Failed to get session");
+        const s = await getSession();
+        if (!s) {
+            throw new sdkTypes.ZeroXKeyError("Session not found.", sdkTypes.ZeroXKeyErrorCodes.NOT_FOUND);
+        }
+        await utils.withZeroXKeyErrorHandling(() => client.setActiveSession(params), () => logout(), callbacks, "Failed to set active session");
+        setSession(session);
+        await utils.withZeroXKeyErrorHandling(async () => {
+            await maybeRefreshWallets();
+            await maybeRefreshUser();
+        }, () => logout(), callbacks, "Failed to refresh data after setting active session");
+        return;
+    }, [client, callbacks, session, user, masterConfig]);
+    const getActiveSessionKey = react.useCallback(async () => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.getActiveSessionKey(), () => logout(), callbacks, "Failed to get active session key");
+    }, [client, callbacks, masterConfig, session, user]);
+    const clearUnusedKeyPairs = react.useCallback(async () => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.clearUnusedKeyPairs(), () => logout(), callbacks, "Failed to clear unused key pairs");
+    }, [client, callbacks, masterConfig, session, user]);
+    const createApiKeyPair = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.createApiKeyPair(params), () => logout(), callbacks, "Failed to create API key pair");
+    }, [client, callbacks, session, user, masterConfig]);
+    const getProxyAuthConfig = react.useCallback(async () => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.getProxyAuthConfig(), () => logout(), callbacks, "Failed to get proxy auth config");
+    }, [client, callbacks, masterConfig, session, user]);
+    const verifyAppProofs = react.useCallback(async (params) => {
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        return utils.withZeroXKeyErrorHandling(() => client.verifyAppProofs(params), () => logout(), callbacks, "Failed to verify app proofs");
+    }, [client, callbacks]);
+    const refreshUser = react.useCallback(async (params) => {
+        const { stampWith, organizationId, userId } = params || {};
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const user = await utils.withZeroXKeyErrorHandling(() => fetchUser({
+            stampWith,
+            ...(organizationId && { organizationId }),
+            ...(userId && { userId }),
+        }), () => logout(), callbacks, "Failed to refresh user");
+        if (user) {
+            setUser(user);
+        }
+    }, [client, callbacks, fetchUser, session, user]);
+    /**
+     * @internal
+     * Auto-refresh user only if enabled in config. This is only used internally.
+     *
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @param params.userId - user ID to fetch specific user details (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves when the user is refreshed, or does nothing if auto-refresh is disabled
+     */
+    const maybeRefreshUser = react.useCallback(async (params) => {
+        if (!masterConfig?.autoRefreshManagedState)
+            return;
+        return refreshUser(params);
+    }, [masterConfig, refreshUser]);
+    const refreshWallets = react.useCallback(async (params) => {
+        const { stampWith, organizationId, userId } = params || {};
+        if (!client)
+            throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+        const wallets = await utils.withZeroXKeyErrorHandling(() => fetchWallets({
+            stampWith,
+            ...(organizationId && { organizationId }),
+            ...(userId && { userId }),
+        }), () => logout(), callbacks, "Failed to refresh wallets");
+        if (wallets) {
+            setWallets(wallets);
+        }
+        return wallets;
+    }, [client, callbacks, fetchWallets, session, user]);
+    /**
+     * @internal
+     * Auto-refresh wallets only if enabled in config. This is only used internally.
+     *
+     * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+     * @param params.userId - user ID to fetch specific user details (defaults to the current session's userId).
+     * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+     * @returns A promise that resolves to an array of wallets, or an empty array if auto-refresh is disabled
+     */
+    const maybeRefreshWallets = react.useCallback(async (params) => {
+        if (!masterConfig?.autoRefreshManagedState)
+            return [];
+        return refreshWallets(params);
+    }, [masterConfig, refreshWallets]);
+    const handleDiscordOauth = react.useCallback(async (params) => {
+        const { additionalState: additionalParameters } = params || {};
+        const { clientId, redirectUri, appScheme: scheme, } = getOauthProviderSettings(sdkTypes.OAuthProviders.DISCORD);
+        try {
+            if (!masterConfig) {
+                throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!clientId) {
+                throw new sdkTypes.ZeroXKeyError("Discord Client ID is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!redirectUri) {
+                throw new sdkTypes.ZeroXKeyError("OAuth Redirect URI is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!scheme) {
+                throw new sdkTypes.ZeroXKeyError("Missing appScheme. Please set auth.oauth.appScheme.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            // Create key pair and generate nonce
+            const publicKey = await createApiKeyPair();
+            if (!publicKey) {
+                throw new sdkTypes.ZeroXKeyError("Failed to create public key for OAuth.", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            const nonce = utils$1.bytesToHex(sha2.sha256(publicKey));
+            // Generate PKCE challenge pair and store verifier
+            const { verifier, codeChallenge } = await oauth.generateChallengePair();
+            await oauth.storePKCEVerifier(sdkTypes.OAuthProviders.DISCORD, verifier);
+            // Build OAuth URL (direct Discord URL, not proxy)
+            const discordAuthUrl = oauth.buildOAuthUrl({
+                provider: sdkTypes.OAuthProviders.DISCORD,
+                clientId,
+                redirectUri,
+                publicKey,
+                nonce,
+                codeChallenge,
+                additionalState: additionalParameters,
+                useOauthProxyOrigin: false,
+            });
+            if (!(await reactNativeInappbrowserReborn.InAppBrowser.isAvailable())) {
+                throw new sdkTypes.ZeroXKeyError("InAppBrowser is not available", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            const result = await reactNativeInappbrowserReborn.InAppBrowser.openAuth(discordAuthUrl, scheme, {
+                dismissButtonStyle: "cancel",
+                animated: true,
+                modalPresentationStyle: "fullScreen",
+                modalTransitionStyle: "coverVertical",
+                modalEnabled: true,
+                enableBarCollapsing: false,
+                showTitle: true,
+                enableUrlBarHiding: true,
+                enableDefaultShare: true,
+            });
+            if (!result || result.type !== "success" || !result.url) {
+                throw new sdkTypes.ZeroXKeyError("OAuth flow did not complete successfully", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            // Parse the deep link result
+            const parsed = oauth.parseInAppBrowserResult(result.url);
+            if (!parsed.authCode) {
+                throw new sdkTypes.ZeroXKeyError("Missing authorization code from Discord OAuth", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            // Handle PKCE flow: exchange code for token and complete
+            await oauth.handlePKCEFlow({
+                provider: sdkTypes.OAuthProviders.DISCORD,
+                publicKey,
+                authCode: parsed.authCode,
+                ...(parsed.sessionKey && { sessionKey: parsed.sessionKey }),
+                ...(callbacks && { callbacks }),
+                completeOauth,
+                exchangeCodeForToken: async (codeVerifier) => {
+                    const resp = await client?.httpClient?.proxyOAuth2Authenticate({
+                        provider: "OAUTH2_PROVIDER_DISCORD",
+                        authCode: parsed.authCode,
+                        redirectUri,
+                        codeVerifier,
+                        clientId,
+                        nonce,
+                    });
+                    const oidcToken = resp?.oidcToken;
+                    if (!oidcToken) {
+                        throw new sdkTypes.ZeroXKeyError("Missing oidcToken from OAuth exchange", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+                    }
+                    return oidcToken;
+                },
+            });
+            return;
+        }
+        catch (error) {
+            throw error;
+        }
+    }, [client, callbacks, masterConfig, session, user]);
+    const handleXOauth = react.useCallback(async (params) => {
+        const { additionalState: additionalParameters } = params || {};
+        const { clientId, redirectUri, appScheme: scheme, } = getOauthProviderSettings(sdkTypes.OAuthProviders.X);
+        try {
+            if (!masterConfig) {
+                throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!clientId) {
+                throw new sdkTypes.ZeroXKeyError("Twitter Client ID is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!redirectUri) {
+                throw new sdkTypes.ZeroXKeyError("OAuth Redirect URI is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!scheme) {
+                throw new sdkTypes.ZeroXKeyError("Missing appScheme. Please set auth.oauth.appScheme.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            const publicKey = await createApiKeyPair();
+            if (!publicKey) {
+                throw new sdkTypes.ZeroXKeyError("Failed to create public key for OAuth.", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            const nonce = utils$1.bytesToHex(sha2.sha256(publicKey));
+            // Generate PKCE challenge pair and store verifier
+            const { verifier, codeChallenge } = await oauth.generateChallengePair();
+            await oauth.storePKCEVerifier(sdkTypes.OAuthProviders.X, verifier);
+            // Build OAuth URL (direct X/Twitter URL, not proxy)
+            const twitterAuthUrl = oauth.buildOAuthUrl({
+                provider: sdkTypes.OAuthProviders.X,
+                clientId,
+                redirectUri,
+                publicKey,
+                nonce,
+                codeChallenge,
+                additionalState: additionalParameters,
+                useOauthProxyOrigin: false,
+            });
+            if (!(await reactNativeInappbrowserReborn.InAppBrowser.isAvailable())) {
+                throw new sdkTypes.ZeroXKeyError("InAppBrowser is not available", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            const result = await reactNativeInappbrowserReborn.InAppBrowser.openAuth(twitterAuthUrl, scheme, {
+                dismissButtonStyle: "cancel",
+                animated: true,
+                modalPresentationStyle: "fullScreen",
+                modalTransitionStyle: "coverVertical",
+                modalEnabled: true,
+                enableBarCollapsing: false,
+                showTitle: true,
+                enableUrlBarHiding: true,
+                enableDefaultShare: true,
+            });
+            if (!result || result.type !== "success" || !result.url) {
+                throw new sdkTypes.ZeroXKeyError("OAuth flow did not complete successfully", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            // Parse the deep link result
+            const parsed = oauth.parseInAppBrowserResult(result.url);
+            if (!parsed.authCode) {
+                throw new sdkTypes.ZeroXKeyError("Missing authorization code from Twitter OAuth", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            // Handle PKCE flow: exchange code for token and complete
+            await oauth.handlePKCEFlow({
+                provider: sdkTypes.OAuthProviders.X,
+                publicKey,
+                authCode: parsed.authCode,
+                ...(parsed.sessionKey && { sessionKey: parsed.sessionKey }),
+                ...(callbacks && { callbacks }),
+                completeOauth,
+                exchangeCodeForToken: async (codeVerifier) => {
+                    const resp = await client?.httpClient?.proxyOAuth2Authenticate({
+                        provider: "OAUTH2_PROVIDER_X",
+                        authCode: parsed.authCode,
+                        redirectUri,
+                        codeVerifier,
+                        clientId,
+                        nonce,
+                    });
+                    const oidcToken = resp?.oidcToken;
+                    if (!oidcToken) {
+                        throw new sdkTypes.ZeroXKeyError("Missing oidcToken from OAuth exchange", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+                    }
+                    return oidcToken;
+                },
+            });
+            return;
+        }
+        catch (error) {
+            throw error;
+        }
+    }, [client, callbacks, masterConfig, session, user]);
+    const handleGoogleOauth = react.useCallback(async (params) => {
+        const { clientId, redirectUri, appScheme: scheme, } = getOauthProviderSettings(sdkTypes.OAuthProviders.GOOGLE);
+        try {
+            if (!masterConfig) {
+                throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!clientId) {
+                throw new sdkTypes.ZeroXKeyError("Google Client ID is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!redirectUri) {
+                throw new sdkTypes.ZeroXKeyError("OAuth Redirect URI is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!scheme) {
+                throw new sdkTypes.ZeroXKeyError("Missing appScheme. Please set auth.oauth.appScheme.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            const finalRedirectUri = `${redirectUri}?scheme=${encodeURIComponent(scheme)}`;
+            // Create key pair and generate nonce
+            const publicKey = await createApiKeyPair();
+            if (!publicKey) {
+                throw new sdkTypes.ZeroXKeyError("Failed to create public key for OAuth.", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            const nonce = utils$1.bytesToHex(sha2.sha256(publicKey));
+            // Build OAuth URL using ZeroXKey OAuth proxy
+            const oauthUrl = oauth.buildOAuthUrl({
+                provider: sdkTypes.OAuthProviders.GOOGLE,
+                clientId,
+                redirectUri: finalRedirectUri,
+                publicKey,
+                nonce,
+                useOauthProxyOrigin: true,
+            });
+            if (!(await reactNativeInappbrowserReborn.InAppBrowser.isAvailable())) {
+                throw new sdkTypes.ZeroXKeyError("InAppBrowser is not available", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            const result = await reactNativeInappbrowserReborn.InAppBrowser.openAuth(oauthUrl, scheme, {
+                dismissButtonStyle: "cancel",
+                animated: true,
+                modalPresentationStyle: "fullScreen",
+                modalTransitionStyle: "coverVertical",
+                modalEnabled: true,
+                enableBarCollapsing: false,
+                showTitle: true,
+                enableUrlBarHiding: true,
+                enableDefaultShare: true,
+            });
+            if (!result || result.type !== "success" || !result.url) {
+                throw new sdkTypes.ZeroXKeyError("OAuth flow did not complete successfully", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            // Parse the deep link result
+            const parsed = oauth.parseInAppBrowserResult(result.url);
+            if (!parsed.idToken) {
+                throw new sdkTypes.ZeroXKeyError("oidcToken not found in the response", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            // Complete OAuth flow
+            await oauth.completeOAuthFlow({
+                provider: sdkTypes.OAuthProviders.GOOGLE,
+                publicKey,
+                oidcToken: parsed.idToken,
+                ...(parsed.sessionKey && { sessionKey: parsed.sessionKey }),
+                ...(callbacks && { callbacks }),
+                completeOauth,
+            });
+            return;
+        }
+        catch (error) {
+            throw error;
+        }
+    }, [client, callbacks, masterConfig, session, user]);
+    const handleAppleOauth = react.useCallback(async (params) => {
+        const { additionalState: additionalParameters } = params || {};
+        const { clientId, redirectUri, appScheme: scheme, } = getOauthProviderSettings(sdkTypes.OAuthProviders.APPLE);
+        try {
+            if (!masterConfig) {
+                throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!clientId) {
+                throw new sdkTypes.ZeroXKeyError("Apple Client ID is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!redirectUri) {
+                throw new sdkTypes.ZeroXKeyError("OAuth Redirect URI is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!scheme) {
+                throw new sdkTypes.ZeroXKeyError("Missing appScheme. Please set auth.oauth.appScheme.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            const finalRedirectUri = `${redirectUri}?scheme=${encodeURIComponent(scheme)}`;
+            // Create key pair and generate nonce
+            const publicKey = await createApiKeyPair();
+            if (!publicKey) {
+                throw new sdkTypes.ZeroXKeyError("Failed to create public key for OAuth.", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            const nonce = utils$1.bytesToHex(sha2.sha256(publicKey));
+            // Build OAuth URL using ZeroXKey OAuth proxy
+            const oauthUrl = oauth.buildOAuthUrl({
+                provider: sdkTypes.OAuthProviders.APPLE,
+                clientId,
+                redirectUri: finalRedirectUri,
+                publicKey,
+                nonce,
+                additionalState: additionalParameters,
+                useOauthProxyOrigin: true,
+            });
+            if (!(await reactNativeInappbrowserReborn.InAppBrowser.isAvailable())) {
+                throw new sdkTypes.ZeroXKeyError("InAppBrowser is not available", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            const result = await reactNativeInappbrowserReborn.InAppBrowser.openAuth(oauthUrl, scheme, {
+                dismissButtonStyle: "cancel",
+                animated: true,
+                modalPresentationStyle: "fullScreen",
+                modalTransitionStyle: "coverVertical",
+                modalEnabled: true,
+                enableBarCollapsing: false,
+                showTitle: true,
+                enableUrlBarHiding: true,
+                enableDefaultShare: true,
+            });
+            if (!result || result.type !== "success" || !result.url) {
+                throw new sdkTypes.ZeroXKeyError("OAuth flow did not complete successfully", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            // Parse the deep link result
+            const parsed = oauth.parseInAppBrowserResult(result.url);
+            if (!parsed.idToken) {
+                throw new sdkTypes.ZeroXKeyError("oidcToken not found in the response", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            // Complete OAuth flow
+            await oauth.completeOAuthFlow({
+                provider: sdkTypes.OAuthProviders.APPLE,
+                publicKey,
+                oidcToken: parsed.idToken,
+                ...(parsed.sessionKey && { sessionKey: parsed.sessionKey }),
+                ...(callbacks && { callbacks }),
+                completeOauth,
+            });
+            return;
+        }
+        catch (error) {
+            throw error;
+        }
+    }, [client, callbacks, masterConfig, session, user]);
+    const handleFacebookOauth = react.useCallback(async (params) => {
+        const { additionalState: additionalParameters } = params || {};
+        const { clientId, redirectUri, appScheme: scheme, } = getOauthProviderSettings(sdkTypes.OAuthProviders.FACEBOOK);
+        try {
+            if (!masterConfig) {
+                throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!clientId) {
+                throw new sdkTypes.ZeroXKeyError("Facebook Client ID is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!redirectUri) {
+                throw new sdkTypes.ZeroXKeyError("OAuth Redirect URI is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            if (!scheme) {
+                throw new sdkTypes.ZeroXKeyError("Missing appScheme. Please set auth.oauth.appScheme.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            const finalRedirectUri = `${redirectUri}?scheme=${encodeURIComponent(scheme)}`;
+            // Create key pair and generate nonce
+            const publicKey = await createApiKeyPair();
+            if (!publicKey) {
+                throw new sdkTypes.ZeroXKeyError("Failed to create public key for OAuth.", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            const nonce = utils$1.bytesToHex(sha2.sha256(publicKey));
+            // Generate PKCE challenge pair and store verifier
+            const { verifier, codeChallenge } = await oauth.generateChallengePair();
+            await oauth.storePKCEVerifier(sdkTypes.OAuthProviders.FACEBOOK, verifier);
+            // Build OAuth URL using ZeroXKey OAuth proxy
+            const oauthUrl = oauth.buildOAuthUrl({
+                provider: sdkTypes.OAuthProviders.FACEBOOK,
+                clientId,
+                redirectUri: finalRedirectUri,
+                publicKey,
+                nonce,
+                codeChallenge,
+                additionalState: additionalParameters,
+                useOauthProxyOrigin: true,
+            });
+            if (!(await reactNativeInappbrowserReborn.InAppBrowser.isAvailable())) {
+                throw new sdkTypes.ZeroXKeyError("InAppBrowser is not available", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+            }
+            const result = await reactNativeInappbrowserReborn.InAppBrowser.openAuth(oauthUrl, scheme, {
+                dismissButtonStyle: "cancel",
+                animated: true,
+                modalPresentationStyle: "fullScreen",
+                modalTransitionStyle: "coverVertical",
+                modalEnabled: true,
+                enableBarCollapsing: false,
+                showTitle: true,
+                enableUrlBarHiding: true,
+                enableDefaultShare: true,
+            });
+            if (!result || result.type !== "success" || !result.url) {
+                throw new sdkTypes.ZeroXKeyError("OAuth flow did not complete successfully", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            // Parse the deep link result
+            const parsed = oauth.parseInAppBrowserResult(result.url);
+            if (!parsed.authCode) {
+                throw new sdkTypes.ZeroXKeyError("Missing authorization code from Facebook OAuth", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+            }
+            // Handle PKCE flow: exchange code for token and complete
+            await oauth.handlePKCEFlow({
+                provider: sdkTypes.OAuthProviders.FACEBOOK,
+                publicKey,
+                authCode: parsed.authCode,
+                ...(parsed.sessionKey && { sessionKey: parsed.sessionKey }),
+                ...(callbacks && { callbacks }),
+                completeOauth,
+                exchangeCodeForToken: async (codeVerifier) => {
+                    const tokenData = await oauth.exchangeCodeForToken(clientId, finalRedirectUri, parsed.authCode, codeVerifier);
+                    const idToken = tokenData?.id_token;
+                    if (!idToken) {
+                        throw new sdkTypes.ZeroXKeyError("Missing oidcToken from OAuth exchange", sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR);
+                    }
+                    return idToken;
+                },
+            });
+            return;
+        }
+        catch (error) {
+            throw error;
+        }
+    }, [client, callbacks, masterConfig, session, user]);
+    react.useEffect(() => {
+        if (proxyAuthConfigRef.current)
+            return;
+        // Only fetch the proxy auth config once. Use that to build the master config.
+        const fetchProxyAuthConfig = async () => {
+            try {
+                let proxyAuthConfig;
+                if (shouldFetchWalletKitConfig) {
+                    // Only fetch the proxy auth config if we have an authProxyId and the autoFetchWalletKitConfig param is enabled or not passed in.
+                    const sanitizedAuthProxyUrl = config.authProxyUrl && config.authProxyUrl.trim()
+                        ? config.authProxyUrl
+                        : undefined;
+                    proxyAuthConfig = await core.getAuthProxyConfig(config.authProxyConfigId, // Can assert safely. See shouldFetchWalletKitConfig definition.
+                    sanitizedAuthProxyUrl);
+                    proxyAuthConfigRef.current = proxyAuthConfig;
+                }
+                setMasterConfig(buildConfig(proxyAuthConfig));
+            }
+            catch {
+                setClientState(base.ClientState.Error);
+            }
+        };
+        fetchProxyAuthConfig();
+    }, []);
+    react.useEffect(() => {
+        // Start the client initialization process once we have the master config.
+        if (!masterConfig)
+            return;
+        initializeClient();
+    }, [masterConfig]);
+    react.useEffect(() => {
+        // Handle changes to the passed in config prop -- update the master config
+        // Rebuild the master config with the updated config and stored proxyAuthConfig
+        // If we don't have a stored proxyAuthConfig and we need to fetch it, we wait until that fetch is done in the other useEffect.
+        // If shouldFetchWalletKitConfig is false, we'll never have a proxyAuthConfig to build the master config with, so this useEffect should always run.
+        if (!proxyAuthConfigRef.current && shouldFetchWalletKitConfig)
+            return;
+        setMasterConfig(buildConfig(proxyAuthConfigRef.current ?? undefined));
+    }, [config, proxyAuthConfigRef.current]);
+    react.useEffect(() => {
+        // authState must be consistent with session state. We found during testing that there are cases where the session and authState can be out of sync in very rare edge cases.
+        // This will ensure that they are always in sync and remove the need to setAuthState manually in other places.
+        if (session && utils.isValidSession(session)) {
+            setAuthState(base.AuthState.Authenticated);
+        }
+        else {
+            setAuthState(base.AuthState.Unauthenticated);
+        }
+    }, [session]);
+    react.useEffect(() => {
+        // After client and config are ready, initialize sessions then mark client ready.
+        if (!client || !masterConfig)
+            return;
+        clearSessionTimeouts();
+        initializeSessions().finally(() => {
+            setClientState(base.ClientState.Ready);
+        });
+        return () => {
+            clearSessionTimeouts();
+        };
+    }, [client]);
+    return (jsxRuntime.jsx(Types.ClientContext.Provider, { value: {
+            session,
+            allSessions,
+            clientState,
+            authState,
+            user,
+            wallets,
+            config: masterConfig,
+            httpClient: client?.httpClient,
+            createHttpClient,
+            createPasskey,
+            logout,
+            loginWithPasskey,
+            signUpWithPasskey,
+            initOtp,
+            verifyOtp,
+            loginWithOtp,
+            signUpWithOtp,
+            completeOtp,
+            loginWithOauth,
+            signUpWithOauth,
+            completeOauth,
+            fetchWallets,
+            fetchWalletAccounts,
+            fetchPrivateKeys,
+            verifyAppProofs,
+            refreshWallets,
+            signMessage,
+            signTransaction,
+            signAndSendTransaction,
+            ethSendTransaction,
+            ethSendErc20Transfer,
+            solSendTransaction,
+            pollTransactionStatus,
+            fetchUser,
+            fetchOrCreateP256ApiKeyUser,
+            fetchOrCreatePolicies,
+            refreshUser,
+            updateUserEmail,
+            removeUserEmail,
+            updateUserPhoneNumber,
+            removeUserPhoneNumber,
+            updateUserName,
+            addOauthProvider,
+            removeOauthProviders,
+            addPasskey,
+            removePasskeys,
+            createWallet,
+            createWalletAccounts,
+            exportWallet,
+            exportPrivateKey,
+            exportWalletAccount,
+            importWallet,
+            importPrivateKey,
+            deleteSubOrganization,
+            storeSession,
+            clearSession,
+            clearAllSessions,
+            refreshSession,
+            getSession,
+            getAllSessions,
+            setActiveSession,
+            clearUnusedKeyPairs,
+            getActiveSessionKey,
+            createApiKeyPair,
+            getProxyAuthConfig,
+            handleGoogleOauth,
+            handleXOauth,
+            handleDiscordOauth,
+            handleAppleOauth,
+            handleFacebookOauth,
+            fetchBootProofForAppProof,
+        }, children: children }));
+};
+
+exports.ZeroXKeyProvider = ZeroXKeyProvider;
+//# sourceMappingURL=ZeroXKeyProvider.js.map