@turnkey/react-wallet-kit 1.5.1 → 1.6.1

package/dist/providers/client/Provider.js

@@ -71,6 +71,9 @@ const ClientProvider = ({
   const [user, setUser] = react.useState(undefined);
   const [clientState, setClientState] = react.useState();
   const [authState, setAuthState] = react.useState(base.AuthState.Unauthenticated);
+  // if there is no authProxyConfigId or if autoFetchWalletKitConfig is specifically
+  // set to false, we don't need to fetch the config
+  const shouldFetchWalletKitConfig = !!config.authProxyConfigId && (config.autoFetchWalletKitConfig ?? true);
   // we use this custom hook to only update the state if the value is different
   // this is so our useEffect that calls `initializeWalletProviderListeners()` only runs when it needs to
   const [walletProviders, setWalletProviders] = utils.useWalletProviderState();
@@ -378,28 +381,29 @@ const ClientProvider = ({
     // Set a default ordering for the overall auth methods
     const methodOrder = config.auth?.methodOrder ?? [oauthOrder.length > 0 ? "socials" : null, resolvedMethods.emailOtpAuthEnabled ? "email" : null, resolvedMethods.smsOtpAuthEnabled ? "sms" : null, resolvedMethods.passkeyAuthEnabled ? "passkey" : null, resolvedMethods.walletAuthEnabled ? "wallet" : null].filter(Boolean);
     // Warn if they are trying to set auth proxy only settings directly
-    if (config.auth?.sessionExpirationSeconds) {
-      console.warn("Turnkey SDK warning. You have set sessionExpirationSeconds directly in the TurnkeyProvider. This setting will be ignored because you are using an auth proxy. Please configure session expiration in the Turnkey dashboard.");
-    }
-    if (config.auth?.otpAlphanumeric !== undefined) {
-      console.warn("Turnkey SDK warning. You have set otpAlphanumeric directly in the TurnkeyProvider. This setting will be ignored because you are using an auth proxy. Please configure OTP settings in the Turnkey dashboard.");
-    }
-    if (config.auth?.otpLength) {
-      console.warn("Turnkey SDK warning. You have set otpLength directly in the TurnkeyProvider. This setting will be ignored because you are using an auth proxy. Please configure OTP settings in the Turnkey dashboard.");
+    if (proxyAuthConfig) {
+      if (config.auth?.sessionExpirationSeconds) {
+        console.warn("Turnkey SDK warning. You have set sessionExpirationSeconds directly in the TurnkeyProvider. This setting will be ignored because you are using an auth proxy. Please configure session expiration in the Turnkey dashboard.");
+      }
+      if (config.auth?.otpAlphanumeric !== undefined) {
+        console.warn("Turnkey SDK warning. You have set otpAlphanumeric directly in the TurnkeyProvider. This setting will be ignored because you are using an auth proxy. Please configure OTP settings in the Turnkey dashboard.");
+      }
+      if (config.auth?.otpLength) {
+        console.warn("Turnkey SDK warning. You have set otpLength directly in the TurnkeyProvider. This setting will be ignored because you are using an auth proxy. Please configure OTP settings in the Turnkey dashboard.");
+      }
     }
-    // These are settings that can only be set via the auth proxy config
-    const authProxyOnlySettings = {
-      sessionExpirationSeconds: proxyAuthConfig?.sessionExpirationSeconds,
-      otpAlphanumeric: proxyAuthConfig?.otpAlphanumeric ?? true,
-      // This fallback will never be hit. This is purely for the tests to pass before mono is released
-      otpLength: proxyAuthConfig?.otpLength ?? "6" // This fallback will never be hit. This is purely for the tests to pass before mono is released
+    // These are settings that, if using the auth proxy, must be set in the dashboard. They override any local settings unless they are not using auth proxy or are not fetching the auth proxy config.
+    const authProxyPrioSettings = {
+      sessionExpirationSeconds: proxyAuthConfig?.sessionExpirationSeconds ?? config.auth?.sessionExpirationSeconds,
+      otpAlphanumeric: proxyAuthConfig?.otpAlphanumeric ?? config.auth?.otpAlphanumeric ?? true,
+      otpLength: proxyAuthConfig?.otpLength ?? config.auth?.otpLength ?? "6"
     };
     return {
       ...config,
       // Overrides:
       auth: {
         ...config.auth,
-        ...authProxyOnlySettings,
+        ...authProxyPrioSettings,
         methods: resolvedMethods,
         oauthConfig: {
           ...config.auth?.oauthConfig,
@@ -525,8 +529,18 @@ const ClientProvider = ({
           return;
         }
         setSession(allLocalStorageSessions[activeSessionKey]);
-        await refreshUser();
-        await refreshWallets();
+        // we use `maybeFetchWallets()` instead of `maybeRefreshWallets()` here to avoid a race condition
+        // specifically, if WalletConnect finishes initializing before this promise resolves,
+        // `maybeRefreshWallets()` could overwrite the WalletConnect wallet state with an outdated
+        // list of wallets that doesn’t yet include the WalletConnect wallets
+        const [, wallets] = await Promise.all([maybeRefreshUser(), (() => {
+          if (!masterConfig?.autoRefreshManagedState) return [];
+          return fetchWallets();
+        })()]);
+        // the prev wallets should only ever be WalletConnect wallets
+        if (wallets) {
+          setWallets(prev => utils.mergeWalletsWithoutDuplicates(prev, wallets));
+        }
         return;
       }
     } catch (error) {
@@ -619,6 +633,32 @@ const ClientProvider = ({
             // to refresh the uri, there is no need to refresh the wallets state
             if (evt?.type === "pairingExpired") {
               debouncedFetchWalletProviders();
+              return;
+            }
+            // if WalletConnect initialization failed, refresh providers
+            // (the failed provider will be removed from the list)
+            if (evt?.type === "failed") {
+              debouncedFetchWalletProviders();
+              callbacks?.onError?.(new sdkTypes.TurnkeyError(`WalletConnect initialization failed: ${evt.error || "Unknown error"}`, sdkTypes.TurnkeyErrorCodes.WALLET_CONNECT_INITIALIZATION_ERROR, evt.error));
+              return;
+            }
+            if (evt?.type === "initialized") {
+              // this updates our walletProvider state
+              const providers = await debouncedFetchWalletProviders();
+              // if we have an active session, we need to restore any possibly connected
+              // WalletConnect wallets since its now initialized
+              const currentSession = await getSession();
+              if (currentSession) {
+                const wcProviders = providers?.filter(p => p.interfaceType === core.WalletInterfaceType.WalletConnect);
+                const wcWallets = await fetchWallets({
+                  walletProviders: wcProviders,
+                  connectedOnly: true
+                });
+                if (wcWallets.length > 0) {
+                  setWallets(prev => utils.mergeWalletsWithoutDuplicates(prev, wcWallets));
+                }
+              }
+              return;
             }
             // any other event (disconnect, chain switch, accounts changed)
             // we refresh the wallets state
@@ -632,100 +672,6 @@ const ClientProvider = ({
       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 since epoch.
-   * @throws {TurnkeyError} If an error occurs while scheduling the session expiration.
-   */
-  async function scheduleSessionExpiration(params) {
-    const {
-      sessionKey,
-      expiry
-    } = params;
-    try {
-      const warnKey = `${sessionKey}-warning`;
-      // Replace any prior timers for this session
-      timers.clearKey(expiryTimeoutsRef.current, sessionKey);
-      timers.clearKey(expiryTimeoutsRef.current, warnKey);
-      const now = Date.now();
-      const expiryMs = expiry * 1000;
-      const timeUntilExpiry = expiryMs - now;
-      const beforeExpiry = async () => {
-        const activeSession = await getSession();
-        if (!activeSession && expiryTimeoutsRef.current[warnKey]) {
-          // Keep nudging until session materializes (short 10s timer is fine)
-          timers.setTimeoutInMap(expiryTimeoutsRef.current, warnKey, beforeExpiry, 10_000);
-          return;
-        }
-        const session = await getSession({
-          sessionKey
-        });
-        if (!session) return;
-        callbacks?.beforeSessionExpiry?.({
-          sessionKey
-        });
-        if (masterConfig?.auth?.autoRefreshSession) {
-          await refreshSession({
-            expirationSeconds: session.expirationSeconds,
-            sessionKey
-          });
-        }
-      };
-      const expireSession = async () => {
-        const expiredSession = await getSession({
-          sessionKey
-        });
-        if (!expiredSession) return;
-        callbacks?.onSessionExpired?.({
-          sessionKey
-        });
-        if ((await getActiveSessionKey()) === sessionKey) {
-          setSession(undefined);
-        }
-        setAllSessions(prev => {
-          if (!prev) return prev;
-          const next = {
-            ...prev
-          };
-          delete next[sessionKey];
-          return next;
-        });
-        await clearSession({
-          sessionKey
-        });
-        // Remove timers for this session
-        timers.clearKey(expiryTimeoutsRef.current, sessionKey);
-        timers.clearKey(expiryTimeoutsRef.current, warnKey);
-        await logout();
-      };
-      // Already expired → expire immediately
-      if (timeUntilExpiry <= 0) {
-        await expireSession();
-        return;
-      }
-      // Warning timer (if threshold is in the future)
-      const warnAt = expiryMs - utils.SESSION_WARNING_THRESHOLD_MS;
-      if (warnAt <= now) {
-        void beforeExpiry(); // fire-and-forget is fine
-      } else {
-        timers.setCappedTimeoutInMap(expiryTimeoutsRef.current, warnKey, beforeExpiry, warnAt - now);
-      }
-      // Actual expiry timer (safe for long delays)
-      timers.setCappedTimeoutInMap(expiryTimeoutsRef.current, sessionKey, expireSession, timeUntilExpiry);
-    } catch (error) {
-      if (error instanceof sdkTypes.TurnkeyError || error instanceof sdkTypes.TurnkeyNetworkError) {
-        callbacks?.onError?.(error);
-      } else {
-        callbacks?.onError?.(new sdkTypes.TurnkeyError(`Failed to schedule session expiration for ${sessionKey}`, sdkTypes.TurnkeyErrorCodes.SCHEDULE_SESSION_EXPIRY_ERROR, error));
-      }
-    }
-  }
   /**
    * Clears all scheduled session timers (warning + expiry).
    *
@@ -782,8 +728,7 @@ const ClientProvider = ({
       const allSessions = await client.getAllSessions();
       setSession(session);
       setAllSessions(allSessions);
-      await refreshWallets();
-      await refreshUser();
+      await Promise.all([maybeRefreshWallets(), maybeRefreshUser()]);
       if (masterConfig?.auth?.verifyWalletOnSignup === true && appProofs && appProofs.length > 0 && action === sdkTypes.AuthAction.SIGNUP) {
         // On signup, if we have appProofs, verify them
         await handleVerifyAppProofs({
@@ -844,13 +789,9 @@ const ClientProvider = ({
     }
     return client.createHttpClient(params);
   }, [client]);
-  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
-    }), () => logout(), callbacks, "Failed to create passkey");
+  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(), undefined, callbacks, "Failed to get active session key");
   }, [client, callbacks]);
   const logout = react.useCallback(async params => {
     if (!client) {
@@ -863,9 +804,264 @@ const ClientProvider = ({
       await client.logout(params);
       // We only handle post logout if the sessionKey is defined since that means we actually logged out of a session.
       if (sessionKey) handlePostLogout(sessionKey);
-    }, () => logout(), callbacks, "Failed to logout");
+    }, undefined, callbacks, "Failed to logout");
     return;
+  }, [client, callbacks, getActiveSessionKey]);
+  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), undefined, callbacks, "Failed to get session");
   }, [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(), undefined, callbacks, "Failed to get all sessions");
+  }, [client, callbacks]);
+  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
+    }), undefined, callbacks, "Failed to create passkey");
+  }, [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), () => logout(), callbacks, "Failed to fetch user");
+  }, [client, callbacks, logout]);
+  const fetchWalletProviders = react.useCallback(async chain => {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withTurnkeyErrorHandling(async () => {
+      const newProviders = await client.fetchWalletProviders(chain);
+      // we update state with the latest providers
+      // we keep this state so that initializeWalletProviderListeners() re-runs
+      // whenever the list of connected providers changes
+      // this ensures we attach disconnect listeners for each connected provider
+      setWalletProviders(newProviders);
+      return newProviders;
+    }, undefined, callbacks, "Failed to fetch wallet providers");
+  }, [client, callbacks]);
+  const fetchWallets = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    return utils.withTurnkeyErrorHandling(() => client.fetchWallets(params), () => logout(), callbacks, "Failed to fetch wallets");
+  }, [client, callbacks, logout]);
+  const refreshUser = react.useCallback(async params => {
+    const {
+      stampWith,
+      organizationId,
+      userId
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const user = await utils.withTurnkeyErrorHandling(() => fetchUser({
+      stampWith,
+      ...(organizationId && {
+        organizationId
+      }),
+      ...(userId && {
+        userId
+      })
+    }), () => logout(), callbacks, "Failed to refresh user");
+    if (user) {
+      setUser(user);
+    }
+  }, [client, callbacks, fetchUser, logout]);
+  /**
+   * @internal
+   * Auto-refresh user only if enabled in config. This is only used internally.
+   *
+   * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+   * @param params.userId - user ID to fetch specific user details (defaults to the current session's userId).
+   * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+   * @returns A promise that resolves when the user is refreshed, or does nothing if auto-refresh is disabled
+   */
+  const maybeRefreshUser = react.useCallback(async params => {
+    if (!masterConfig?.autoRefreshManagedState) return;
+    return refreshUser(params);
+  }, [masterConfig, refreshUser]);
+  const refreshWallets = react.useCallback(async params => {
+    const {
+      stampWith,
+      organizationId,
+      userId
+    } = params || {};
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    const walletProviders = await utils.withTurnkeyErrorHandling(() => fetchWalletProviders(), undefined, callbacks, "Failed to refresh wallets");
+    const wallets = await utils.withTurnkeyErrorHandling(() => fetchWallets({
+      stampWith,
+      walletProviders,
+      ...(organizationId && {
+        organizationId
+      }),
+      ...(userId && {
+        userId
+      })
+    }), () => logout(), callbacks, "Failed to refresh wallets");
+    if (wallets) {
+      setWallets(wallets);
+    }
+    return wallets;
+  }, [client, callbacks, fetchWalletProviders, fetchWallets, logout]);
+  /**
+   * @internal
+   * Auto-refresh wallets only if enabled in config. This is only used internally.
+   *
+   * @param params.organizationId - organization ID to specify the sub-organization (defaults to the current session's organizationId).
+   * @param params.userId - user ID to fetch specific user details (defaults to the current session's userId).
+   * @param params.stampWith - parameter to stamp the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+   * @returns A promise that resolves to an array of wallets, or an empty array if auto-refresh is disabled
+   */
+  const maybeRefreshWallets = react.useCallback(async params => {
+    if (!masterConfig?.autoRefreshManagedState) return [];
+    return refreshWallets(params);
+  }, [masterConfig, refreshWallets]);
+  const clearSession = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    await utils.withTurnkeyErrorHandling(async () => client.clearSession(params), undefined, callbacks, "Failed to clear session");
+    const sessionKey = params?.sessionKey ?? (await getActiveSessionKey());
+    if (!sessionKey) return;
+    if (!params?.sessionKey) {
+      setSession(undefined);
+    }
+    clearSessionTimeouts([sessionKey]);
+    // clear only the cleared session from allSessions
+    const newAllSessions = {
+      ...allSessions
+    };
+    if (newAllSessions) {
+      delete newAllSessions[sessionKey];
+    }
+    setAllSessions(newAllSessions);
+    return;
+  }, [client, callbacks, getActiveSessionKey, allSessions]);
+  /**
+   * @internal
+   * Schedules a session expiration and warning timer for the given session key.
+   *
+   * - Sets up two timers: one for warning before expiry and one for actual expiry.
+   * - Uses capped timeouts under the hood so delays > 24.8 days are safe (see utils/timers.ts).
+   *
+   * @param params.sessionKey - The key of the session to schedule expiration for.
+   * @param params.expiry - The expiration time in seconds since epoch.
+   * @throws {TurnkeyError} If an error occurs while scheduling the session expiration.
+   */
+  const scheduleSessionExpiration = react.useCallback(async params => {
+    const {
+      sessionKey,
+      expiry
+    } = params;
+    try {
+      const warnKey = `${sessionKey}-warning`;
+      // Replace any prior timers for this session
+      timers.clearKey(expiryTimeoutsRef.current, sessionKey);
+      timers.clearKey(expiryTimeoutsRef.current, warnKey);
+      const now = Date.now();
+      const expiryMs = expiry * 1000;
+      const timeUntilExpiry = expiryMs - now;
+      const runRefresh = async () => {
+        const activeSession = await getSession();
+        if (!activeSession && expiryTimeoutsRef.current[warnKey]) {
+          // Keep nudging until session materializes (short 10s timer is fine)
+          timers.setTimeoutInMap(expiryTimeoutsRef.current, warnKey, runRefresh, 10_000);
+          return;
+        }
+        const session = await getSession({
+          sessionKey
+        });
+        if (!session) return;
+        callbacks?.beforeSessionExpiry?.({
+          sessionKey
+        });
+        if (masterConfig?.auth?.autoRefreshSession) {
+          await refreshSession({
+            expirationSeconds: session.expirationSeconds,
+            sessionKey
+          });
+        }
+      };
+      const expireSession = async () => {
+        const expiredSession = await getSession({
+          sessionKey
+        });
+        if (!expiredSession) return;
+        callbacks?.onSessionExpired?.({
+          sessionKey
+        });
+        if ((await getActiveSessionKey()) === sessionKey) {
+          setSession(undefined);
+        }
+        setAllSessions(prev => {
+          if (!prev) return prev;
+          const next = {
+            ...prev
+          };
+          delete next[sessionKey];
+          return next;
+        });
+        await clearSession({
+          sessionKey
+        });
+        // Remove timers for this session
+        timers.clearKey(expiryTimeoutsRef.current, sessionKey);
+        timers.clearKey(expiryTimeoutsRef.current, warnKey);
+        await logout();
+      };
+      // Already expired → expire immediately
+      if (timeUntilExpiry <= 0) {
+        await expireSession();
+        return;
+      }
+      // Warning timer (if threshold is in the future)
+      const warnAt = expiryMs - utils.SESSION_WARNING_THRESHOLD_MS;
+      if (warnAt <= now) {
+        void runRefresh(); // fire-and-forget is fine
+      } else {
+        timers.setCappedTimeoutInMap(expiryTimeoutsRef.current, warnKey, runRefresh, warnAt - now);
+      }
+      // Actual expiry timer (safe for long delays)
+      timers.setCappedTimeoutInMap(expiryTimeoutsRef.current, sessionKey, expireSession, timeUntilExpiry);
+    } catch (error) {
+      if (error instanceof sdkTypes.TurnkeyError || error instanceof sdkTypes.TurnkeyNetworkError) {
+        callbacks?.onError?.(error);
+      } else {
+        callbacks?.onError?.(new sdkTypes.TurnkeyError(`Failed to schedule session expiration for ${sessionKey}`, sdkTypes.TurnkeyErrorCodes.SCHEDULE_SESSION_EXPIRY_ERROR, error));
+      }
+    }
+  },
+  // Note: `refreshSession()` is intentionally NOT in the dependency array even though
+  // it's called in runRefresh. This is because: `refreshSession()` itself calls `scheduleSessionExpiration()`,
+  // creating a circular dependency that would cause infinite re-renders
+  //
+  // this is fine because `refreshSession()` reference is stable enough for this use case (session
+  // expiration timers are long-lived and don't need to re-subscribe on every `refreshSession()` change)
+  [callbacks, masterConfig, getSession, getActiveSessionKey, clearSession, logout]);
+  const refreshSession = react.useCallback(async params => {
+    if (!client) {
+      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
+    const activeSessionKey = await client.getActiveSessionKey();
+    if (!activeSessionKey) {
+      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    }
+    const sessionKey = params?.sessionKey ?? activeSessionKey;
+    const res = await utils.withTurnkeyErrorHandling(() => client.refreshSession({
+      ...params
+    }), () => logout(), callbacks, "Failed to refresh session");
+    const session = await getSession({
+      sessionKey
+    });
+    if (session && sessionKey) {
+      await scheduleSessionExpiration({
+        sessionKey,
+        expiry: session.expiry
+      });
+    }
+    const allSessions = await getAllSessions();
+    setSession(session);
+    setAllSessions(allSessions);
+    return res;
+  }, [client, callbacks, logout, getSession, scheduleSessionExpiration, getAllSessions]);
   const loginWithPasskey = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
@@ -884,7 +1080,7 @@ const ClientProvider = ({
       });
     }
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, masterConfig, logout, handlePostAuth]);
   const signUpWithPasskey = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
@@ -924,61 +1120,55 @@ const ClientProvider = ({
       });
     }
     return res;
-  }, [client, callbacks]);
-  const fetchWalletProviders = react.useCallback(async chain => {
-    if (!client) {
-      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    }
-    const newProviders = await client.fetchWalletProviders(chain);
-    // we update state with the latest providers
-    // we keep this state so that initializeWalletProviderListeners() re-runs
-    // whenever the list of connected providers changes
-    // this ensures we attach disconnect listeners for each connected provider
-    setWalletProviders(newProviders);
-    return newProviders;
-  }, [client, callbacks]);
+  }, [client, callbacks, logout, handlePostAuth, masterConfig]);
   const connectWalletAccount = react.useCallback(async walletProvider => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
-    const address = await client.connectWalletAccount(walletProvider);
-    let wallets;
-    const s = await getSession();
-    if (s) {
-      // this will update our walletProvider state
-      wallets = await refreshWallets();
-    } else {
-      wallets = await fetchWallets({
-        connectedOnly: true
-      });
-    }
-    // we narrow to only connected wallets
-    // because we know the account must come from one of them
-    const connectedWallets = wallets.filter(w => w.source === core.WalletSource.Connected);
-    // find the matching account
-    const matchedAccount = connectedWallets.flatMap(w => w.accounts).find(a => a.address === address);
-    if (!matchedAccount) {
-      throw new sdkTypes.TurnkeyError(`No connected wallet account found for address: ${address}`, sdkTypes.TurnkeyErrorCodes.NO_WALLET_FOUND);
-    }
-    return matchedAccount;
-  }, [client, callbacks]);
+    return utils.withTurnkeyErrorHandling(async () => {
+      const address = await client.connectWalletAccount(walletProvider);
+      let wallets;
+      const s = await getSession();
+      if (s) {
+        // this will update our walletProvider state
+        wallets = await maybeRefreshWallets();
+      } else {
+        wallets = await fetchWallets({
+          connectedOnly: true
+        });
+      }
+      // we narrow to only connected wallets
+      // because we know the account must come from one of them
+      const connectedWallets = wallets.filter(w => w.source === core.WalletSource.Connected);
+      // find the matching account
+      const matchedAccount = connectedWallets.flatMap(w => w.accounts).find(a => a.address === address);
+      if (!matchedAccount) {
+        throw new sdkTypes.TurnkeyError(`No connected wallet account found for address: ${address}`, sdkTypes.TurnkeyErrorCodes.NO_WALLET_FOUND);
+      }
+      return matchedAccount;
+    }, () => logout(), callbacks, "Failed to connect wallet account");
+  }, [client, callbacks, getSession, logout, maybeRefreshWallets, fetchWallets]);
   const disconnectWalletAccount = react.useCallback(async walletProvider => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
-    await client.disconnectWalletAccount(walletProvider);
-    // no need here to call `refreshWallets()` because the provider emits a disconnect event which
-    // will trigger a refresh via the listener we set up in `initializeWalletProviderListeners()`
+    await utils.withTurnkeyErrorHandling(async () => {
+      await client.disconnectWalletAccount(walletProvider);
+      // no need here to call `maybeRefreshWallets()` because the provider emits a disconnect event which
+      // will trigger a refresh via the listener we set up in `initializeWalletProviderListeners()`
+    }, undefined, callbacks, "Failed to disconnect wallet account");
   }, [client, callbacks]);
   const switchWalletAccountChain = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
