@turnkey/react-wallet-kit 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/providers/client/Provider.js

@@ -4,7 +4,8 @@
 var jsxRuntime = require('react/jsx-runtime');
 var sha2 = require('@noble/hashes/sha2');
 var utils$1 = require('@noble/hashes/utils');
-var utils = require('../../utils.js');
+var utils = require('../../utils/utils.js');
+var timers = require('../../utils/timers.js');
 var core = require('@turnkey/core');
 var react = require('react');
 var sdkTypes = require('@turnkey/sdk-types');
@@ -23,7 +24,7 @@ var UpdatePhoneNumber = require('../../components/user/UpdatePhoneNumber.js');
 var UpdateUserName = require('../../components/user/UpdateUserName.js');
 var RemoveOAuthProvider = require('../../components/user/RemoveOAuthProvider.js');
 var RemovePasskey = require('../../components/user/RemovePasskey.js');
-var LinkWallet = require('../../components/user/LinkWallet.js');
+var 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');
@@ -32,7 +33,7 @@ var RemovePhoneNumber = require('../../components/user/RemovePhoneNumber.js');
 /**
  * Provides Turnkey client authentication, session management, wallet operations, and user profile management
  * for the React Wallet Kit SDK. This context provider encapsulates all core authentication flows (Passkey, Wallet, OTP, OAuth),
- * session lifecycle (creation, expiration, refresh), wallet linking/import/export, and user profile updates (email, phone, name).
+ * session lifecycle (creation, expiration, refresh), wallet connecting/import/export, and user profile updates (email, phone, name).
  *
  * The provider automatically initializes the Turnkey client, fetches configuration (including proxy auth config if needed),
  * and synchronizes session and authentication state. It exposes a comprehensive set of methods for authentication flows,
@@ -41,9 +42,9 @@ var RemovePhoneNumber = require('../../components/user/RemovePhoneNumber.js');
  * Features:
  * - Passkey, Wallet, OTP (Email/SMS), and OAuth (Google, Apple, Facebook) authentication and sign-up flows.
  * - Session management: creation, expiration scheduling, refresh, and clearing.
- * - Wallet management: fetch, link, import, export, account management.
+ * - 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 linking, and profile updates.
+ * - Modal-driven UI flows for authentication, wallet connecting, and profile updates.
  * - Error handling and callback integration for custom error and event responses.
  *
  * Usage:
@@ -67,6 +68,9 @@ const ClientProvider = ({
   const [user, setUser] = react.useState(undefined);
   const [clientState, setClientState] = react.useState();
   const [authState, setAuthState] = react.useState(base.AuthState.Unauthenticated);
+  // 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);
@@ -74,78 +78,6 @@ const ClientProvider = ({
     pushPage,
     closeModal
   } = Hook.useModal();
-  react.useEffect(() => {
-    if (proxyAuthConfigRef.current) return;
-    // Only fetch the proxy auth config once. Use that to build the master config.
-    const fetchProxyAuthConfig = async () => {
-      try {
-        let proxyAuthConfig;
-        if (config.authProxyConfigId) {
-          // Only fetch the proxy auth config if we have an authProxyId. This is a way for devs to explicitly disable the proxy auth.
-          proxyAuthConfig = await core.getAuthProxyConfig(config.authProxyConfigId, config.authProxyUrl);
-          proxyAuthConfigRef.current = proxyAuthConfig;
-        }
-        setMasterConfig(buildConfig(proxyAuthConfig));
-      } catch {
-        setClientState(base.ClientState.Error);
-      }
-    };
-    fetchProxyAuthConfig();
-  }, []);
-  react.useEffect(() => {
-    // Start the client initialization process once we have the master config.
-    if (!masterConfig) return;
-    initializeClient();
-  }, [masterConfig]);
-  react.useEffect(() => {
-    // Handle changes to the passed in config prop -- update the master config
-    // If the proxyAuthConfigRef is already set, we don't need to fetch it again. Rebuild the master config with the updated config and stored proxyAuthConfig
-    if (!proxyAuthConfigRef.current && config.authProxyConfigId) return;
-    setMasterConfig(buildConfig(proxyAuthConfigRef.current ?? undefined));
-  }, [config, proxyAuthConfigRef.current]);
-  /**
-   * @internal
-   * we use debouncedFetchWallets() to prevent multiple rapid wallet events
-   * like accountsChanged and disconnect from triggering fetchWallets repeatedly
-   * it must be defined outside the useEffect so all event listeners share the same
-   * debounced function instance - otherwise, a new one would be created on every render
-   */
-  const debouncedFetchWallets = utils.useDebouncedCallback(fetchWallets, 100);
-  react.useEffect(() => {
-    if (!client) return;
-    let cleanup = () => {};
-    initializeProviders(getWalletProviders, debouncedFetchWallets).then(fn => {
-      cleanup = fn;
-    }).catch(err => {
-      console.error("Failed to init providers:", err);
-    });
-    return () => {
-      cleanup();
-    };
-  }, [client, debouncedFetchWallets]);
-  react.useEffect(() => {
-    // authState must be consistent with session state. We found during testing that there are cases where the session and authState can be out of sync in very rare edge cases.
-    // This will ensure that they are always in sync and remove the need to setAuthState manually in other places.
-    if (session && 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();
-      initializeSessions().finally(() => {
-        // Set the client state to ready only after all initializations are done.
-        setClientState(base.ClientState.Ready);
-      });
-    });
-    return () => {
-      clearSessionTimeouts();
-    };
-  }, [client]);
   const completeRedirectOauth = async () => {
     // Check for either hash or search parameters that could indicate an OAuth redirect
     if (window.location.hash || window.location.search) {
@@ -161,6 +93,7 @@ const ClientProvider = ({
           const flow = stateParams.get("flow");
           const publicKey = stateParams.get("publicKey");
           const openModal = stateParams.get("openModal");
+          const sessionKey = stateParams.get("sessionKey");
           if (provider === "facebook" && flow === "redirect" && publicKey) {
             // We have all the required parameters for a Facebook PKCE flow
             const clientId = masterConfig?.auth?.oauthConfig?.facebookClientId;
@@ -185,8 +118,13 @@ const ClientProvider = ({
                             await completeOauth({
                               oidcToken,
                               publicKey,
-                              providerName: "facebook"
+                              providerName: "facebook",
+                              ...(sessionKey && {
+                                sessionKey
+                              })
                             });
+                            // Clean up the URL after processing
+                            window.history.replaceState(null, document.title, window.location.pathname);
                             resolve();
                           } catch (err) {
                             reject(err);
@@ -209,6 +147,114 @@ const ClientProvider = ({
               });
             }
           }
+          if (provider === "discord" && flow === "redirect" && publicKey) {
+            const clientId = masterConfig?.auth?.oauthConfig?.discordClientId;
+            const redirectURI = masterConfig?.auth?.oauthConfig?.oauthRedirectUri;
+            const verifier = sessionStorage.getItem("discord_verifier");
+            const nonce = stateParams.get("nonce");
+            const sessionKey = stateParams.get("sessionKey");
+            if (clientId && redirectURI && verifier && nonce) {
+              await new Promise((resolve, reject) => {
+                pushPage({
+                  key: `Discord OAuth`,
+                  content: jsxRuntime.jsx(Action.ActionPage, {
+                    title: `Authenticating with Discord...`,
+                    action: async () => {
+                      try {
+                        const resp = await client?.httpClient.proxyOAuth2Authenticate({
+                          provider: "OAUTH2_PROVIDER_DISCORD",
+                          authCode: code,
+                          redirectUri: redirectURI,
+                          codeVerifier: verifier,
+                          nonce: nonce
+                        });
+                        sessionStorage.removeItem("discord_verifier");
+                        const oidcToken = resp?.oidcToken;
+                        if (!oidcToken) {
+                          throw new sdkTypes.TurnkeyError("Missing OIDC token", sdkTypes.TurnkeyErrorCodes.OAUTH_LOGIN_ERROR);
+                        }
+                        await completeOauth({
+                          oidcToken,
+                          publicKey,
+                          providerName: "discord",
+                          ...(sessionKey && {
+                            sessionKey
+                          })
+                        });
+                        // Clean up the URL after processing
+                        window.history.replaceState(null, document.title, window.location.pathname);
+                        resolve(null);
+                      } catch (err) {
+                        reject(err);
+                        if (callbacks?.onError) {
+                          callbacks.onError(err instanceof sdkTypes.TurnkeyError ? err : new sdkTypes.TurnkeyError("Discord authentication failed", sdkTypes.TurnkeyErrorCodes.OAUTH_SIGNUP_ERROR, err));
+                        }
+                      }
+                    },
+                    icon: jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, {
+                      size: "3x",
+                      icon: freeBrandsSvgIcons.faDiscord
+                    })
+                  }),
+                  showTitle: false
+                });
+              });
+            }
+          }
+          if (provider === "twitter" && flow === "redirect" && publicKey) {
+            const clientId = masterConfig?.auth?.oauthConfig?.xClientId;
+            const redirectURI = masterConfig?.auth?.oauthConfig?.oauthRedirectUri;
+            const verifier = sessionStorage.getItem("twitter_verifier");
+            const nonce = stateParams.get("nonce");
+            const sessionKey = stateParams.get("sessionKey");
+            if (clientId && redirectURI && verifier && nonce) {
+              await new Promise((resolve, reject) => {
+                pushPage({
+                  key: `Twitter OAuth`,
+                  content: jsxRuntime.jsx(Action.ActionPage, {
+                    title: `Authenticating with Twitter...`,
+                    action: async () => {
+                      try {
+                        const resp = await client?.httpClient.proxyOAuth2Authenticate({
+                          provider: "OAUTH2_PROVIDER_X",
+                          authCode: code,
+                          redirectUri: redirectURI,
+                          codeVerifier: verifier,
+                          nonce: nonce
+                        });
+                        sessionStorage.removeItem("twitter_verifier");
+                        const oidcToken = resp?.oidcToken;
+                        if (!oidcToken) {
+                          throw new sdkTypes.TurnkeyError("Missing OIDC token", sdkTypes.TurnkeyErrorCodes.OAUTH_LOGIN_ERROR);
+                        }
+                        await completeOauth({
+                          oidcToken,
+                          publicKey,
+                          providerName: "twitter",
+                          ...(sessionKey && {
+                            sessionKey
+                          })
+                        });
+                        // Clean up the URL after processing
+                        window.history.replaceState(null, document.title, window.location.pathname);
+                        resolve(null);
+                      } catch (err) {
+                        reject(err);
+                        if (callbacks?.onError) {
+                          callbacks.onError(err instanceof sdkTypes.TurnkeyError ? err : new sdkTypes.TurnkeyError("Twitter authentication failed", sdkTypes.TurnkeyErrorCodes.OAUTH_SIGNUP_ERROR, err));
+                        }
+                      }
+                    },
+                    icon: jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, {
+                      size: "3x",
+                      icon: freeBrandsSvgIcons.faXTwitter
+                    })
+                  }),
+                  showTitle: false
+                });
+              });
+            }
+          }
         }
       }
       // Handle Google/Apple redirects (uses hash with id_token)
@@ -220,7 +266,8 @@ const ClientProvider = ({
           provider,
           flow,
           publicKey,
-          openModal
+          openModal,
+          sessionKey
         } = utils.parseOAuthRedirect(hash);
         if (idToken && flow === "redirect" && publicKey) {
           if (openModal === "true") {
@@ -252,7 +299,10 @@ const ClientProvider = ({
                         publicKey,
                         ...(provider ? {
                           providerName: provider
-                        } : {})
+                        } : {}),
+                        ...(sessionKey && {
+                          sessionKey
+                        })
                       });
                       resolve(null);
                     } catch (err) {
@@ -292,11 +342,13 @@ const ClientProvider = ({
       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")
     };
     // Set a default ordering for the oAuth methods
-    const oauthOrder = config.auth?.oauthOrder ?? ["google", "apple", "facebook"].filter(provider => resolvedMethods[`${provider}OauthEnabled`]);
+    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);
     return {
@@ -438,14 +490,86 @@ const ClientProvider = ({
   };
   /**
    * @internal
-   * Schedules a session expiration and warning timeout for the given session key.
+   * Attach listeners for connected wallet providers so we can refresh state on changes.
+   *
+   * - Ethereum: listens for disconnect and chain switches to trigger a refresh.
+   * - Solana: listens for disconnect via Wallet Standard `change` events to trigger a refresh.
+   * - WalletConnect: listens for disconnect via our custom wrapper’s `change` event to trigger a refresh.
    *
-   * - This function sets up two timeouts: one for warning before the session expires and another to expire the session.
-   * - The warning timeout is set to trigger before the session expires, allowing for actions like refreshing the session.
-   * - The expiration timeout clears the session and triggers any necessary callbacks.
+   * Notes:
+   * - Only providers that are connected are bound.
+   * - WalletConnect is excluded from the “native” paths and handled via its unified `change` event.
+   *
+   * @param walletProviders - Discovered providers; only connected ones are bound.
+   * @param onWalletsChanged - Invoked when a relevant provider event occurs.
+   * @returns Cleanup function that removes all listeners registered by this call.
+   */
+  async function initializeWalletProviderListeners(walletProviders, onWalletsChanged) {
+    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) : [];
+    // we exclude WalletConnect from the native event wiring
+    // this is because WC is handled separately with a custom wrapper’s
+    //  `change` event
+    const wcProviders = walletProviders.filter(p => p.interfaceType === core.WalletInterfaceType.WalletConnect && p.connectedAddresses.length > 0);
+    function attachEthereumListeners(provider, onWalletsChanged) {
+      if (typeof provider.on !== "function") return;
+      const handleChainChanged = _chainId => onWalletsChanged();
+      const handleAccountsChanged = accounts => {
+        if (accounts.length === 0) onWalletsChanged();
+      };
+      const handleDisconnect = () => onWalletsChanged();
+      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, onWalletsChanged) {
+      const cleanups = [];
+      const walletEvents = provider?.features?.["standard:events"];
+      if (walletEvents?.on) {
+        const offChange = walletEvents.on("change", _evt => {
+          onWalletsChanged();
+        });
+        cleanups.push(offChange);
+      }
+      return () => cleanups.forEach(fn => fn());
+    }
+    ethProviders.forEach(p => {
+      const cleanup = attachEthereumListeners(p.provider, onWalletsChanged);
+      if (cleanup) cleanups.push(cleanup);
+    });
+    solProviders.forEach(p => {
+      const cleanup = attachSolanaListeners(p.provider, onWalletsChanged);
+      if (cleanup) cleanups.push(cleanup);
+    });
+    wcProviders.forEach(p => {
+      const standardEvents = p.provider?.features?.["standard:events"];
+      if (standardEvents?.on) {
+        const unsubscribe = standardEvents.on("change", onWalletsChanged);
+        cleanups.push(unsubscribe);
+      }
+    });
+    return () => {
+      cleanups.forEach(remove => remove());
+    };
+  }
+  /**
+   * @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 for the session.
+   * @param params.expiry - The expiration time in seconds since epoch.
    * @throws {TurnkeyError} If an error occurs while scheduling the session expiration.
    */
   async function scheduleSessionExpiration(params) {
@@ -454,21 +578,18 @@ const ClientProvider = ({
       expiry
     } = params;
     try {
-      // Clear any existing timeout for this session key
-      if (expiryTimeoutsRef.current[sessionKey]) {
-        clearTimeout(expiryTimeoutsRef.current[sessionKey]);
-        delete expiryTimeoutsRef.current[sessionKey];
-      }
-      if (expiryTimeoutsRef.current[`${sessionKey}-warning`]) {
-        clearTimeout(expiryTimeoutsRef.current[`${sessionKey}-warning`]);
-        delete expiryTimeoutsRef.current[`${sessionKey}-warning`];
-      }
-      const timeUntilExpiry = expiry * 1000 - Date.now();
+      const warnKey = `${sessionKey}-warning`;
+      // Replace any prior timers for this session
+      timers.clearKey(expiryTimeoutsRef.current, sessionKey);
+      timers.clearKey(expiryTimeoutsRef.current, warnKey);
+      const now = Date.now();
+      const expiryMs = expiry * 1000;
+      const timeUntilExpiry = expiryMs - now;
       const beforeExpiry = async () => {
         const activeSession = await getSession();
-        if (!activeSession && expiryTimeoutsRef.current[sessionKey]) {
-          clearTimeout(expiryTimeoutsRef.current[`${sessionKey}-warning`]);
-          expiryTimeoutsRef.current[`${sessionKey}-warning`] = setTimeout(beforeExpiry, 10000);
+        if (!activeSession && expiryTimeoutsRef.current[warnKey]) {
+          // Keep nudging until session materializes (short 10s timer is fine)
+          timers.setTimeoutInMap(expiryTimeoutsRef.current, warnKey, beforeExpiry, 10_000);
           return;
         }
         const session = await getSession({
@@ -496,27 +617,36 @@ const ClientProvider = ({
         if ((await getActiveSessionKey()) === sessionKey) {
           setSession(undefined);
         }
-        setAllSessions(prevSessions => {
-          if (!prevSessions) return prevSessions;
-          const newSessions = {
-            ...prevSessions
+        setAllSessions(prev => {
+          if (!prev) return prev;
+          const next = {
+            ...prev
           };
-          delete newSessions[sessionKey];
-          return newSessions;
+          delete next[sessionKey];
+          return next;
         });
         await clearSession({
           sessionKey
         });
-        delete expiryTimeoutsRef.current[sessionKey];
-        delete expiryTimeoutsRef.current[`${sessionKey}-warning`];
+        // Remove timers for this session
+        timers.clearKey(expiryTimeoutsRef.current, sessionKey);
+        timers.clearKey(expiryTimeoutsRef.current, warnKey);
         await logout();
       };
-      if (timeUntilExpiry <= utils.SESSION_WARNING_THRESHOLD_MS) {
-        beforeExpiry();
+      // Already expired → expire immediately
+      if (timeUntilExpiry <= 0) {
+        await expireSession();
+        return;
+      }
+      // Warning timer (if threshold is in the future)
+      const warnAt = expiryMs - utils.SESSION_WARNING_THRESHOLD_MS;
+      if (warnAt <= now) {
+        void beforeExpiry(); // fire-and-forget is fine
       } else {
-        expiryTimeoutsRef.current[`${sessionKey}-warning`] = setTimeout(beforeExpiry, timeUntilExpiry - utils.SESSION_WARNING_THRESHOLD_MS);
+        timers.setCappedTimeoutInMap(expiryTimeoutsRef.current, warnKey, beforeExpiry, warnAt - now);
       }
-      expiryTimeoutsRef.current[sessionKey] = setTimeout(expireSession, timeUntilExpiry);
+      // Actual expiry timer (safe for long delays)
+      timers.setCappedTimeoutInMap(expiryTimeoutsRef.current, sessionKey, expireSession, timeUntilExpiry);
     } catch (error) {
       if (error instanceof sdkTypes.TurnkeyError || error instanceof sdkTypes.TurnkeyNetworkError) {
         callbacks?.onError?.(error);
@@ -526,25 +656,25 @@ const ClientProvider = ({
     }
   }
   /**
-   * Clears all scheduled session expiration and warning timeouts for the client.
+   * Clears all scheduled session timers (warning + expiry).
    *
-   * - This function removes all active session expiration and warning timeouts managed by the provider.
-   * - It is called automatically when sessions are re-initialized or on logout to prevent memory leaks and ensure no stale timeouts remain.
-   * - All timeouts stored in `expiryTimeoutsRef` are cleared and the reference is reset.
+   * - Removes all active timers managed by this client.
+   * - Useful on re-init or logout to avoid stale timers.
    *
-   * @throws {TurnkeyError} If an error occurs while clearing the timeouts.
+   * @throws {TurnkeyError} If an error occurs while clearing the timers.
    */
-  function clearSessionTimeouts() {
+  function clearSessionTimeouts(sessionKeys) {
     try {
-      Object.values(expiryTimeoutsRef.current).forEach(timeout => {
-        clearTimeout(timeout);
-      });
-      expiryTimeoutsRef.current = {};
+      if (sessionKeys) {
+        timers.clearKeys(expiryTimeoutsRef.current, sessionKeys);
+      } else {
+        timers.clearAll(expiryTimeoutsRef.current); // clears & deletes everything
+      }
     } catch (error) {
       if (error instanceof sdkTypes.TurnkeyError || error instanceof sdkTypes.TurnkeyNetworkError) {
         callbacks?.onError?.(error);
       } else {
-        callbacks?.onError?.(new sdkTypes.TurnkeyError(`Failed to clear session timeouts`, sdkTypes.TurnkeyErrorCodes.CLEAR_SESSION_TIMEOUTS_ERROR, error));
+        callbacks?.onError?.(new sdkTypes.TurnkeyError("Failed to clear session timeouts", sdkTypes.TurnkeyErrorCodes.CLEAR_SESSION_TIMEOUTS_ERROR, error));
       }
     }
   }
@@ -560,7 +690,12 @@ const ClientProvider = ({
    * @returns A void promise.
    * @throws {TurnkeyError} If the client is not initialized or if there is an error during the process.
    */
-  const handlePostAuth = async () => {
+  const handlePostAuth = async params => {
+    const {
+      method,
+      action,
+      identifier
+    } = params;
     try {
       const sessionKey = await getActiveSessionKey();
       const session = await getSession({
@@ -577,6 +712,12 @@ const ClientProvider = ({
       setAllSessions(allSessions);
       await refreshWallets();
       await refreshUser();
+      callbacks?.onAuthenticationSuccess?.({
+        session,
+        method,
+        action,
+        identifier
+      });
     } catch (error) {
       if (error instanceof sdkTypes.TurnkeyError || error instanceof sdkTypes.TurnkeyNetworkError) {
         callbacks?.onError?.(error);
@@ -590,42 +731,58 @@ const ClientProvider = ({
    * Handles the post-logout flow.
    *
    * - This function is called after a successful logout or session clear.
-   * - It clears all scheduled session expiration and warning timeouts to prevent memory leaks.
-   * - It resets the session state, removes all session and user data from memory, and clears the wallets list.
+   * - 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 {TurnkeyError} If there is an error during the post-logout process.
    */
-  const handlePostLogout = () => {
+  const handlePostLogout = sessionKey => {
     try {
-      clearSessionTimeouts();
+      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);
-      setAllSessions(undefined);
       setUser(undefined);
       setWallets([]);
     } catch (error) {
       callbacks?.onError?.(new sdkTypes.TurnkeyError(`Failed to initialize sessions`, sdkTypes.TurnkeyErrorCodes.HANDLE_POST_LOGOUT_ERROR, error));
     }
   };
-  async function createPasskey(params) {
+  const createPasskey = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
     return utils.withTurnkeyErrorHandling(() => client.createPasskey({
       ...params
     }), callbacks, "Failed to create passkey");
-  }
-  async function logout(params) {
+  }, [client, callbacks]);
+  const logout = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
-    utils.withTurnkeyErrorHandling(() => client.logout(params), callbacks, "Failed to logout");
-    handlePostLogout();
+    await utils.withTurnkeyErrorHandling(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);
+    }, callbacks, "Failed to logout");
     return;
-  }
-  async function loginWithPasskey(params) {
+  }, [client, callbacks]);
+  const loginWithPasskey = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
@@ -635,11 +792,15 @@ const ClientProvider = ({
       expirationSeconds
     }), callbacks, "Failed to login with passkey");
     if (res) {
-      await handlePostAuth();
+      await handlePostAuth({
+        method: base.AuthMethod.Passkey,
+        action: sdkTypes.AuthAction.LOGIN,
+        identifier: res.credentialId
+      });
     }
     return res;
-  }
-  async function signUpWithPasskey(params) {
+  }, [client, callbacks]);
+  const signUpWithPasskey = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
@@ -670,95 +831,61 @@ const ClientProvider = ({
       expirationSeconds
     }), callbacks, "Failed to sign up with passkey");
     if (res) {
-      await handlePostAuth();
+      await handlePostAuth({
+        method: base.AuthMethod.Passkey,
+        action: sdkTypes.AuthAction.SIGNUP,
+        identifier: res.credentialId
+      });
     }
     return res;
-  }
-  async function getWalletProviders(chain) {
+  }, [client, callbacks]);
+  const getWalletProviders = react.useCallback(async chain => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
-    return await client.getWalletProviders(chain);
-  }
-  async function connectWalletAccount(walletProvider) {
+    const newProviders = await client.getWalletProviders(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;
+  }, [client, callbacks]);
+  const connectWalletAccount = react.useCallback(async walletProvider => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
     await client.connectWalletAccount(walletProvider);
+    // this will update our walletProvider state
     await refreshWallets();
-  }
-  async function disconnectWalletAccount(walletProvider) {
+  }, [client, callbacks]);
+  const disconnectWalletAccount = react.useCallback(async walletProvider => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
     await client.disconnectWalletAccount(walletProvider);
-    // we only refresh the wallets if there is an active session
-    // this is needed because for WalletConnect you can unlink a wallet before
-    // actually being logged in
-    if (session) {
+    // we only refresh the wallets if:
+    // 1. there is an active session. This is needed because for WalletConnect
+    //    you can disconnect a wallet before actually being logged in
+    //
+    // 2. it was a WalletConnect provider that we just disconnected. Since
+    //    native providers emit a disconnect event which will already refresh
+    //    the wallets. This event is triggered in `initializeWalletProviderListeners()`
+    if (session && walletProvider.interfaceType === core.WalletInterfaceType.WalletConnect) {
+      // this will update our walletProvider state
       await refreshWallets();
     }
-  }
-  async function switchWalletProviderChain(walletProvider, chainOrId) {
+  }, [client, callbacks]);
+  const switchWalletAccountChain = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
-    await client.switchWalletProviderChain(walletProvider, chainOrId);
-  }
-  // TODO: MOE PLEASE COMMENT THESE
-  async function initializeProviders(getWalletProviders, onWalletsChanged) {
-    const cleanups = [];
-    // we only want to initialize these listeners for native wallet providers
-    // and not WalletConnect
-    const nativeOnly = p => p.interfaceType !== core.WalletInterfaceType.WalletConnect;
-    const ethProviders = masterConfig?.walletConfig?.chains.ethereum?.native ? (await getWalletProviders(core.Chain.Ethereum)).filter(nativeOnly) : [];
-    const solProviders = masterConfig?.walletConfig?.chains.solana?.native ? (await getWalletProviders(core.Chain.Solana)).filter(nativeOnly) : [];
-    function attachEthereumListeners(provider, onWalletsChanged) {
-      if (typeof provider.on !== "function") return;
-      const handleAccountsChanged = accounts => {
-        if (accounts.length === 0) onWalletsChanged();
-      };
-      const handleDisconnect = () => onWalletsChanged();
-      provider.on("accountsChanged", handleAccountsChanged);
-      provider.on("disconnect", handleDisconnect);
-      return () => {
-        provider.removeListener("accountsChanged", handleAccountsChanged);
-        provider.removeListener("disconnect", handleDisconnect);
-      };
-    }
-    function attachSolanaListeners(provider, onWalletsChanged) {
-      const cleanups = [];
-      const walletEvents = provider.features?.["standard:events"];
-      if (walletEvents?.on) {
-        const handleChange = event => {
-          if (event.type === "change" || event.type === "accountsChanged") {
-            onWalletsChanged();
-          }
-        };
-        walletEvents.on("change", handleChange);
-        walletEvents.on("accountsChanged", handleChange);
-        cleanups.push(() => {
-          walletEvents.off?.("change", handleChange);
-          walletEvents.off?.("accountsChanged", handleChange);
-        });
-      }
-      return cleanups.length > 0 ? () => {
-        cleanups.forEach(fn => fn());
-      } : () => {};
-    }
-    ethProviders.forEach(p => {
-      const cleanup = attachEthereumListeners(p.provider, onWalletsChanged);
-      if (cleanup) cleanups.push(cleanup);
-    });
-    solProviders.forEach(p => {
-      const cleanup = attachSolanaListeners(p.provider, onWalletsChanged);
-      if (cleanup) cleanups.push(cleanup);
+    await client.switchWalletAccountChain({
+      ...params,
+      walletProviders
     });
-    return () => {
-      cleanups.forEach(remove => remove());
-    };
-  }
-  async function loginWithWallet(params) {
+  }, [client, callbacks]);
+  const loginWithWallet = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
@@ -768,11 +895,15 @@ const ClientProvider = ({
       expirationSeconds
     }), callbacks, "Failed to login with wallet");
     if (res) {
-      await handlePostAuth();
+      await handlePostAuth({
+        method: base.AuthMethod.Wallet,
+        action: sdkTypes.AuthAction.LOGIN,
+        identifier: res.address
+      });
     }
     return res;
-  }
-  async function signUpWithWallet(params) {
+  }, [client, callbacks]);
+  const signUpWithWallet = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
@@ -793,11 +924,15 @@ const ClientProvider = ({
       expirationSeconds
     }), callbacks, "Failed to sign up with wallet");
     if (res) {
-      await handlePostAuth();
+      await handlePostAuth({
+        method: base.AuthMethod.Wallet,
+        action: sdkTypes.AuthAction.SIGNUP,
+        identifier: res.address
+      });
     }
     return res;
-  }
-  async function loginOrSignupWithWallet(params) {
+  }, [client, callbacks, masterConfig]);
+  const loginOrSignupWithWallet = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
@@ -818,33 +953,41 @@ const ClientProvider = ({
       expirationSeconds
     }), callbacks, "Failed to login or sign up with wallet");
     if (res) {
-      await handlePostAuth();
+      await handlePostAuth({
+        method: base.AuthMethod.Wallet,
+        action: res.action,
+        identifier: res.address
+      });
     }
     return res;
-  }
-  async function initOtp(params) {
+  }, [client, callbacks, masterConfig]);
+  const initOtp = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
     return utils.withTurnkeyErrorHandling(() => client.initOtp(params), callbacks, "Failed to initialize OTP");
-  }
-  async function verifyOtp(params) {
+  }, [client, callbacks]);
+  const verifyOtp = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
     return utils.withTurnkeyErrorHandling(() => client.verifyOtp(params), callbacks, "Failed to verify OTP");
-  }
-  async function loginWithOtp(params) {
+  }, [client, callbacks]);
+  const loginWithOtp = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
     const res = await utils.withTurnkeyErrorHandling(() => client.loginWithOtp(params), callbacks, "Failed to login with OTP");
     if (res) {
-      await handlePostAuth();
+      await handlePostAuth({
+        method: base.AuthMethod.Otp,
+        action: sdkTypes.AuthAction.LOGIN,
+        identifier: params.verificationToken
+      });
     }
     return res;
-  }
-  async function signUpWithOtp(params) {
+  }, [client, callbacks]);
+  const signUpWithOtp = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
@@ -868,11 +1011,15 @@ const ClientProvider = ({
     };
     const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithOtp(params), callbacks, "Failed to sign up with OTP");
     if (res) {
-      await handlePostAuth();
+      await handlePostAuth({
+        method: base.AuthMethod.Otp,
+        action: sdkTypes.AuthAction.SIGNUP,
+        identifier: params.verificationToken
+      });
     }
     return res;
-  }
-  async function completeOtp(params) {
+  }, [client, callbacks, masterConfig]);
+  const completeOtp = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
@@ -896,11 +1043,29 @@ const ClientProvider = ({
     };
     const res = await utils.withTurnkeyErrorHandling(() => client.completeOtp(params), callbacks, "Failed to complete OTP");
     if (res) {
-      await handlePostAuth();
+      await handlePostAuth({
+        method: base.AuthMethod.Otp,
+        action: res.action,
+        identifier: res.verificationToken
+      });
     }
     return res;
-  }
-  async function completeOauth(params) {
+  }, [client, callbacks, masterConfig]);
+  const loginWithOauth = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const res = await utils.withTurnkeyErrorHandling(() => client.loginWithOauth(params), callbacks, "Failed to login with OAuth");
+    if (res) {
+      await handlePostAuth({
+        method: base.AuthMethod.Oauth,
+        action: sdkTypes.AuthAction.LOGIN,
+        identifier: params.oidcToken
+      });
+    }
+    return res;
+  }, [client, callbacks]);
+  const signUpWithOauth = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
@@ -908,30 +1073,24 @@ const ClientProvider = ({
       throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
     }
     // If createSubOrgParams is not provided, use the default from masterConfig
-    const createSubOrgParams = params.createSubOrgParams ?? masterConfig.auth?.createSuborgParams?.oauth;
+    let createSubOrgParams = params.createSubOrgParams ?? masterConfig.auth?.createSuborgParams?.oauth;
     params = createSubOrgParams !== undefined ? {
       ...params,
       createSubOrgParams
     } : {
       ...params
     };
-    const res = await utils.withTurnkeyErrorHandling(() => client.completeOauth(params), callbacks, "Failed to complete OAuth");
+    const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithOauth(params), callbacks, "Failed to sign up with OAuth");
     if (res) {
-      await handlePostAuth();
+      await handlePostAuth({
+        method: base.AuthMethod.Oauth,
+        action: sdkTypes.AuthAction.SIGNUP,
+        identifier: params.oidcToken
+      });
     }
     return res;
