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

package/dist/providers/client/Provider.js

@@ -0,0 +1,3934 @@
+'use client';
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var sha2 = require('@noble/hashes/sha2');
+var utils$1 = require('@noble/hashes/utils');
+var storage = require('../../utils/oauth/storage.js');
+require('../../utils/oauth/config.js');
+var url = require('../../utils/oauth/url.js');
+var completion = require('../../utils/oauth/completion.js');
+var pkce = require('../../utils/oauth/pkce.js');
+var helpers = require('../../utils/oauth/helpers.js');
+var utils = require('../../utils/utils.js');
+var timers = require('../../utils/timers.js');
+var core = require('@0xkey-io/core');
+var react = require('react');
+var sdkTypes = require('@0xkey-io/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 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 ConnectWallet = require('../../components/user/ConnectWallet.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');
+var Verify = require('../../components/verify/Verify.js');
+var OnRamp = require('../../components/onramp/OnRamp.js');
+var Svg = require('../../components/design/Svg.js');
+var SendTransaction = require('../../components/send-transaction/SendTransaction.js');
+var helpers$1 = require('../../components/send-transaction/helpers.js');
+
+/**
+ * Provides ZeroXKey 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 connecting/import/export, and user profile updates (email, phone, name).
+ *
+ * The provider automatically initializes the ZeroXKey client, fetches configuration (including proxy auth config if needed),
+ * and synchronizes session and authentication state. It exposes a comprehensive set of methods for authentication flows,
+ * wallet management, and user profile operations, as well as UI handlers for modal-driven flows.
+ *
+ * Features:
+ * - Passkey, Wallet, OTP (Email/SMS), and OAuth (Google, Apple, Facebook, X, Discord) authentication and sign-up flows.
+ * - Session management: creation, expiration scheduling, refresh, and clearing.
+ * - Wallet management: fetch, connect, import, export, account management.
+ * - User profile management: email, phone, name, OAuth provider, and passkey linking/removal.
+ * - Modal-driven UI flows for authentication, wallet connecting, and profile updates.
+ * - Error handling and callback integration for custom error and event responses.
+ *
+ * Usage:
+ * Wrap your application with `ZeroXKeyProvider` to enable authentication and wallet features via context.
+ *
+ * @param config - The ZeroXKey provider configuration object.
+ * @param children - React children to be rendered within the provider.
+ * @param callbacks - Optional callbacks for error handling and session events.
+ *
+ * @returns A React context provider exposing authentication, wallet, and user management methods and state.
+ */
+const ClientProvider = ({
+  config,
+  children,
+  callbacks
+}) => {
+  const [client, setClient] = react.useState(undefined);
+  const [session, setSession] = react.useState(undefined);
+  const [masterConfig, setMasterConfig] = react.useState(undefined);
+  const [wallets, setWallets] = react.useState([]);
+  const [user, setUser] = react.useState(undefined);
+  const [clientState, setClientState] = react.useState();
+  const [authState, setAuthState] = react.useState(base.AuthState.Unauthenticated);
+  // if there is no authProxyConfigId or if autoFetchWalletKitConfig is specifically
+  // set to false, we don't need to fetch the config
+  const shouldFetchWalletKitConfig = !!config.authProxyConfigId && (config.autoFetchWalletKitConfig ?? true);
+  // we use this custom hook to only update the state if the value is different
+  // this is so our useEffect that calls `initializeWalletProviderListeners()` only runs when it needs to
+  const [walletProviders, setWalletProviders] = utils.useWalletProviderState();
+  const expiryTimeoutsRef = react.useRef({});
+  const proxyAuthConfigRef = react.useRef(null);
+  const [allSessions, setAllSessions] = react.useState(undefined);
+  const {
+    isMobile,
+    pushPage,
+    popPage,
+    closeModal
+  } = Hook.useModal();
+  const completeRedirectOauth = async () => {
+    // Since we use localStorage (see storage.ts), we always clean up OAuth data
+    // when this runs — even if there are no OAuth params in the URL (e.g. the
+    // user canceled at the provider and came back manually)
+    try {
+      // Check for either hash or search parameters that could indicate an OAuth redirect
+      if (!window.location.hash && !window.location.search) {
+        // No OAuth redirect parameters found, nothing to do
+        return;
+      }
+      /**
+       * Wraps an OAuth completion action with optional modal UI.
+       * This is the key difference between redirect and popup flows:
+       * - Popup: No modal needed (the popup window itself is the UI)
+       * - Redirect: Optional modal to show loading/success states on return
+       */
+      const withModalWrapper = async params => {
+        const {
+          provider,
+          isAddProvider,
+          metadata,
+          openModal,
+          action
+        } = params;
+        const providerDisplayName = helpers.capitalizeProviderName(provider);
+        const icon = helpers.getProviderIcon(provider);
+        if (openModal === "true") {
+          // Show modal UI for the completion
+          await new Promise((resolve, reject) => {
+            pushPage({
+              key: `${providerDisplayName} OAuth`,
+              content: jsxRuntime.jsx(Action.ActionPage, {
+                closeOnComplete: isAddProvider ? false : true,
+                title: isAddProvider ? `Adding ${providerDisplayName} provider...` : `Authenticating with ${providerDisplayName}...`,
+                action: async () => {
+                  try {
+                    await action();
+                    if (isAddProvider && metadata) {
+                      // Don't show success for auth. Not needed
+                      pushPage({
+                        key: "OAuth Provider Added",
+                        content: jsxRuntime.jsx(Success.SuccessPage, {
+                          text: `Successfully added ${providerDisplayName} OAuth provider!`,
+                          duration: metadata.successPageDuration ?? 2000,
+                          onComplete: () => {
+                            closeModal();
+                          }
+                        }),
+                        preventBack: true,
+                        showTitle: false
+                      });
+                    }
+                    resolve();
+                  } catch (err) {
+                    reject(err);
+                    popPage();
+                  }
+                },
+                icon: jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, {
+                  icon: icon,
+                  size: "3x"
+                })
+              }),
+              showTitle: false,
+              onClose: () => {
+                reject(new sdkTypes.ZeroXKeyError(isAddProvider ? `User canceled the ${providerDisplayName} add provider process.` : `User canceled the ${providerDisplayName} authentication process.`, sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED));
+              }
+            });
+          });
+        } else {
+          // No modal - execute directly
+          await action();
+        }
+      };
+      // Handle PKCE-based OAuth redirects (Facebook, Discord, X) with code in search parameters
+      if (window.location.search && window.location.search.includes("code=") && window.location.search.includes("state=")) {
+        // Parse the URL using our unified helper
+        const result = url.parseOAuthResponse(window.location.href);
+        if (!result || !result.authCode || !result.publicKey) {
+          return;
+        }
+        if (result.flow !== "redirect") {
+          // To complete OAuth we need redirect flow
+          return;
+        }
+        const {
+          authCode: code,
+          provider,
+          publicKey,
+          oauthIntent,
+          sessionKey,
+          nonce,
+          openModal
+        } = result;
+        const isAddProvider = oauthIntent === storage.OAUTH_INTENT_ADD_PROVIDER;
+        const metadata = isAddProvider ? storage.getOAuthAddProviderMetadata() : null;
+        /**
+         * Helper to complete PKCE redirect flow with optional modal wrapper.
+         * Uses completePKCEFlow from oauth utils for the core logic.
+         * We put this in a separate function to avoid duplicating for each provider.
+         */
+        const completePKCERedirect = async (providerName, exchangeCodeFn) => {
+          const action = async () => {
+            try {
+              await completion.completePKCEFlow({
+                publicKey,
+                providerName,
+                sessionKey: sessionKey ?? undefined,
+                callbacks,
+                completeOauth,
+                onAddProvider:
+                // Only set onAddProvider if we are adding a provider and have metadata
+                isAddProvider && metadata ? async oidcToken => {
+                  await addOauthProvider({
+                    providerName: provider,
+                    oidcToken,
+                    organizationId: metadata.organizationId,
+                    userId: metadata.userId,
+                    ...(metadata.stampWith && {
+                      stampWith: metadata.stampWith
+                    })
+                  });
+                } : undefined,
+                exchangeCodeForToken: exchangeCodeFn
+              });
+            } catch (err) {
+              if (callbacks?.onError) {
+                const providerDisplayName = helpers.capitalizeProviderName(providerName);
+                callbacks.onError(err instanceof sdkTypes.ZeroXKeyError ? err : new sdkTypes.ZeroXKeyError(`${providerDisplayName} authentication failed`, sdkTypes.ZeroXKeyErrorCodes.OAUTH_SIGNUP_ERROR, err));
+              }
+              throw err;
+            }
+          };
+          await withModalWrapper({
+            provider: providerName,
+            isAddProvider,
+            metadata,
+            openModal,
+            action
+          });
+          // Clean up URL after successful completion
+          url.cleanupOAuthUrl();
+        };
+        // FACEBOOK
+        if (provider === sdkTypes.OAuthProviders.FACEBOOK) {
+          const clientId = masterConfig?.auth?.oauthConfig?.facebookClientId;
+          const redirectURI = masterConfig?.auth?.oauthConfig?.oauthRedirectUri;
+          const hasVerifier = storage.hasPKCEVerifier(sdkTypes.OAuthProviders.FACEBOOK);
+          if (clientId && redirectURI && hasVerifier) {
+            await completePKCERedirect(sdkTypes.OAuthProviders.FACEBOOK, async codeVerifier => {
+              const tokenResponse = await pkce.exchangeFacebookCodeForToken(clientId, redirectURI, code, codeVerifier);
+              const oidcToken = tokenResponse?.id_token;
+              if (!oidcToken) {
+                throw new sdkTypes.ZeroXKeyError("Missing OIDC token", sdkTypes.ZeroXKeyErrorCodes.OAUTH_LOGIN_ERROR);
+              }
+              return oidcToken;
+            });
+          }
+          return;
+        }
+        // DISCORD
+        if (provider === sdkTypes.OAuthProviders.DISCORD) {
+          const clientId = masterConfig?.auth?.oauthConfig?.discordClientId;
+          const redirectURI = result.redirectUri ?? masterConfig?.auth?.oauthConfig?.oauthRedirectUri;
+          const hasVerifier = storage.hasPKCEVerifier(sdkTypes.OAuthProviders.DISCORD);
+          if (clientId && redirectURI && hasVerifier && nonce) {
+            await completePKCERedirect(sdkTypes.OAuthProviders.DISCORD, async codeVerifier => {
+              const resp = await client?.httpClient.proxyOAuth2Authenticate({
+                provider: "OAUTH2_PROVIDER_DISCORD",
+                authCode: code,
+                redirectUri: redirectURI,
+                codeVerifier,
+                clientId,
+                nonce
+              });
+              const oidcToken = resp?.oidcToken;
+              if (!oidcToken) {
+                throw new sdkTypes.ZeroXKeyError("Missing OIDC token", sdkTypes.ZeroXKeyErrorCodes.OAUTH_LOGIN_ERROR);
+              }
+              return oidcToken;
+            });
+          }
+          return;
+        }
+        // X (Twitter)
+        if (provider === sdkTypes.OAuthProviders.X) {
+          const clientId = masterConfig?.auth?.oauthConfig?.xClientId;
+          const redirectURI = result.redirectUri ?? masterConfig?.auth?.oauthConfig?.oauthRedirectUri;
+          const hasVerifier = storage.hasPKCEVerifier(sdkTypes.OAuthProviders.X);
+          if (clientId && redirectURI && hasVerifier && nonce) {
+            await completePKCERedirect(sdkTypes.OAuthProviders.X, async codeVerifier => {
+              const resp = await client?.httpClient.proxyOAuth2Authenticate({
+                provider: "OAUTH2_PROVIDER_X",
+                authCode: code,
+                redirectUri: redirectURI,
+                codeVerifier,
+                clientId,
+                nonce
+              });
+              const oidcToken = resp?.oidcToken;
+              if (!oidcToken) {
+                throw new sdkTypes.ZeroXKeyError("Missing OIDC token", sdkTypes.ZeroXKeyErrorCodes.OAUTH_LOGIN_ERROR);
+              }
+              return oidcToken;
+            });
+          }
+          return;
+        }
+      }
+      // Handle Google/Apple redirects (uses hash with idToken - non-PKCE)
+      if (window.location.hash) {
+        // Parse the URL using our unified helper
+        const result = url.parseOAuthResponse(window.location.href);
+        if (!result || !result.idToken || result.flow !== "redirect" || !result.publicKey) {
+          // idToken and publicKey are required to complete OAuth. These are both in the hash for non-PKCE providers
+          return;
+        }
+        const {
+          idToken,
+          provider,
+          publicKey,
+          openModal,
+          sessionKey,
+          oauthIntent
+        } = result;
+        const isAddProvider = oauthIntent === storage.OAUTH_INTENT_ADD_PROVIDER;
+        const metadata = isAddProvider ? storage.getOAuthAddProviderMetadata() : null;
+        const resolvedProvider = provider || sdkTypes.OAuthProviders.GOOGLE;
+        // Use completeOAuthFlow from utils for the core completion logic
+        const action = async () => {
+          await completion.completeOAuthFlow({
+            provider: resolvedProvider,
+            publicKey,
+            oidcToken: idToken,
+            sessionKey: sessionKey ?? undefined,
+            callbacks,
+            completeOauth,
+            onAddProvider: isAddProvider && metadata ? async oidcToken => {
+              await addOauthProvider({
+                providerName: resolvedProvider,
+                oidcToken,
+                organizationId: metadata.organizationId,
+                userId: metadata.userId,
+                ...(metadata.stampWith && {
+                  stampWith: metadata.stampWith
+                })
+              });
+            } : undefined
+          });
+        };
+        await withModalWrapper({
+          provider: resolvedProvider,
+          isAddProvider,
+          metadata,
+          openModal: openModal ?? undefined,
+          action
+        });
+        // Clean up the URL after processing
+        url.cleanupOAuthUrlPreserveSearch();
+      }
+    } finally {
+      storage.clearAllOAuthData();
+    }
+  };
+  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"),
+      xOauthEnabled: config.auth?.methods?.xOauthEnabled ?? proxyAuthConfig?.enabledProviders.includes("x"),
+      discordOauthEnabled: config.auth?.methods?.discordOauthEnabled ?? proxyAuthConfig?.enabledProviders.includes("discord"),
+      appleOauthEnabled: config.auth?.methods?.appleOauthEnabled ?? proxyAuthConfig?.enabledProviders.includes("apple"),
+      facebookOauthEnabled: config.auth?.methods?.facebookOauthEnabled ?? proxyAuthConfig?.enabledProviders.includes("facebook")
+    };
+    const resolvedClientIds = {
+      googleClientId: config.auth?.oauthConfig?.googleClientId ?? proxyAuthConfig?.oauthClientIds?.google,
+      appleClientId: config.auth?.oauthConfig?.appleClientId ?? proxyAuthConfig?.oauthClientIds?.apple,
+      facebookClientId: config.auth?.oauthConfig?.facebookClientId ?? proxyAuthConfig?.oauthClientIds?.facebook,
+      xClientId: config.auth?.oauthConfig?.xClientId ?? proxyAuthConfig?.oauthClientIds?.x,
+      discordClientId: config.auth?.oauthConfig?.discordClientId ?? proxyAuthConfig?.oauthClientIds?.discord
+    };
+    const redirectUrl = config.auth?.oauthConfig?.oauthRedirectUri ?? proxyAuthConfig?.oauthRedirectUrl;
+    // Set a default ordering for the oAuth methods
+    const oauthOrder = config.auth?.oauthOrder ?? ["google", "apple", "x", "discord", "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);
+    // Warn if they are trying to set auth proxy only settings directly
+    if (proxyAuthConfig) {
+      if (config.auth?.sessionExpirationSeconds) {
+        console.warn("ZeroXKey SDK warning. You have set sessionExpirationSeconds directly in the ZeroXKeyProvider. This setting will be ignored because you are using an auth proxy. Please configure session expiration in the ZeroXKey dashboard.");
+      }
+      if (config.auth?.otpAlphanumeric !== undefined) {
+        console.warn("ZeroXKey SDK warning. You have set otpAlphanumeric directly in the ZeroXKeyProvider. This setting will be ignored because you are using an auth proxy. Please configure OTP settings in the ZeroXKey dashboard.");
+      }
+      if (config.auth?.otpLength) {
+        console.warn("ZeroXKey SDK warning. You have set otpLength directly in the ZeroXKeyProvider. This setting will be ignored because you are using an auth proxy. Please configure OTP settings in the ZeroXKey dashboard.");
+      }
+    }
+    // These are settings that, if using the auth proxy, must be set in the dashboard. They override any local settings unless they are not using auth proxy or are not fetching the auth proxy config.
+    const authProxyPrioSettings = {
+      sessionExpirationSeconds: proxyAuthConfig?.sessionExpirationSeconds ?? config.auth?.sessionExpirationSeconds,
+      otpAlphanumeric: proxyAuthConfig?.otpAlphanumeric ?? config.auth?.otpAlphanumeric ?? true,
+      otpLength: proxyAuthConfig?.otpLength ?? config.auth?.otpLength ?? "6"
+    };
+    return {
+      ...config,
+      // Overrides:
+      auth: {
+        ...config.auth,
+        ...authProxyPrioSettings,
+        methods: resolvedMethods,
+        oauthConfig: {
+          ...config.auth?.oauthConfig,
+          ...resolvedClientIds,
+          oauthRedirectUri: redirectUrl,
+          // on mobile we default to true since many mobile browsers
+          // (e.g. Safari) block popups
+          openOauthInPage: isMobile ? true : config.auth?.oauthConfig?.openOauthInPage
+        },
+        methodOrder,
+        oauthOrder,
+        autoRefreshSession: config.auth?.autoRefreshSession ?? true
+      },
+      autoRefreshManagedState: config.autoRefreshManagedState ?? true,
+      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,
+            // keep user's value if provided; default only when undefined
+            native: config.walletConfig?.chains?.ethereum?.native ?? true
+          },
+          solana: {
+            ...config.walletConfig?.chains?.solana,
+            // keep user's value if provided; default only when undefined
+            native: config.walletConfig?.chains?.solana?.native ?? true
+          }
+        }
+      },
+      importIframeUrl: config.importIframeUrl ?? "https://import.0xkey.com",
+      exportIframeUrl: config.exportIframeUrl ?? "https://export.0xkey.com"
+    };
+  };
+  /**
+   * Initializes the ZeroXKey client with the provided configuration.
+   * This function sets up the client, fetches the proxy auth config if needed,
+   * and prepares the client for use in authentication and wallet operations.
+   *
+   * @internal
+   */
+  const initializeClient = async () => {
+    if (!masterConfig || client || clientState == base.ClientState.Loading) return;
+    try {
+      setClientState(base.ClientState.Loading);
+      const zeroXKeyClient = new core.ZeroXKeyClient({
+        apiBaseUrl: masterConfig.apiBaseUrl,
+        authProxyUrl: masterConfig.authProxyUrl,
+        authProxyConfigId: masterConfig.authProxyConfigId,
+        organizationId: masterConfig.organizationId,
+        // 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
+          })
+        },
+        defaultStamperType: masterConfig.defaultStamperType
+      });
+      await zeroXKeyClient.init();
+      setClient(zeroXKeyClient);
+      // Don't set clientState to ready until we fetch the proxy auth config (See other fetchProxyAuthConfig useEffect)
+    } catch (error) {
+      setClientState(base.ClientState.Error);
+      if (error instanceof sdkTypes.ZeroXKeyError || error instanceof sdkTypes.ZeroXKeyNetworkError) {
+        callbacks?.onError?.(error);
+      } else {
+        callbacks?.onError?.(new sdkTypes.ZeroXKeyError(`Failed to initialize ZeroXKey client`, sdkTypes.ZeroXKeyErrorCodes.INITIALIZE_CLIENT_ERROR, error));
+      }
+    }
+  };
+  /**
+   * Initializes the user sessions by fetching all active sessions and setting up their state.
+   * @internal
+   */
+  const initializeSessions = async () => {
+    setSession(undefined);
+    setAllSessions(undefined);
+    try {
+      const allLocalStorageSessions = await getAllSessions();
+      if (!allLocalStorageSessions) return;
+      await Promise.all(Object.keys(allLocalStorageSessions).map(async sessionKey => {
+        const session = allLocalStorageSessions?.[sessionKey];
+        if (!utils.isValidSession(session)) {
+          await clearSession({
+            sessionKey
+          });
+          if (sessionKey === (await getActiveSessionKey())) {
+            setSession(undefined);
+          }
+          delete allLocalStorageSessions[sessionKey];
+          return;
+        }
+        scheduleSessionExpiration({
+          sessionKey,
+          expiry: session.expiry
+        });
+      }));
+      setAllSessions(allLocalStorageSessions || undefined);
+      const activeSessionKey = await client?.getActiveSessionKey();
+      if (activeSessionKey) {
+        // If we have an active session key, set
+        if (!allLocalStorageSessions[activeSessionKey]) {
+          return;
+        }
+        setSession(allLocalStorageSessions[activeSessionKey]);
+        // we use `maybeFetchWallets()` instead of `maybeRefreshWallets()` here to avoid a race condition
+        // specifically, if WalletConnect finishes initializing before this promise resolves,
+        // `maybeRefreshWallets()` could overwrite the WalletConnect wallet state with an outdated
+        // list of wallets that doesn’t yet include the WalletConnect wallets
+        const [, wallets] = await Promise.all([maybeRefreshUser(), (() => {
+          if (!masterConfig?.autoRefreshManagedState) return [];
+          return fetchWallets();
+        })()]);
+        // the prev wallets should only ever be WalletConnect wallets
+        if (wallets) {
+          setWallets(prev => utils.mergeWalletsWithoutDuplicates(prev, wallets));
+        }
+        return;
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError || error instanceof sdkTypes.ZeroXKeyNetworkError) {
+        callbacks?.onError?.(error);
+      } else {
+        callbacks?.onError?.(new sdkTypes.ZeroXKeyError(`Failed to initialize sessions`, sdkTypes.ZeroXKeyErrorCodes.INITIALIZE_SESSION_ERROR, error));
+      }
+    }
+  };
+  /**
+   * @internal
+   * Attach listeners for connected wallet providers so we can refresh state on changes.
+   *
+   * - Ethereum: listens for disconnect and chain/account changes to trigger a refresh.
+   * - Solana: listens for disconnect via Wallet Standard `change` events to trigger a refresh.
+   * - WalletConnect:
+   *    - listens for disconnect and other state changes via its unified `change` event
+   *    - additionally listens for `pairingExpired` events (proposal expiration), in which
+   *      case we re-fetch providers to refresh the pairing URI for the UI.
+   *
+   * Notes:
+   * - Only connected providers are bound, except WalletConnect which must always register
+   *   to handle proposal expiration even if no active session exists.
+   * - Since all WalletConnect providers share the same session, we only attach to one.
+   *
+   * @param walletProviders - Discovered providers; only connected ones are bound.
+   * @param onUpdateState - Invoked when a relevant provider event occurs.
+   * @returns Cleanup function that removes all listeners registered by this call.
+   */
+  async function initializeWalletProviderListeners(walletProviders, onUpdateState) {
+    if (walletProviders.length === 0) return () => {};
+    const cleanups = [];
+    // we only want to initialize these listeners for connected walletProviders
+    const nativeOnly = provider => provider.interfaceType !== core.WalletInterfaceType.WalletConnect;
+    const ethProviders = masterConfig?.walletConfig?.chains.ethereum?.native ? walletProviders.filter(provider => provider.chainInfo.namespace === core.Chain.Ethereum && nativeOnly(provider) && provider.connectedAddresses.length > 0) : [];
+    const solProviders = masterConfig?.walletConfig?.chains.solana?.native ? walletProviders.filter(provider => provider.chainInfo.namespace === core.Chain.Solana && nativeOnly(provider) && provider.connectedAddresses.length > 0) : [];
+    // WalletConnect is excluded from native event wiring. Instead,
+    // it uses a unified `change` event exposed by our custom wrapper
+    //
+    // unlike native providers, we register listeners for WalletConnect
+    // even if it’s not currently “connected”. This is required so we
+    // can detect proposal expiration events and display the new regenerated
+    // URI for the UI
+    const wcProviders = walletProviders.filter(p => p.interfaceType === core.WalletInterfaceType.WalletConnect);
+    // since all WalletConnect providers share the same underlying session
+    // and emit identical events, we only attach listeners to a single provider
+    const wcProvider = wcProviders.find(p => p.interfaceType === core.WalletInterfaceType.WalletConnect);
+    function attachEthereumListeners(provider, onUpdateState) {
+      if (typeof provider.on !== "function") return;
+      const handleChainChanged = async _chainId => onUpdateState();
+      const handleAccountsChanged = async accounts => {
+        if (accounts.length === 0) onUpdateState();
+      };
+      const handleDisconnect = () => onUpdateState();
+      provider.on("chainChanged", handleChainChanged);
+      provider.on("accountsChanged", handleAccountsChanged);
+      provider.on("disconnect", handleDisconnect);
+      return () => {
+        provider.removeListener("chainChanged", handleChainChanged);
+        provider.removeListener("accountsChanged", handleAccountsChanged);
+        provider.removeListener("disconnect", handleDisconnect);
+      };
+    }
+    function attachSolanaListeners(provider, onUpdateState) {
+      const cleanups = [];
+      const walletEvents = provider?.features?.["standard:events"];
+      if (walletEvents?.on) {
+        const offChange = walletEvents.on("change", async _evt => {
+          await onUpdateState();
+        });
+        cleanups.push(offChange);
+      }
+      return () => cleanups.forEach(fn => fn());
+    }
+    ethProviders.forEach(p => {
+      const cleanup = attachEthereumListeners(p.provider, onUpdateState);
+      if (cleanup) cleanups.push(cleanup);
+    });
+    solProviders.forEach(p => {
+      const cleanup = attachSolanaListeners(p.provider, onUpdateState);
+      if (cleanup) cleanups.push(cleanup);
+    });
+    if (wcProvider) {
+      const standardEvents = wcProvider.provider?.features?.["standard:events"];
+      if (standardEvents?.on) {
+        if (standardEvents?.on) {
+          const unsubscribe = standardEvents.on("change", async evt => {
+            // if the event is a proposalExpired, we want to re-fetch the providers
+            // to refresh the uri, there is no need to refresh the wallets state
+            if (evt?.type === "pairingExpired") {
+              debouncedFetchWalletProviders();
+              return;
+            }
+            // if WalletConnect initialization failed, refresh providers
+            // (the failed provider will be removed from the list)
+            if (evt?.type === "failed") {
+              debouncedFetchWalletProviders();
+              callbacks?.onError?.(new sdkTypes.ZeroXKeyError(`WalletConnect initialization failed: ${evt.error || "Unknown error"}`, sdkTypes.ZeroXKeyErrorCodes.WALLET_CONNECT_INITIALIZATION_ERROR, evt.error));
+              return;
+            }
+            if (evt?.type === "initialized") {
+              // this updates our walletProvider state
+              const providers = await debouncedFetchWalletProviders();
+              // if we have an active session, we need to restore any possibly connected
+              // WalletConnect wallets since its now initialized
+              const currentSession = await getSession();
+              if (currentSession) {
+                const wcProviders = providers?.filter(p => p.interfaceType === core.WalletInterfaceType.WalletConnect);
+                const wcWallets = await fetchWallets({
+                  walletProviders: wcProviders,
+                  connectedOnly: true
+                });
+                if (wcWallets.length > 0) {
+                  setWallets(prev => utils.mergeWalletsWithoutDuplicates(prev, wcWallets));
+                }
+              }
+              return;
+            }
+            // any other event (disconnect, chain switch, accounts changed)
+            // we refresh the wallets state
+            await onUpdateState();
+          });
+          cleanups.push(unsubscribe);
+        }
+      }
+    }
+    return () => {
+      cleanups.forEach(remove => remove());
+    };
+  }
+  /**
+   * Clears all scheduled session timers (warning + expiry).
+   *
+   * - Removes all active timers managed by this client.
+   * - Useful on re-init or logout to avoid stale timers.
+   *
+   * @throws {ZeroXKeyError} If an error occurs while clearing the timers.
+   */
+  function clearSessionTimeouts(sessionKeys) {
+    try {
+      if (sessionKeys) {
+        timers.clearKeys(expiryTimeoutsRef.current, sessionKeys);
+      } else {
+        timers.clearAll(expiryTimeoutsRef.current); // clears & deletes everything
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError || error instanceof sdkTypes.ZeroXKeyNetworkError) {
+        callbacks?.onError?.(error);
+      } else {
+        callbacks?.onError?.(new sdkTypes.ZeroXKeyError("Failed to clear session timeouts", sdkTypes.ZeroXKeyErrorCodes.CLEAR_SESSION_TIMEOUTS_ERROR, error));
+      }
+    }
+  }
+  /**
+   * @internal
+   * Handles the post-authentication flow.
+   *
+   * - This function is called after a successful authentication (login or sign-up) via any supported method (Passkey, Wallet, OTP, OAuth).
+   * - It fetches the active session and all sessions, updates the session state, and schedules session expiration and warning timeouts.
+   * - It also refreshes the user's wallets and profile information to ensure the provider state is up to date.
+   * - This function is used internally after all authentication flows to synchronize state and trigger any necessary callbacks.
+   *
+   * @returns A void promise.
+   * @throws {ZeroXKeyError} If the client is not initialized or if there is an error during the process.
+   */
+  const handlePostAuth = async params => {
+    const {
+      method,
+      action,
+      identifier,
+      appProofs
+    } = params;
+    try {
+      const sessionKey = await getActiveSessionKey();
+      const session = await getSession({
+        ...(sessionKey && {
+          sessionKey
+        })
+      });
+      if (session && sessionKey) await scheduleSessionExpiration({
+        sessionKey,
+        expiry: session.expiry
+      });
+      const allSessions = await client.getAllSessions();
+      setSession(session);
+      setAllSessions(allSessions);
+      await Promise.all([maybeRefreshWallets(), maybeRefreshUser()]);
+      if (masterConfig?.auth?.verifyWalletOnSignup === true && appProofs && appProofs.length > 0 && action === sdkTypes.AuthAction.SIGNUP) {
+        // On signup, if we have appProofs, verify them
+        await handleVerifyAppProofs({
+          appProofs
+        });
+      }
+      callbacks?.onAuthenticationSuccess?.({
+        session,
+        method,
+        action,
+        identifier
+      });
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError || error instanceof sdkTypes.ZeroXKeyNetworkError) {
+        callbacks?.onError?.(error);
+      } else {
+        callbacks?.onError?.(new sdkTypes.ZeroXKeyError(`Failed to handle post-authentication`, sdkTypes.ZeroXKeyErrorCodes.HANDLE_POST_AUTH_ERROR, error));
+      }
+    }
+  };
+  /**
+   * @internal
+   * Handles the post-logout flow.
+   *
+   * - This function is called after a successful logout or session clear.
+   * - It clears all scheduled session expiration and warning timeouts associated to the session key to prevent memory leaks.
+   * - It resets the session state, removes user data from memory, the logged out session from all sessions state, and clears the wallets list.
+   * - This ensures that all sensitive information is removed from the provider state after logout.
+   * - Called internally after logout or when all sessions are cleared.
+   *
+   * @returns void
+   * @throws {ZeroXKeyError} If there is an error during the post-logout process.
+   */
+  const handlePostLogout = sessionKey => {
+    try {
+      clearSessionTimeouts(sessionKey ? [sessionKey, `${sessionKey}-warning`] : undefined);
+      setAllSessions(prev => {
+        if (!prev) return prev;
+        if (sessionKey) {
+          const next = {
+            ...prev
+          };
+          delete next[sessionKey];
+          return next;
+        }
+        return {};
+      });
+      setSession(undefined);
+      setUser(undefined);
+      setWallets([]);
+    } catch (error) {
+      callbacks?.onError?.(new sdkTypes.ZeroXKeyError(`Failed to initialize sessions`, sdkTypes.ZeroXKeyErrorCodes.HANDLE_POST_LOGOUT_ERROR, error));
+    }
+  };
+  const createHttpClient = react.useCallback(params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return client.createHttpClient(params);
+  }, [client]);
+  const getActiveSessionKey = react.useCallback(async () => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.getActiveSessionKey(), undefined, callbacks, "Failed to get active session key");
+  }, [client, callbacks]);
+  const logout = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    await utils.withZeroXKeyErrorHandling(async () => {
+      // If no sessionKey is provided, we try to get the active one.
+      let sessionKey = params?.sessionKey;
+      if (!sessionKey) sessionKey = await getActiveSessionKey();
+      await client.logout(params);
+      // We only handle post logout if the sessionKey is defined since that means we actually logged out of a session.
+      if (sessionKey) handlePostLogout(sessionKey);
+    }, undefined, callbacks, "Failed to logout");
+    return;
+  }, [client, callbacks, getActiveSessionKey]);
+  const getSession = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.getSession(params), undefined, callbacks, "Failed to get session");
+  }, [client, callbacks]);
+  const getAllSessions = react.useCallback(async () => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.getAllSessions(), undefined, callbacks, "Failed to get all sessions");
+  }, [client, callbacks]);
+  const createPasskey = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withZeroXKeyErrorHandling(() => client.createPasskey({
+      ...params
+    }), undefined, callbacks, "Failed to create passkey");
+  }, [client, callbacks]);
+  const fetchUser = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.fetchUser(params), () => logout(), callbacks, "Failed to fetch user");
+  }, [client, callbacks, logout]);
+  const fetchWalletProviders = react.useCallback(async chain => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withZeroXKeyErrorHandling(async () => {
+      const newProviders = await client.fetchWalletProviders(chain);
+      // we update state with the latest providers
+      // we keep this state so that initializeWalletProviderListeners() re-runs
+      // whenever the list of connected providers changes
+      // this ensures we attach disconnect listeners for each connected provider
+      setWalletProviders(newProviders);
+      return newProviders;
+    }, undefined, callbacks, "Failed to fetch wallet providers");
+  }, [client, callbacks]);
+  const fetchWallets = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withZeroXKeyErrorHandling(() => client.fetchWallets(params), () => logout(), callbacks, "Failed to fetch wallets");
+  }, [client, callbacks, logout]);
+  const refreshUser = react.useCallback(async params => {
+    const {
+      stampWith,
+      organizationId,
+      userId
+    } = params || {};
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const user = await utils.withZeroXKeyErrorHandling(() => fetchUser({
+      stampWith,
+      ...(organizationId && {
+        organizationId
+      }),
+      ...(userId && {
+        userId
+      })
+    }), () => logout(), callbacks, "Failed to refresh user");
+    if (user) {
+      setUser(user);
+    }
+  }, [client, callbacks, fetchUser, logout]);
+  /**
+   * @internal
+   * Auto-refresh user only if enabled in config. This is only used internally.
+   *
+   * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+   * @param params.userId - user ID to fetch specific user details (defaults to the current session's userId).
+   * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+   * @returns A promise that resolves when the user is refreshed, or does nothing if auto-refresh is disabled
+   */
+  const maybeRefreshUser = react.useCallback(async params => {
+    if (!masterConfig?.autoRefreshManagedState) return;
+    return refreshUser(params);
+  }, [masterConfig, refreshUser]);
+  const refreshWallets = react.useCallback(async params => {
+    const {
+      stampWith,
+      organizationId,
+      userId
+    } = params || {};
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const walletProviders = await utils.withZeroXKeyErrorHandling(() => fetchWalletProviders(), undefined, callbacks, "Failed to refresh wallets");
+    const wallets = await utils.withZeroXKeyErrorHandling(() => fetchWallets({
+      stampWith,
+      walletProviders,
+      ...(organizationId && {
+        organizationId
+      }),
+      ...(userId && {
+        userId
+      })
+    }), () => logout(), callbacks, "Failed to refresh wallets");
+    if (wallets) {
+      setWallets(wallets);
+    }
+    return wallets;
+  }, [client, callbacks, fetchWalletProviders, fetchWallets, logout]);
+  /**
+   * @internal
+   * Auto-refresh wallets only if enabled in config. This is only used internally.
+   *
+   * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+   * @param params.userId - user ID to fetch specific user details (defaults to the current session's userId).
+   * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+   * @returns A promise that resolves to an array of wallets, or an empty array if auto-refresh is disabled
+   */
+  const maybeRefreshWallets = react.useCallback(async params => {
+    if (!masterConfig?.autoRefreshManagedState) return [];
+    return refreshWallets(params);
+  }, [masterConfig, refreshWallets]);
+  const clearSession = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    await utils.withZeroXKeyErrorHandling(async () => client.clearSession(params), undefined, callbacks, "Failed to clear session");
+    const sessionKey = params?.sessionKey ?? (await getActiveSessionKey());
+    if (!sessionKey) return;
+    if (!params?.sessionKey) {
+      setSession(undefined);
+    }
+    clearSessionTimeouts([sessionKey]);
+    // clear only the cleared session from allSessions
+    const newAllSessions = {
+      ...allSessions
+    };
+    if (newAllSessions) {
+      delete newAllSessions[sessionKey];
+    }
+    setAllSessions(newAllSessions);
+    return;
+  }, [client, callbacks, getActiveSessionKey, allSessions]);
+  /**
+   * @internal
+   * Schedules a session expiration and warning timer for the given session key.
+   *
+   * - Sets up two timers: one for warning before expiry and one for actual expiry.
+   * - Uses capped timeouts under the hood so delays > 24.8 days are safe (see utils/timers.ts).
+   *
+   * @param params.sessionKey - The key of the session to schedule expiration for.
+   * @param params.expiry - The expiration time in seconds since epoch.
+   * @throws {ZeroXKeyError} If an error occurs while scheduling the session expiration.
+   */
+  const scheduleSessionExpiration = react.useCallback(async params => {
+    const {
+      sessionKey,
+      expiry
+    } = params;
+    try {
+      const warnKey = `${sessionKey}-warning`;
+      // Replace any prior timers for this session
+      timers.clearKey(expiryTimeoutsRef.current, sessionKey);
+      timers.clearKey(expiryTimeoutsRef.current, warnKey);
+      const now = Date.now();
+      const expiryMs = expiry * 1000;
+      const timeUntilExpiry = expiryMs - now;
+      const runRefresh = async () => {
+        const activeSession = await getSession();
+        if (!activeSession && expiryTimeoutsRef.current[warnKey]) {
+          // Keep nudging until session materializes (short 10s timer is fine)
+          timers.setTimeoutInMap(expiryTimeoutsRef.current, warnKey, runRefresh, 10_000);
+          return;
+        }
+        const session = await getSession({
+          sessionKey
+        });
+        if (!session) return;
+        callbacks?.beforeSessionExpiry?.({
+          sessionKey
+        });
+        if (masterConfig?.auth?.autoRefreshSession) {
+          await refreshSession({
+            expirationSeconds: session.expirationSeconds,
+            sessionKey
+          });
+        }
+      };
+      const expireSession = async () => {
+        const expiredSession = await getSession({
+          sessionKey
+        });
+        if (!expiredSession) return;
+        callbacks?.onSessionExpired?.({
+          sessionKey
+        });
+        if ((await getActiveSessionKey()) === sessionKey) {
+          setSession(undefined);
+        }
+        setAllSessions(prev => {
+          if (!prev) return prev;
+          const next = {
+            ...prev
+          };
+          delete next[sessionKey];
+          return next;
+        });
+        await clearSession({
+          sessionKey
+        });
+        // Remove timers for this session
+        timers.clearKey(expiryTimeoutsRef.current, sessionKey);
+        timers.clearKey(expiryTimeoutsRef.current, warnKey);
+        await logout();
+      };
+      // Already expired → expire immediately
+      if (timeUntilExpiry <= 0) {
+        await expireSession();
+        return;
+      }
+      // Warning timer (if threshold is in the future)
+      const warnAt = expiryMs - utils.SESSION_WARNING_THRESHOLD_MS;
+      if (warnAt <= now) {
+        void runRefresh(); // fire-and-forget is fine
+      } else {
+        timers.setCappedTimeoutInMap(expiryTimeoutsRef.current, warnKey, runRefresh, warnAt - now);
+      }
+      // Actual expiry timer (safe for long delays)
+      timers.setCappedTimeoutInMap(expiryTimeoutsRef.current, sessionKey, expireSession, timeUntilExpiry);
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError || error instanceof sdkTypes.ZeroXKeyNetworkError) {
+        callbacks?.onError?.(error);
+      } else {
+        callbacks?.onError?.(new sdkTypes.ZeroXKeyError(`Failed to schedule session expiration for ${sessionKey}`, sdkTypes.ZeroXKeyErrorCodes.SCHEDULE_SESSION_EXPIRY_ERROR, error));
+      }
+    }
+  },
+  // Note: `refreshSession()` is intentionally NOT in the dependency array even though
+  // it's called in runRefresh. This is because: `refreshSession()` itself calls `scheduleSessionExpiration()`,
+  // creating a circular dependency that would cause infinite re-renders
+  //
+  // this is fine because `refreshSession()` reference is stable enough for this use case (session
+  // expiration timers are long-lived and don't need to re-subscribe on every `refreshSession()` change)
+  [callbacks, masterConfig, getSession, getActiveSessionKey, clearSession, logout]);
+  const refreshSession = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const activeSessionKey = await client.getActiveSessionKey();
+    if (!activeSessionKey) {
+      throw new sdkTypes.ZeroXKeyError("No active session found.", sdkTypes.ZeroXKeyErrorCodes.NO_SESSION_FOUND);
+    }
+    const sessionKey = params?.sessionKey ?? activeSessionKey;
+    const res = await utils.withZeroXKeyErrorHandling(() => client.refreshSession({
+      ...params
+    }), () => logout(), callbacks, "Failed to refresh session");
+    const session = await getSession({
+      sessionKey
+    });
+    if (session && sessionKey) {
+      await scheduleSessionExpiration({
+        sessionKey,
+        expiry: session.expiry
+      });
+    }
+    const allSessions = await getAllSessions();
+    setSession(session);
+    setAllSessions(allSessions);
+    return res;
+  }, [client, callbacks, logout, getSession, scheduleSessionExpiration, getAllSessions]);
+  const loginWithPasskey = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const expirationSeconds = params?.expirationSeconds ?? masterConfig?.auth?.sessionExpirationSeconds ?? core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+    const res = await utils.withZeroXKeyErrorHandling(() => client.loginWithPasskey({
+      ...params,
+      expirationSeconds
+    }), () => logout(), callbacks, "Failed to login with passkey");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Passkey,
+        action: sdkTypes.AuthAction.LOGIN,
+        identifier: res.credentialId,
+        appProofs: res.appProofs
+      });
+    }
+    return res;
+  }, [client, callbacks, masterConfig, logout, handlePostAuth]);
+  const signUpWithPasskey = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    // If createSubOrgParams is not provided, use the default from masterConfig
+    let createSubOrgParams = params?.createSubOrgParams ?? masterConfig.auth?.createSuborgParams?.passkeyAuth;
+    params = createSubOrgParams !== undefined ? {
+      ...params,
+      createSubOrgParams
+    } : {
+      ...params
+    };
+    const expirationSeconds = params?.expirationSeconds ?? masterConfig?.auth?.sessionExpirationSeconds ?? core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+    const websiteName = 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.withZeroXKeyErrorHandling(() => client.signUpWithPasskey({
+      ...params,
+      passkeyDisplayName: passkeyName,
+      expirationSeconds
+    }), () => logout(), callbacks, "Failed to sign up with passkey");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Passkey,
+        action: sdkTypes.AuthAction.SIGNUP,
+        identifier: res.credentialId,
+        appProofs: res.appProofs
+      });
+    }
+    return res;
+  }, [client, callbacks, logout, handlePostAuth, masterConfig]);
+  const connectWalletAccount = react.useCallback(async walletProvider => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withZeroXKeyErrorHandling(async () => {
+      const address = await client.connectWalletAccount(walletProvider);
+      let wallets;
+      const s = await getSession();
+      if (s) {
+        // this will update our walletProvider state
+        wallets = await maybeRefreshWallets();
+      } else {
+        wallets = await fetchWallets({
+          connectedOnly: true
+        });
+      }
+      // we narrow to only connected wallets
+      // because we know the account must come from one of them
+      const connectedWallets = wallets.filter(w => w.source === core.WalletSource.Connected);
+      // find the matching account
+      const matchedAccount = connectedWallets.flatMap(w => w.accounts).find(a => a.address === address);
+      if (!matchedAccount) {
+        throw new sdkTypes.ZeroXKeyError(`No connected wallet account found for address: ${address}`, sdkTypes.ZeroXKeyErrorCodes.NO_WALLET_FOUND);
+      }
+      return matchedAccount;
+    }, () => logout(), callbacks, "Failed to connect wallet account");
+  }, [client, callbacks, getSession, logout, maybeRefreshWallets, fetchWallets]);
+  const disconnectWalletAccount = react.useCallback(async walletProvider => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    await utils.withZeroXKeyErrorHandling(async () => {
+      await client.disconnectWalletAccount(walletProvider);
+      // no need here to call `maybeRefreshWallets()` because the provider emits a disconnect event which
+      // will trigger a refresh via the listener we set up in `initializeWalletProviderListeners()`
+    }, undefined, callbacks, "Failed to disconnect wallet account");
+  }, [client, callbacks]);
+  const switchWalletAccountChain = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    await utils.withZeroXKeyErrorHandling(async () => {
+      await client.switchWalletAccountChain({
+        ...params,
+        walletProviders
+      });
+    }, undefined, callbacks, "Failed to switch wallet account chain");
+  }, [client, walletProviders, callbacks]);
+  const buildWalletLoginRequest = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const expirationSeconds = params?.expirationSeconds ?? masterConfig?.auth?.sessionExpirationSeconds ?? core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+    return await utils.withZeroXKeyErrorHandling(() => client.buildWalletLoginRequest({
+      ...params,
+      expirationSeconds
+    }), undefined, callbacks, "Failed to login with wallet");
+  }, [client, callbacks, masterConfig]);
+  const loginWithWallet = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const expirationSeconds = params?.expirationSeconds ?? masterConfig?.auth?.sessionExpirationSeconds ?? core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+    const res = await utils.withZeroXKeyErrorHandling(() => client.loginWithWallet({
+      ...params,
+      expirationSeconds
+    }), undefined, callbacks, "Failed to login with wallet");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Wallet,
+        action: sdkTypes.AuthAction.LOGIN,
+        identifier: res.address,
+        appProofs: res.appProofs
+      });
+    }
+    return res;
+  }, [client, callbacks, handlePostAuth, masterConfig]);
+  const signUpWithWallet = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    // If createSubOrgParams is not provided, use the default from masterConfig
+    let createSubOrgParams = params.createSubOrgParams ?? masterConfig.auth?.createSuborgParams?.walletAuth;
+    params = createSubOrgParams !== undefined ? {
+      ...params,
+      createSubOrgParams
+    } : {
+      ...params
+    };
+    const expirationSeconds = params?.expirationSeconds ?? masterConfig?.auth?.sessionExpirationSeconds ?? core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+    const res = await utils.withZeroXKeyErrorHandling(() => client.signUpWithWallet({
+      ...params,
+      expirationSeconds
+    }), undefined, callbacks, "Failed to sign up with wallet");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Wallet,
+        action: sdkTypes.AuthAction.SIGNUP,
+        identifier: res.address,
+        appProofs: res.appProofs
+      });
+    }
+    return res;
+  }, [client, callbacks, handlePostAuth, masterConfig]);
+  const loginOrSignupWithWallet = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    // If createSubOrgParams is not provided, use the default from masterConfig
+    let createSubOrgParams = params.createSubOrgParams ?? masterConfig.auth?.createSuborgParams?.walletAuth;
+    params = createSubOrgParams !== undefined ? {
+      ...params,
+      createSubOrgParams
+    } : {
+      ...params
+    };
+    const expirationSeconds = params?.expirationSeconds ?? masterConfig?.auth?.sessionExpirationSeconds ?? core.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
+    const res = await utils.withZeroXKeyErrorHandling(() => client.loginOrSignupWithWallet({
+      ...params,
+      expirationSeconds
+    }), undefined, callbacks, "Failed to login or sign up with wallet");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Wallet,
+        action: res.action,
+        identifier: res.address,
+        appProofs: res.appProofs
+      });
+    }
+    return res;
+  }, [client, callbacks, handlePostAuth, masterConfig]);
+  const initOtp = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withZeroXKeyErrorHandling(() => client.initOtp(params), undefined, callbacks, "Failed to initialize OTP");
+  }, [client, callbacks]);
+  const verifyOtp = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withZeroXKeyErrorHandling(() => client.verifyOtp(params), undefined, callbacks, "Failed to verify OTP");
+  }, [client, callbacks]);
+  const loginWithOtp = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const res = await utils.withZeroXKeyErrorHandling(() => client.loginWithOtp(params), undefined, callbacks, "Failed to login with OTP");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Otp,
+        action: sdkTypes.AuthAction.LOGIN,
+        identifier: params.verificationToken,
+        appProofs: res.appProofs
+      });
+    }
+    return res;
+  }, [client, callbacks, handlePostAuth]);
+  const signUpWithOtp = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    // If createSubOrgParams is not provided, use the default from masterConfig
+    let createSubOrgParams = params.createSubOrgParams;
+    if (!createSubOrgParams && masterConfig?.auth?.createSuborgParams) {
+      if (params.otpType === core.OtpType.Email) {
+        createSubOrgParams = masterConfig.auth.createSuborgParams.emailOtpAuth;
+      } else if (params.otpType === core.OtpType.Sms) {
+        createSubOrgParams = masterConfig.auth.createSuborgParams.smsOtpAuth;
+      }
+    }
+    params = createSubOrgParams !== undefined ? {
+      ...params,
+      createSubOrgParams
+    } : {
+      ...params
+    };
+    const res = await utils.withZeroXKeyErrorHandling(() => client.signUpWithOtp(params), undefined, callbacks, "Failed to sign up with OTP");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Otp,
+        action: sdkTypes.AuthAction.SIGNUP,
+        identifier: params.verificationToken,
+        appProofs: res.appProofs
+      });
+    }
+    return res;
+  }, [client, callbacks, masterConfig, handlePostAuth]);
+  const completeOtp = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    // If createSubOrgParams is not provided, use the default from masterConfig
+    let createSubOrgParams = params.createSubOrgParams;
+    if (!createSubOrgParams && masterConfig?.auth?.createSuborgParams) {
+      if (params.otpType === core.OtpType.Email) {
+        createSubOrgParams = masterConfig.auth.createSuborgParams.emailOtpAuth;
+      } else if (params.otpType === core.OtpType.Sms) {
+        createSubOrgParams = masterConfig.auth.createSuborgParams.smsOtpAuth;
+      }
+    }
+    params = createSubOrgParams !== undefined ? {
+      ...params,
+      createSubOrgParams
+    } : {
+      ...params
+    };
+    const res = await utils.withZeroXKeyErrorHandling(() => client.completeOtp(params), undefined, callbacks, "Failed to complete OTP");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Otp,
+        action: res.action,
+        identifier: res.verificationToken,
+        appProofs: res.appProofs
+      });
+    }
+    return res;
+  }, [client, callbacks, handlePostAuth, masterConfig]);
+  const loginWithOauth = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const res = await utils.withZeroXKeyErrorHandling(() => client.loginWithOauth(params), undefined, callbacks, "Failed to login with OAuth");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Oauth,
+        action: sdkTypes.AuthAction.LOGIN,
+        identifier: params.oidcToken,
+        appProofs: res.appProofs
+      });
+    }
+    return res;
+  }, [client, callbacks, handlePostAuth]);
+  const signUpWithOauth = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    // If createSubOrgParams is not provided, use the default from masterConfig
+    let createSubOrgParams = params.createSubOrgParams ?? masterConfig.auth?.createSuborgParams?.oauth;
+    params = createSubOrgParams !== undefined ? {
+      ...params,
+      createSubOrgParams
+    } : {
+      ...params
+    };
+    const res = await utils.withZeroXKeyErrorHandling(() => client.signUpWithOauth(params), undefined, callbacks, "Failed to sign up with OAuth");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Oauth,
+        action: sdkTypes.AuthAction.SIGNUP,
+        identifier: params.oidcToken,
+        appProofs: res.appProofs
+      });
+    }
+    return res;
+  }, [client, callbacks, handlePostAuth, masterConfig]);
+  const completeOauth = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    // If createSubOrgParams is not provided, use the default from masterConfig
+    const createSubOrgParams = params.createSubOrgParams ?? masterConfig.auth?.createSuborgParams?.oauth;
+    params = createSubOrgParams !== undefined ? {
+      ...params,
+      createSubOrgParams
+    } : {
+      ...params
+    };
+    const res = await utils.withZeroXKeyErrorHandling(() => client.completeOauth(params), undefined, callbacks, "Failed to complete OAuth");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Oauth,
+        action: res.action,
+        identifier: params.oidcToken,
+        appProofs: res.appProofs
+      });
+    }
+    return res;
+  }, [client, callbacks, masterConfig, handlePostAuth]);
+  const fetchWalletAccounts = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withZeroXKeyErrorHandling(() => client.fetchWalletAccounts(params), () => logout(), callbacks, "Failed to fetch wallet accounts");
+  }, [client, callbacks, logout]);
+  const fetchPrivateKeys = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withZeroXKeyErrorHandling(() => client.fetchPrivateKeys(params), () => logout(), callbacks, "Failed to fetch private keys");
+  }, [client, callbacks, logout]);
+  const signMessage = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.signMessage(params), () => logout(), callbacks, "Failed to sign message");
+  }, [client, callbacks, logout]);
+  const handleSignMessage = react.useCallback(async params => {
+    const {
+      successPageDuration = 2000
+    } = params;
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.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
+          }),
+          ...(params?.organizationId && {
+            organizationId: params.organizationId
+          })
+        }),
+        onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the signing process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+      });
+    });
+  }, [client, callbacks, pushPage]);
+  const signTransaction = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.signTransaction(params), () => logout(), callbacks, "Failed to sign transaction");
+  }, [client, callbacks, logout]);
+  const ethSendTransaction = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.ethSendTransaction(params), () => logout(), callbacks, "Failed to send eth transaction");
+  }, [client, callbacks, logout]);
+  const ethSendErc20Transfer = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.ethSendErc20Transfer(params), () => logout(), callbacks, "Failed to send ERC20 transfer");
+  }, [client, callbacks, logout]);
+  const solSendTransaction = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.solSendTransaction(params), () => logout(), callbacks, "Failed to send sol transaction");
+  }, [client, callbacks, logout]);
+  const signAndSendTransaction = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.signAndSendTransaction(params), () => logout(), callbacks, "Failed to sign and send transaction");
+  }, [client, callbacks, logout]);
+  const pollTransactionStatus = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.pollTransactionStatus(params), () => logout(), callbacks, "Failed to poll transaction status");
+  }, [client, callbacks]);
+  const fetchOrCreateP256ApiKeyUser = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.fetchOrCreateP256ApiKeyUser(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
+  }, [client, callbacks, logout]);
+  const fetchOrCreatePolicies = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.fetchOrCreatePolicies(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
+  }, [client, callbacks, logout]);
+  const updateUserEmail = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.updateUserEmail(params), () => logout(), callbacks, "Failed to update user email");
+    if (res) await maybeRefreshUser({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
+    });
+    return res;
+  }, [client, callbacks, logout, maybeRefreshUser]);
+  const removeUserEmail = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.removeUserEmail(params), () => logout(), callbacks, "Failed to remove user email");
+    if (res) await maybeRefreshUser({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
+    });
+    return res;
+  }, [client, callbacks, logout, maybeRefreshUser]);
+  const updateUserPhoneNumber = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.updateUserPhoneNumber(params), () => logout(), callbacks, "Failed to update user phone number");
+    if (res) await maybeRefreshUser({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
+    });
+    return res;
+  }, [client, callbacks, logout, maybeRefreshUser]);
+  const removeUserPhoneNumber = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.removeUserPhoneNumber(params), () => logout(), callbacks, "Failed to remove user phone number");
+    if (res) await maybeRefreshUser({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
+    });
+    return res;
+  }, [client, callbacks, logout, maybeRefreshUser]);
+  const updateUserName = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.updateUserName(params), () => logout(), callbacks, "Failed to update user name");
+    if (res) await maybeRefreshUser({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
+    });
+    return res;
+  }, [client, callbacks, logout, maybeRefreshUser]);
+  const addOauthProvider = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.addOauthProvider(params), () => logout(), callbacks, "Failed to add OAuth provider");
+    if (res) await maybeRefreshUser({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
+    });
+    return res;
+  }, [client, callbacks, logout, maybeRefreshUser]);
+  const removeOauthProviders = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.removeOauthProviders(params), () => logout(), callbacks, "Failed to remove OAuth providers");
+    if (res) await maybeRefreshUser({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
+    });
+    return res;
+  }, [client, callbacks, logout, maybeRefreshUser]);
+  const addPasskey = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.addPasskey(params), () => logout(), callbacks, "Failed to add passkey");
+    if (res) await maybeRefreshUser({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
+    });
+    return res;
+  }, [client, callbacks, logout, maybeRefreshUser]);
+  const removePasskeys = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.removePasskeys(params), () => logout(), callbacks, "Failed to remove passkeys");
+    if (res) await maybeRefreshUser({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
+    });
+    return res;
+  }, [client, callbacks, logout, maybeRefreshUser]);
+  const createWallet = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.createWallet(params), () => logout(), callbacks, "Failed to create wallet");
+    const s = await getSession();
+    if (res && s) await maybeRefreshWallets({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      })
+    });
+    return res;
+  }, [client, session, callbacks, logout, maybeRefreshWallets, getSession]);
+  const createWalletAccounts = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.createWalletAccounts(params), () => logout(), callbacks, "Failed to create wallet accounts");
+    const s = await getSession();
+    if (res && s) await maybeRefreshWallets({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      })
+    });
+    return res;
+  }, [client, session, callbacks, logout, getSession, maybeRefreshWallets]);
+  const exportWallet = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.exportWallet(params), () => logout(), callbacks, "Failed to export wallet");
+    const s = await getSession();
+    if (res && s) await maybeRefreshWallets({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      })
+    });
+    return res;
+  }, [client, session, callbacks, logout, getSession, maybeRefreshWallets]);
+  const exportPrivateKey = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.exportPrivateKey(params), () => logout(), callbacks, "Failed to export private key");
+    return res;
+  }, [client, callbacks, logout]);
+  const exportWalletAccount = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.exportWalletAccount(params), () => logout(), callbacks, "Failed to export wallet accounts");
+    const s = await getSession();
+    if (res && s) await maybeRefreshWallets({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      })
+    });
+    return res;
+  }, [client, callbacks, logout, getSession, maybeRefreshWallets]);
+  const importWallet = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.importWallet(params), () => logout(), callbacks, "Failed to import wallet");
+    const s = await getSession();
+    if (res && s) await maybeRefreshWallets({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
+    });
+    return res;
+  }, [client, callbacks, logout, getSession, maybeRefreshWallets]);
+  const importPrivateKey = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const res = await utils.withZeroXKeyErrorHandling(() => client.importPrivateKey(params), () => logout(), callbacks, "Failed to import private key");
+    return res;
+  }, [client, callbacks, logout]);
+  const deleteSubOrganization = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.deleteSubOrganization(params), () => logout(), callbacks, "Failed to delete sub-organization");
+  }, [client, callbacks, logout]);
+  const storeSession = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    await utils.withZeroXKeyErrorHandling(() => client.storeSession(params), () => logout(), callbacks, "Failed to store session");
+    const sessionKey = await getActiveSessionKey();
+    const session = await getSession({
+      ...(sessionKey && {
+        sessionKey
+      })
+    });
+    if (session && sessionKey) await scheduleSessionExpiration({
+      sessionKey,
+      expiry: session.expiry
+    });
+    const allSessions = await getAllSessions();
+    setSession(session);
+    setAllSessions(allSessions);
+    await Promise.all([maybeRefreshWallets(), maybeRefreshUser()]);
+  }, [client, callbacks, logout, getActiveSessionKey, getSession, scheduleSessionExpiration, getAllSessions, maybeRefreshWallets, maybeRefreshUser]);
+  const clearAllSessions = react.useCallback(async () => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    setSession(undefined);
+    setAllSessions(undefined);
+    clearSessionTimeouts();
+    return await utils.withZeroXKeyErrorHandling(() => client.clearAllSessions(), () => logout(), callbacks, "Failed to clear all sessions");
+  }, [client, callbacks, logout, clearSessionTimeouts]);
+  const setActiveSession = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const session = await utils.withZeroXKeyErrorHandling(() => client.getSession({
+      sessionKey: params.sessionKey
+    }), () => logout(), callbacks, "Failed to get session");
+    const s = await getSession();
+    if (!s) {
+      throw new sdkTypes.ZeroXKeyError("Session not found.", sdkTypes.ZeroXKeyErrorCodes.NOT_FOUND);
+    }
+    await utils.withZeroXKeyErrorHandling(() => client.setActiveSession(params), () => logout(), callbacks, "Failed to set active session");
+    setSession(session);
+    await utils.withZeroXKeyErrorHandling(async () => {
+      await Promise.all([maybeRefreshWallets(), maybeRefreshUser()]);
+    }, () => logout(), callbacks, "Failed to refresh data after setting active session");
+    return;
+  }, [client, callbacks, logout, getSession, maybeRefreshWallets, maybeRefreshUser]);
+  const clearUnusedKeyPairs = react.useCallback(async () => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.clearUnusedKeyPairs(), undefined, callbacks, "Failed to clear unused key pairs");
+  }, [client, callbacks]);
+  const createApiKeyPair = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.createApiKeyPair(params), undefined, callbacks, "Failed to create API key pair");
+  }, [client, callbacks]);
+  const getProxyAuthConfig = react.useCallback(async () => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.getProxyAuthConfig(), undefined, callbacks, "Failed to get proxy auth config");
+  }, [client, callbacks]);
+  const fetchBootProofForAppProof = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.fetchBootProofForAppProof(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
+  }, [client, callbacks, logout]);
+  const verifyAppProofs = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.verifyAppProofs(params), () => logout(), callbacks, "Failed to verify app proofs");
+  }, [client, callbacks, logout]);
+  const handleDiscordOauth = react.useCallback(async params => {
+    const {
+      clientId = masterConfig?.auth?.oauthConfig?.discordClientId,
+      openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
+      additionalState: additionalParameters
+    } = params || {};
+    const provider = sdkTypes.OAuthProviders.DISCORD;
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    if (!clientId) {
+      throw new sdkTypes.ZeroXKeyError("Discord Client ID is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    if (!masterConfig.auth?.oauthConfig?.oauthRedirectUri) {
+      throw new sdkTypes.ZeroXKeyError("OAuth Redirect URI is not configured.", sdkTypes.ZeroXKeyErrorCodes.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 and store verifier
+    const {
+      verifier,
+      codeChallenge
+    } = await pkce.generateChallengePair();
+    storage.storePKCEVerifier(provider, verifier);
+    // Build OAuth URL
+    const authUrl = url.buildOAuthUrl({
+      provider,
+      clientId,
+      redirectUri,
+      publicKey,
+      nonce,
+      flow,
+      codeChallenge,
+      additionalState: additionalParameters
+    });
+    if (openInPage) {
+      // Remainder of logic will occur in completeRedirectOauth
+      return url.redirectToOAuthProvider(authUrl);
+    }
+    // Popup flow
+    const authWindow = url.openOAuthPopup();
+    if (!authWindow) {
+      throw new Error(`Failed to open ${helpers.capitalizeProviderName(provider)} login window.`);
+    }
+    authWindow.location.href = authUrl;
+    return new Promise((resolve, reject) => {
+      const interval = setInterval(() => {
+        try {
+          if (authWindow.closed) {
+            clearInterval(interval);
+            reject(new Error("Authentication window was closed."));
+            return;
+          }
+          const url$1 = authWindow.location.href || "";
+          if (url$1.startsWith(window.location.origin)) {
+            const result = url.parseOAuthResponse(url$1, provider);
+            if (result) {
+              authWindow.close();
+              clearInterval(interval);
+              completion.completeOAuthPopup({
+                provider,
+                publicKey,
+                result,
+                callbacks,
+                completeOauth,
+                onOauthSuccess: params?.onOauthSuccess,
+                exchangeCodeForToken: async codeVerifier => {
+                  const resp = await client?.httpClient.proxyOAuth2Authenticate({
+                    provider: "OAUTH2_PROVIDER_DISCORD",
+                    authCode: result.authCode,
+                    redirectUri,
+                    codeVerifier,
+                    clientId,
+                    nonce
+                  });
+                  return resp?.oidcToken ?? "";
+                }
+              }).then(() => resolve()).catch(reject);
+            }
+          }
+        } catch {
+          // ignore cross-origin
+        }
+      }, 500);
+      if (authWindow.closed) {
+        clearInterval(interval);
+      }
+    });
+  }, [client, callbacks, completeOauth, createApiKeyPair, masterConfig]);
+  const handleXOauth = react.useCallback(async params => {
+    const {
+      clientId = masterConfig?.auth?.oauthConfig?.xClientId,
+      openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
+      additionalState: additionalParameters
+    } = params || {};
+    const provider = sdkTypes.OAuthProviders.X;
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    if (!clientId) {
+      throw new sdkTypes.ZeroXKeyError("Twitter Client ID is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    if (!masterConfig.auth?.oauthConfig?.oauthRedirectUri) {
+      throw new sdkTypes.ZeroXKeyError("OAuth Redirect URI is not configured.", sdkTypes.ZeroXKeyErrorCodes.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 and store verifier
+    const {
+      verifier,
+      codeChallenge
+    } = await pkce.generateChallengePair();
+    storage.storePKCEVerifier(provider, verifier);
+    // Build OAuth URL
+    const authUrl = url.buildOAuthUrl({
+      provider,
+      clientId,
+      redirectUri,
+      publicKey,
+      nonce,
+      flow,
+      codeChallenge,
+      additionalState: additionalParameters
+    });
+    if (openInPage) {
+      // Remainder of logic will occur in completeRedirectOauth
+      return url.redirectToOAuthProvider(authUrl);
+    }
+    // Popup flow
+    const authWindow = url.openOAuthPopup();
+    if (!authWindow) {
+      throw new Error(`Failed to open ${helpers.capitalizeProviderName(provider)} login window.`);
+    }
+    authWindow.location.href = authUrl;
+    return new Promise((resolve, reject) => {
+      const interval = setInterval(() => {
+        try {
+          if (authWindow.closed) {
+            clearInterval(interval);
+            reject(new Error("Authentication window was closed."));
+            return;
+          }
+          const url$1 = authWindow.location.href || "";
+          if (url$1.startsWith(window.location.origin)) {
+            const result = url.parseOAuthResponse(url$1, provider);
+            if (result) {
+              authWindow.close();
+              clearInterval(interval);
+              completion.completeOAuthPopup({
+                provider,
+                publicKey,
+                result,
+                callbacks,
+                completeOauth,
+                onOauthSuccess: params?.onOauthSuccess,
+                exchangeCodeForToken: async codeVerifier => {
+                  const resp = await client?.httpClient.proxyOAuth2Authenticate({
+                    provider: "OAUTH2_PROVIDER_X",
+                    authCode: result.authCode,
+                    redirectUri,
+                    codeVerifier,
+                    clientId,
+                    nonce
+                  });
+                  return resp?.oidcToken ?? "";
+                }
+              }).then(() => resolve()).catch(reject);
+            }
+          }
+        } catch {
+          // ignore cross-origin
+        }
+      }, 500);
+      if (authWindow.closed) {
+        clearInterval(interval);
+      }
+    });
+  }, [client, callbacks, completeOauth, createApiKeyPair, masterConfig]);
+  const handleGoogleOauth = react.useCallback(async params => {
+    const {
+      clientId = masterConfig?.auth?.oauthConfig?.googleClientId,
+      openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
+      additionalState: additionalParameters
+    } = params || {};
+    const provider = sdkTypes.OAuthProviders.GOOGLE;
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    if (!clientId) {
+      throw new sdkTypes.ZeroXKeyError("Google Client ID is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    if (!masterConfig.auth?.oauthConfig?.oauthRedirectUri) {
+      throw new sdkTypes.ZeroXKeyError("OAuth Redirect URI is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    const flow = openInPage ? "redirect" : "popup";
+    // Google requires no trailing slash
+    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));
+    // Build OAuth URL
+    const authUrl = url.buildOAuthUrl({
+      provider,
+      clientId,
+      redirectUri,
+      publicKey,
+      nonce,
+      flow,
+      additionalState: additionalParameters
+    });
+    if (openInPage) {
+      // Remainder of logic will occur in completeRedirectOauth
+      return url.redirectToOAuthProvider(authUrl);
+    }
+    // Popup flow
+    const authWindow = url.openOAuthPopup();
+    if (!authWindow) {
+      throw new Error(`Failed to open ${helpers.capitalizeProviderName(provider)} login window.`);
+    }
+    authWindow.location.href = authUrl;
+    return new Promise((resolve, reject) => {
+      const interval = setInterval(() => {
+        try {
+          if (authWindow.closed) {
+            clearInterval(interval);
+            reject(new Error("Authentication window was closed."));
+            return;
+          }
+          const url$1 = authWindow.location.href || "";
+          if (url$1.startsWith(window.location.origin)) {
+            const result = url.parseOAuthResponse(url$1, provider);
+            if (result) {
+              authWindow.close();
+              clearInterval(interval);
+              completion.completeOAuthPopup({
+                provider,
+                publicKey,
+                result,
+                callbacks,
+                completeOauth,
+                onOauthSuccess: params?.onOauthSuccess
+              }).then(() => resolve()).catch(reject);
+            }
+          }
+        } catch {
+          // Ignore cross-origin errors
+        }
+      }, 500);
+      if (authWindow.closed) {
+        clearInterval(interval);
+      }
+    });
+  }, [callbacks, completeOauth, createApiKeyPair, masterConfig]);
+  const handleAppleOauth = react.useCallback(async params => {
+    const {
+      clientId = masterConfig?.auth?.oauthConfig?.appleClientId,
+      openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
+      additionalState: additionalParameters
+    } = params || {};
+    const provider = sdkTypes.OAuthProviders.APPLE;
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    if (!clientId) {
+      throw new sdkTypes.ZeroXKeyError("Apple Client ID is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    if (!masterConfig.auth?.oauthConfig?.oauthRedirectUri) {
+      throw new sdkTypes.ZeroXKeyError("OAuth Redirect URI is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    const flow = openInPage ? "redirect" : "popup";
+    // TODO (Amir): Apple needs the '/' at the end. Maybe we should add it if not there?
+    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));
+    // Build OAuth URL
+    const authUrl = url.buildOAuthUrl({
+      provider,
+      clientId,
+      redirectUri,
+      publicKey,
+      nonce,
+      flow,
+      additionalState: additionalParameters
+    });
+    if (openInPage) {
+      // Remainder of logic will occur in completeRedirectOauth
+      return url.redirectToOAuthProvider(authUrl);
+    }
+    // Popup flow
+    const authWindow = url.openOAuthPopup();
+    if (!authWindow) {
+      throw new Error(`Failed to open ${helpers.capitalizeProviderName(provider)} login window.`);
+    }
+    authWindow.location.href = authUrl;
+    return new Promise((resolve, reject) => {
+      const interval = setInterval(() => {
+        try {
+          if (authWindow.closed) {
+            clearInterval(interval);
+            reject(new Error("Authentication window was closed."));
+            return;
+          }
+          const url$1 = authWindow.location.href || "";
+          if (url$1.startsWith(window.location.origin)) {
+            const result = url.parseOAuthResponse(url$1, provider);
+            if (result) {
+              authWindow.close();
+              clearInterval(interval);
+              completion.completeOAuthPopup({
+                provider,
+                publicKey,
+                result,
+                callbacks,
+                completeOauth,
+                onOauthSuccess: params?.onOauthSuccess
+              }).then(() => resolve()).catch(reject);
+            }
+          }
+        } catch {
+          // Ignore cross-origin errors
+        }
+      }, 500);
+      if (authWindow.closed) {
+        clearInterval(interval);
+      }
+    });
+  }, [callbacks, completeOauth, createApiKeyPair, masterConfig]);
+  const handleFacebookOauth = react.useCallback(async params => {
+    const {
+      clientId = masterConfig?.auth?.oauthConfig?.facebookClientId,
+      openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
+      additionalState: additionalParameters
+    } = params || {};
+    const provider = sdkTypes.OAuthProviders.FACEBOOK;
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    if (!clientId) {
+      throw new sdkTypes.ZeroXKeyError("Facebook Client ID is not configured.", sdkTypes.ZeroXKeyErrorCodes.INVALID_CONFIGURATION);
+    }
+    if (!masterConfig.auth?.oauthConfig?.oauthRedirectUri) {
+      throw new sdkTypes.ZeroXKeyError("OAuth Redirect URI is not configured.", sdkTypes.ZeroXKeyErrorCodes.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 and store verifier
+    const {
+      verifier,
+      codeChallenge
+    } = await pkce.generateChallengePair();
+    storage.storePKCEVerifier(provider, verifier);
+    // Build OAuth URL
+    const authUrl = url.buildOAuthUrl({
+      provider,
+      clientId,
+      redirectUri,
+      publicKey,
+      nonce,
+      flow,
+      codeChallenge,
+      additionalState: additionalParameters
+    });
+    if (openInPage) {
+      // Remainder of logic will occur in completeRedirectOauth
+      return url.redirectToOAuthProvider(authUrl);
+    }
+    // Popup flow
+    const authWindow = url.openOAuthPopup();
+    if (!authWindow) {
+      throw new Error(`Failed to open ${helpers.capitalizeProviderName(provider)} login window.`);
+    }
+    authWindow.location.href = authUrl;
+    return new Promise((resolve, reject) => {
+      const interval = setInterval(() => {
+        try {
+          if (authWindow.closed) {
+            clearInterval(interval);
+            reject(new Error("Authentication window was closed."));
+            return;
+          }
+          const url$1 = authWindow.location.href || "";
+          if (url$1.startsWith(window.location.origin)) {
+            const result = url.parseOAuthResponse(url$1, provider);
+            if (result) {
+              authWindow.close();
+              clearInterval(interval);
+              completion.completeOAuthPopup({
+                provider,
+                publicKey,
+                result,
+                callbacks,
+                completeOauth,
+                onOauthSuccess: params?.onOauthSuccess,
+                exchangeCodeForToken: async codeVerifier => {
+                  const tokenData = await pkce.exchangeFacebookCodeForToken(clientId, redirectUri, result.authCode, codeVerifier);
+                  return tokenData.id_token;
+                }
+              }).then(() => resolve()).catch(reject);
+            }
+          }
+        } catch {
+          // Ignore cross-origin errors
+        }
+      }, 500);
+      if (authWindow.closed) {
+        clearInterval(interval);
+      }
+    });
+  }, [callbacks, completeOauth, createApiKeyPair, masterConfig]);
+  const handleLogin = react.useCallback(async params => {
+    const logo = masterConfig?.ui?.darkMode ? params?.logoDark ?? masterConfig?.ui?.logoDark : params?.logoLight ?? masterConfig?.ui?.logoLight;
+    pushPage({
+      key: params?.title ?? "Log in or sign up",
+      content: jsxRuntime.jsx(index.AuthComponent, {
+        sessionKey: params?.sessionKey,
+        logo: logo,
+        logoClassName: params?.logoClassName,
+        title: params?.title
+      }),
+      showTitle: false,
+      preventClose: true
+    });
+  }, [pushPage, masterConfig]);
+  const handleExportWallet = react.useCallback(async params => {
+    const {
+      walletId,
+      targetPublicKey,
+      stampWith,
+      organizationId
+    } = params;
+    return new Promise((resolve, reject) => pushPage({
+      key: "Export wallet",
+      content: jsxRuntime.jsx(Export.ExportComponent, {
+        target: walletId,
+        exportType: base.ExportType.Wallet,
+        ...(targetPublicKey !== undefined && {
+          targetPublicKey
+        }),
+        ...(stampWith !== undefined && {
+          stampWith
+        }),
+        ...(organizationId !== undefined && {
+          organizationId
+        }),
+        onSuccess: () => resolve(),
+        onError: error => reject(error)
+      }),
+      onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the export wallet process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+    }));
+  }, [pushPage]);
+  const handleExportPrivateKey = react.useCallback(async params => {
+    const {
+      privateKeyId,
+      targetPublicKey,
+      keyFormat,
+      stampWith,
+      organizationId
+    } = params;
+    return new Promise((resolve, reject) => pushPage({
+      key: "Export private key",
+      content: jsxRuntime.jsx(Export.ExportComponent, {
+        target: privateKeyId,
+        exportType: base.ExportType.PrivateKey,
+        ...(keyFormat !== undefined && {
+          keyFormat
+        }),
+        ...(targetPublicKey !== undefined && {
+          targetPublicKey
+        }),
+        ...(stampWith !== undefined && {
+          stampWith
+        }),
+        ...(organizationId !== undefined && {
+          organizationId
+        }),
+        onSuccess: () => resolve(),
+        onError: error => reject(error)
+      }),
+      onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the export private key process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+    }));
+  }, [pushPage]);
+  const handleExportWalletAccount = react.useCallback(async params => {
+    const {
+      address,
+      targetPublicKey,
+      keyFormat,
+      stampWith,
+      organizationId
+    } = params;
+    return new Promise((resolve, reject) => pushPage({
+      key: "Export wallet account",
+      content: jsxRuntime.jsx(Export.ExportComponent, {
+        target: address,
+        exportType: base.ExportType.WalletAccount,
+        ...(keyFormat !== undefined && {
+          keyFormat
+        }),
+        ...(targetPublicKey !== undefined && {
+          targetPublicKey
+        }),
+        ...(stampWith !== undefined && {
+          stampWith
+        }),
+        ...(organizationId !== undefined && {
+          organizationId
+        }),
+        onSuccess: () => resolve(),
+        onError: error => reject(error)
+      }),
+      onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the export wallet account process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+    }));
+  }, [pushPage]);
+  const handleImportWallet = react.useCallback(async params => {
+    const {
+      defaultWalletAccounts,
+      successPageDuration = 2000,
+      stampWith,
+      walletName,
+      clearClipboardOnPaste,
+      organizationId,
+      userId
+    } = params || {};
+    try {
+      return utils.withZeroXKeyErrorHandling(() => new Promise((resolve, reject) => pushPage({
+        key: "Import wallet",
+        content: jsxRuntime.jsx(Import.ImportComponent, {
+          importType: base.ImportType.Wallet,
+          onError: error => {
+            reject(error);
+          },
+          onSuccess: walletId => resolve(walletId),
+          ...(defaultWalletAccounts !== undefined && {
+            defaultWalletAccounts
+          }),
+          ...(successPageDuration !== undefined && {
+            successPageDuration
+          }),
+          ...(clearClipboardOnPaste !== undefined && {
+            clearClipboardOnPaste // Note: This is defaulted to true in the IframeStamper
+          }),
+          ...(stampWith !== undefined && {
+            stampWith
+          }),
+          ...(walletName !== undefined && {
+            name: walletName
+          }),
+          ...(organizationId !== undefined && {
+            organizationId
+          }),
+          ...(userId !== undefined && {
+            userId
+          })
+        })
+      })), () => logout());
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to import wallet.", sdkTypes.ZeroXKeyErrorCodes.IMPORT_WALLET_ERROR, error);
+    }
+  }, [pushPage, logout]);
+  const handleImportPrivateKey = react.useCallback(async params => {
+    const {
+      curve,
+      addressFormats,
+      successPageDuration = 2000,
+      stampWith,
+      keyName,
+      keyFormat,
+      clearClipboardOnPaste,
+      organizationId
+    } = params || {};
+    try {
+      return utils.withZeroXKeyErrorHandling(() => new Promise((resolve, reject) => pushPage({
+        key: "Import private key",
+        content: jsxRuntime.jsx(Import.ImportComponent, {
+          importType: base.ImportType.PrivateKey,
+          curve: curve,
+          addressFormats: addressFormats,
+          keyFormat: keyFormat,
+          onError: error => {
+            reject(error);
+          },
+          onSuccess: privateKeyId => resolve(privateKeyId),
+          ...(successPageDuration !== undefined && {
+            successPageDuration
+          }),
+          ...(clearClipboardOnPaste !== undefined && {
+            clearClipboardOnPaste // Note: This is defaulted to true in the IframeStamper
+          }),
+          ...(stampWith !== undefined && {
+            stampWith
+          }),
+          ...(keyName !== undefined && {
+            name: keyName
+          }),
+          ...(organizationId !== undefined && {
+            organizationId
+          })
+        })
+      })), () => logout());
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to import private key.", sdkTypes.ZeroXKeyErrorCodes.IMPORT_WALLET_ERROR, error);
+    }
+  }, [pushPage, logout]);
+  const handleUpdateUserName = react.useCallback(async params => {
+    const {
+      successPageDuration = 2000,
+      subTitle,
+      title,
+      stampWith
+    } = params || {};
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || user?.userId;
+    if (!userId) {
+      throw new sdkTypes.ZeroXKeyError("A user ID is required to update a user name.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    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.withZeroXKeyErrorHandling(() => 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
+              }),
+              organizationId: organizationId,
+              userId: userId
+            }),
+            showTitle: false
+          });
+        }), () => logout());
+      } else {
+        const res = await updateUserName({
+          userName: params.userName,
+          userId: params.userId ?? user.userId,
+          stampWith,
+          ...(organizationId !== undefined && {
+            organizationId
+          })
+        });
+        onSuccess();
+        return res;
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to update user name.", sdkTypes.ZeroXKeyErrorCodes.UPDATE_USER_NAME_ERROR, error);
+    }
+  }, [client, getSession, user, pushPage, closeModal, updateUserName, logout]);
+  const handleUpdateUserPhoneNumber = react.useCallback(async params => {
+    const {
+      successPageDuration = 2000,
+      subTitle,
+      title,
+      stampWith
+    } = params || {};
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.CONFIG_NOT_INITIALIZED);
+    }
+    if (!masterConfig.auth?.methods?.smsOtpAuthEnabled) {
+      throw new sdkTypes.ZeroXKeyError("SMS OTP authentication is not enabled in the configuration.", sdkTypes.ZeroXKeyErrorCodes.AUTH_METHOD_NOT_ENABLED);
+    }
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.ZeroXKeyError("A user ID is required to update a phone number.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    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.withZeroXKeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Update Phone Number",
+            content: jsxRuntime.jsx(UpdatePhoneNumber.UpdatePhoneNumber, {
+              successPageDuration: successPageDuration,
+              onSuccess: userId => resolve(userId),
+              onError: error => reject(error),
+              organizationId: organizationId,
+              userId: userId,
+              ...(title !== undefined && {
+                title
+              }),
+              ...(subTitle !== undefined && {
+                subTitle
+              }),
+              ...(stampWith !== undefined && {
+                stampWith
+              })
+            }),
+            showTitle: false
+          });
+        }), () => logout());
+      } else {
+        const {
+          otpId,
+          otpEncryptionTargetBundle
+        } = await initOtp({
+          otpType: core.OtpType.Sms,
+          contact: params.phoneNumber
+        });
+        return utils.withZeroXKeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Update Phone Number",
+            content: jsxRuntime.jsx(OTP.OtpVerification, {
+              otpType: core.OtpType.Sms,
+              contact: params.phoneNumber,
+              otpId: otpId,
+              otpEncryptionTargetBundle: otpEncryptionTargetBundle,
+              otpLength: masterConfig.auth?.otpLength !== undefined ? Number(masterConfig.auth.otpLength) : undefined,
+              alphanumeric: masterConfig.auth?.otpAlphanumeric,
+              onContinue: async otpCode => {
+                try {
+                  const {
+                    verificationToken
+                  } = await verifyOtp({
+                    otpId,
+                    otpCode,
+                    otpEncryptionTargetBundle,
+                    contact: params.phoneNumber,
+                    otpType: core.OtpType.Sms
+                  });
+                  const res = await updateUserPhoneNumber({
+                    phoneNumber: params.phoneNumber,
+                    verificationToken,
+                    userId,
+                    organizationId,
+                    ...(stampWith !== undefined && {
+                      stampWith
+                    })
+                  });
+                  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
+          });
+        }), () => logout(), callbacks, "Failed to update phone number");
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to initialize OTP for sms verification.", sdkTypes.ZeroXKeyErrorCodes.INIT_OTP_ERROR, error);
+    }
+  }, [client, masterConfig, getSession, pushPage, closeModal, logout, initOtp, verifyOtp, updateUserPhoneNumber, user, callbacks]);
+  const handleUpdateUserEmail = react.useCallback(async params => {
+    const {
+      successPageDuration = 2000,
+      subTitle,
+      title,
+      stampWith
+    } = params || {};
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.ZeroXKeyError("A user ID is required to update an email.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    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.withZeroXKeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Update Email",
+            content: jsxRuntime.jsx(UpdateEmail.UpdateEmail, {
+              successPageDuration: successPageDuration,
+              onSuccess: userId => {
+                resolve(userId);
+              },
+              onError: error => reject(error),
+              organizationId: organizationId,
+              userId: userId,
+              ...(title !== undefined && {
+                title
+              }),
+              ...(subTitle !== undefined && {
+                subTitle
+              }),
+              ...(stampWith !== undefined && {
+                stampWith
+              })
+            }),
+            showTitle: false
+          });
+        }), () => logout());
+      } else {
+        const {
+          otpId,
+          otpEncryptionTargetBundle
+        } = await initOtp({
+          otpType: core.OtpType.Email,
+          contact: params.email
+        });
+        return utils.withZeroXKeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Update Email",
+            content: jsxRuntime.jsx(OTP.OtpVerification, {
+              otpType: core.OtpType.Email,
+              contact: params.email,
+              otpId: otpId,
+              otpEncryptionTargetBundle: otpEncryptionTargetBundle,
+              otpLength: masterConfig?.auth?.otpLength !== undefined ? Number(masterConfig.auth.otpLength) : undefined,
+              alphanumeric: masterConfig?.auth?.otpAlphanumeric,
+              onContinue: async otpCode => {
+                try {
+                  const {
+                    verificationToken
+                  } = await verifyOtp({
+                    otpId,
+                    otpCode,
+                    otpEncryptionTargetBundle,
+                    contact: params.email,
+                    otpType: core.OtpType.Email
+                  });
+                  const res = await updateUserEmail({
+                    email: params.email,
+                    verificationToken,
+                    userId,
+                    organizationId,
+                    ...(stampWith !== undefined && {
+                      stampWith
+                    })
+                  });
+                  onSuccess();
+                  resolve(res);
+                } catch (error) {
+                  reject(error);
+                }
+              },
+              ...(!user?.userEmail && {
+                title: title ?? "Connect an email"
+              }),
+              ...(subTitle !== undefined && {
+                subTitle
+              })
+            }),
+            showTitle: false
+          });
+        }), () => logout(), callbacks, "Failed to update email");
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to initialize OTP for email verification.", sdkTypes.ZeroXKeyErrorCodes.INIT_OTP_ERROR, error);
+    }
+  }, [client, getSession, pushPage, closeModal, logout, initOtp, masterConfig, verifyOtp, updateUserEmail, user, callbacks]);
+  const handleAddEmail = react.useCallback(async params => {
+    const {
+      successPageDuration = 2000,
+      subTitle,
+      title,
+      stampWith
+    } = params || {};
+    if (!client) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.ZeroXKeyError("A user ID is required to add an email.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    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.withZeroXKeyErrorHandling(() => 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
+              } : {}),
+              organizationId: organizationId,
+              userId: userId,
+              stampWith: stampWith
+            }),
+            showTitle: false
+          });
+        }), () => logout());
+      } else {
+        const {
+          otpId,
+          otpEncryptionTargetBundle
+        } = await initOtp({
+          otpType: core.OtpType.Email,
+          contact: params.email
+        });
+        return utils.withZeroXKeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Add Email",
+            content: jsxRuntime.jsx(OTP.OtpVerification, {
+              otpType: core.OtpType.Email,
+              contact: params.email,
+              otpId: otpId,
+              otpEncryptionTargetBundle: otpEncryptionTargetBundle,
+              otpLength: masterConfig?.auth?.otpLength !== undefined ? Number(masterConfig.auth.otpLength) : undefined,
+              alphanumeric: masterConfig?.auth?.otpAlphanumeric,
+              onContinue: async otpCode => {
+                try {
+                  const {
+                    verificationToken
+                  } = await verifyOtp({
+                    otpId,
+                    otpCode,
+                    otpEncryptionTargetBundle,
+                    contact: params.email,
+                    otpType: core.OtpType.Email
+                  });
+                  const res = await updateUserEmail({
+                    email: params.email,
+                    verificationToken,
+                    userId,
+                    organizationId,
+                    stampWith
+                  });
+                  onSuccess();
+                  resolve(res);
+                } catch (error) {
+                  reject(error);
+                }
+              },
+              ...(!user?.userEmail && {
+                title: title ?? "Connect an email"
+              }),
+              ...(subTitle !== undefined && {
+                subTitle
+              })
+            }),
+            showTitle: false
+          });
+        }), () => logout(), callbacks, "Failed to add email");
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to initialize OTP for email verification.", sdkTypes.ZeroXKeyErrorCodes.INIT_OTP_ERROR, error);
+    }
+  }, [client, getSession, pushPage, closeModal, user, logout, initOtp, masterConfig, verifyOtp, updateUserEmail, callbacks]);
+  const handleAddPhoneNumber = react.useCallback(async params => {
+    const {
+      successPageDuration = 2000,
+      subTitle,
+      title,
+      stampWith
+    } = params || {};
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!masterConfig) {
+      throw new sdkTypes.ZeroXKeyError("Config is not ready yet!", sdkTypes.ZeroXKeyErrorCodes.CONFIG_NOT_INITIALIZED);
+    }
+    if (!masterConfig.auth?.methods?.smsOtpAuthEnabled) {
+      throw new sdkTypes.ZeroXKeyError("SMS OTP authentication is not enabled in the configuration.", sdkTypes.ZeroXKeyErrorCodes.AUTH_METHOD_NOT_ENABLED);
+    }
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.ZeroXKeyError("A user ID is required to add a phone number.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    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.withZeroXKeyErrorHandling(() => 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
+              }),
+              organizationId: organizationId,
+              userId: userId,
+              stampWith: stampWith
+            }),
+            showTitle: false
+          });
+        }), () => logout(), callbacks, "Failed to add phone number");
+      } else {
+        const {
+          otpId,
+          otpEncryptionTargetBundle
+        } = await initOtp({
+          otpType: core.OtpType.Sms,
+          contact: params.phoneNumber
+        });
+        return utils.withZeroXKeyErrorHandling(() => new Promise((resolve, reject) => {
+          pushPage({
+            key: "Add Phone Number",
+            content: jsxRuntime.jsx(OTP.OtpVerification, {
+              otpType: core.OtpType.Sms,
+              contact: params.phoneNumber,
+              otpId: otpId,
+              otpEncryptionTargetBundle: otpEncryptionTargetBundle,
+              otpLength: masterConfig.auth?.otpLength !== undefined ? Number(masterConfig.auth.otpLength) : undefined,
+              alphanumeric: masterConfig?.auth?.otpAlphanumeric,
+              onContinue: async otpCode => {
+                try {
+                  const {
+                    verificationToken
+                  } = await verifyOtp({
+                    otpId,
+                    otpCode,
+                    otpEncryptionTargetBundle,
+                    contact: params.phoneNumber,
+                    otpType: core.OtpType.Sms
+                  });
+                  const res = await updateUserPhoneNumber({
+                    phoneNumber: params.phoneNumber,
+                    verificationToken,
+                    userId,
+                    organizationId,
+                    stampWith
+                  });
+                  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
+          });
+        }), () => logout(), callbacks, "Failed to add phone number");
+      }
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to initialize OTP for sms verification.", sdkTypes.ZeroXKeyErrorCodes.INIT_OTP_ERROR, error);
+    }
+  }, [client, masterConfig, getSession, pushPage, closeModal, user, logout, callbacks, initOtp, verifyOtp, updateUserPhoneNumber]);
+  const handleRemovePasskey = react.useCallback(async params => {
+    const {
+      authenticatorId,
+      successPageDuration = 2000,
+      subTitle,
+      title,
+      stampWith,
+      userId
+    } = params;
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    return utils.withZeroXKeyErrorHandling(() => 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
+          }),
+          ...(organizationId !== undefined && {
+            organizationId
+          })
+        }),
+        showTitle: false,
+        preventBack: true
+      });
+    }), () => logout(), callbacks, "Failed to remove passkey");
+  }, [client, getSession, pushPage, logout, callbacks]);
+  const handleAddPasskey = react.useCallback(async params => {
+    const {
+      name,
+      displayName,
+      successPageDuration = 2000,
+      stampWith
+    } = params || {};
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.ZeroXKeyError("A user ID or a valid session is required to add a passkey.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    try {
+      const resPromise = addPasskey({
+        ...(name && {
+          name
+        }),
+        ...(displayName && {
+          displayName
+        }),
+        userId,
+        stampWith,
+        ...(organizationId && {
+          organizationId
+        })
+      });
+      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.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to add passkey in handler.", sdkTypes.ZeroXKeyErrorCodes.ADD_PASSKEY_ERROR, error);
+    }
+  }, [client, getSession, addPasskey, pushPage, closeModal]);
+  const handleRemoveOauthProvider = react.useCallback(async params => {
+    const {
+      providerId,
+      successPageDuration = 2000,
+      subTitle,
+      title,
+      stampWith
+    } = params;
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    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
+            }),
+            ...(organizationId !== undefined && {
+              organizationId
+            })
+          }),
+          showTitle: false,
+          preventBack: true,
+          onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the remove OAuth provider process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+        });
+      });
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to remove OAuth provider in handler.", sdkTypes.ZeroXKeyErrorCodes.REMOVE_OAUTH_PROVIDER_ERROR, error);
+    }
+  }, [client, getSession, pushPage]);
+  const handleAddOauthProvider = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const {
+      providerName,
+      stampWith,
+      successPageDuration = 2000,
+      openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false
+    } = params;
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.ZeroXKeyError("A user ID is required to add an OAuth provider.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    return new Promise(async (resolve, reject) => {
+      try {
+        const onOauthSuccess = async params => {
+          await addOauthProvider({
+            providerName: params.providerName,
+            oidcToken: params.oidcToken,
+            stampWith,
+            organizationId,
+            userId
+          });
+          resolve();
+          pushPage({
+            key: "OAuth Provider Added",
+            content: jsxRuntime.jsx(Success.SuccessPage, {
+              text: `Successfully added ${params.providerName} OAuth provider!`,
+              duration: successPageDuration,
+              onComplete: () => {
+                closeModal();
+              }
+            }),
+            preventBack: true,
+            showTitle: false
+          });
+        };
+        if (openInPage) {
+          storage.storeOAuthAddProviderMetadata({
+            organizationId,
+            userId,
+            ...(stampWith && {
+              stampWith: stampWith
+            }),
+            successPageDuration
+          });
+        }
+        const additionalState = openInPage ? {
+          oauthIntent: storage.OAUTH_INTENT_ADD_PROVIDER,
+          ...(successPageDuration > 0 && {
+            openModal: "true"
+          })
+        } : undefined;
+        switch (providerName) {
+          case sdkTypes.OAuthProviders.DISCORD:
+            {
+              return await handleDiscordOauth({
+                openInPage,
+                ...(additionalState && {
+                  additionalState
+                }),
+                ...(!openInPage && {
+                  onOauthSuccess
+                })
+              });
+            }
+          case sdkTypes.OAuthProviders.X:
+            {
+              return await handleXOauth({
+                openInPage,
+                ...(additionalState && {
+                  additionalState
+                }),
+                ...(!openInPage && {
+                  onOauthSuccess
+                })
+              });
+            }
+          case sdkTypes.OAuthProviders.GOOGLE:
+            {
+              return await handleGoogleOauth({
+                openInPage,
+                ...(additionalState && {
+                  additionalState
+                }),
+                ...(!openInPage && {
+                  onOauthSuccess
+                })
+              });
+            }
+          case sdkTypes.OAuthProviders.APPLE:
+            {
+              return await handleAppleOauth({
+                openInPage,
+                ...(additionalState && {
+                  additionalState
+                }),
+                ...(!openInPage && {
+                  onOauthSuccess
+                })
+              });
+            }
+          case sdkTypes.OAuthProviders.FACEBOOK:
+            {
+              return await handleFacebookOauth({
+                openInPage,
+                ...(additionalState && {
+                  additionalState
+                }),
+                ...(!openInPage && {
+                  onOauthSuccess
+                })
+              });
+            }
+          default:
+            {
+              throw new sdkTypes.ZeroXKeyError(`Unsupported OAuth provider: ${providerName}`, sdkTypes.ZeroXKeyErrorCodes.NOT_FOUND);
+            }
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }, [client, getSession, addOauthProvider, pushPage, closeModal, handleDiscordOauth, handleXOauth, handleGoogleOauth, handleAppleOauth, handleFacebookOauth]);
+  const handleConnectExternalWallet = react.useCallback(async params => {
+    const {
+      successPageDuration = 2000
+    } = params || {};
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    if (!masterConfig?.walletConfig?.features?.connecting) {
+      throw new sdkTypes.ZeroXKeyError("Wallet connecting is not enabled.", sdkTypes.ZeroXKeyErrorCodes.FEATURE_NOT_ENABLED);
+    }
+    return new Promise((resolve, reject) => {
+      pushPage({
+        key: "Connect wallet",
+        content: jsxRuntime.jsx(ConnectWallet.ConnectWalletModal, {
+          successPageDuration: successPageDuration,
+          onSuccess: (type, account) => {
+            resolve({
+              type,
+              account
+            });
+          }
+        }),
+        onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the connect wallet process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+      });
+    });
+  }, [client, masterConfig, fetchWalletProviders, pushPage]);
+  const handleRemoveUserEmail = react.useCallback(async params => {
+    const {
+      successPageDuration = 2000,
+      stampWith,
+      userId
+    } = params || {};
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    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);
+            },
+            ...(organizationId !== undefined && {
+              organizationId
+            })
+          }),
+          showTitle: false,
+          preventBack: true,
+          onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the remove email process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+        });
+      });
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to remove user email.", sdkTypes.ZeroXKeyErrorCodes.UPDATE_USER_EMAIL_ERROR, error);
+    }
+  }, [getSession, pushPage]);
+  const handleRemoveUserPhoneNumber = react.useCallback(async params => {
+    const {
+      successPageDuration = 2000,
+      stampWith,
+      userId
+    } = params || {};
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    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);
+            },
+            ...(organizationId !== undefined && {
+              organizationId
+            })
+          }),
+          showTitle: false,
+          preventBack: true,
+          onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the remove phone number process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+        });
+      });
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to remove user phone number.", sdkTypes.ZeroXKeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR, error);
+    }
+  }, [getSession, pushPage]);
+  const handleSendTransaction = react.useCallback(async params => {
+    const session = await getSession();
+    const organizationId = params.organizationId || session?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    const {
+      transaction,
+      icon,
+      stampWith,
+      successPageDuration = 2000
+    } = params;
+    const {
+      caip2
+    } = transaction;
+    const isSolanaTransaction = caip2.startsWith("solana:");
+    return new Promise((resolve, reject) => {
+      const action = async () => {
+        const sendTransactionStatusId = isSolanaTransaction ? await solSendTransaction({
+          organizationId,
+          transaction: transaction,
+          stampWith
+        }) : await (async () => {
+          const {
+            from,
+            to,
+            value,
+            data,
+            nonce,
+            gasLimit,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            sponsor
+          } = transaction;
+          const cleanedData = data && data !== "0x" && data !== "" ? data : undefined;
+          const tx = {
+            from,
+            to,
+            caip2,
+            sponsor: sponsor ?? false,
+            ...(value ? {
+              value
+            } : {}),
+            ...(cleanedData ? {
+              data: cleanedData
+            } : {}),
+            ...(nonce ? {
+              nonce
+            } : {}),
+            ...(gasLimit ? {
+              gasLimit
+            } : {}),
+            ...(maxFeePerGas ? {
+              maxFeePerGas
+            } : {}),
+            ...(maxPriorityFeePerGas ? {
+              maxPriorityFeePerGas
+            } : {})
+          };
+          return ethSendTransaction({
+            organizationId,
+            transaction: tx,
+            stampWith
+          });
+        })();
+        if (!sendTransactionStatusId) {
+          throw new sdkTypes.ZeroXKeyError("Missing sendTransactionStatusId", sdkTypes.ZeroXKeyErrorCodes.BAD_RESPONSE);
+        }
+        const pollResult = await pollTransactionStatus({
+          organizationId,
+          sendTransactionStatusId
+        });
+        const txDetails = pollResult;
+        const txHash = txDetails.eth?.txHash ?? txDetails.solana?.signature ?? txDetails.txHash;
+        return txHash ? {
+          txHash
+        } : {};
+      };
+      pushPage({
+        key: "Send Transaction",
+        showTitle: false,
+        preventBack: true,
+        onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the transaction.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED)),
+        content: jsxRuntime.jsx(SendTransaction.SendTransactionPage, {
+          icon: icon ?? helpers$1.getChainLogo(caip2),
+          action: action,
+          caip2: caip2,
+          successPageDuration: successPageDuration,
+          onSuccess: () => resolve(),
+          onError: err => reject(err)
+        })
+      });
+    });
+  }, [ethSendTransaction, getSession, pollTransactionStatus, pushPage, solSendTransaction]);
+  const handleSendErc20Transfer = react.useCallback(async params => {
+    const session = await getSession();
+    const organizationId = params.organizationId || session?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    const {
+      transfer,
+      icon,
+      stampWith,
+      successPageDuration = 2000
+    } = params;
+    const {
+      caip2
+    } = transfer;
+    return new Promise((resolve, reject) => {
+      const action = async () => {
+        const sendTransactionStatusId = await ethSendErc20Transfer({
+          organizationId,
+          transfer,
+          stampWith
+        });
+        if (!sendTransactionStatusId) {
+          throw new sdkTypes.ZeroXKeyError("Missing sendTransactionStatusId", sdkTypes.ZeroXKeyErrorCodes.BAD_RESPONSE);
+        }
+        const pollResult = await pollTransactionStatus({
+          organizationId,
+          sendTransactionStatusId
+        });
+        const txHash = pollResult?.eth?.txHash ?? pollResult?.txHash;
+        return txHash ? {
+          txHash
+        } : {};
+      };
+      pushPage({
+        key: "Send ERC20 Transfer",
+        showTitle: false,
+        preventBack: true,
+        onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the transaction.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED)),
+        content: jsxRuntime.jsx(SendTransaction.SendTransactionPage, {
+          icon: icon ?? helpers$1.getChainLogo(caip2),
+          action: action,
+          caip2: caip2,
+          successPageDuration: successPageDuration,
+          onSuccess: () => resolve(),
+          onError: err => reject(err)
+        })
+      });
+    });
+  }, [ethSendErc20Transfer, getSession, pollTransactionStatus, pushPage]);
+  const handleOnRamp = react.useCallback(async params => {
+    const {
+      walletAccount,
+      fiatCurrencyAmount,
+      fiatCurrencyCode,
+      paymentMethod,
+      countrySubdivisionCode,
+      urlForSignature,
+      countryCode,
+      onrampProvider = "FIAT_ON_RAMP_PROVIDER_MOONPAY",
+      sandboxMode = true,
+      successPageDuration = 2000,
+      openInNewTab = false
+    } = params;
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    let cryptoCurrencyCode;
+    let network;
+    switch (true) {
+      case walletAccount.addressFormat === "ADDRESS_FORMAT_ETHEREUM":
+        cryptoCurrencyCode = sdkTypes.FiatOnRampCryptoCurrency.ETHEREUM;
+        network = sdkTypes.FiatOnRampBlockchainNetwork.ETHEREUM;
+        break;
+      case walletAccount.addressFormat?.includes("ADDRESS_FORMAT_BITCOIN"):
+        cryptoCurrencyCode = sdkTypes.FiatOnRampCryptoCurrency.BITCOIN;
+        network = sdkTypes.FiatOnRampBlockchainNetwork.BITCOIN;
+        break;
+      case walletAccount.addressFormat === "ADDRESS_FORMAT_SOLANA":
+        cryptoCurrencyCode = sdkTypes.FiatOnRampCryptoCurrency.SOLANA;
+        network = sdkTypes.FiatOnRampBlockchainNetwork.SOLANA;
+        break;
+      default:
+        cryptoCurrencyCode = sdkTypes.FiatOnRampCryptoCurrency.ETHEREUM;
+        network = sdkTypes.FiatOnRampBlockchainNetwork.ETHEREUM;
+        break;
+    }
+    const openNewTab = openInNewTab || isMobile;
+    cryptoCurrencyCode = params.cryptoCurrencyCode || cryptoCurrencyCode;
+    network = params.network || network;
+    return new Promise((resolve, reject) => {
+      const OnRampContainer = () => {
+        const [completed, setCompleted] = react.useState(false);
+        const pollingRef = react.useRef(null);
+        const cleanup = () => {
+          if (pollingRef.current) {
+            clearInterval(pollingRef.current);
+            pollingRef.current = null;
+          }
+        };
+        react.useEffect(() => {
+          return () => {
+            cleanup();
+          };
+        }, []);
+        const action = async () => {
+          try {
+            let onRampWindow = null;
+            if (openNewTab) {
+              onRampWindow = window.open("", "_blank");
+              if (!onRampWindow) throw new Error("Failed to open On Ramp tab.");
+            }
+            const result = await client?.httpClient?.initFiatOnRamp({
+              onrampProvider,
+              walletAddress: walletAccount.address,
+              network,
+              cryptoCurrencyCode,
+              sandboxMode,
+              organizationId,
+              ...(fiatCurrencyCode ? {
+                fiatCurrencyCode
+              } : {}),
+              ...(fiatCurrencyAmount ? {
+                fiatCurrencyAmount
+              } : {}),
+              ...(paymentMethod ? {
+                paymentMethod
+              } : {}),
+              ...(countryCode ? {
+                countryCode
+              } : {}),
+              ...(countrySubdivisionCode ? {
+                countrySubdivisionCode
+              } : {}),
+              ...(sandboxMode !== undefined ? {
+                sandboxMode
+              } : {}),
+              ...(urlForSignature ? {
+                urlForSignature
+              } : {})
+            });
+            if (!result?.onRampUrl) throw new Error("Missing onRampUrl");
+            if (openNewTab && onRampWindow) {
+              onRampWindow.location.href = result.onRampUrl.toString();
+            } else {
+              const popupWidth = 500;
+              const popupHeight = 600;
+              const left = window.screenX + (window.innerWidth - popupWidth) / 2;
+              const top = window.screenY + (window.innerHeight - popupHeight) / 2;
+              onRampWindow = window.open(result.onRampUrl.toString(), "_blank", `width=${popupWidth},height=${popupHeight},top=${top},left=${left},scrollbars=yes,resizable=yes`);
+              if (!onRampWindow) throw new Error("Failed to open On Ramp window.");
+            }
+            const onRampTransactionId = result.onRampTransactionId;
+            if (!onRampTransactionId) throw new Error("No onRampTransactionId returned");
+            return new Promise((resolveAction, rejectAction) => {
+              pollingRef.current = setInterval(async () => {
+                try {
+                  if (onrampProvider === "FIAT_ON_RAMP_PROVIDER_COINBASE" && onRampWindow?.closed) {
+                    cleanup();
+                    rejectAction(new Error("On-ramp popup closed by user"));
+                    return;
+                  }
+                  let currentUrl = "";
+                  try {
+                    currentUrl = onRampWindow?.location.href || "";
+                  } catch {}
+                  if (currentUrl && currentUrl.startsWith(window.location.origin)) {
+                    cleanup();
+                    onRampWindow?.close();
+                    setCompleted(true);
+                    resolveAction();
+                    return;
+                  }
+                  const resp = await client?.httpClient?.getOnRampTransactionStatus({
+                    transactionId: onRampTransactionId,
+                    refresh: true
+                  });
+                  const status = resp?.transactionStatus;
+                  if (["COMPLETED", "FAILED", "CANCELLED"].includes(status ?? "")) {
+                    cleanup();
+                    try {
+                      onRampWindow?.close();
+                    } catch {}
+                    setCompleted(true);
+                    resolveAction();
+                  }
+                } catch (error) {
+                  console.warn("Polling error (ignored):", error);
+                }
+              }, 3000);
+            });
+          } catch (err) {
+            cleanup();
+            throw err;
+          }
+        };
+        return jsxRuntime.jsx(OnRamp.OnRampPage, {
+          icon: onrampProvider === "FIAT_ON_RAMP_PROVIDER_COINBASE" ? jsxRuntime.jsx(Svg.CoinbaseLogo, {
+            className: "w-12 h-12"
+          }) : jsxRuntime.jsx(Svg.MoonPayLogo, {
+            className: "w-12 h-12"
+          }),
+          onrampProvider: onrampProvider,
+          action: action,
+          sandboxMode: sandboxMode,
+          completed: completed,
+          successPageDuration: successPageDuration,
+          onSuccess: () => resolve(),
+          onError: err => reject(err)
+        });
+      };
+      pushPage({
+        key: "Fiat OnRamp",
+        content: jsxRuntime.jsx(OnRampContainer, {}),
+        showTitle: false,
+        preventBack: true,
+        onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the onramp process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+      });
+    });
+  }, [getSession, client, pushPage]);
+  const handleVerifyAppProofs = react.useCallback(async params => {
+    const {
+      appProofs,
+      successPageDuration = 3000,
+      stampWith
+    } = params || {};
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    try {
+      return new Promise((resolve, reject) => {
+        pushPage({
+          key: "Verify app proofs",
+          content: jsxRuntime.jsx(Verify.VerifyPage, {
+            appProofs: appProofs,
+            onSuccess: () => {
+              resolve();
+            },
+            onError: error => {
+              reject(error);
+            },
+            successPageDuration: successPageDuration,
+            ...(stampWith && {
+              stampWith
+            }),
+            ...(organizationId !== undefined && {
+              organizationId
+            })
+          }),
+          showTitle: false,
+          preventBack: true,
+          onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the verify app proofs process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+        });
+      });
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to verify app proofs.", sdkTypes.ZeroXKeyErrorCodes.VERIFY_APP_PROOFS_ERROR, error);
+    }
+  }, [getSession, pushPage]);
+  react.useEffect(() => {
+    if (proxyAuthConfigRef.current) return;
+    // Only fetch the proxy auth config once. Use that to build the master config.
+    const fetchProxyAuthConfig = async () => {
+      try {
+        let proxyAuthConfig;
+        if (shouldFetchWalletKitConfig) {
+          // Only fetch the proxy auth config if we have an authProxyId and the autoFetchWalletKitConfig param is enabled or not passed in.
+          proxyAuthConfig = await core.getAuthProxyConfig(config.authProxyConfigId,
+          // Can assert safely. See shouldFetchWalletKitConfig definition.
+          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
+    // Rebuild the master config with the updated config and stored proxyAuthConfig
+    // If we don't have a stored proxyAuthConfig and we need to fetch it, we wait until that fetch is done in the other useEffect.
+    // If shouldFetchWalletKitConfig is false, we'll never have a proxyAuthConfig to build the master config with, so this useEffect should always run.
+    if (!proxyAuthConfigRef.current && shouldFetchWalletKitConfig) return;
+    setMasterConfig(buildConfig(proxyAuthConfigRef.current ?? undefined));
+  }, [config, proxyAuthConfigRef.current]);
+  /**
+   * @internal
+   * We create `debouncedRefreshWallets()` so that multiple rapid wallet events
+   * (for example, on Solana a single disconnect can emit several events we listen for)
+   * only trigger `maybeRefreshWallets()` once.
+   *
+   * Defining the debounced function outside of the `useEffect` ensures all event
+   * listeners in `initializeWalletProviderListeners` share the same instance, instead of creating
+   * a new one on every render.
+   */
+  const debouncedRefreshWallets = utils.useDebouncedCallback(maybeRefreshWallets, 100);
+  const debouncedFetchWalletProviders = utils.useDebouncedCallback(fetchWalletProviders, 100);
+  react.useEffect(() => {
+    const handleUpdateState = async () => {
+      // we only refresh the wallets if there is an active session
+      // this is needed because a disconnect event can occur
+      // while the user is unauthenticated
+      //
+      // WalletProviders state is updated regardless of session state
+      const currentSession = await getSession();
+      if (currentSession) {
+        // this updates both the wallets and walletProviders state
+        await debouncedRefreshWallets();
+      } else {
+        // this updates only the walletProviders state
+        await debouncedFetchWalletProviders();
+      }
+    };
+    let cleanup = () => {};
+    initializeWalletProviderListeners(walletProviders, handleUpdateState).then(fn => {
+      cleanup = fn;
+    }).catch(err => {
+      console.error("Failed to init providers:", err);
+    });
+    return () => {
+      cleanup();
+    };
+  }, [walletProviders, getSession, debouncedRefreshWallets, debouncedFetchWalletProviders]);
+  react.useEffect(() => {
+    // authState must be consistent with session state. We found during testing that there are cases where the session and authState can be out of sync in very rare edge cases.
+    // This will ensure that they are always in sync and remove the need to setAuthState manually in other places.
+    if (session && utils.isValidSession(session)) {
+      setAuthState(base.AuthState.Authenticated);
+    } else {
+      setAuthState(base.AuthState.Unauthenticated);
+    }
+  }, [session]);
+  react.useEffect(() => {
+    // 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();
+      // if auth or wallet connecting features are enabled, we want to fetch
+      // the wallet providers to set the state
+      if (masterConfig.walletConfig?.features?.auth || masterConfig.walletConfig?.features?.connecting) {
+        fetchWalletProviders();
+      }
+      initializeSessions().finally(() => {
+        // Set the client state to ready only after all initializations are done.
+        setClientState(base.ClientState.Ready);
+      });
+    });
+    return () => {
+      clearSessionTimeouts();
+    };
+  }, [client]);
+  return jsxRuntime.jsx(Types.ClientContext.Provider, {
+    value: {
+      session,
+      allSessions,
+      clientState,
+      authState,
+      user,
+      wallets,
+      walletProviders,
+      config: masterConfig,
+      httpClient: client?.httpClient,
+      createHttpClient,
+      createPasskey,
+      logout,
+      loginWithPasskey,
+      signUpWithPasskey,
+      fetchWalletProviders,
+      connectWalletAccount,
+      disconnectWalletAccount,
+      switchWalletAccountChain,
+      buildWalletLoginRequest,
+      loginWithWallet,
+      signUpWithWallet,
+      loginOrSignupWithWallet,
+      initOtp,
+      verifyOtp,
+      loginWithOtp,
+      signUpWithOtp,
+      completeOtp,
+      loginWithOauth,
+      signUpWithOauth,
+      completeOauth,
+      fetchWallets,
+      fetchWalletAccounts,
+      fetchPrivateKeys,
+      refreshWallets,
+      signMessage,
+      signTransaction,
+      ethSendTransaction,
+      ethSendErc20Transfer,
+      solSendTransaction,
+      signAndSendTransaction,
+      pollTransactionStatus,
+      fetchUser,
+      fetchOrCreateP256ApiKeyUser,
+      fetchOrCreatePolicies,
+      refreshUser,
+      updateUserEmail,
+      removeUserEmail,
+      updateUserPhoneNumber,
+      removeUserPhoneNumber,
+      updateUserName,
+      addOauthProvider,
+      removeOauthProviders,
+      addPasskey,
+      removePasskeys,
+      createWallet,
+      createWalletAccounts,
+      exportWallet,
+      exportPrivateKey,
+      exportWalletAccount,
+      importWallet,
+      importPrivateKey,
+      deleteSubOrganization,
+      storeSession,
+      clearSession,
+      clearAllSessions,
+      refreshSession,
+      getSession,
+      getAllSessions,
+      setActiveSession,
+      clearUnusedKeyPairs,
+      getActiveSessionKey,
+      createApiKeyPair,
+      getProxyAuthConfig,
+      fetchBootProofForAppProof,
+      verifyAppProofs,
+      handleLogin,
+      handleGoogleOauth,
+      handleXOauth,
+      handleDiscordOauth,
+      handleAppleOauth,
+      handleFacebookOauth,
+      handleExportWallet,
+      handleExportPrivateKey,
+      handleExportWalletAccount,
+      handleImportWallet,
+      handleImportPrivateKey,
+      handleUpdateUserEmail,
+      handleUpdateUserPhoneNumber,
+      handleUpdateUserName,
+      handleAddOauthProvider,
+      handleRemoveOauthProvider,
+      handleAddPasskey,
+      handleRemovePasskey,
+      handleAddEmail,
+      handleAddPhoneNumber,
+      handleSignMessage,
+      handleConnectExternalWallet,
+      handleRemoveUserEmail,
+      handleRemoveUserPhoneNumber,
+      handleVerifyAppProofs,
+      handleOnRamp,
+      handleSendTransaction,
+      handleSendErc20Transfer
+    },
+    children: children
+  });
+};
+
+exports.ClientProvider = ClientProvider;
+//# sourceMappingURL=Provider.js.map