-    await client.switchWalletAccountChain({
-      ...params,
-      walletProviders
-    });
-  }, [client, callbacks, walletProviders]);
+    await utils.withTurnkeyErrorHandling(async () => {
+      await client.switchWalletAccountChain({
+        ...params,
+        walletProviders
+      });
+    }, undefined, callbacks, "Failed to switch wallet account chain");
+  }, [client, walletProviders, callbacks]);
   const buildWalletLoginRequest = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
@@ -987,8 +1177,8 @@ const ClientProvider = ({
     return await utils.withTurnkeyErrorHandling(() => client.buildWalletLoginRequest({
       ...params,
       expirationSeconds
-    }), () => logout(), callbacks, "Failed to login with wallet");
-  }, [client, callbacks]);
+    }), undefined, callbacks, "Failed to login with wallet");
+  }, [client, callbacks, masterConfig]);
   const loginWithWallet = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
@@ -997,7 +1187,7 @@ const ClientProvider = ({
     const res = await utils.withTurnkeyErrorHandling(() => client.loginWithWallet({
       ...params,
       expirationSeconds
-    }), () => logout(), callbacks, "Failed to login with wallet");
+    }), undefined, callbacks, "Failed to login with wallet");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Wallet,
@@ -1007,7 +1197,7 @@ const ClientProvider = ({
       });
     }
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, handlePostAuth, masterConfig]);
   const signUpWithWallet = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