-  }
-  async function loginWithOauth(params) {
-    if (!client) {
-      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    }
-    const res = await utils.withTurnkeyErrorHandling(() => client.loginWithOauth(params), callbacks, "Failed to login with OAuth");
-    if (res) {
-      await handlePostAuth();
-    }
-    return res;
-  }
-  async function signUpWithOauth(params) {
+  }, [client, callbacks, masterConfig]);
+  const completeOauth = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
@@ -939,43 +1098,53 @@ const ClientProvider = ({
       throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
     }
     // If createSubOrgParams is not provided, use the default from masterConfig
-    let createSubOrgParams = params.createSubOrgParams ?? masterConfig.auth?.createSuborgParams?.oauth;
+    const createSubOrgParams = params.createSubOrgParams ?? masterConfig.auth?.createSuborgParams?.oauth;
     params = createSubOrgParams !== undefined ? {
       ...params,
       createSubOrgParams
     } : {
       ...params
     };
-    const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithOauth(params), callbacks, "Failed to sign up with OAuth");
+    const res = await utils.withTurnkeyErrorHandling(() => client.completeOauth(params), callbacks, "Failed to complete OAuth");
     if (res) {
-      await handlePostAuth();
+      await handlePostAuth({
+        method: base.AuthMethod.Oauth,
+        action: res.action,
+        identifier: params.oidcToken
+      });
     }
     return res;
