@turnkey/react-wallet-kit 1.0.0-beta.0

package/dist/providers/client/Provider.js

@@ -0,0 +1,2489 @@
+'use client';
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var sha2 = require('@noble/hashes/sha2');
+var utils$1 = require('@noble/hashes/utils');
+var utils = require('../../utils.js');
+var core = require('@turnkey/core');
+var react = require('react');
+var sdkTypes = require('@turnkey/sdk-types');
+var Hook = require('../modal/Hook.js');
+var base = require('../../types/base.js');
+var index = require('../../components/auth/index.js');
+var reactFontawesome = require('@fortawesome/react-fontawesome');
+var freeBrandsSvgIcons = require('@fortawesome/free-brands-svg-icons');
+var Action = require('../../components/auth/Action.js');
+var Message = require('../../components/sign/Message.js');
+var Export = require('../../components/export/Export.js');
+var Import = require('../../components/import/Import.js');
+var Success = require('../../components/design/Success.js');
+var UpdateEmail = require('../../components/user/UpdateEmail.js');
+var UpdatePhoneNumber = require('../../components/user/UpdatePhoneNumber.js');
+var UpdateUserName = require('../../components/user/UpdateUserName.js');
+var RemoveOAuthProvider = require('../../components/user/RemoveOAuthProvider.js');
+var RemovePasskey = require('../../components/user/RemovePasskey.js');
+var LinkWallet = require('../../components/user/LinkWallet.js');
+var Types = require('./Types.js');
+var OTP = require('../../components/auth/OTP.js');
+var RemoveEmail = require('../../components/user/RemoveEmail.js');
+var RemovePhoneNumber = require('../../components/user/RemovePhoneNumber.js');
+
+/**
+ * Provides Turnkey client authentication, session management, wallet operations, and user profile management
+ * for the React Wallet Kit SDK. This context provider encapsulates all core authentication flows (Passkey, Wallet, OTP, OAuth),
+ * session lifecycle (creation, expiration, refresh), wallet linking/import/export, and user profile updates (email, phone, name).
+ *
+ * The provider automatically initializes the Turnkey 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, Wallet, OTP (Email/SMS), and OAuth (Google, Apple, Facebook) authentication and sign-up flows.
+ * - Session management: creation, expiration scheduling, refresh, and clearing.
+ * - Wallet management: fetch, link, import, export, account management.
+ * - User profile management: email, phone, name, OAuth provider, and passkey linking/removal.
+ * - Modal-driven UI flows for authentication, wallet linking, and profile updates.
+ * - Error handling and callback integration for custom error and event responses.
+ *
+ * Usage:
+ * Wrap your application with `TurnkeyProvider` to enable authentication and wallet features via context.
+ *
+ * @param config - The Turnkey 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 ClientProvider = ({
+  config,
+  children,
+  callbacks
+}) => {
+  const [client, setClient] = react.useState(undefined);
+  const [session, setSession] = react.useState(undefined);
+  const [autoRefreshSession, setAutoRefreshSession] = react.useState(false);
+  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);
+  const {
+    pushPage,
+    closeModal
+  } = Hook.useModal();
+  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 (config.authProxyConfigId) {
+          // Only fetch the proxy auth config if we have an authProxyId. This is a way for devs to explicitly disable the proxy auth.
+          proxyAuthConfig = await core.getAuthProxyConfig(config.authProxyConfigId, config.authProxyUrl);
+          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
+    // If the proxyAuthConfigRef is already set, we don't need to fetch it again. Rebuild the master config with the updated config and stored proxyAuthConfig
+    if (!proxyAuthConfigRef.current && config.authProxyConfigId) return;
+    setMasterConfig(buildConfig(proxyAuthConfigRef.current ?? undefined));
+  }, [config, proxyAuthConfigRef.current]);
+  /**
+   * @internal
+   * we use debouncedFetchWallets() to prevent multiple rapid wallet events
+   * like accountsChanged and disconnect from triggering fetchWallets repeatedly
+   * it must be defined outside the useEffect so all event listeners share the same
+   * debounced function instance - otherwise, a new one would be created on every render
+   */
+  const debouncedFetchWallets = utils.useDebouncedCallback(fetchWallets, 100);
+  react.useEffect(() => {
+    if (!client) return;
+    let cleanup = () => {};
+    initializeProviders(getWalletProviders, debouncedFetchWallets).then(fn => {
+      cleanup = fn;
+    }).catch(err => {
+      console.error("Failed to init providers:", err);
+    });
+    return () => {
+      cleanup();
+    };
+  }, [client, debouncedFetchWallets]);
+  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) {
+      setAuthState(base.AuthState.Authenticated);
+    } else {
+      setAuthState(base.AuthState.Unauthenticated);
+    }
+  }, [session]);
+  react.useEffect(() => {
+    // This will handle any redirect based oAuth. It then initializes the session. This is the last step before client is considered "ready"
+    if (!client || !masterConfig) return;
+    completeRedirectOauth().finally(() => {
+      clearSessionTimeouts();
+      initializeSessions().finally(() => {
+        // Set the client state to ready only after all initializations are done.
+        setClientState(base.ClientState.Ready);
+      });
+    });
+    return () => {
+      clearSessionTimeouts();
+    };
+  }, [client]);
+  const completeRedirectOauth = async () => {
+    // Check for either hash or search parameters that could indicate an OAuth redirect
+    if (window.location.hash || window.location.search) {
+      // Handle Facebook redirect (uses search params with code)
+      if (window.location.search && window.location.search.includes("code=") && window.location.search.includes("state=")) {
+        const searchParams = new URLSearchParams(window.location.search.substring(1));
+        const code = searchParams.get("code");
+        const state = searchParams.get("state");
+        // Parse state parameter
+        if (state && code) {
+          const stateParams = new URLSearchParams(state);
+          const provider = stateParams.get("provider");
+          const flow = stateParams.get("flow");
+          const publicKey = stateParams.get("publicKey");
+          const openModal = stateParams.get("openModal");
+          if (provider === "facebook" && flow === "redirect" && publicKey) {
+            // We have all the required parameters for a Facebook PKCE flow
+            const clientId = masterConfig?.auth?.oauthConfig?.facebookClientId;
+            const redirectURI = masterConfig?.auth?.oauthConfig?.oauthRedirectUri;
+            if (clientId && redirectURI) {
+              await utils.handleFacebookPKCEFlow({
+                code,
+                publicKey,
+                openModal,
+                clientId,
+                redirectURI,
+                callbacks,
+                completeOauth,
+                onPushPage: oidcToken => {
+                  return new Promise((resolve, reject) => {
+                    pushPage({
+                      key: `Facebook OAuth`,
+                      content: jsxRuntime.jsx(Action.ActionPage, {
+                        title: `Authenticating with Facebook...`,
+                        action: async () => {
+                          try {
+                            await completeOauth({
+                              oidcToken,
+                              publicKey,
+                              providerName: "facebook"
+                            });
+                            resolve();
+                          } catch (err) {
+                            reject(err);
+                          }
+                        },
+                        icon: jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, {
+                          size: "3x",
+                          icon: freeBrandsSvgIcons.faFacebook
+                        })
+                      }),
+                      showTitle: false
+                    });
+                  });
+                }
+              }).catch(error => {
+                // Handle errors
+                if (callbacks?.onError) {
+                  callbacks.onError(error instanceof sdkTypes.TurnkeyError ? error : new sdkTypes.TurnkeyError("Facebook authentication failed", sdkTypes.TurnkeyErrorCodes.OAUTH_SIGNUP_ERROR, error));
+                }
+              });
+            }
+          }
+        }
+      }
+      // Handle Google/Apple redirects (uses hash with id_token)
+      else if (window.location.hash) {
+        const hash = window.location.hash.substring(1);
+        // Parse the hash using our helper functions
+        const {
+          idToken,
+          provider,
+          flow,
+          publicKey,
+          openModal
+        } = utils.parseOAuthRedirect(hash);
+        if (idToken && flow === "redirect" && publicKey) {
+          if (openModal === "true") {
+            const providerName = provider ? provider.charAt(0).toUpperCase() + provider.slice(1) : "Provider";
+            // Determine which icon to show based on the provider
+            let icon;
+            if (provider === "apple") {
+              icon = jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, {
+                size: "3x",
+                icon: freeBrandsSvgIcons.faApple
+              });
+            } else {
+              // Default to Google icon
+              icon = jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, {
+                size: "3x",
+                icon: freeBrandsSvgIcons.faGoogle
+              });
+            }
+            // This state is set when the OAuth flow comes from the AuthComponent
+            await new Promise((resolve, reject) => {
+              pushPage({
+                key: `${providerName} OAuth`,
+                content: jsxRuntime.jsx(Action.ActionPage, {
+                  title: `Authenticating with ${providerName}...`,
+                  action: async () => {
+                    try {
+                      await completeOauth({
+                        oidcToken: idToken,
+                        publicKey,
+                        ...(provider ? {
+                          providerName: provider
+                        } : {})
+                      });
+                      resolve(null);
+                    } catch (err) {
+                      reject(err);
+                    }
+                  },
+                  icon: icon
+                }),
+                showTitle: false
+              });
+            });
+          } else if (callbacks?.onOauthRedirect) {
+            callbacks.onOauthRedirect({
+              idToken,
+              publicKey
+            });
+          } else {
+            completeOauth({
+              oidcToken: idToken,
+              publicKey,
+              ...(provider ? {
+                providerName: provider
+              } : {})
+            });
+          }
+          // Clean up the URL after processing
+          window.history.replaceState(null, document.title, window.location.pathname + window.location.search);
+        }
+      }
+    }
+  };
+  const buildConfig = proxyAuthConfig => {
+    // Juggle the local overrides with the values set in the dashboard (proxyAuthConfig).
+    const resolvedMethods = {
+      emailOtpAuthEnabled: config.auth?.methods?.emailOtpAuthEnabled ?? proxyAuthConfig?.enabledProviders.includes("email"),
+      smsOtpAuthEnabled: config.auth?.methods?.smsOtpAuthEnabled ?? proxyAuthConfig?.enabledProviders.includes("sms"),
+      passkeyAuthEnabled: config.auth?.methods?.passkeyAuthEnabled ?? proxyAuthConfig?.enabledProviders.includes("passkey"),
+      walletAuthEnabled: config.auth?.methods?.walletAuthEnabled ?? proxyAuthConfig?.enabledProviders.includes("wallet"),
+      googleOauthEnabled: config.auth?.methods?.googleOauthEnabled ?? proxyAuthConfig?.enabledProviders.includes("google"),
+      appleOauthEnabled: config.auth?.methods?.appleOauthEnabled ?? proxyAuthConfig?.enabledProviders.includes("apple"),
+      facebookOauthEnabled: config.auth?.methods?.facebookOauthEnabled ?? proxyAuthConfig?.enabledProviders.includes("facebook")
+    };
+    // Set a default ordering for the oAuth methods
+    const oauthOrder = config.auth?.oauthOrder ?? ["google", "apple", "facebook"].filter(provider => resolvedMethods[`${provider}OauthEnabled`]);
+    // Set a default ordering for the overall auth methods
+    const methodOrder = config.auth?.methodOrder ?? [oauthOrder.length > 0 ? "socials" : null, resolvedMethods.emailOtpAuthEnabled ? "email" : null, resolvedMethods.smsOtpAuthEnabled ? "sms" : null, resolvedMethods.passkeyAuthEnabled ? "passkey" : null, resolvedMethods.walletAuthEnabled ? "wallet" : null].filter(Boolean);
+    return {
+      ...config,
+      // Overrides:
+      auth: {
+        ...config.auth,
+        methods: resolvedMethods,
+        oauthConfig: {
+          ...config.auth?.oauthConfig,
+          openOauthInPage: config.auth?.oauthConfig?.openOauthInPage
+        },
+        sessionExpirationSeconds: proxyAuthConfig?.sessionExpirationSeconds,
+        methodOrder,
+        oauthOrder
+      },
+      walletConfig: {
+        ...config.walletConfig,
+        features: {
+          ...config.walletConfig?.features,
+          auth:
+          // If walletAuthEnabled is not set, default to true. Wallet auth can be enabled/disabled in the dashboard or by explicitly changing the walletAuthEnabled / walletConfig auth feature.
+          resolvedMethods.walletAuthEnabled ?? config.walletConfig?.features?.auth ?? true,
+          connecting: config.walletConfig?.features?.connecting ?? true // Default connecting to true if not set. We don't care about auth settings here.
+        },
+        chains: {
+          ...config.walletConfig?.chains,
+          ethereum: {
+            ...config.walletConfig?.chains?.ethereum,
+            native: true // Always enable native Ethereum support
+          },
+          solana: {
+            ...config.walletConfig?.chains?.solana,
+            native: true // Always enable native Solana support
+          }
+        }
+      },
+      importIframeUrl: config.importIframeUrl ?? "https://import.turnkey.com",
+      exportIframeUrl: config.exportIframeUrl ?? "https://export.turnkey.com"
+    };
+  };
+  /**
+   * Initializes the Turnkey 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 turnkeyClient = new core.TurnkeyClient({
+        apiBaseUrl: masterConfig.apiBaseUrl,
+        authProxyUrl: masterConfig.authProxyUrl,
+        authProxyConfigId: masterConfig.authProxyConfigId,
+        organizationId: masterConfig.organizationId,
+        // 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 || []
+        },
+        walletConfig: {
+          features: {
+            ...masterConfig.walletConfig?.features
+          },
+          chains: {
+            ...masterConfig.walletConfig?.chains
+          },
+          ...(masterConfig.walletConfig?.walletConnect && {
+            walletConnect: masterConfig.walletConfig.walletConnect
+          })
+        }
+      });
+      setAutoRefreshSession(masterConfig?.auth?.autoRefreshSession ?? false);
+      await turnkeyClient.init();
+      setClient(turnkeyClient);
+      // 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.TurnkeyError || error instanceof sdkTypes.TurnkeyNetworkError) {
+        callbacks?.onError?.(error);
+      } else {
+        callbacks?.onError?.(new sdkTypes.TurnkeyError(`Failed to initialize Turnkey client`, sdkTypes.TurnkeyErrorCodes.INITIALIZE_CLIENT_ERROR, error));
+      }
+    }
+  };
+  /**
+   * Initializes the user sessions by fetching all active sessions and setting up their state.
+   * @internal
+   */
+  const initializeSessions = async () => {
+    try {
+      const allSessions = await getAllSessions();
+      if (!allSessions) {
+        return;
+      }
+      await Promise.all(Object.keys(allSessions).map(async sessionKey => {
+        const session = allSessions?.[sessionKey];
+        if (!utils.isValidSession(session)) {
+          await clearSession({
+            sessionKey
+          });
+          return;
+        }
+        scheduleSessionExpiration({
+          sessionKey,
+          expiry: session.expiry
+        });
+      }));
+      setAllSessions(allSessions);
+      const activeSessionKey = await client?.getActiveSessionKey();
+      if (activeSessionKey) {
+        setSession(allSessions?.[activeSessionKey]);
+        await refreshUser();
+        await refreshWallets();
+        return;
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError || error instanceof sdkTypes.TurnkeyNetworkError) {
+        callbacks?.onError?.(error);
+      } else {
+        callbacks?.onError?.(new sdkTypes.TurnkeyError(`Failed to initialize sessions`, sdkTypes.TurnkeyErrorCodes.INITIALIZE_SESSION_ERROR, error));
+      }
+    }
+  };
+  /**
+   * @internal
+   * Schedules a session expiration and warning timeout for the given session key.
+   *
+   * - This function sets up two timeouts: one for warning before the session expires and another to expire the session.
+   * - The warning timeout is set to trigger before the session expires, allowing for actions like refreshing the session.
+   * - The expiration timeout clears the session and triggers any necessary callbacks.
+   *
+   * @param params.sessionKey - The key of the session to schedule expiration for.
+   * @param params.expiry - The expiration time in seconds for the session.
+   * @throws {TurnkeyError} If an error occurs while scheduling the session expiration.
+   */
+  async function scheduleSessionExpiration(params) {
+    const {
+      sessionKey,
+      expiry
+    } = params;
+    try {
+      // Clear any existing timeout for this session key
+      if (expiryTimeoutsRef.current[sessionKey]) {
+        clearTimeout(expiryTimeoutsRef.current[sessionKey]);
+        delete expiryTimeoutsRef.current[sessionKey];
+      }
+      if (expiryTimeoutsRef.current[`${sessionKey}-warning`]) {
+        clearTimeout(expiryTimeoutsRef.current[`${sessionKey}-warning`]);
+        delete expiryTimeoutsRef.current[`${sessionKey}-warning`];
+      }
+      const timeUntilExpiry = expiry * 1000 - Date.now();
+      const beforeExpiry = async () => {
+        const activeSession = await getSession();
+        if (!activeSession && expiryTimeoutsRef.current[sessionKey]) {
+          clearTimeout(expiryTimeoutsRef.current[`${sessionKey}-warning`]);
+          expiryTimeoutsRef.current[`${sessionKey}-warning`] = setTimeout(beforeExpiry, 10000);
+          return;
+        }
+        const session = await getSession({
+          sessionKey
+        });
+        if (!session) return;
+        callbacks?.beforeSessionExpiry?.({
+          sessionKey
+        });
+        if (autoRefreshSession) {
+          await refreshSession({
+            expirationSeconds: session.expirationSeconds,
+            sessionKey
+          });
+        }
+      };
+      const expireSession = async () => {
+        const expiredSession = await getSession({
+          sessionKey
+        });
+        if (!expiredSession) return;
+        callbacks?.onSessionExpired?.({
+          sessionKey
+        });
+        await clearSession({
+          sessionKey
+        });
+        delete expiryTimeoutsRef.current[sessionKey];
+        delete expiryTimeoutsRef.current[`${sessionKey}-warning`];
+        await logout();
+      };
+      if (timeUntilExpiry <= utils.SESSION_WARNING_THRESHOLD_MS) {
+        beforeExpiry();
+      } else {
+        expiryTimeoutsRef.current[`${sessionKey}-warning`] = setTimeout(beforeExpiry, timeUntilExpiry - utils.SESSION_WARNING_THRESHOLD_MS);
+      }
+      expiryTimeoutsRef.current[sessionKey] = setTimeout(expireSession, timeUntilExpiry);
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError || error instanceof sdkTypes.TurnkeyNetworkError) {
+        callbacks?.onError?.(error);
+      } else {
+        callbacks?.onError?.(new sdkTypes.TurnkeyError(`Failed to schedule session expiration for ${sessionKey}`, sdkTypes.TurnkeyErrorCodes.SCHEDULE_SESSION_EXPIRY_ERROR, error));
+      }
+    }
+  }
+  /**
+   * Clears all scheduled session expiration and warning timeouts for the client.
+   *
+   * - This function removes all active session expiration and warning timeouts managed by the provider.
+   * - It is called automatically when sessions are re-initialized or on logout to prevent memory leaks and ensure no stale timeouts remain.
+   * - All timeouts stored in `expiryTimeoutsRef` are cleared and the reference is reset.
+   *
+   * @throws {TurnkeyError} If an error occurs while clearing the timeouts.
+   */
+  function clearSessionTimeouts() {
+    try {
+      Object.values(expiryTimeoutsRef.current).forEach(timeout => {
+        clearTimeout(timeout);
+      });
+      expiryTimeoutsRef.current = {};
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError || error instanceof sdkTypes.TurnkeyNetworkError) {
+        callbacks?.onError?.(error);
+      } else {
+        callbacks?.onError?.(new sdkTypes.TurnkeyError(`Failed to clear session timeouts`, sdkTypes.TurnkeyErrorCodes.CLEAR_SESSION_TIMEOUTS_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 {TurnkeyError} If the client is not initialized or if there is an error during the process.
+   */
+  const handlePostAuth = async () => {
+    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 refreshWallets();
+      await refreshUser();
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError || error instanceof sdkTypes.TurnkeyNetworkError) {
+        callbacks?.onError?.(error);
+      } else {
+        callbacks?.onError?.(new sdkTypes.TurnkeyError(`Failed to handle post-authentication`, sdkTypes.TurnkeyErrorCodes.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 to prevent memory leaks.
+   * - It resets the session state, removes all session and user data from memory, 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 {TurnkeyError} If there is an error during the post-logout process.
+   */
+  const handlePostLogout = () => {
+    try {
+      clearSessionTimeouts();
+      setSession(undefined);
+      setAllSessions(undefined);
+      setUser(undefined);
+      setWallets([]);
+    } catch (error) {
+      callbacks?.onError?.(new sdkTypes.TurnkeyError(`Failed to initialize sessions`, sdkTypes.TurnkeyErrorCodes.HANDLE_POST_LOGOUT_ERROR, error));
+    }
+  };
+  async function createPasskey(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withTurnkeyErrorHandling(() => client.createPasskey({
+      ...params
+    }), callbacks, "Failed to create passkey");
+  }
+  async function logout(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    utils.withTurnkeyErrorHandling(() => client.logout(params), callbacks, "Failed to logout");
+    handlePostLogout();
+    return;
+  }
+  async function loginWithPasskey(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const expirationSeconds = masterConfig?.auth?.sessionExpirationSeconds ?? core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+    const res = await utils.withTurnkeyErrorHandling(() => client.loginWithPasskey({
+      ...params,
+      expirationSeconds
+    }), callbacks, "Failed to login with passkey");
+    if (res) {
+      await handlePostAuth();
+    }
+    return res;
+  }
+  async function signUpWithPasskey(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.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 = masterConfig?.auth?.sessionExpirationSeconds ?? core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+    const websiteName = window.location.hostname;
+    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.withTurnkeyErrorHandling(() => client.signUpWithPasskey({
+      ...params,
+      passkeyDisplayName: passkeyName,
+      expirationSeconds
+    }), callbacks, "Failed to sign up with passkey");
+    if (res) {
+      await handlePostAuth();
+    }
+    return res;
+  }
+  async function getWalletProviders(chain) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return await client.getWalletProviders(chain);
+  }
+  async function connectWalletAccount(walletProvider) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    await client.connectWalletAccount(walletProvider);
+    await refreshWallets();
+  }
+  async function disconnectWalletAccount(walletProvider) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    await client.disconnectWalletAccount(walletProvider);
+    // we only refresh the wallets if there is an active session
+    // this is needed because for WalletConnect you can unlink a wallet before
+    // actually being logged in
+    if (session) {
+      await refreshWallets();
+    }
+  }
+  async function switchWalletProviderChain(walletProvider, chainOrId) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    await client.switchWalletProviderChain(walletProvider, chainOrId);
+  }
+  // TODO: MOE PLEASE COMMENT THESE
+  async function initializeProviders(getWalletProviders, onWalletsChanged) {
+    const cleanups = [];
+    const [ethProviders, solProviders] = await Promise.all([getWalletProviders(core.Chain.Ethereum), getWalletProviders(core.Chain.Solana)]);
+    function attachEthereumListeners(provider, onWalletsChanged) {
+      if (typeof provider.on !== "function") return;
+      const handleAccountsChanged = accounts => {
+        if (accounts.length === 0) onWalletsChanged();
+      };
+      const handleDisconnect = () => onWalletsChanged();
+      provider.on("accountsChanged", handleAccountsChanged);
+      provider.on("disconnect", handleDisconnect);
+      return () => {
+        provider.removeListener("accountsChanged", handleAccountsChanged);
+        provider.removeListener("disconnect", handleDisconnect);
+      };
+    }
+    function attachSolanaListeners(provider, onWalletsChanged) {
+      const cleanups = [];
+      const walletEvents = provider.features?.["standard:events"];
+      if (walletEvents?.on) {
+        const handleChange = event => {
+          if (event.type === "change" || event.type === "accountsChanged") {
+            onWalletsChanged();
+          }
+        };
+        walletEvents.on("change", handleChange);
+        walletEvents.on("accountsChanged", handleChange);
+        cleanups.push(() => {
+          walletEvents.off?.("change", handleChange);
+          walletEvents.off?.("accountsChanged", handleChange);
+        });
+      }
+      return cleanups.length > 0 ? () => {
+        cleanups.forEach(fn => fn());
+      } : () => {};
+    }
+    ethProviders.forEach(p => {
+      const cleanup = attachEthereumListeners(p.provider, onWalletsChanged);
+      if (cleanup) cleanups.push(cleanup);
+    });
+    solProviders.forEach(p => {
+      const cleanup = attachSolanaListeners(p.provider, onWalletsChanged);
+      if (cleanup) cleanups.push(cleanup);
+    });
+    return () => {
+      cleanups.forEach(remove => remove());
+    };
+  }
+  async function loginWithWallet(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const expirationSeconds = masterConfig?.auth?.sessionExpirationSeconds ?? core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+    const res = await utils.withTurnkeyErrorHandling(() => client.loginWithWallet({
+      ...params,
+      expirationSeconds
+    }), callbacks, "Failed to login with wallet");
+    if (res) {
+      await handlePostAuth();
+    }
+    return res;
+  }
+  async function signUpWithWallet(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    // If createSubOrgParams is not provided, use the default from masterConfig
+    let createSubOrgParams = params.createSubOrgParams ?? masterConfig.auth?.createSuborgParams?.walletAuth;
+    params = createSubOrgParams !== undefined ? {
+      ...params,
+      createSubOrgParams
+    } : {
+      ...params
+    };
+    const expirationSeconds = masterConfig?.auth?.sessionExpirationSeconds ?? core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+    const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithWallet({
+      ...params,
+      expirationSeconds
+    }), callbacks, "Failed to sign up with wallet");
+    if (res) {
+      await handlePostAuth();
+    }
+    return res;
+  }
+  async function loginOrSignupWithWallet(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    // If createSubOrgParams is not provided, use the default from masterConfig
+    let createSubOrgParams = params.createSubOrgParams ?? masterConfig.auth?.createSuborgParams?.walletAuth;
+    params = createSubOrgParams !== undefined ? {
+      ...params,
+      createSubOrgParams
+    } : {
+      ...params
+    };
+    const expirationSeconds = masterConfig?.auth?.sessionExpirationSeconds ?? core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+    const res = await utils.withTurnkeyErrorHandling(() => client.loginOrSignupWithWallet({
+      ...params,
+      expirationSeconds
+    }), callbacks, "Failed to login or sign up with wallet");
+    if (res) {
+      await handlePostAuth();
+    }
+    return res;
+  }
+  async function initOtp(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withTurnkeyErrorHandling(() => client.initOtp(params), callbacks, "Failed to initialize OTP");
+  }
+  async function verifyOtp(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withTurnkeyErrorHandling(() => client.verifyOtp(params), callbacks, "Failed to verify OTP");
+  }
+  async function loginWithOtp(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const res = await utils.withTurnkeyErrorHandling(() => client.loginWithOtp(params), callbacks, "Failed to login with OTP");
+    if (res) {
+      await handlePostAuth();
+    }
+    return res;
+  }
+  async function signUpWithOtp(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.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.withTurnkeyErrorHandling(() => client.signUpWithOtp(params), callbacks, "Failed to sign up with OTP");
+    if (res) {
+      await handlePostAuth();
+    }
+    return res;
+  }
+  async function completeOtp(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.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.withTurnkeyErrorHandling(() => client.completeOtp(params), callbacks, "Failed to complete OTP");
+    if (res) {
+      await handlePostAuth();
+    }
+    return res;
+  }
+  async function completeOauth(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.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.withTurnkeyErrorHandling(() => client.completeOauth(params), callbacks, "Failed to complete OAuth");
+    if (res) {
+      await handlePostAuth();
+    }
+    return res;
+  }
+  async function loginWithOauth(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const res = await utils.withTurnkeyErrorHandling(() => client.loginWithOauth(params), callbacks, "Failed to login with OAuth");
+    if (res) {
+      await handlePostAuth();
+    }
+    return res;
+  }
+  async function signUpWithOauth(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.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.withTurnkeyErrorHandling(() => client.signUpWithOauth(params), callbacks, "Failed to sign up with OAuth");
+    if (res) {
+      await handlePostAuth();
+    }
+    return res;
+  }
+  async function fetchWallets(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withTurnkeyErrorHandling(() => client.fetchWallets(params), callbacks, "Failed to fetch wallets");
+  }
+  async function fetchWalletAccounts(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withTurnkeyErrorHandling(() => client.fetchWalletAccounts(params), callbacks, "Failed to fetch wallet accounts");
+  }
+  async function signMessage(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withTurnkeyErrorHandling(() => client.signMessage(params), callbacks, "Failed to sign message");
+  }
+  async function handleSignMessage(params) {
+    const {
+      successPageDuration = 2000
+    } = params;
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return new Promise((resolve, reject) => {
+      pushPage({
+        key: "Sign Message",
+        content: jsxRuntime.jsx(Message.SignMessageModal, {
+          message: params.message,
+          subText: params?.subText,
+          walletAccount: params.walletAccount,
+          stampWith: params.stampWith,
+          successPageDuration: successPageDuration,
+          onSuccess: result => {
+            resolve(result);
+          },
+          onError: error => {
+            reject(error);
+          },
+          ...(params?.encoding && {
+            encoding: params.encoding
+          }),
+          ...(params?.hashFunction && {
+            hashFunction: params.hashFunction
+          }),
+          ...(params?.addEthereumPrefix && {
+            addEthereumPrefix: params.addEthereumPrefix
+          })
+        })
+      });
+    });
+  }
+  async function signTransaction(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withTurnkeyErrorHandling(() => client.signTransaction(params), callbacks, "Failed to sign transaction");
+  }
+  async function signAndSendTransaction(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withTurnkeyErrorHandling(() => client.signAndSendTransaction(params), callbacks, "Failed to sign transaction");
+  }
+  async function fetchUser(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withTurnkeyErrorHandling(() => client.fetchUser(params), callbacks, "Failed to fetch user");
+  }
+  async function updateUserEmail(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.updateUserEmail(params), callbacks, "Failed to update user email");
+    if (res) await refreshUser({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function removeUserEmail(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.removeUserEmail(params), callbacks, "Failed to remove user email");
+    if (res) await refreshUser({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function updateUserPhoneNumber(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.updateUserPhoneNumber(params), callbacks, "Failed to update user phone number");
+    if (res) await refreshUser({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function removeUserPhoneNumber(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.removeUserPhoneNumber(params), callbacks, "Failed to remove user phone number");
+    if (res) await refreshUser({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function updateUserName(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.updateUserName(params), callbacks, "Failed to update user name");
+    if (res) await refreshUser({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function addOauthProvider(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.addOauthProvider(params), callbacks, "Failed to add OAuth provider");
+    if (res) await refreshUser({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function removeOauthProviders(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.removeOauthProviders(params), callbacks, "Failed to remove OAuth providers");
+    if (res) await refreshUser({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function addPasskey(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.addPasskey(params), callbacks, "Failed to add passkey");
+    if (res) await refreshUser({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function removePasskeys(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.removePasskeys(params), callbacks, "Failed to remove passkeys");
+    if (res) await refreshUser({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function createWallet(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.createWallet(params), callbacks, "Failed to create wallet");
+    if (res) await refreshWallets({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function createWalletAccounts(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.createWalletAccounts(params), callbacks, "Failed to create wallet accounts");
+    if (res) await refreshWallets({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function exportWallet(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.exportWallet(params), callbacks, "Failed to export wallet");
+    if (res) await refreshWallets({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function importWallet(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withTurnkeyErrorHandling(() => client.importWallet(params), callbacks, "Failed to import wallet");
+    if (res) await refreshWallets({
+      stampWith: params?.stampWith
+    });
+    return res;
+  }
+  async function deleteSubOrganization(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withTurnkeyErrorHandling(() => client.deleteSubOrganization(params), callbacks, "Failed to delete sub-organization");
+  }
+  async function storeSession(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    await utils.withTurnkeyErrorHandling(() => client.storeSession(params), 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);
+    return;
+  }
+  async function clearSession(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    await utils.withTurnkeyErrorHandling(() => client.clearSession(params), callbacks, "Failed to clear session");
+    const session = await getSession();
+    const allSessions = await getAllSessions();
+    setSession(session);
+    setAllSessions(allSessions);
+    return;
+  }
+  async function clearAllSessions() {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    setSession(undefined);
+    setAllSessions(undefined);
+    return await utils.withTurnkeyErrorHandling(() => client.clearAllSessions(), callbacks, "Failed to clear all sessions");
+  }
+  async function refreshSession(params) {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const activeSessionKey = await client.getActiveSessionKey();
+    if (!activeSessionKey) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    const sessionKey = params?.sessionKey ?? activeSessionKey;
+    const res = await utils.withTurnkeyErrorHandling(() => client.refreshSession({
+      ...params
+    }), 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;
+  }
+  async function getSession(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withTurnkeyErrorHandling(() => client.getSession(params), callbacks, "Failed to get session");
+  }
+  async function getAllSessions() {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withTurnkeyErrorHandling(() => client.getAllSessions(), callbacks, "Failed to get all sessions");
+  }
+  async function setActiveSession(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const session = await utils.withTurnkeyErrorHandling(() => client.getSession({
+      sessionKey: params.sessionKey
+    }), callbacks, "Failed to get session");
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("Session not found.", sdkTypes.TurnkeyErrorCodes.NOT_FOUND);
+    }
+    await utils.withTurnkeyErrorHandling(() => client.setActiveSession(params), callbacks, "Failed to set active session");
+    setSession(session);
+    return;
+  }
+  async function getActiveSessionKey() {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withTurnkeyErrorHandling(() => client.getActiveSessionKey(), callbacks, "Failed to get active session key");
+  }
+  async function clearUnusedKeyPairs() {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withTurnkeyErrorHandling(() => client.clearUnusedKeyPairs(), callbacks, "Failed to clear unused key pairs");
+  }
+  async function createApiKeyPair(params) {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withTurnkeyErrorHandling(() => client.createApiKeyPair(params), callbacks, "Failed to create API key pair");
+  }
+  async function getProxyAuthConfig() {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withTurnkeyErrorHandling(() => client.getProxyAuthConfig(), callbacks, "Failed to get proxy auth config");
+  }
+  async function refreshUser(params) {
+    const {
+      stampWith
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const user = await utils.withTurnkeyErrorHandling(() => fetchUser({
+      stampWith
+    }), callbacks, "Failed to refresh user");
+    if (user) {
+      setUser(user);
+    }
+  }
+  async function refreshWallets(params) {
+    const {
+      stampWith
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const wallets = await utils.withTurnkeyErrorHandling(() => fetchWallets({
+      stampWith
+    }), callbacks, "Failed to refresh wallets");
+    if (wallets) {
+      setWallets(wallets);
+    }
+  }
+  async function handleGoogleOauth(params) {
+    const {
+      clientId = masterConfig?.auth?.oauthConfig?.googleClientId,
+      openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
+      additionalState: additionalParameters
+    } = params || {};
+    try {
+      if (!masterConfig) {
+        throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      if (!clientId) {
+        throw new sdkTypes.TurnkeyError("Google Client ID is not configured.", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      if (!masterConfig.auth?.oauthConfig?.oauthRedirectUri) {
+        throw new sdkTypes.TurnkeyError("OAuth Redirect URI is not configured.", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      const flow = openInPage ? "redirect" : "popup";
+      const redirectURI = masterConfig.auth?.oauthConfig.oauthRedirectUri.replace(/\/$/, "");
+      // Create key pair and generate nonce
+      const publicKey = await createApiKeyPair();
+      if (!publicKey) {
+        throw new Error("Failed to create public key for OAuth.");
+      }
+      const nonce = utils$1.bytesToHex(sha2.sha256(publicKey));
+      // Construct Google Auth URL
+      const googleAuthUrl = new URL(utils.GOOGLE_AUTH_URL);
+      googleAuthUrl.searchParams.set("client_id", clientId);
+      googleAuthUrl.searchParams.set("redirect_uri", redirectURI);
+      googleAuthUrl.searchParams.set("response_type", "id_token");
+      googleAuthUrl.searchParams.set("scope", "openid email profile");
+      googleAuthUrl.searchParams.set("nonce", nonce);
+      googleAuthUrl.searchParams.set("prompt", "select_account");
+      // Create state parameter
+      let state = `provider=google&flow=${flow}&publicKey=${encodeURIComponent(publicKey)}`;
+      if (additionalParameters) {
+        const additionalState = Object.entries(additionalParameters).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+        if (additionalState) {
+          state += `&${additionalState}`;
+        }
+      }
+      googleAuthUrl.searchParams.set("state", state);
+      if (openInPage) {
+        // Redirect current page to Google Auth
+        window.location.href = googleAuthUrl.toString();
+        return new Promise((_, reject) => {
+          // By here, the page should have already redirected. We wait here since the function is async.
+          // We want any function that runs this to simply wait until the page redirects.
+          // A 5 min timeout is set just in case, idk
+          const timeout = setTimeout(() => {
+            reject(new Error("Authentication timed out."));
+          }, 300000); // 5 minutes
+          // If the page is unloaded (user navigates away), clear the timeout
+          window.addEventListener("beforeunload", () => clearTimeout(timeout));
+        });
+      } else {
+        // Open popup window
+        const width = utils.popupWidth;
+        const height = utils.popupHeight;
+        const left = window.screenX + (window.innerWidth - width) / 2;
+        const top = window.screenY + (window.innerHeight - height) / 2;
+        const authWindow = window.open("about:blank", "_blank", `width=${width},height=${height},top=${top},left=${left},scrollbars=yes,resizable=yes`);
+        if (!authWindow) {
+          throw new Error("Failed to open Google login window.");
+        }
+        authWindow.location.href = googleAuthUrl.toString();
+        // Return a promise that resolves when the OAuth flow completes
+        // This following code will only run for the popup flow
+        return new Promise((resolve, reject) => {
+          const interval = setInterval(() => {
+            try {
+              // Check if window was closed without completing auth
+              if (authWindow.closed) {
+                clearInterval(interval);
+                reject(new Error("Authentication window was closed."));
+                return;
+              }
+              const url = authWindow.location.href || "";
+              if (url.startsWith(window.location.origin)) {
+                const hashParams = new URLSearchParams(url.split("#")[1]);
+                const idToken = hashParams.get("id_token");
+                if (idToken) {
+                  authWindow.close();
+                  clearInterval(interval);
+                  if (params?.onOauthSuccess) {
+                    params.onOauthSuccess({
+                      oidcToken: idToken,
+                      providerName: "google"
+                    });
+                  } else if (callbacks?.onOauthRedirect) {
+                    callbacks.onOauthRedirect({
+                      idToken,
+                      publicKey
+                    });
+                  } else {
+                    completeOauth({
+                      oidcToken: idToken,
+                      publicKey,
+                      providerName: "google"
+                    }).then(() => resolve()).catch(reject);
+                    return;
+                  }
+                  resolve();
+                }
+              }
+            } catch (error) {
+              // Ignore cross-origin errors
+            }
+          }, 500);
+          if (authWindow.closed) {
+            clearInterval(interval);
+          }
+        });
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function handleAppleOauth(params) {
+    const {
+      clientId = masterConfig?.auth?.oauthConfig?.appleClientId,
+      openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
+      additionalState: additionalParameters
+    } = params || {};
+    try {
+      if (!masterConfig) {
+        throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      if (!clientId) {
+        throw new sdkTypes.TurnkeyError("Apple Client ID is not configured.", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      if (!masterConfig.auth?.oauthConfig?.oauthRedirectUri) {
+        throw new sdkTypes.TurnkeyError("OAuth Redirect URI is not configured.", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      const flow = openInPage ? "redirect" : "popup";
+      const redirectURI = masterConfig.auth?.oauthConfig.oauthRedirectUri; // TODO (Amir): Apple needs the '/' at the end. Maybe we should add it if not there?
+      // Create key pair and generate nonce
+      const publicKey = await createApiKeyPair();
+      if (!publicKey) {
+        throw new Error("Failed to create public key for OAuth.");
+      }
+      const nonce = utils$1.bytesToHex(sha2.sha256(publicKey));
+      // Construct Apple Auth URL
+      const appleAuthUrl = new URL(utils.APPLE_AUTH_URL);
+      appleAuthUrl.searchParams.set("client_id", clientId);
+      appleAuthUrl.searchParams.set("redirect_uri", redirectURI);
+      appleAuthUrl.searchParams.set("response_type", "code id_token");
+      appleAuthUrl.searchParams.set("response_mode", "fragment");
+      appleAuthUrl.searchParams.set("nonce", nonce);
+      // Create state parameter
+      let state = `provider=apple&flow=${flow}&publicKey=${encodeURIComponent(publicKey)}`;
+      if (additionalParameters) {
+        const additionalState = Object.entries(additionalParameters).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+        if (additionalState) {
+          state += `&${additionalState}`;
+        }
+      }
+      appleAuthUrl.searchParams.set("state", state);
+      if (openInPage) {
+        // Redirect current page to Apple Auth
+        window.location.href = appleAuthUrl.toString();
+        return new Promise((_, reject) => {
+          // Set a timeout just in case the redirect doesn't happen
+          const timeout = setTimeout(() => {
+            reject(new Error("Authentication timed out."));
+          }, 300000); // 5 minutes
+          // If the page is unloaded (user navigates away), clear the timeout
+          window.addEventListener("beforeunload", () => clearTimeout(timeout));
+        });
+      } else {
+        // Open popup window
+        const width = utils.popupWidth;
+        const height = utils.popupHeight;
+        const left = window.screenX + (window.innerWidth - width) / 2;
+        const top = window.screenY + (window.innerHeight - height) / 2;
+        const authWindow = window.open("about:blank", "_blank", `width=${width},height=${height},top=${top},left=${left},scrollbars=yes,resizable=yes`);
+        if (!authWindow) {
+          throw new Error("Failed to open Apple login window.");
+        }
+        authWindow.location.href = appleAuthUrl.toString();
+        // Return a promise that resolves when the OAuth flow completes
+        return new Promise((resolve, reject) => {
+          const interval = setInterval(() => {
+            try {
+              // Check if window was closed without completing auth
+              if (authWindow.closed) {
+                clearInterval(interval);
+                reject(new Error("Authentication window was closed."));
+                return;
+              }
+              const url = authWindow.location.href || "";
+              if (url.startsWith(window.location.origin)) {
+                const hashParams = new URLSearchParams(url.split("#")[1]);
+                const idToken = hashParams.get("id_token");
+                if (idToken) {
+                  authWindow.close();
+                  clearInterval(interval);
+                  if (params?.onOauthSuccess) {
+                    params.onOauthSuccess({
+                      oidcToken: idToken,
+                      providerName: "apple"
+                    });
+                  } else if (callbacks?.onOauthRedirect) {
+                    callbacks.onOauthRedirect({
+                      idToken,
+                      publicKey
+                    });
+                  } else {
+                    completeOauth({
+                      oidcToken: idToken,
+                      publicKey,
+                      providerName: "apple"
+                    }).then(() => resolve()).catch(reject);
+                    return;
+                  }
+                  resolve();
+                }
+              }
+            } catch (error) {
+              // Ignore cross-origin errors
+            }
+          }, 500);
+          if (authWindow.closed) {
+            clearInterval(interval);
+          }
+        });
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function handleFacebookOauth(params) {
+    const {
+      clientId = masterConfig?.auth?.oauthConfig?.facebookClientId,
+      openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
+      additionalState: additionalParameters
+    } = params || {};
+    try {
+      if (!masterConfig) {
+        throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      if (!clientId) {
+        throw new sdkTypes.TurnkeyError("Facebook Client ID is not configured.", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      if (!masterConfig.auth?.oauthConfig?.oauthRedirectUri) {
+        throw new sdkTypes.TurnkeyError("OAuth Redirect URI is not configured.", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      const flow = openInPage ? "redirect" : "popup";
+      const redirectURI = masterConfig.auth?.oauthConfig.oauthRedirectUri;
+      // Create key pair and generate nonce
+      const publicKey = await createApiKeyPair();
+      if (!publicKey) {
+        throw new Error("Failed to create public key for OAuth.");
+      }
+      const nonce = utils$1.bytesToHex(sha2.sha256(publicKey));
+      // Generate PKCE challenge pair
+      const {
+        verifier,
+        codeChallenge
+      } = await utils.generateChallengePair();
+      // Store verifier for later token exchange
+      sessionStorage.setItem("facebook_verifier", verifier);
+      // Construct Facebook Auth URL
+      const facebookAuthUrl = new URL(utils.FACEBOOK_AUTH_URL);
+      facebookAuthUrl.searchParams.set("client_id", clientId);
+      facebookAuthUrl.searchParams.set("redirect_uri", redirectURI);
+      facebookAuthUrl.searchParams.set("response_type", "code");
+      facebookAuthUrl.searchParams.set("code_challenge", codeChallenge);
+      facebookAuthUrl.searchParams.set("code_challenge_method", "S256");
+      facebookAuthUrl.searchParams.set("nonce", nonce);
+      facebookAuthUrl.searchParams.set("scope", "openid");
+      // Create state parameter
+      let state = `provider=facebook&flow=${flow}&publicKey=${encodeURIComponent(publicKey)}`;
+      if (additionalParameters) {
+        const additionalState = Object.entries(additionalParameters).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+        if (additionalState) {
+          state += `&${additionalState}`;
+        }
+      }
+      facebookAuthUrl.searchParams.set("state", state);
+      if (openInPage) {
+        // Redirect current page to Facebook Auth
+        window.location.href = facebookAuthUrl.toString();
+        return new Promise((_, reject) => {
+          // Set a timeout just in case the redirect doesn't happen
+          const timeout = setTimeout(() => {
+            reject(new Error("Authentication timed out."));
+          }, 300000); // 5 minutes
+          // If the page is unloaded (user navigates away), clear the timeout
+          window.addEventListener("beforeunload", () => clearTimeout(timeout));
+        });
+      } else {
+        // Open popup window
+        const width = utils.popupWidth;
+        const height = utils.popupHeight;
+        const left = window.screenX + (window.innerWidth - width) / 2;
+        const top = window.screenY + (window.innerHeight - height) / 2;
+        const authWindow = window.open("about:blank", "_blank", `width=${width},height=${height},top=${top},left=${left},scrollbars=yes,resizable=yes`);
+        if (!authWindow) {
+          throw new Error("Failed to open Facebook login window.");
+        }
+        authWindow.location.href = facebookAuthUrl.toString();
+        // Return a promise that resolves when the OAuth flow completes
+        return new Promise((resolve, reject) => {
+          const interval = setInterval(() => {
+            try {
+              // Check if window was closed without completing auth
+              if (authWindow.closed) {
+                clearInterval(interval);
+                reject(new Error("Authentication window was closed."));
+                return;
+              }
+              const url = authWindow.location.href || "";
+              if (url.startsWith(window.location.origin)) {
+                const urlParams = new URLSearchParams(new URL(url).search);
+                const authCode = urlParams.get("code");
+                const stateParam = urlParams.get("state");
+                if (authCode && stateParam && stateParam.includes("provider=facebook")) {
+                  authWindow.close();
+                  clearInterval(interval);
+                  // Exchange code for token
+                  const verifier = sessionStorage.getItem("facebook_verifier");
+                  if (!verifier) {
+                    reject(new Error("Missing PKCE verifier"));
+                    return;
+                  }
+                  utils.exchangeCodeForToken(clientId, redirectURI, authCode, verifier).then(tokenData => {
+                    sessionStorage.removeItem("facebook_verifier");
+                    if (params?.onOauthSuccess) {
+                      params.onOauthSuccess({
+                        oidcToken: tokenData.id_token,
+                        providerName: "apple"
+                      });
+                    } else if (callbacks?.onOauthRedirect) {
+                      callbacks.onOauthRedirect({
+                        idToken: tokenData.id_token,
+                        publicKey
+                      });
+                    } else {
+                      completeOauth({
+                        oidcToken: tokenData.id_token,
+                        publicKey,
+                        providerName: "facebook"
+                      }).then(() => resolve()).catch(reject);
+                      return;
+                    }
+                    resolve();
+                  }).catch(reject);
+                }
+              }
+            } catch (error) {
+              // Ignore cross-origin errors
+            }
+          }, 500);
+          if (authWindow.closed) {
+            clearInterval(interval);
+          }
+        });
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+  const handleLogin = async () => {
+    pushPage({
+      key: "Log in or sign up",
+      content: jsxRuntime.jsx(index.AuthComponent, {})
+    });
+  };
+  const handleExport = async params => {
+    const {
+      walletId,
+      exportType,
+      targetPublicKey,
+      stampWith
+    } = params;
+    pushPage({
+      key: "Export Wallet",
+      content: jsxRuntime.jsx(Export.ExportComponent, {
+        walletId: walletId ?? wallets[0]?.walletId,
+        exportType: exportType ?? base.ExportType.Wallet,
+        ...(targetPublicKey !== undefined ? {
+          targetPublicKey
+        } : {}),
+        ...(stampWith !== undefined ? {
+          stampWith
+        } : {})
+      })
+    });
+  };
+  const handleImport = async params => {
+    const {
+      defaultWalletAccounts,
+      successPageDuration = 2000,
+      stampWith
+    } = params || {};
+    try {
+      return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => pushPage({
+        key: "Import Wallet",
+        content: jsxRuntime.jsx(Import.ImportComponent, {
+          onError: error => {
+            reject(error);
+          },
+          onSuccess: walletId => resolve(walletId),
+          ...(defaultWalletAccounts !== undefined && {
+            defaultWalletAccounts
+          }),
+          ...(successPageDuration !== undefined && {
+            successPageDuration
+          }),
+          ...(stampWith !== undefined && {
+            stampWith
+          })
+        })
+      })));
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError) {
+        throw error;
+      }
+      throw new sdkTypes.TurnkeyError("Failed to import wallet.", sdkTypes.TurnkeyErrorCodes.IMPORT_WALLET_ERROR, error);
+    }
+  };
+  const handleUpdateUserName = async params => {
+    const {
+      successPageDuration = 2000,
+      subTitle,
+      title,
+      stampWith
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    const onSuccess = () => {
+      if (!successPageDuration) return;
+      pushPage({
+        key: "success",
+        content: jsxRuntime.jsx(Success.SuccessPage, {
+          text: "User name changed successfully!",
+          duration: successPageDuration,
+          onComplete: () => {
+            closeModal();
+          }
+        }),
+        preventBack: true,
+        showTitle: false
+      });
+    };
+    try {
+      if (!params?.userName && params?.userName !== "") {
+        return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Update User Name",
+            content: jsxRuntime.jsx(UpdateUserName.UpdateUserName, {
+              onSuccess: userId => {
+                resolve(userId);
+              },
+              onError: error => {
+                reject(error);
+              },
+              successPageDuration: successPageDuration,
+              stampWith: stampWith,
+              ...(title !== undefined ? {
+                title
+              } : {}),
+              ...(subTitle !== undefined ? {
+                subTitle
+              } : {})
+            }),
+            showTitle: false
+          });
+        }));
+      } else {
+        const res = await updateUserName({
+          userName: params.userName,
+          userId: user.userId,
+          stampWith
+        });
+        onSuccess();
+        return res;
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError) {
+        throw error;
+      }
+      throw new sdkTypes.TurnkeyError("Failed to update user name.", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_NAME_ERROR, error);
+    }
+  };
+  const handleUpdateUserPhoneNumber = async params => {
+    const {
+      successPageDuration = 2000,
+      subTitle,
+      title
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.CONFIG_NOT_INITIALIZED);
+    }
+    if (!masterConfig.auth?.methods?.smsOtpAuthEnabled) {
+      throw new sdkTypes.TurnkeyError("SMS OTP authentication is not enabled in the configuration.", sdkTypes.TurnkeyErrorCodes.AUTH_METHOD_NOT_ENABLED);
+    }
+    const onSuccess = () => {
+      if (!successPageDuration) return;
+      pushPage({
+        key: "success",
+        content: jsxRuntime.jsx(Success.SuccessPage, {
+          text: "Phone number changed successfully!",
+          duration: successPageDuration,
+          onComplete: () => {
+            closeModal();
+          }
+        }),
+        preventBack: true,
+        showTitle: false
+      });
+    };
+    try {
+      if (!params?.phoneNumber && params?.phoneNumber !== "") {
+        return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Update Phone Number",
+            content: jsxRuntime.jsx(UpdatePhoneNumber.UpdatePhoneNumber, {
+              successPageDuration: successPageDuration,
+              onSuccess: userId => resolve(userId),
+              onError: error => reject(error),
+              ...(title !== undefined ? {
+                title
+              } : {}),
+              ...(subTitle !== undefined ? {
+                subTitle
+              } : {})
+            }),
+            showTitle: false
+          });
+        }));
+      } else {
+        const otpId = await initOtp({
+          otpType: core.OtpType.Sms,
+          contact: params.phoneNumber
+        });
+        return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Update Phone Number",
+            content: jsxRuntime.jsx(OTP.OtpVerification, {
+              otpType: core.OtpType.Sms,
+              contact: params.phoneNumber,
+              otpId: otpId,
+              onContinue: async otpCode => {
+                try {
+                  const {
+                    verificationToken
+                  } = await verifyOtp({
+                    otpId,
+                    otpCode,
+                    contact: params.phoneNumber,
+                    otpType: core.OtpType.Sms
+                  });
+                  const res = await updateUserPhoneNumber({
+                    phoneNumber: params.phoneNumber,
+                    verificationToken,
+                    userId: user.userId
+                  });
+                  onSuccess();
+                  resolve(res);
+                } catch (error) {
+                  reject(error);
+                }
+              },
+              ...(!user?.userPhoneNumber && {
+                title: title ?? "Connect a phone number"
+              }),
+              ...(subTitle !== undefined && {
+                subTitle
+              }),
+              ...(params.formattedPhone && {
+                formattedPhone: params.formattedPhone
+              })
+            }),
+            showTitle: false
+          });
+        }), callbacks, "Failed to update phone number");
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError) {
+        throw error;
+      }
+      throw new sdkTypes.TurnkeyError("Failed to initialize OTP for sms verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
+    }
+  };
+  const handleUpdateUserEmail = async params => {
+    const {
+      successPageDuration = 2000,
+      subTitle,
+      title
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    const onSuccess = () => {
+      if (!successPageDuration) return;
+      pushPage({
+        key: "success",
+        content: jsxRuntime.jsx(Success.SuccessPage, {
+          text: "Email changed successfully!",
+          duration: successPageDuration,
+          onComplete: () => {
+            closeModal();
+          }
+        }),
+        preventBack: true,
+        showTitle: false
+      });
+    };
+    try {
+      if (!params?.email && params?.email !== "") {
+        return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Update Email",
+            content: jsxRuntime.jsx(UpdateEmail.UpdateEmail, {
+              successPageDuration: successPageDuration,
+              onSuccess: userId => {
+                resolve(userId);
+              },
+              onError: error => reject(error),
+              ...(title !== undefined ? {
+                title
+              } : {}),
+              ...(subTitle !== undefined ? {
+                subTitle
+              } : {})
+            }),
+            showTitle: false
+          });
+        }));
+      } else {
+        const otpId = await initOtp({
+          otpType: core.OtpType.Email,
+          contact: params.email
+        });
+        return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Update Email",
+            content: jsxRuntime.jsx(OTP.OtpVerification, {
+              otpType: core.OtpType.Email,
+              contact: params.email,
+              otpId: otpId,
+              onContinue: async otpCode => {
+                try {
+                  const {
+                    verificationToken
+                  } = await verifyOtp({
+                    otpId,
+                    otpCode,
+                    contact: params.email,
+                    otpType: core.OtpType.Email
+                  });
+                  const res = await updateUserEmail({
+                    email: params.email,
+                    verificationToken,
+                    userId: user.userId
+                  });
+                  onSuccess();
+                  resolve(res);
+                } catch (error) {
+                  reject(error);
+                }
+              },
+              ...(!user?.userEmail && {
+                title: title ?? "Connect an email"
+              }),
+              ...(subTitle !== undefined && {
+                subTitle
+              })
+            }),
+            showTitle: false
+          });
+        }), callbacks, "Failed to update email");
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError) {
+        throw error;
+      }
+      throw new sdkTypes.TurnkeyError("Failed to initialize OTP for email verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
+    }
+  };
+  const handleAddEmail = async params => {
+    const {
+      successPageDuration = 2000,
+      subTitle,
+      title
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    const onSuccess = () => {
+      if (!successPageDuration) return;
+      pushPage({
+        key: "success",
+        content: jsxRuntime.jsx(Success.SuccessPage, {
+          text: "Email added successfully!",
+          duration: successPageDuration,
+          onComplete: () => {
+            closeModal();
+          }
+        }),
+        preventBack: true,
+        showTitle: false
+      });
+    };
+    try {
+      if (!params?.email && params?.email !== "") {
+        return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Add Email",
+            content: jsxRuntime.jsx(UpdateEmail.UpdateEmail, {
+              successPageDuration: successPageDuration,
+              onSuccess: userId => {
+                resolve(userId);
+              },
+              onError: error => reject(error),
+              ...(!user?.userEmail ? {
+                title: title ?? "Connect an email"
+              } : {}),
+              ...(subTitle !== undefined ? {
+                subTitle
+              } : {})
+            }),
+            showTitle: false
+          });
+        }));
+      } else {
+        const otpId = await initOtp({
+          otpType: core.OtpType.Email,
+          contact: params.email
+        });
+        return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Add Email",
+            content: jsxRuntime.jsx(OTP.OtpVerification, {
+              otpType: core.OtpType.Email,
+              contact: params.email,
+              otpId: otpId,
+              onContinue: async otpCode => {
+                try {
+                  const {
+                    verificationToken
+                  } = await verifyOtp({
+                    otpId,
+                    otpCode,
+                    contact: params.email,
+                    otpType: core.OtpType.Email
+                  });
+                  const res = await updateUserEmail({
+                    email: params.email,
+                    verificationToken,
+                    userId: user.userId
+                  });
+                  onSuccess();
+                  resolve(res);
+                } catch (error) {
+                  reject(error);
+                }
+              },
+              ...(!user?.userEmail && {
+                title: title ?? "Connect an email"
+              }),
+              ...(subTitle !== undefined && {
+                subTitle
+              })
+            }),
+            showTitle: false
+          });
+        }), callbacks, "Failed to add email");
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError) {
+        throw error;
+      }
+      throw new sdkTypes.TurnkeyError("Failed to initialize OTP for email verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
+    }
+  };
+  const handleAddPhoneNumber = async params => {
+    const {
+      successPageDuration = 2000,
+      subTitle,
+      title
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.CONFIG_NOT_INITIALIZED);
+    }
+    if (!masterConfig.auth?.methods?.smsOtpAuthEnabled) {
+      throw new sdkTypes.TurnkeyError("SMS OTP authentication is not enabled in the configuration.", sdkTypes.TurnkeyErrorCodes.AUTH_METHOD_NOT_ENABLED);
+    }
+    const onSuccess = () => {
+      if (!successPageDuration) return;
+      pushPage({
+        key: "success",
+        content: jsxRuntime.jsx(Success.SuccessPage, {
+          text: "Phone number updated successfully!",
+          duration: successPageDuration,
+          onComplete: () => {
+            closeModal();
+          }
+        }),
+        preventBack: true,
+        showTitle: false
+      });
+    };
+    try {
+      if (!params?.phoneNumber && params?.phoneNumber !== "") {
+        return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Add Phone Number",
+            content: jsxRuntime.jsx(UpdatePhoneNumber.UpdatePhoneNumber, {
+              successPageDuration: successPageDuration,
+              onSuccess: userId => {
+                resolve(userId);
+              },
+              onError: error => {
+                reject(error);
+              },
+              ...(!user?.userPhoneNumber && {
+                title: title ?? "Connect a phone number"
+              }),
+              ...(subTitle !== undefined && {
+                subTitle
+              })
+            }),
+            showTitle: false
+          });
+        }), callbacks, "Failed to add phone number");
+      } else {
+        const otpId = await initOtp({
+          otpType: core.OtpType.Sms,
+          contact: params.phoneNumber
+        });
+        return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Add Phone Number",
+            content: jsxRuntime.jsx(OTP.OtpVerification, {
+              otpType: core.OtpType.Sms,
+              contact: params.phoneNumber,
+              otpId: otpId,
+              onContinue: async otpCode => {
+                try {
+                  const {
+                    verificationToken
+                  } = await verifyOtp({
+                    otpId,
+                    otpCode,
+                    contact: params.phoneNumber,
+                    otpType: core.OtpType.Sms
+                  });
+                  const res = await updateUserPhoneNumber({
+                    phoneNumber: params.phoneNumber,
+                    verificationToken,
+                    userId: user.userId
+                  });
+                  onSuccess();
+                  resolve(res);
+                } catch (error) {
+                  reject(error);
+                }
+              },
+              ...(!user?.userPhoneNumber && {
+                title: title ?? "Connect a phone number"
+              }),
+              ...(subTitle !== undefined && {
+                subTitle
+              }),
+              ...(params.formattedPhone && {
+                formattedPhone: params.formattedPhone
+              })
+            }),
+            showTitle: false
+          });
+        }), callbacks, "Failed to add phone number");
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError) {
+        throw error;
+      }
+      throw new sdkTypes.TurnkeyError("Failed to initialize OTP for sms verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
+    }
+  };
+  const handleRemovePasskey = async params => {
+    const {
+      authenticatorId,
+      successPageDuration = 2000,
+      subTitle,
+      title,
+      stampWith,
+      userId
+    } = params;
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => {
+      pushPage({
+        key: "Remove Passkey",
+        content: jsxRuntime.jsx(RemovePasskey.RemovePasskey, {
+          authenticatorId: authenticatorId,
+          successPageDuration: successPageDuration,
+          onSuccess: authenticatorIds => {
+            resolve(authenticatorIds);
+          },
+          onError: error => {
+            reject(error);
+          },
+          stampWith: stampWith,
+          ...(userId && {
+            userId
+          }),
+          ...(title !== undefined && {
+            title
+          }),
+          ...(subTitle !== undefined && {
+            subTitle
+          })
+        }),
+        showTitle: false,
+        preventBack: true
+      });
+    }), callbacks, "Failed to remove passkey");
+  };
+  const handleAddPasskey = async params => {
+    const {
+      name,
+      displayName,
+      successPageDuration = 2000,
+      stampWith
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    const userId = params?.userId || session.userId;
+    try {
+      const resPromise = addPasskey({
+        ...(name && {
+          name
+        }),
+        ...(displayName && {
+          displayName
+        }),
+        userId,
+        stampWith
+      });
+      resPromise.then(() => {
+        pushPage({
+          key: "Passkey Added",
+          content: jsxRuntime.jsx(Success.SuccessPage, {
+            text: "Successfully added passkey!",
+            duration: successPageDuration,
+            onComplete: () => {
+              closeModal();
+            }
+          }),
+          preventBack: true,
+          showTitle: false
+        });
+      });
+      return await resPromise;
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError) {
+        throw error;
+      }
+      throw new sdkTypes.TurnkeyError("Failed to add passkey in handler.", sdkTypes.TurnkeyErrorCodes.ADD_PASSKEY_ERROR, error);
+    }
+  };
+  const handleRemoveOauthProvider = async params => {
+    const {
+      providerId,
+      successPageDuration = 2000,
+      subTitle,
+      title,
+      stampWith
+    } = params;
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    try {
+      return new Promise((resolve, reject) => {
+        pushPage({
+          key: "Remove OAuth Provider",
+          content: jsxRuntime.jsx(RemoveOAuthProvider.RemoveOAuthProvider, {
+            providerId: providerId,
+            stampWith: stampWith,
+            successPageDuration: successPageDuration,
+            onSuccess: providerIds => {
+              resolve(providerIds);
+            },
+            onError: error => {
+              reject(error);
+            },
+            ...(title !== undefined && {
+              title
+            }),
+            ...(subTitle !== undefined && {
+              subTitle
+            })
+          }),
+          showTitle: false,
+          preventBack: true
+        });
+      });
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError) {
+        throw error;
+      }
+      throw new sdkTypes.TurnkeyError("Failed to remove OAuth provider in handler.", sdkTypes.TurnkeyErrorCodes.REMOVE_OAUTH_PROVIDER_ERROR, error);
+    }
+  };
+  const handleAddOauthProvider = async params => {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    const {
+      providerName,
+      stampWith
+    } = params;
+    const onOauthSuccess = async params => {
+      await addOauthProvider({
+        providerName: params.providerName,
+        oidcToken: params.oidcToken,
+        stampWith
+      });
+      pushPage({
+        key: "OAuth Provider Added",
+        content: jsxRuntime.jsx(Success.SuccessPage, {
+          text: `Successfully added ${params.providerName} OAuth provider!`,
+          duration: 3000,
+          onComplete: () => {
+            closeModal();
+          }
+        }),
+        preventBack: true,
+        showTitle: false
+      });
+    };
+    switch (providerName) {
+      case sdkTypes.OAuthProviders.GOOGLE:
+        {
+          await handleGoogleOauth({
+            openInPage: false,
+            onOauthSuccess
+          });
+          break;
+        }
+      case sdkTypes.OAuthProviders.APPLE:
+        {
+          await handleAppleOauth({
+            openInPage: false,
+            onOauthSuccess
+          });
+          break;
+        }
+      case sdkTypes.OAuthProviders.FACEBOOK:
+        {
+          await handleFacebookOauth({
+            openInPage: false,
+            onOauthSuccess
+          });
+          break;
+        }
+      default:
+        {
+          throw new sdkTypes.TurnkeyError(`Unsupported OAuth provider: ${providerName}`, sdkTypes.TurnkeyErrorCodes.NOT_FOUND);
+        }
+    }
+  };
+  const handleLinkExternalWallet = async params => {
+    const {
+      successPageDuration = 2000
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    if (!masterConfig?.walletConfig?.features?.connecting) {
+      throw new sdkTypes.TurnkeyError("Wallet connecting is not enabled.", sdkTypes.TurnkeyErrorCodes.FEATURE_NOT_ENABLED);
+    }
+    const providers = await getWalletProviders();
+    pushPage({
+      key: "Link Wallet",
+      content: jsxRuntime.jsx(LinkWallet.LinkWalletModal, {
+        providers: providers,
+        successPageDuration: successPageDuration
+      })
+    });
+  };
+  const handleRemoveUserEmail = async params => {
+    const {
+      successPageDuration = 2000,
+      stampWith,
+      userId
+    } = params || {};
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    try {
+      return new Promise((resolve, reject) => {
+        pushPage({
+          key: "Remove Email",
+          content: jsxRuntime.jsx(RemoveEmail.RemoveEmail, {
+            successPageDuration: successPageDuration,
+            ...(userId && {
+              userId
+            }),
+            ...(stampWith && {
+              stampWith
+            }),
+            onSuccess: userId => {
+              resolve(userId);
+            },
+            onError: error => {
+              reject(error);
+            }
+          }),
+          showTitle: false,
+          preventBack: true
+        });
+      });
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError) {
+        throw error;
+      }
+      throw new sdkTypes.TurnkeyError("Failed to remove user email.", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_EMAIL_ERROR, error);
+    }
+  };
+  const handleRemoveUserPhoneNumber = async params => {
+    const {
+      successPageDuration = 2000,
+      stampWith,
+      userId
+    } = params || {};
+    if (!session) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    try {
+      return new Promise((resolve, reject) => {
+        pushPage({
+          key: "Remove Phone Number",
+          content: jsxRuntime.jsx(RemovePhoneNumber.RemovePhoneNumber, {
+            successPageDuration: successPageDuration,
+            ...(userId && {
+              userId
+            }),
+            ...(stampWith && {
+              stampWith
+            }),
+            onSuccess: userId => {
+              resolve(userId);
+            },
+            onError: error => {
+              reject(error);
+            }
+          }),
+          showTitle: false,
+          preventBack: true
+        });
+      });
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError) {
+        throw error;
+      }
+      throw new sdkTypes.TurnkeyError("Failed to remove user phone number.", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR, error);
+    }
+  };
+  return jsxRuntime.jsx(Types.ClientContext.Provider, {
+    value: {
+      session,
+      allSessions,
+      clientState,
+      authState,
+      user,
+      wallets,
+      config: masterConfig,
+      httpClient: client?.httpClient,
+      createPasskey,
+      logout,
+      loginWithPasskey,
+      signUpWithPasskey,
+      getWalletProviders,
+      connectWalletAccount,
+      disconnectWalletAccount,
+      switchWalletProviderChain,
+      loginWithWallet,
+      signUpWithWallet,
+      loginOrSignupWithWallet,
+      initOtp,
+      verifyOtp,
+      loginWithOtp,
+      signUpWithOtp,
+      completeOtp,
+      loginWithOauth,
+      signUpWithOauth,
+      completeOauth,
+      fetchWallets,
+      fetchWalletAccounts,
+      refreshWallets,
+      signMessage,
+      signTransaction,
+      signAndSendTransaction,
+      fetchUser,
+      refreshUser,
+      updateUserEmail,
+      removeUserEmail,
+      updateUserPhoneNumber,
+      removeUserPhoneNumber,
+      updateUserName,
+      addOauthProvider,
+      removeOauthProviders,
+      addPasskey,
+      removePasskeys,
+      createWallet,
+      createWalletAccounts,
+      exportWallet,
+      importWallet,
+      deleteSubOrganization,
+      storeSession,
+      clearSession,
+      clearAllSessions,
+      refreshSession,
+      getSession,
+      getAllSessions,
+      setActiveSession,
+      clearUnusedKeyPairs,
+      getActiveSessionKey,
+      createApiKeyPair,
+      getProxyAuthConfig,
+      handleLogin,
+      handleGoogleOauth,
+      handleAppleOauth,
+      handleFacebookOauth,
+      handleExport,
+      handleImport,
+      handleUpdateUserEmail,
+      handleUpdateUserPhoneNumber,
+      handleUpdateUserName,
+      handleAddOauthProvider,
+      handleRemoveOauthProvider,
+      handleAddPasskey,
+      handleRemovePasskey,
+      handleAddEmail,
+      handleAddPhoneNumber,
+      handleSignMessage,
+      handleLinkExternalWallet,
+      handleRemoveUserEmail,
+      handleRemoveUserPhoneNumber
+    },
+    children: children
+  });
+};
+
+exports.ClientProvider = ClientProvider;
+//# sourceMappingURL=Provider.js.map