@@ -1027,7 +1217,7 @@ const ClientProvider = ({
     const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithWallet({
       ...params,
       expirationSeconds
-    }), () => logout(), callbacks, "Failed to sign up with wallet");
+    }), undefined, callbacks, "Failed to sign up with wallet");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Wallet,
@@ -1037,7 +1227,7 @@ const ClientProvider = ({
       });
     }
     return res;
-  }, [client, callbacks, masterConfig]);
+  }, [client, callbacks, handlePostAuth, masterConfig]);
   const loginOrSignupWithWallet = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
@@ -1057,7 +1247,7 @@ const ClientProvider = ({
     const res = await utils.withTurnkeyErrorHandling(() => client.loginOrSignupWithWallet({
       ...params,
       expirationSeconds
-    }), () => logout(), callbacks, "Failed to login or sign up with wallet");
+    }), undefined, callbacks, "Failed to login or sign up with wallet");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Wallet,
@@ -1067,24 +1257,24 @@ const ClientProvider = ({
       });
     }
     return res;
-  }, [client, callbacks, masterConfig]);
+  }, [client, callbacks, handlePostAuth, 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), () => logout(), callbacks, "Failed to initialize OTP");
+    return utils.withTurnkeyErrorHandling(() => client.initOtp(params), undefined, callbacks, "Failed to initialize OTP");
   }, [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), () => logout(), callbacks, "Failed to verify OTP");