-  }
-  async function fetchWallets(params) {
+  }, [client, callbacks, masterConfig]);
+  const fetchWallets = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
     return utils.withTurnkeyErrorHandling(() => client.fetchWallets(params), callbacks, "Failed to fetch wallets");
-  }
-  async function fetchWalletAccounts(params) {
+  }, [client, callbacks]);
+  const fetchWalletAccounts = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
     return utils.withTurnkeyErrorHandling(() => client.fetchWalletAccounts(params), callbacks, "Failed to fetch wallet accounts");
-  }
-  async function signMessage(params) {
+  }, [client, callbacks]);
+  const fetchPrivateKeys = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withTurnkeyErrorHandling(() => client.fetchPrivateKeys(params), callbacks, "Failed to fetch private keys");
+  }, [client, callbacks]);
+  const signMessage = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.signMessage(params), callbacks, "Failed to sign message");
-  }
-  async function handleSignMessage(params) {
+  }, [client, callbacks]);
+  const handleSignMessage = react.useCallback(async params => {
     const {
       successPageDuration = 2000
     } = params;
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return new Promise((resolve, reject) => {
       pushPage({
-        key: "Sign Message",
+        key: "Sign message",
         content: jsxRuntime.jsx(Message.SignMessageModal, {
           message: params.message,
           subText: params?.subText,
@@ -1000,146 +1169,146 @@ const ClientProvider = ({
         })
       });
     });
-  }
-  async function signTransaction(params) {
+  }, [client, callbacks]);
+  const signTransaction = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.signTransaction(params), callbacks, "Failed to sign transaction");
-  }
-  async function signAndSendTransaction(params) {
+  }, [client, callbacks]);
+  const signAndSendTransaction = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.signAndSendTransaction(params), callbacks, "Failed to sign transaction");
-  }
-  async function fetchUser(params) {
+  }, [client, callbacks]);
+  const fetchUser = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.fetchUser(params), callbacks, "Failed to fetch user");
-  }
-  async function updateUserEmail(params) {
+  }, [client, callbacks]);
+  const updateUserEmail = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.updateUserEmail(params), callbacks, "Failed to update user email");
     if (res) await refreshUser({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function removeUserEmail(params) {
+  }, [client, callbacks]);
+  const removeUserEmail = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.removeUserEmail(params), callbacks, "Failed to remove user email");
     if (res) await refreshUser({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function updateUserPhoneNumber(params) {
+  }, [client, callbacks]);
+  const updateUserPhoneNumber = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.updateUserPhoneNumber(params), callbacks, "Failed to update user phone number");
     if (res) await refreshUser({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function removeUserPhoneNumber(params) {
+  }, [client, callbacks]);
+  const removeUserPhoneNumber = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.removeUserPhoneNumber(params), callbacks, "Failed to remove user phone number");
     if (res) await refreshUser({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function updateUserName(params) {
+  }, [client, callbacks]);
+  const updateUserName = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.updateUserName(params), callbacks, "Failed to update user name");
     if (res) await refreshUser({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function addOauthProvider(params) {
+  }, [client, callbacks]);
+  const addOauthProvider = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.addOauthProvider(params), callbacks, "Failed to add OAuth provider");
     if (res) await refreshUser({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function removeOauthProviders(params) {
+  }, [client, callbacks]);
+  const removeOauthProviders = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.removeOauthProviders(params), callbacks, "Failed to remove OAuth providers");
     if (res) await refreshUser({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function addPasskey(params) {
+  }, [client, callbacks]);
+  const addPasskey = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.addPasskey(params), callbacks, "Failed to add passkey");
     if (res) await refreshUser({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function removePasskeys(params) {
+  }, [client, callbacks]);
+  const removePasskeys = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.removePasskeys(params), callbacks, "Failed to remove passkeys");
     if (res) await refreshUser({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function createWallet(params) {
+  }, [client, callbacks]);
+  const createWallet = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.createWallet(params), callbacks, "Failed to create wallet");
     if (res) await refreshWallets({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function createWalletAccounts(params) {
+  }, [client, callbacks]);
+  const createWalletAccounts = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.createWalletAccounts(params), callbacks, "Failed to create wallet accounts");
     if (res) await refreshWallets({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function exportWallet(params) {
+  }, [client, callbacks]);
+  const exportWallet = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.exportWallet(params), callbacks, "Failed to export wallet");
     if (res) await refreshWallets({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function exportPrivateKey(params) {
+  }, [client, callbacks]);
+  const exportPrivateKey = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.exportPrivateKey(params), callbacks, "Failed to export private key");
     return res;