+    return utils.withTurnkeyErrorHandling(() => client.verifyOtp(params), undefined, callbacks, "Failed to verify OTP");
   }, [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), () => logout(), callbacks, "Failed to login with OTP");
+    const res = await utils.withTurnkeyErrorHandling(() => client.loginWithOtp(params), undefined, callbacks, "Failed to login with OTP");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Otp,
@@ -1094,7 +1284,7 @@ const ClientProvider = ({
       });
     }
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, handlePostAuth]);
   const signUpWithOtp = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
@@ -1117,7 +1307,7 @@ const ClientProvider = ({
     } : {
       ...params
     };
-    const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithOtp(params), () => logout(), callbacks, "Failed to sign up with OTP");
+    const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithOtp(params), undefined, callbacks, "Failed to sign up with OTP");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Otp,
@@ -1127,7 +1317,7 @@ const ClientProvider = ({
       });
     }
     return res;
-  }, [client, callbacks, masterConfig]);
+  }, [client, callbacks, masterConfig, handlePostAuth]);
   const completeOtp = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
@@ -1150,7 +1340,7 @@ const ClientProvider = ({
     } : {
       ...params
     };
-    const res = await utils.withTurnkeyErrorHandling(() => client.completeOtp(params), () => logout(), callbacks, "Failed to complete OTP");
+    const res = await utils.withTurnkeyErrorHandling(() => client.completeOtp(params), undefined, callbacks, "Failed to complete OTP");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Otp,
@@ -1160,12 +1350,12 @@ const ClientProvider = ({
       });
     }
     return res;
-  }, [client, callbacks, masterConfig]);
+  }, [client, callbacks, handlePostAuth, 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), () => logout(), callbacks, "Failed to login with OAuth");
+    const res = await utils.withTurnkeyErrorHandling(() => client.loginWithOauth(params), undefined, callbacks, "Failed to login with OAuth");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Oauth,
@@ -1175,7 +1365,7 @@ const ClientProvider = ({
       });
     }
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, handlePostAuth]);
   const signUpWithOauth = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
@@ -1191,7 +1381,7 @@ const ClientProvider = ({
     } : {
       ...params
     };
-    const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithOauth(params), () => logout(), callbacks, "Failed to sign up with OAuth");
+    const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithOauth(params), undefined, callbacks, "Failed to sign up with OAuth");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Oauth,
@@ -1201,7 +1391,7 @@ const ClientProvider = ({
       });
     }
     return res;
-  }, [client, callbacks, masterConfig]);
+  }, [client, callbacks, handlePostAuth, masterConfig]);
   const completeOauth = react.useCallback(async params => {
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
@@ -1217,7 +1407,7 @@ const ClientProvider = ({
     } : {
       ...params
     };
-    const res = await utils.withTurnkeyErrorHandling(() => client.completeOauth(params), () => logout(), callbacks, "Failed to complete OAuth");
+    const res = await utils.withTurnkeyErrorHandling(() => client.completeOauth(params), undefined, callbacks, "Failed to complete OAuth");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Oauth,
@@ -1227,29 +1417,23 @@ const ClientProvider = ({
       });
     }
     return res;
-  }, [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), () => logout(), callbacks, "Failed to fetch wallets");
-  }, [client, callbacks]);
+  }, [client, callbacks, masterConfig, handlePostAuth]);
   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), () => logout(), callbacks, "Failed to fetch wallet accounts");
-  }, [client, callbacks]);
+  }, [client, callbacks, logout]);
   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), () => logout(), callbacks, "Failed to fetch private keys");
-  }, [client, callbacks]);
+  }, [client, callbacks, logout]);
   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), () => logout(), callbacks, "Failed to sign message");
-  }, [client, callbacks]);
+  }, [client, callbacks, logout]);
   const handleSignMessage = react.useCallback(async params => {
     const {
       successPageDuration = 2000
@@ -1286,31 +1470,27 @@ const ClientProvider = ({
         onClose: () => reject(new sdkTypes.TurnkeyError("User canceled the signing process.", sdkTypes.TurnkeyErrorCodes.USER_CANCELED))
       });
     });
-  }, [client, callbacks]);
+  }, [client, callbacks, pushPage]);
   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), () => logout(), callbacks, "Failed to sign transaction");
-  }, [client, callbacks]);
+  }, [client, callbacks, logout]);
   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), () => logout(), callbacks, "Failed to sign transaction");
-  }, [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), () => logout(), callbacks, "Failed to fetch user");
-  }, [client, callbacks]);
+  }, [client, callbacks, logout]);
   const fetchOrCreateP256ApiKeyUser = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.fetchOrCreateP256ApiKeyUser(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
-  }, [client, callbacks]);
+  }, [client, callbacks, logout]);
   const fetchOrCreatePolicies = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.fetchOrCreatePolicies(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
-  }, [client, callbacks]);
+  }, [client, callbacks, logout]);
   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), () => logout(), callbacks, "Failed to update user email");
-    if (res) await refreshUser({
+    if (res) await maybeRefreshUser({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
@@ -1320,11 +1500,11 @@ const ClientProvider = ({
       })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, logout, maybeRefreshUser]);
   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), () => logout(), callbacks, "Failed to remove user email");
-    if (res) await refreshUser({
+    if (res) await maybeRefreshUser({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
@@ -1334,11 +1514,11 @@ const ClientProvider = ({
       })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, logout, maybeRefreshUser]);
   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), () => logout(), callbacks, "Failed to update user phone number");
-    if (res) await refreshUser({
+    if (res) await maybeRefreshUser({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
@@ -1348,11 +1528,11 @@ const ClientProvider = ({
       })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, logout, maybeRefreshUser]);
   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), () => logout(), callbacks, "Failed to remove user phone number");
-    if (res) await refreshUser({
+    if (res) await maybeRefreshUser({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
@@ -1362,11 +1542,11 @@ const ClientProvider = ({
       })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, logout, maybeRefreshUser]);
   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), () => logout(), callbacks, "Failed to update user name");
-    if (res) await refreshUser({
+    if (res) await maybeRefreshUser({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
@@ -1376,11 +1556,11 @@ const ClientProvider = ({
       })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, logout, maybeRefreshUser]);
   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), () => logout(), callbacks, "Failed to add OAuth provider");
-    if (res) await refreshUser({
+    if (res) await maybeRefreshUser({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
@@ -1390,11 +1570,11 @@ const ClientProvider = ({
       })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, logout, maybeRefreshUser]);
   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), () => logout(), callbacks, "Failed to remove OAuth providers");
-    if (res) await refreshUser({
+    if (res) await maybeRefreshUser({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
@@ -1404,11 +1584,11 @@ const ClientProvider = ({
       })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, logout, maybeRefreshUser]);
   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), () => logout(), callbacks, "Failed to add passkey");
-    if (res) await refreshUser({
+    if (res) await maybeRefreshUser({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
@@ -1418,11 +1598,11 @@ const ClientProvider = ({
       })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, logout, maybeRefreshUser]);
   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), () => logout(), callbacks, "Failed to remove passkeys");
-    if (res) await refreshUser({
+    if (res) await maybeRefreshUser({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
@@ -1432,65 +1612,65 @@ const ClientProvider = ({
       })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, logout, maybeRefreshUser]);
   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), () => logout(), callbacks, "Failed to create wallet");
     const s = await getSession();
-    if (res && s) await refreshWallets({
+    if (res && s) await maybeRefreshWallets({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
       })
     });
     return res;