-  }
-  async function exportWalletAccount(params) {
+  }, [client, callbacks]);
+  const exportWalletAccount = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.exportWalletAccount(params), callbacks, "Failed to export wallet accounts");
     if (res) await refreshWallets({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function importWallet(params) {
+  }, [client, callbacks]);
+  const importWallet = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.importWallet(params), callbacks, "Failed to import wallet");
     if (res) await refreshWallets({
       stampWith: params?.stampWith
     });
     return res;
-  }
-  async function importPrivateKey(params) {
+  }, [client, callbacks]);
+  const importPrivateKey = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const res = await utils.withTurnkeyErrorHandling(() => client.importPrivateKey(params), callbacks, "Failed to import private key");
     return res;
-  }
-  async function deleteSubOrganization(params) {
+  }, [client, callbacks]);
+  const deleteSubOrganization = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.deleteSubOrganization(params), callbacks, "Failed to delete sub-organization");
-  }
-  async function storeSession(params) {
+  }, [client, callbacks]);
+  const storeSession = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     await utils.withTurnkeyErrorHandling(() => client.storeSession(params), callbacks, "Failed to store session");
     const sessionKey = await getActiveSessionKey();
@@ -1156,8 +1325,8 @@ const ClientProvider = ({
     setSession(session);
     setAllSessions(allSessions);
     return;
-  }
-  async function clearSession(params) {
+  }, [client, callbacks]);
+  const clearSession = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     await utils.withTurnkeyErrorHandling(() => client.clearSession(params), callbacks, "Failed to clear session");
     const session = await getSession();