-  }, [client, session, callbacks]);
+  }, [client, session, callbacks, logout, maybeRefreshWallets, getSession]);
   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), () => logout(), callbacks, "Failed to create wallet accounts");
     const s = await getSession();
-    if (res && s) await refreshWallets({
+    if (res && s) await maybeRefreshWallets({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
       })
     });
     return res;
-  }, [client, session, callbacks]);
+  }, [client, session, callbacks, logout, getSession, maybeRefreshWallets]);
   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), () => logout(), callbacks, "Failed to export wallet");
     const s = await getSession();
-    if (res && s) await refreshWallets({
+    if (res && s) await maybeRefreshWallets({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
       })
     });
     return res;
-  }, [client, session, callbacks]);
+  }, [client, session, callbacks, logout, getSession, maybeRefreshWallets]);
   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), () => logout(), callbacks, "Failed to export private key");
     return res;
-  }, [client, callbacks]);
+  }, [client, callbacks, logout]);
   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), () => logout(), callbacks, "Failed to export wallet accounts");
     const s = await getSession();
-    if (res && s) await refreshWallets({
+    if (res && s) await maybeRefreshWallets({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
       })
     });
     return res;
-  }, [client, callbacks, masterConfig, session, user]);
+  }, [client, callbacks, logout, getSession, maybeRefreshWallets]);
   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), () => logout(), callbacks, "Failed to import wallet");
     const s = await getSession();
-    if (res && s) await refreshWallets({
+    if (res && s) await maybeRefreshWallets({
       stampWith: params?.stampWith,
       ...(params?.organizationId && {
         organizationId: params.organizationId
@@ -1500,16 +1680,16 @@ const ClientProvider = ({
       })
     });
     return res;
-  }, [client, callbacks, masterConfig, session, user]);
+  }, [client, callbacks, logout, getSession, maybeRefreshWallets]);
   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), () => logout(), callbacks, "Failed to import private key");
     return res;
-  }, [client, callbacks, masterConfig, session, user]);
+  }, [client, callbacks, logout]);
   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), () => logout(), callbacks, "Failed to delete sub-organization");
-  }, [client, callbacks, masterConfig, session, user]);
+  }, [client, callbacks, logout]);
   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), () => logout(), callbacks, "Failed to store session");
@@ -1526,69 +1706,15 @@ const ClientProvider = ({
     const allSessions = await getAllSessions();
     setSession(session);
     setAllSessions(allSessions);
-    await refreshWallets();
-    await refreshUser();
-  }, [client, callbacks, masterConfig, session, user]);
-  const clearSession = react.useCallback(async params => {
-    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    await utils.withTurnkeyErrorHandling(async () => client.clearSession(params), () => logout(), callbacks, "Failed to clear session");
-    const sessionKey = params?.sessionKey ?? (await getActiveSessionKey());
-    if (!sessionKey) return;
-    if (!params?.sessionKey) {
-      setSession(undefined);
-    }
-    clearSessionTimeouts([sessionKey]);
-    // clear only the cleared session from allSessions
-    const newAllSessions = {
-      ...allSessions
-    };
-    if (newAllSessions) {
-      delete newAllSessions[sessionKey];
-    }
-    setAllSessions(newAllSessions);
-    return;
-  }, [client, callbacks, session, user, masterConfig]);
+    await Promise.all([maybeRefreshWallets(), maybeRefreshUser()]);
+  }, [client, callbacks, logout, getActiveSessionKey, getSession, scheduleSessionExpiration, getAllSessions, maybeRefreshWallets, maybeRefreshUser]);
   const clearAllSessions = react.useCallback(async () => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     setSession(undefined);
     setAllSessions(undefined);
     clearSessionTimeouts();
     return await utils.withTurnkeyErrorHandling(() => client.clearAllSessions(), () => logout(), callbacks, "Failed to clear all sessions");
-  }, [client, callbacks, session, user, masterConfig]);
-  const refreshSession = react.useCallback(async params => {
-    if (!client) {
-      throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    }
-    const activeSessionKey = await client.getActiveSessionKey();
-    if (!activeSessionKey) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
-    }
-    const sessionKey = params?.sessionKey ?? activeSessionKey;
-    const res = await utils.withTurnkeyErrorHandling(() => client.refreshSession({
-      ...params
-    }), () => logout(), callbacks, "Failed to refresh session");
-    const session = await getSession({
-      sessionKey
-    });
-    if (session && sessionKey) {
-      await scheduleSessionExpiration({
-        sessionKey,
-        expiry: session.expiry
-      });
-    }
-    const allSessions = await getAllSessions();
-    setSession(session);
-    setAllSessions(allSessions);
-    return res;
-  }, [client, callbacks, scheduleSessionExpiration, session, user, masterConfig]);
-  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), () => logout(), callbacks, "Failed to get session");
-  }, [client, callbacks, masterConfig, session, user]);
-  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(), () => logout(), callbacks, "Failed to get all sessions");
-  }, [client, callbacks, masterConfig, session, user]);
+  }, [client, callbacks, logout, clearSessionTimeouts]);
   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({
@@ -1601,80 +1727,30 @@ const ClientProvider = ({
     await utils.withTurnkeyErrorHandling(() => client.setActiveSession(params), () => logout(), callbacks, "Failed to set active session");
     setSession(session);
     await utils.withTurnkeyErrorHandling(async () => {
-      await refreshWallets();
-      await refreshUser();
+      await Promise.all([maybeRefreshWallets(), maybeRefreshUser()]);
     }, () => logout(), callbacks, "Failed to refresh data after setting active session");
     return;
-  }, [client, callbacks, session, user, masterConfig]);
-  const getActiveSessionKey = react.useCallback(async () => {
-    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    return utils.withTurnkeyErrorHandling(() => client.getActiveSessionKey(), () => logout(), callbacks, "Failed to get active session key");
-  }, [client, callbacks, masterConfig, session, user]);
+  }, [client, callbacks, logout, getSession, maybeRefreshWallets, maybeRefreshUser]);
   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(), () => logout(), callbacks, "Failed to clear unused key pairs");
-  }, [client, callbacks, masterConfig, session, user]);
+    return utils.withTurnkeyErrorHandling(() => client.clearUnusedKeyPairs(), undefined, callbacks, "Failed to clear unused key pairs");
+  }, [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), () => logout(), callbacks, "Failed to create API key pair");
-  }, [client, callbacks, session, user, masterConfig]);
+    return utils.withTurnkeyErrorHandling(() => client.createApiKeyPair(params), undefined, callbacks, "Failed to create API key pair");
+  }, [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(), () => logout(), callbacks, "Failed to get proxy auth config");
-  }, [client, callbacks, masterConfig, session, user]);
-  const refreshUser = react.useCallback(async params => {
-    if (!masterConfig?.autoRefreshManagedState) return;
-    const {
-      stampWith,
-      organizationId,
-      userId
-    } = params || {};
-    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    const user = await utils.withTurnkeyErrorHandling(() => fetchUser({
-      stampWith,
-      ...(organizationId && {
-        organizationId
-      }),
-      ...(userId && {
-        userId
-      })
-    }), () => logout(), callbacks, "Failed to refresh user");
-    if (user) {
-      setUser(user);
-    }
-  }, [client, callbacks, fetchUser, masterConfig, session, user]);
+    return utils.withTurnkeyErrorHandling(() => client.getProxyAuthConfig(), undefined, callbacks, "Failed to get proxy auth config");
+  }, [client, callbacks]);
   const fetchBootProofForAppProof = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.fetchBootProofForAppProof(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
-  }, [client, callbacks]);
+  }, [client, callbacks, logout]);
   const verifyAppProofs = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withTurnkeyErrorHandling(() => client.verifyAppProofs(params), () => logout(), callbacks, "Failed to verify app proofs");
-  }, [client, callbacks]);
-  const refreshWallets = react.useCallback(async params => {
-    if (!masterConfig?.autoRefreshManagedState) return [];
-    const {
-      stampWith,
-      organizationId,
-      userId
-    } = params || {};
-    if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    const walletProviders = await utils.withTurnkeyErrorHandling(() => fetchWalletProviders(), () => logout(), callbacks, "Failed to refresh wallets");
-    const wallets = await utils.withTurnkeyErrorHandling(() => fetchWallets({
-      stampWith,
-      walletProviders,
-      ...(organizationId && {
-        organizationId
-      }),
-      ...(userId && {
-        userId
-      })
-    }), () => logout(), callbacks, "Failed to refresh wallets");
-    if (wallets) {
-      setWallets(wallets);
-    }
-    return wallets;
-  }, [client, callbacks, fetchWalletProviders, fetchWallets, masterConfig, session, user]);
+  }, [client, callbacks, logout]);
   const handleDiscordOauth = react.useCallback(async params => {
     const {
       clientId = masterConfig?.auth?.oauthConfig?.discordClientId,
@@ -1814,7 +1890,7 @@ const ClientProvider = ({
     } catch (error) {
       throw error;
     }
-  }, [client, callbacks, completeOauth, createApiKeyPair, masterConfig, session, user]);
+  }, [client, callbacks, completeOauth, createApiKeyPair, masterConfig]);
   const handleXOauth = react.useCallback(async params => {
     const {
       clientId = masterConfig?.auth?.oauthConfig?.xClientId,
@@ -1954,7 +2030,7 @@ const ClientProvider = ({
     } catch (error) {
       throw error;
     }
-  }, [client, callbacks, masterConfig, session, user]);
+  }, [client, callbacks, completeOauth, createApiKeyPair, masterConfig]);
   const handleGoogleOauth = react.useCallback(async params => {
     const {
       clientId = masterConfig?.auth?.oauthConfig?.googleClientId,
@@ -2083,7 +2159,7 @@ const ClientProvider = ({
     } catch (error) {
       throw error;
     }
-  }, [client, callbacks, masterConfig, session, user]);
+  }, [callbacks, completeOauth, createApiKeyPair, masterConfig]);
   const handleAppleOauth = react.useCallback(async params => {
     const {
       clientId = masterConfig?.auth?.oauthConfig?.appleClientId,
@@ -2208,7 +2284,7 @@ const ClientProvider = ({
     } catch (error) {
       throw error;
     }
-  }, [client, callbacks, masterConfig, session, user]);
+  }, [callbacks, completeOauth, createApiKeyPair, masterConfig]);
   const handleFacebookOauth = react.useCallback(async params => {
     const {
       clientId = masterConfig?.auth?.oauthConfig?.facebookClientId,
@@ -2351,7 +2427,7 @@ const ClientProvider = ({
     } catch (error) {
       throw error;
     }
-  }, [client, callbacks, masterConfig, client, session, user]);
+  }, [callbacks, completeOauth, createApiKeyPair, masterConfig]);
   const handleLogin = react.useCallback(async params => {
     const logo = masterConfig?.ui?.darkMode ? params?.logoDark ?? masterConfig?.ui?.logoDark : params?.logoLight ?? masterConfig?.ui?.logoLight;
     pushPage({
@@ -2364,7 +2440,7 @@ const ClientProvider = ({
       }),
       showTitle: logo ? false : true
     });
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [pushPage, masterConfig]);
   const handleExportWallet = react.useCallback(async params => {
     const {
       walletId,
@@ -2391,7 +2467,7 @@ const ClientProvider = ({
       }),
       onClose: () => reject(new sdkTypes.TurnkeyError("User canceled the export wallet process.", sdkTypes.TurnkeyErrorCodes.USER_CANCELED))
     }));
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [pushPage]);
   const handleExportPrivateKey = react.useCallback(async params => {
     const {
       privateKeyId,
@@ -2422,7 +2498,7 @@ const ClientProvider = ({
       }),
       onClose: () => reject(new sdkTypes.TurnkeyError("User canceled the export private key process.", sdkTypes.TurnkeyErrorCodes.USER_CANCELED))
     }));
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [pushPage]);
   const handleExportWalletAccount = react.useCallback(async params => {
     const {
       address,
@@ -2453,7 +2529,7 @@ const ClientProvider = ({
       }),
       onClose: () => reject(new sdkTypes.TurnkeyError("User canceled the export wallet account process.", sdkTypes.TurnkeyErrorCodes.USER_CANCELED))
     }));
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [pushPage]);
   const handleImportWallet = react.useCallback(async params => {
     const {
       defaultWalletAccounts,
@@ -2502,7 +2578,7 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to import wallet.", sdkTypes.TurnkeyErrorCodes.IMPORT_WALLET_ERROR, error);
     }
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [pushPage, logout]);
   const handleImportPrivateKey = react.useCallback(async params => {
     const {
       curve,
@@ -2547,7 +2623,7 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to import private key.", sdkTypes.TurnkeyErrorCodes.IMPORT_WALLET_ERROR, error);
     }
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [pushPage, logout]);
   const handleUpdateUserName = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
@@ -2624,7 +2700,7 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to update user name.", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_NAME_ERROR, error);
     }
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [client, getSession, user, pushPage, closeModal, updateUserName, logout]);
   const handleUpdateUserPhoneNumber = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
@@ -2746,7 +2822,7 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to initialize OTP for sms verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
     }
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [client, masterConfig, getSession, pushPage, closeModal, logout, initOtp, verifyOtp, updateUserPhoneNumber, user, callbacks]);
   const handleUpdateUserEmail = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
@@ -2861,7 +2937,7 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to initialize OTP for email verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
     }
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [client, getSession, pushPage, closeModal, logout, initOtp, masterConfig, verifyOtp, updateUserEmail, user, callbacks]);
   const handleAddEmail = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
@@ -2974,7 +3050,7 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to initialize OTP for email verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
     }
-  }, [pushPage, client, session, user]);
+  }, [client, getSession, pushPage, closeModal, user, logout, initOtp, masterConfig, verifyOtp, updateUserEmail, callbacks]);
   const handleAddPhoneNumber = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