@@ -1165,14 +1334,14 @@ const ClientProvider = ({
     setSession(session);
     setAllSessions(allSessions);
     return;
-  }
-  async function clearAllSessions() {
+  }, [client, callbacks]);
+  const clearAllSessions = react.useCallback(async () => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     setSession(undefined);
     setAllSessions(undefined);
     return await utils.withTurnkeyErrorHandling(() => client.clearAllSessions(), callbacks, "Failed to clear all sessions");
-  }
-  async function refreshSession(params) {
+  }, [client, callbacks]);
+  const refreshSession = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
@@ -1200,16 +1369,16 @@ const ClientProvider = ({
     setSession(session);
     setAllSessions(allSessions);
     return res;
-  }
-  async function getSession(params) {
+  }, [client, callbacks]);
+  const getSession = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.getSession(params), callbacks, "Failed to get session");
-  }
-  async function getAllSessions() {
+  }, [client, callbacks]);
+  const getAllSessions = react.useCallback(async () => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.getAllSessions(), callbacks, "Failed to get all sessions");
-  }
-  async function setActiveSession(params) {
+  }, [client, callbacks]);
+  const setActiveSession = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const session = await utils.withTurnkeyErrorHandling(() => client.getSession({
       sessionKey: params.sessionKey
@@ -1219,25 +1388,29 @@ const ClientProvider = ({
     }
     await utils.withTurnkeyErrorHandling(() => client.setActiveSession(params), callbacks, "Failed to set active session");
     setSession(session);
+    await utils.withTurnkeyErrorHandling(async () => {
+      await refreshWallets();
+      await refreshUser();
+    }, callbacks, "Failed to refresh data after setting active session");
     return;
-  }
-  async function getActiveSessionKey() {
+  }, [client, callbacks]);
+  const getActiveSessionKey = react.useCallback(async () => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.getActiveSessionKey(), callbacks, "Failed to get active session key");
-  }
-  async function clearUnusedKeyPairs() {
+  }, [client, callbacks]);
+  const clearUnusedKeyPairs = react.useCallback(async () => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.clearUnusedKeyPairs(), callbacks, "Failed to clear unused key pairs");
-  }
-  async function createApiKeyPair(params) {
+  }, [client, callbacks]);
+  const createApiKeyPair = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.createApiKeyPair(params), callbacks, "Failed to create API key pair");
-  }
-  async function getProxyAuthConfig() {
+  }, [client, callbacks]);
+  const getProxyAuthConfig = react.useCallback(async () => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.getProxyAuthConfig(), callbacks, "Failed to get proxy auth config");
-  }
-  async function refreshUser(params) {
+  }, [client, callbacks]);
+  const refreshUser = react.useCallback(async params => {
     const {
       stampWith
     } = params || {};
@@ -1248,20 +1421,298 @@ const ClientProvider = ({
     if (user) {
       setUser(user);
     }
-  }
-  async function refreshWallets(params) {
+  }, [client, callbacks]);
+  const refreshWallets = react.useCallback(async params => {
+    const {
+      stampWith
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const walletProviders = await utils.withTurnkeyErrorHandling(() => getWalletProviders(), callbacks, "Failed to refresh wallets");
+    const wallets = await utils.withTurnkeyErrorHandling(() => fetchWallets({
+      stampWith,
+      walletProviders
+    }), callbacks, "Failed to refresh wallets");
+    if (wallets) {
+      setWallets(wallets);
+    }
+  }, [client, callbacks, getWalletProviders, fetchWallets]);
+  const handleDiscordOauth = react.useCallback(async params => {
+    const {
+      clientId = masterConfig?.auth?.oauthConfig?.discordClientId,
+      openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
+      additionalState: additionalParameters
+    } = params || {};
+    try {
+      if (!masterConfig) {
+        throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      if (!clientId) {
+        throw new sdkTypes.TurnkeyError("Discord Client ID is not configured.", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      if (!masterConfig.auth?.oauthConfig?.oauthRedirectUri) {
+        throw new sdkTypes.TurnkeyError("OAuth Redirect URI is not configured.", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      const flow = openInPage ? "redirect" : "popup";
+      const redirectURI = masterConfig.auth?.oauthConfig.oauthRedirectUri;
+      // Create key pair and generate nonce
+      const publicKey = await createApiKeyPair();
+      if (!publicKey) {
+        throw new Error("Failed to create public key for OAuth.");
+      }
+      const nonce = utils$1.bytesToHex(sha2.sha256(publicKey));
+      // Generate PKCE challenge pair
+      const {
+        verifier,
+        codeChallenge
+      } = await utils.generateChallengePair();
+      sessionStorage.setItem("discord_verifier", verifier);
+      // Construct Discord Auth URL
+      const discordAuthUrl = new URL(utils.DISCORD_AUTH_URL);
+      discordAuthUrl.searchParams.set("client_id", clientId);
+      discordAuthUrl.searchParams.set("redirect_uri", redirectURI);
+      discordAuthUrl.searchParams.set("response_type", "code");
+      discordAuthUrl.searchParams.set("code_challenge", codeChallenge);
+      discordAuthUrl.searchParams.set("code_challenge_method", "S256");
+      discordAuthUrl.searchParams.set("scope", "identify email");
+      discordAuthUrl.searchParams.set("state", `provider=discord&flow=${flow}&publicKey=${encodeURIComponent(publicKey)}&nonce=${nonce}`);
+      if (additionalParameters) {
+        const extra = Object.entries(additionalParameters).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+        if (extra) {
+          discordAuthUrl.searchParams.set("state", discordAuthUrl.searchParams.get("state") + `&${extra}`);
+        }
+      }
+      if (openInPage) {
+        window.location.href = discordAuthUrl.toString();
+        return new Promise((_, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error("Authentication timed out."));
+          }, 300000);
+          window.addEventListener("beforeunload", () => clearTimeout(timeout));
+        });
+      } else {
+        const width = utils.popupWidth;
+        const height = utils.popupHeight;
+        const left = window.screenX + (window.innerWidth - width) / 2;
+        const top = window.screenY + (window.innerHeight - height) / 2;
+        const authWindow = window.open("about:blank", "_blank", `width=${width},height=${height},top=${top},left=${left},scrollbars=yes,resizable=yes`);
+        if (!authWindow) {
+          throw new Error("Failed to open Discord login window.");
+        }
+        authWindow.location.href = discordAuthUrl.toString();
+        return new Promise((resolve, reject) => {
+          const interval = setInterval(() => {
+            try {
+              if (authWindow.closed) {
+                clearInterval(interval);
+                reject(new Error("Authentication window was closed."));
+                return;
+              }
+              const url = authWindow.location.href || "";
+              if (url.startsWith(window.location.origin)) {
+                const urlParams = new URLSearchParams(new URL(url).search);
+                const authCode = urlParams.get("code");
+                const stateParam = urlParams.get("state");
+                const sessionKey = stateParam?.split("&").find(param => param.startsWith("sessionKey="))?.split("=")[1];
+                if (authCode && stateParam && stateParam.includes("provider=discord")) {
+                  authWindow.close();
+                  clearInterval(interval);
+                  const verifier = sessionStorage.getItem("discord_verifier");
+                  if (!verifier) {
+                    reject(new Error("Missing PKCE verifier"));
+                    return;
+                  }
+                  client?.httpClient.proxyOAuth2Authenticate({
+                    provider: "OAUTH2_PROVIDER_DISCORD",
+                    authCode,
+                    redirectUri: redirectURI,
+                    codeVerifier: verifier,
+                    nonce: nonce
+                  }).then(resp => {
+                    sessionStorage.removeItem("discord_verifier");
+                    const oidcToken = resp.oidcToken;
+                    if (params?.onOauthSuccess) {
+                      params.onOauthSuccess({
+                        oidcToken,
+                        providerName: "discord",
+                        ...(sessionKey && {
+                          sessionKey
+                        })
+                      });
+                    } else if (callbacks?.onOauthRedirect) {
+                      callbacks.onOauthRedirect({
+                        idToken: oidcToken,
+                        publicKey,
+                        ...(sessionKey && {
+                          sessionKey
+                        })
+                      });
+                    } else {
+                      completeOauth({
+                        oidcToken,
+                        publicKey,
+                        providerName: "discord",
+                        ...(sessionKey && {
+                          sessionKey
+                        })
+                      }).then(() => resolve()).catch(reject);
+                      return;
+                    }
+                    resolve();
+                  }).catch(reject);
+                }
+              }
+            } catch {
+              // ignore cross-origin
+            }
+          }, 500);
+          if (authWindow.closed) {
+            clearInterval(interval);
+          }
+        });
+      }
+    } catch (error) {
+      throw error;
+    }
+  }, [client, callbacks]);
+  const handleXOauth = react.useCallback(async params => {
     const {
-      stampWith
+      clientId = masterConfig?.auth?.oauthConfig?.xClientId,
+      openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
+      additionalState: additionalParameters
     } = params || {};
-    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    const wallets = await utils.withTurnkeyErrorHandling(() => fetchWallets({
-      stampWith
-    }), callbacks, "Failed to refresh wallets");
-    if (wallets) {
-      setWallets(wallets);
+    try {
+      if (!masterConfig) {
+        throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      if (!clientId) {
+        throw new sdkTypes.TurnkeyError("Twitter Client ID is not configured.", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      if (!masterConfig.auth?.oauthConfig?.oauthRedirectUri) {
+        throw new sdkTypes.TurnkeyError("OAuth Redirect URI is not configured.", sdkTypes.TurnkeyErrorCodes.INVALID_CONFIGURATION);
+      }
+      const flow = openInPage ? "redirect" : "popup";
+      const redirectURI = masterConfig.auth?.oauthConfig.oauthRedirectUri;
+      // Create key pair and generate nonce
+      const publicKey = await createApiKeyPair();
+      if (!publicKey) {
+        throw new Error("Failed to create public key for OAuth.");
+      }
+      const nonce = utils$1.bytesToHex(sha2.sha256(publicKey));
+      // Generate PKCE challenge pair
+      const {
+        verifier,
+        codeChallenge
+      } = await utils.generateChallengePair();
+      sessionStorage.setItem("twitter_verifier", verifier);
+      // Construct Twitter Auth URL
+      const twitterAuthUrl = new URL(utils.X_AUTH_URL);
+      twitterAuthUrl.searchParams.set("client_id", clientId);
+      twitterAuthUrl.searchParams.set("redirect_uri", redirectURI);
+      twitterAuthUrl.searchParams.set("response_type", "code");
+      twitterAuthUrl.searchParams.set("code_challenge", codeChallenge);
+      twitterAuthUrl.searchParams.set("code_challenge_method", "S256");
+      twitterAuthUrl.searchParams.set("scope", "tweet.read users.read");
+      twitterAuthUrl.searchParams.set("state", `provider=twitter&flow=${flow}&publicKey=${encodeURIComponent(publicKey)}&nonce=${nonce}`);
+      if (additionalParameters) {
+        const extra = Object.entries(additionalParameters).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+        if (extra) {
+          twitterAuthUrl.searchParams.set("state", twitterAuthUrl.searchParams.get("state") + `&${extra}`);
+        }
+      }
+      if (openInPage) {
+        window.location.href = twitterAuthUrl.toString();
+        return new Promise((_, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error("Authentication timed out."));
+          }, 300000);
+          window.addEventListener("beforeunload", () => clearTimeout(timeout));
+        });
+      } else {
+        const width = utils.popupWidth;
+        const height = utils.popupHeight;
+        const left = window.screenX + (window.innerWidth - width) / 2;
+        const top = window.screenY + (window.innerHeight - height) / 2;
+        const authWindow = window.open("about:blank", "_blank", `width=${width},height=${height},top=${top},left=${left},scrollbars=yes,resizable=yes`);
+        if (!authWindow) {
+          throw new Error("Failed to open Twitter login window.");
+        }
+        authWindow.location.href = twitterAuthUrl.toString();
+        return new Promise((resolve, reject) => {
+          const interval = setInterval(() => {
+            try {
+              if (authWindow.closed) {
+                clearInterval(interval);
+                reject(new Error("Authentication window was closed."));
+                return;
+              }
+              const url = authWindow.location.href || "";
+              if (url.startsWith(window.location.origin)) {
+                const urlParams = new URLSearchParams(new URL(url).search);
+                const authCode = urlParams.get("code");
+                const stateParam = urlParams.get("state");
+                const sessionKey = stateParam?.split("&").find(param => param.startsWith("sessionKey="))?.split("=")[1];
+                if (authCode && stateParam && stateParam.includes("provider=twitter")) {
+                  authWindow.close();
+                  clearInterval(interval);
+                  const verifier = sessionStorage.getItem("twitter_verifier");
+                  if (!verifier) {
+                    reject(new Error("Missing PKCE verifier"));
+                    return;
+                  }
+                  client?.httpClient.proxyOAuth2Authenticate({
+                    provider: "OAUTH2_PROVIDER_X",
+                    authCode,
+                    redirectUri: redirectURI,
+                    codeVerifier: verifier,
+                    nonce
+                  }).then(resp => {
+                    sessionStorage.removeItem("twitter_verifier");
+                    const oidcToken = resp.oidcToken;
+                    if (params?.onOauthSuccess) {
+                      params.onOauthSuccess({
+                        oidcToken,
+                        providerName: "twitter",
+                        ...(sessionKey && {
+                          sessionKey
+                        })
+                      });
+                    } else if (callbacks?.onOauthRedirect) {
+                      callbacks.onOauthRedirect({
+                        idToken: oidcToken,
+                        publicKey,
+                        ...(sessionKey && {
+                          sessionKey
+                        })
+                      });
+                    } else {
+                      completeOauth({
+                        oidcToken,
+                        publicKey,
+                        providerName: "twitter",
+                        ...(sessionKey && {
+                          sessionKey
+                        })
+                      }).then(() => resolve()).catch(reject);
+                      return;
+                    }
+                    resolve();
+                  }).catch(reject);
+                }
+              }
+            } catch {
+              // ignore cross-origin
+            }
+          }, 500);
+          if (authWindow.closed) {
+            clearInterval(interval);
+          }
+        });
+      }
+    } catch (error) {
+      throw error;
     }
-  }
-  async function handleGoogleOauth(params) {
+  }, [client, callbacks]);
+  const handleGoogleOauth = react.useCallback(async params => {
     const {
       clientId = masterConfig?.auth?.oauthConfig?.googleClientId,
       openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
@@ -1341,24 +1792,35 @@ const ClientProvider = ({
               if (url.startsWith(window.location.origin)) {
                 const hashParams = new URLSearchParams(url.split("#")[1]);
                 const idToken = hashParams.get("id_token");
+                const stateParams = hashParams.get("state");
+                const sessionKey = stateParams?.split("&").find(param => param.startsWith("sessionKey="))?.split("=")[1];
                 if (idToken) {
                   authWindow.close();
                   clearInterval(interval);
                   if (params?.onOauthSuccess) {
                     params.onOauthSuccess({
                       oidcToken: idToken,
-                      providerName: "google"
+                      providerName: "google",
+                      ...(sessionKey && {
+                        sessionKey
+                      })
                     });
                   } else if (callbacks?.onOauthRedirect) {
                     callbacks.onOauthRedirect({
                       idToken,
-                      publicKey
+                      publicKey,
+                      ...(sessionKey && {
+                        sessionKey
+                      })
                     });
                   } else {
                     completeOauth({
                       oidcToken: idToken,
                       publicKey,
-                      providerName: "google"
+                      providerName: "google",
+                      ...(sessionKey && {
+                        sessionKey
+                      })
                     }).then(() => resolve()).catch(reject);
                     return;
                   }
@@ -1377,8 +1839,8 @@ const ClientProvider = ({
     } catch (error) {
       throw error;
     }
-  }
-  async function handleAppleOauth(params) {
+  }, [client, callbacks]);
+  const handleAppleOauth = react.useCallback(async params => {
     const {
       clientId = masterConfig?.auth?.oauthConfig?.appleClientId,
       openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
@@ -1454,24 +1916,35 @@ const ClientProvider = ({
               if (url.startsWith(window.location.origin)) {
                 const hashParams = new URLSearchParams(url.split("#")[1]);
                 const idToken = hashParams.get("id_token");
+                const stateParams = hashParams.get("state");
+                const sessionKey = stateParams?.split("&").find(param => param.startsWith("sessionKey="))?.split("=")[1];
                 if (idToken) {
                   authWindow.close();
                   clearInterval(interval);
                   if (params?.onOauthSuccess) {
                     params.onOauthSuccess({
                       oidcToken: idToken,
-                      providerName: "apple"
+                      providerName: "apple",
+                      ...(sessionKey && {
+                        sessionKey
+                      })
                     });
                   } else if (callbacks?.onOauthRedirect) {
                     callbacks.onOauthRedirect({
                       idToken,
-                      publicKey
+                      publicKey,
+                      ...(sessionKey && {
+                        sessionKey
+                      })
                     });
                   } else {
                     completeOauth({
                       oidcToken: idToken,
                       publicKey,
-                      providerName: "apple"
+                      providerName: "apple",
+                      ...(sessionKey && {
+                        sessionKey
+                      })
                     }).then(() => resolve()).catch(reject);
                     return;
                   }
@@ -1490,8 +1963,8 @@ const ClientProvider = ({
     } catch (error) {
       throw error;
     }
-  }
-  async function handleFacebookOauth(params) {
+  }, [client, callbacks]);
+  const handleFacebookOauth = react.useCallback(async params => {
     const {
       clientId = masterConfig?.auth?.oauthConfig?.facebookClientId,
       openInPage = masterConfig?.auth?.oauthConfig?.openOauthInPage ?? false,
@@ -1578,6 +2051,7 @@ const ClientProvider = ({
                 const authCode = urlParams.get("code");
                 const stateParam = urlParams.get("state");
                 if (authCode && stateParam && stateParam.includes("provider=facebook")) {
+                  const sessionKey = stateParam?.split("&").find(param => param.startsWith("sessionKey="))?.split("=")[1];
                   authWindow.close();
                   clearInterval(interval);
                   // Exchange code for token
@@ -1591,18 +2065,27 @@ const ClientProvider = ({
                     if (params?.onOauthSuccess) {
                       params.onOauthSuccess({
                         oidcToken: tokenData.id_token,
-                        providerName: "apple"
+                        providerName: "facebook",
+                        ...(sessionKey && {
+                          sessionKey
+                        })
                       });
                     } else if (callbacks?.onOauthRedirect) {
                       callbacks.onOauthRedirect({
                         idToken: tokenData.id_token,
-                        publicKey
+                        publicKey,
+                        ...(sessionKey && {
+                          sessionKey
+                        })
                       });
                     } else {
                       completeOauth({
                         oidcToken: tokenData.id_token,
                         publicKey,
-                        providerName: "facebook"
+                        providerName: "facebook",
+                        ...(sessionKey && {
+                          sessionKey
+                        })
                       }).then(() => resolve()).catch(reject);
                       return;
                     }
@@ -1622,21 +2105,23 @@ const ClientProvider = ({
     } catch (error) {
       throw error;
     }
-  }
-  const handleLogin = async () => {
+  }, [client, callbacks]);
+  const handleLogin = react.useCallback(async params => {
     pushPage({
       key: "Log in or sign up",
-      content: jsxRuntime.jsx(index.AuthComponent, {})
+      content: jsxRuntime.jsx(index.AuthComponent, {
+        sessionKey: params?.sessionKey
+      })
     });
-  };
-  const handleExportWallet = async params => {
+  }, [pushPage]);
+  const handleExportWallet = react.useCallback(async params => {
     const {
       walletId,
       targetPublicKey,
       stampWith
     } = params;
     pushPage({
-      key: "Export Wallet",
+      key: "Export wallet",
       content: jsxRuntime.jsx(Export.ExportComponent, {
         target: walletId,
         exportType: base.ExportType.Wallet,
@@ -1648,18 +2133,22 @@ const ClientProvider = ({
         } : {})
       })
     });
-  };
-  const handleExportPrivateKey = async params => {
+  }, [pushPage]);
+  const handleExportPrivateKey = react.useCallback(async params => {
     const {
       privateKeyId,
       targetPublicKey,
+      keyFormat,
       stampWith
     } = params;
     pushPage({
-      key: "Export Private Key",
+      key: "Export private key",
       content: jsxRuntime.jsx(Export.ExportComponent, {
         target: privateKeyId,
         exportType: base.ExportType.PrivateKey,
+        ...(keyFormat !== undefined ? {
+          keyFormat
+        } : {}),
         ...(targetPublicKey !== undefined ? {
           targetPublicKey
         } : {}),
@@ -1668,18 +2157,22 @@ const ClientProvider = ({
         } : {})
       })
     });
-  };
-  const handleExportWalletAccount = async params => {
+  }, [pushPage]);
+  const handleExportWalletAccount = react.useCallback(async params => {
     const {
       address,
       targetPublicKey,
+      keyFormat,
       stampWith
     } = params;
     pushPage({
-      key: "Export Wallet Account",
+      key: "Export wallet account",
       content: jsxRuntime.jsx(Export.ExportComponent, {
         target: address,
         exportType: base.ExportType.WalletAccount,
+        ...(keyFormat !== undefined ? {
+          keyFormat
+        } : {}),
         ...(targetPublicKey !== undefined ? {
           targetPublicKey
         } : {}),
@@ -1688,8 +2181,8 @@ const ClientProvider = ({
         } : {})
       })
     });
-  };
-  const handleImportWallet = async params => {
+  }, [pushPage]);
+  const handleImportWallet = react.useCallback(async params => {
     const {
       defaultWalletAccounts,
       successPageDuration = 2000,
@@ -1697,8 +2190,9 @@ const ClientProvider = ({
     } = params || {};
     try {
       return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => pushPage({
-        key: "Import Wallet",
+        key: "Import wallet",
         content: jsxRuntime.jsx(Import.ImportComponent, {
+          importType: base.ImportType.Wallet,
           onError: error => {
             reject(error);
           },
@@ -1720,8 +2214,41 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to import wallet.", sdkTypes.TurnkeyErrorCodes.IMPORT_WALLET_ERROR, error);
     }
-  };
-  const handleUpdateUserName = async params => {
+  }, [pushPage]);
+  const handleImportPrivateKey = react.useCallback(async params => {
+    const {
+      curve,
+      addressFormats,
+      successPageDuration = 2000,
+      stampWith
+    } = params || {};
+    try {
+      return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => pushPage({
+        key: "Import private key",
+        content: jsxRuntime.jsx(Import.ImportComponent, {
+          importType: base.ImportType.PrivateKey,
+          curve: curve,
+          addressFormats: addressFormats,
+          onError: error => {
+            reject(error);
+          },
+          onSuccess: privateKeyId => resolve(privateKeyId),
+          ...(successPageDuration !== undefined && {
+            successPageDuration
+          }),
+          ...(stampWith !== undefined && {
+            stampWith
+          })
+        })
+      })));
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError) {
+        throw error;
+      }
+      throw new sdkTypes.TurnkeyError("Failed to import private key.", sdkTypes.TurnkeyErrorCodes.IMPORT_WALLET_ERROR, error);
+    }
+  }, [pushPage]);
+  const handleUpdateUserName = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
       subTitle,
@@ -1786,8 +2313,8 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to update user name.", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_NAME_ERROR, error);
     }
-  };
-  const handleUpdateUserPhoneNumber = async params => {
+  }, [pushPage]);
+  const handleUpdateUserPhoneNumber = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
       subTitle,
@@ -1890,8 +2417,8 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to initialize OTP for sms verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
     }
-  };
-  const handleUpdateUserEmail = async params => {
+  }, [pushPage]);
+  const handleUpdateUserEmail = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
       subTitle,
@@ -1987,8 +2514,8 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to initialize OTP for email verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
     }
-  };
-  const handleAddEmail = async params => {
+  }, [pushPage]);
+  const handleAddEmail = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
       subTitle,
@@ -2084,8 +2611,8 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to initialize OTP for email verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
     }
-  };
-  const handleAddPhoneNumber = async params => {
+  }, [pushPage]);
+  const handleAddPhoneNumber = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
       subTitle,
@@ -2192,8 +2719,8 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to initialize OTP for sms verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
     }
-  };
-  const handleRemovePasskey = async params => {
+  }, [pushPage]);
+  const handleRemovePasskey = react.useCallback(async params => {
     const {
       authenticatorId,
       successPageDuration = 2000,
@@ -2233,8 +2760,8 @@ const ClientProvider = ({
         preventBack: true
       });
     }), callbacks, "Failed to remove passkey");
-  };
-  const handleAddPasskey = async params => {
+  }, [pushPage]);
+  const handleAddPasskey = react.useCallback(async params => {
     const {
       name,
       displayName,
@@ -2278,8 +2805,8 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to add passkey in handler.", sdkTypes.TurnkeyErrorCodes.ADD_PASSKEY_ERROR, error);
     }
-  };
-  const handleRemoveOauthProvider = async params => {
+  }, [pushPage]);
+  const handleRemoveOauthProvider = react.useCallback(async params => {
     const {
       providerId,
       successPageDuration = 2000,
@@ -2322,8 +2849,8 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to remove OAuth provider in handler.", sdkTypes.TurnkeyErrorCodes.REMOVE_OAUTH_PROVIDER_ERROR, error);
     }
-  };
-  const handleAddOauthProvider = async params => {
+  }, [pushPage]);
+  const handleAddOauthProvider = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     if (!session) {
       throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
@@ -2352,6 +2879,22 @@ const ClientProvider = ({
       });
     };
     switch (providerName) {
+      case sdkTypes.OAuthProviders.DISCORD:
+        {
+          await handleDiscordOauth({
+            openInPage: false,
+            onOauthSuccess
+          });
+          break;
+        }
+      case sdkTypes.OAuthProviders.X:
+        {
+          await handleXOauth({
+            openInPage: false,
+            onOauthSuccess
+          });
+          break;
+        }
       case sdkTypes.OAuthProviders.GOOGLE:
         {
           await handleGoogleOauth({
@@ -2381,8 +2924,8 @@ const ClientProvider = ({
           throw new sdkTypes.TurnkeyError(`Unsupported OAuth provider: ${providerName}`, sdkTypes.TurnkeyErrorCodes.NOT_FOUND);
         }
     }
-  };
-  const handleLinkExternalWallet = async params => {
+  }, [pushPage]);
+  const handleConnectExternalWallet = react.useCallback(async params => {
     const {
       successPageDuration = 2000
     } = params || {};
@@ -2395,14 +2938,14 @@ const ClientProvider = ({
     }
     const providers = await getWalletProviders();
     pushPage({
-      key: "Link Wallet",
-      content: jsxRuntime.jsx(LinkWallet.LinkWalletModal, {
+      key: "Connect wallet",
+      content: jsxRuntime.jsx(ConnectWallet.ConnectWalletModal, {
         providers: providers,
         successPageDuration: successPageDuration
       })
     });
-  };
-  const handleRemoveUserEmail = async params => {
+  }, [pushPage]);
+  const handleRemoveUserEmail = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
       stampWith,
@@ -2440,8 +2983,8 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to remove user email.", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_EMAIL_ERROR, error);
     }
-  };
-  const handleRemoveUserPhoneNumber = async params => {
+  }, [pushPage]);
+  const handleRemoveUserPhoneNumber = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
       stampWith,
@@ -2479,7 +3022,91 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to remove user phone number.", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR, error);
     }
-  };
+  }, [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 (config.authProxyConfigId) {
+          // Only fetch the proxy auth config if we have an authProxyId. This is a way for devs to explicitly disable the proxy auth.
+          proxyAuthConfig = await core.getAuthProxyConfig(config.authProxyConfigId, config.authProxyUrl);
+          proxyAuthConfigRef.current = proxyAuthConfig;
+        }
+        setMasterConfig(buildConfig(proxyAuthConfig));
+      } catch {
+        setClientState(base.ClientState.Error);
+      }
+    };
+    fetchProxyAuthConfig();
+  }, []);
+  react.useEffect(() => {
+    // Start the client initialization process once we have the master config.
+    if (!masterConfig) return;
+    initializeClient();
+  }, [masterConfig]);
+  react.useEffect(() => {
+    // Handle changes to the passed in config prop -- update the master config
+    // If the proxyAuthConfigRef is already set, we don't need to fetch it again. Rebuild the master config with the updated config and stored proxyAuthConfig
+    if (!proxyAuthConfigRef.current && config.authProxyConfigId) return;
+    setMasterConfig(buildConfig(proxyAuthConfigRef.current ?? undefined));
+  }, [config, proxyAuthConfigRef.current]);
+  /**
+   * @internal
+   * We create `debouncedRefreshWallets()` so that multiple rapid wallet events
+   * (for example, on Solana a single disconnect can emit several events we listen for)
+   * only trigger `refreshWallets()` once.
+   *
+   * Defining the debounced function outside of the `useEffect` ensures all event
+   * listeners in `initializeProviders` share the same instance, instead of creating
+   * a new one on every render.
+   */
+  const debouncedRefreshWallets = utils.useDebouncedCallback(refreshWallets, 100);
+  react.useEffect(() => {
+    if (!client) return;
+    const handleRefreshWallets = 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
+      if (session) {
+        // this will update our walletProvider state
+        await debouncedRefreshWallets();
+      }
+    };
+    let cleanup = () => {};
+    initializeWalletProviderListeners(walletProviders, handleRefreshWallets).then(fn => {
+      cleanup = fn;
+    }).catch(err => {
+      console.error("Failed to init providers:", err);
+    });
+    return () => {
+      cleanup();
+    };
+  }, [client, walletProviders]);
+  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();
+      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,
@@ -2497,7 +3124,7 @@ const ClientProvider = ({
       getWalletProviders,
       connectWalletAccount,
       disconnectWalletAccount,
-      switchWalletProviderChain,
+      switchWalletAccountChain,
       loginWithWallet,
       signUpWithWallet,
       loginOrSignupWithWallet,
@@ -2511,6 +3138,7 @@ const ClientProvider = ({
       completeOauth,
       fetchWallets,
       fetchWalletAccounts,
+      fetchPrivateKeys,
       refreshWallets,
       signMessage,
       signTransaction,
@@ -2547,12 +3175,15 @@ const ClientProvider = ({
       getProxyAuthConfig,
       handleLogin,
       handleGoogleOauth,
+      handleXOauth,
+      handleDiscordOauth,
       handleAppleOauth,
       handleFacebookOauth,
       handleExportWallet,
       handleExportPrivateKey,
       handleExportWalletAccount,
       handleImportWallet,
+      handleImportPrivateKey,
       handleUpdateUserEmail,
       handleUpdateUserPhoneNumber,
       handleUpdateUserName,
@@ -2563,7 +3194,7 @@ const ClientProvider = ({
       handleAddEmail,
       handleAddPhoneNumber,
       handleSignMessage,
-      handleLinkExternalWallet,
+      handleConnectExternalWallet,
       handleRemoveUserEmail,
       handleRemoveUserPhoneNumber
     },