@@ -3096,7 +3172,7 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to initialize OTP for sms verification.", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
     }
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [client, masterConfig, getSession, pushPage, closeModal, user, logout, callbacks, initOtp, verifyOtp, updateUserPhoneNumber]);
   const handleRemovePasskey = react.useCallback(async params => {
     const {
       authenticatorId,
@@ -3142,7 +3218,7 @@ const ClientProvider = ({
         preventBack: true
       });
     }), () => logout(), callbacks, "Failed to remove passkey");
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [client, getSession, pushPage, logout, callbacks]);
   const handleAddPasskey = react.useCallback(async params => {
     const {
       name,
@@ -3195,7 +3271,7 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to add passkey in handler.", sdkTypes.TurnkeyErrorCodes.ADD_PASSKEY_ERROR, error);
     }
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [client, getSession, addPasskey, pushPage, closeModal]);
   const handleRemoveOauthProvider = react.useCallback(async params => {
     const {
       providerId,
@@ -3245,7 +3321,7 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to remove OAuth provider in handler.", sdkTypes.TurnkeyErrorCodes.REMOVE_OAUTH_PROVIDER_ERROR, error);
     }
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [client, getSession, pushPage]);
   const handleAddOauthProvider = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const {
@@ -3331,7 +3407,7 @@ const ClientProvider = ({
         reject(error);
       }
     });
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [client, getSession, addOauthProvider, pushPage, closeModal, handleDiscordOauth, handleXOauth, handleGoogleOauth, handleAppleOauth, handleFacebookOauth]);
   const handleConnectExternalWallet = react.useCallback(async params => {
     const {
       successPageDuration = 2000
@@ -3340,12 +3416,10 @@ const ClientProvider = ({
     if (!masterConfig?.walletConfig?.features?.connecting) {
       throw new sdkTypes.TurnkeyError("Wallet connecting is not enabled.", sdkTypes.TurnkeyErrorCodes.FEATURE_NOT_ENABLED);
     }
-    const providers = await fetchWalletProviders();
     return new Promise((resolve, reject) => {
       pushPage({
         key: "Connect wallet",
         content: jsxRuntime.jsx(ConnectWallet.ConnectWalletModal, {
-          providers: providers,
           successPageDuration: successPageDuration,
           onSuccess: (type, account) => {
             resolve({
@@ -3357,7 +3431,7 @@ const ClientProvider = ({
         onClose: () => reject(new sdkTypes.TurnkeyError("User canceled the connect wallet process.", sdkTypes.TurnkeyErrorCodes.USER_CANCELED))
       });
     });
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [client, masterConfig, fetchWalletProviders, pushPage]);
   const handleRemoveUserEmail = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
@@ -3402,7 +3476,7 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to remove user email.", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_EMAIL_ERROR, error);
     }
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [getSession, pushPage]);
   const handleRemoveUserPhoneNumber = react.useCallback(async params => {
     const {
       successPageDuration = 2000,
@@ -3447,7 +3521,7 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to remove user phone number.", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR, error);
     }
-  }, [pushPage, masterConfig, client, session, user]);
+  }, [getSession, pushPage]);
   const handleOnRamp = react.useCallback(async params => {
     const {
       walletAccount,
@@ -3619,7 +3693,7 @@ const ClientProvider = ({
         onClose: () => reject(new sdkTypes.TurnkeyError("User canceled the onramp process.", sdkTypes.TurnkeyErrorCodes.USER_CANCELED))
       });
     });
-  }, [pushPage, client]);
+  }, [getSession, client, pushPage]);
   const handleVerifyAppProofs = react.useCallback(async params => {
     const {
       appProofs,
@@ -3663,16 +3737,18 @@ const ClientProvider = ({
       }
       throw new sdkTypes.TurnkeyError("Failed to verify app proofs.", sdkTypes.TurnkeyErrorCodes.VERIFY_APP_PROOFS_ERROR, error);
     }
-  }, [pushPage, client]);
+  }, [getSession, pushPage]);
   react.useEffect(() => {
     if (proxyAuthConfigRef.current) return;
     // Only fetch the proxy auth config once. Use that to build the master config.
     const fetchProxyAuthConfig = async () => {
       try {
         let proxyAuthConfig;
-        if (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);
+        if (shouldFetchWalletKitConfig) {
+          // Only fetch the proxy auth config if we have an authProxyId and the autoFetchWalletKitConfig param is enabled or not passed in.
+          proxyAuthConfig = await core.getAuthProxyConfig(config.authProxyConfigId,
+          // Can assert safely. See shouldFetchWalletKitConfig definition.
+          config.authProxyUrl);
           proxyAuthConfigRef.current = proxyAuthConfig;
         }
         setMasterConfig(buildConfig(proxyAuthConfig));
@@ -3689,31 +3765,33 @@ const ClientProvider = ({
   }, [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;
+    // Rebuild the master config with the updated config and stored proxyAuthConfig
+    // If we don't have a stored proxyAuthConfig and we need to fetch it, we wait until that fetch is done in the other useEffect.
+    // If shouldFetchWalletKitConfig is false, we'll never have a proxyAuthConfig to build the master config with, so this useEffect should always run.
+    if (!proxyAuthConfigRef.current && shouldFetchWalletKitConfig) return;
     setMasterConfig(buildConfig(proxyAuthConfigRef.current ?? undefined));
   }, [config, proxyAuthConfigRef.current]);
   /**
    * @internal
    * We create `debouncedRefreshWallets()` so that multiple rapid wallet events
    * (for example, on Solana a single disconnect can emit several events we listen for)
-   * only trigger `refreshWallets()` once.
+   * only trigger `maybeRefreshWallets()` once.
    *
    * Defining the debounced function outside of the `useEffect` ensures all event
    * listeners in `initializeWalletProviderListeners` share the same instance, instead of creating
    * a new one on every render.
    */
-  const debouncedRefreshWallets = utils.useDebouncedCallback(refreshWallets, 100);
+  const debouncedRefreshWallets = utils.useDebouncedCallback(maybeRefreshWallets, 100);
   const debouncedFetchWalletProviders = utils.useDebouncedCallback(fetchWalletProviders, 100);
   react.useEffect(() => {
-    if (!client) return;
     const handleUpdateState = async () => {
       // we only refresh the wallets if there is an active session
       // this is needed because a disconnect event can occur
       // while the user is unauthenticated
       //
       // WalletProviders state is updated regardless of session state
-      if (session) {
+      const currentSession = await getSession();
+      if (currentSession) {
         // this updates both the wallets and walletProviders state
         await debouncedRefreshWallets();
       } else {
@@ -3730,7 +3808,7 @@ const ClientProvider = ({
     return () => {
       cleanup();
     };
-  }, [client, walletProviders, session]);
+  }, [walletProviders, getSession, debouncedRefreshWallets, debouncedFetchWalletProviders]);
   react.useEffect(() => {
     // authState must be consistent with session state. We found during testing that there are cases where the session and authState can be out of sync in very rare edge cases.
     // This will ensure that they are always in sync and remove the need to setAuthState manually in other places.