@turnkey/react-wallet-kit 1.0.0 → 1.1.0

package/dist/providers/client/Provider.js

@@ -362,11 +362,29 @@ const ClientProvider = ({
     const oauthOrder = config.auth?.oauthOrder ?? ["google", "apple", "x", "discord", "facebook"].filter(provider => resolvedMethods[`${provider}OauthEnabled`]);
     // Set a default ordering for the overall auth methods
     const methodOrder = config.auth?.methodOrder ?? [oauthOrder.length > 0 ? "socials" : null, resolvedMethods.emailOtpAuthEnabled ? "email" : null, resolvedMethods.smsOtpAuthEnabled ? "sms" : null, resolvedMethods.passkeyAuthEnabled ? "passkey" : null, resolvedMethods.walletAuthEnabled ? "wallet" : null].filter(Boolean);
+    // Warn if they are trying to set auth proxy only settings directly
+    if (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
+    };
     return {
       ...config,
       // Overrides:
       auth: {
         ...config.auth,
+        ...authProxyOnlySettings,
         methods: resolvedMethods,
         oauthConfig: {
           ...config.auth?.oauthConfig,
@@ -376,7 +394,6 @@ const ClientProvider = ({
           // (e.g. Safari) block popups
           openOauthInPage: isMobile ? true : config.auth?.oauthConfig?.openOauthInPage
         },
-        sessionExpirationSeconds: proxyAuthConfig?.sessionExpirationSeconds,
         methodOrder,
         oauthOrder,
         autoRefreshSession: config.auth?.autoRefreshSession ?? true
@@ -508,36 +525,47 @@ const ClientProvider = ({
    * @internal
    * Attach listeners for connected wallet providers so we can refresh state on changes.
    *
-   * - Ethereum: listens for disconnect and chain switches to trigger a refresh.
+   * - Ethereum: listens for disconnect and chain/account changes to trigger a refresh.
    * - Solana: listens for disconnect via Wallet Standard `change` events to trigger a refresh.
-   * - WalletConnect: listens for disconnect via our custom wrapper’s `change` event to trigger a refresh.
+   * - WalletConnect:
+   *    - listens for disconnect and other state changes via its unified `change` event
+   *    - additionally listens for `pairingExpired` events (proposal expiration), in which
+   *      case we re-fetch providers to refresh the pairing URI for the UI.
    *
    * Notes:
-   * - Only providers that are connected are bound.
-   * - WalletConnect is excluded from the “native” paths and handled via its unified `change` event.
+   * - Only connected providers are bound, except WalletConnect which must always register
+   *   to handle proposal expiration even if no active session exists.
+   * - Since all WalletConnect providers share the same session, we only attach to one.
    *
    * @param walletProviders - Discovered providers; only connected ones are bound.
-   * @param onWalletsChanged - Invoked when a relevant provider event occurs.
+   * @param onUpdateState - Invoked when a relevant provider event occurs.
    * @returns Cleanup function that removes all listeners registered by this call.
    */
-  async function initializeWalletProviderListeners(walletProviders, onWalletsChanged) {
+  async function initializeWalletProviderListeners(walletProviders, onUpdateState) {
     if (walletProviders.length === 0) return () => {};
     const cleanups = [];
     // we only want to initialize these listeners for connected walletProviders
     const nativeOnly = provider => provider.interfaceType !== core.WalletInterfaceType.WalletConnect;
     const ethProviders = masterConfig?.walletConfig?.chains.ethereum?.native ? walletProviders.filter(provider => provider.chainInfo.namespace === core.Chain.Ethereum && nativeOnly(provider) && provider.connectedAddresses.length > 0) : [];
     const solProviders = masterConfig?.walletConfig?.chains.solana?.native ? walletProviders.filter(provider => provider.chainInfo.namespace === core.Chain.Solana && nativeOnly(provider) && provider.connectedAddresses.length > 0) : [];
-    // 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) {
+    // WalletConnect is excluded from native event wiring. Instead,
+    // it uses a unified `change` event exposed by our custom wrapper
+    //
+    // unlike native providers, we register listeners for WalletConnect
+    // even if it’s not currently “connected”. This is required so we
+    // can detect proposal expiration events and display the new regenerated
+    // URI for the UI
+    const wcProviders = walletProviders.filter(p => p.interfaceType === core.WalletInterfaceType.WalletConnect);
+    // since all WalletConnect providers share the same underlying session
+    // and emit identical events, we only attach listeners to a single provider
+    const wcProvider = wcProviders.find(p => p.interfaceType === core.WalletInterfaceType.WalletConnect);
+    function attachEthereumListeners(provider, onUpdateState) {
       if (typeof provider.on !== "function") return;
-      const handleChainChanged = _chainId => onWalletsChanged();
-      const handleAccountsChanged = accounts => {
-        if (accounts.length === 0) onWalletsChanged();
+      const handleChainChanged = async _chainId => onUpdateState();
+      const handleAccountsChanged = async accounts => {
+        if (accounts.length === 0) onUpdateState();
       };
-      const handleDisconnect = () => onWalletsChanged();
+      const handleDisconnect = () => onUpdateState();
       provider.on("chainChanged", handleChainChanged);
       provider.on("accountsChanged", handleAccountsChanged);
       provider.on("disconnect", handleDisconnect);
@@ -547,32 +575,43 @@ const ClientProvider = ({
         provider.removeListener("disconnect", handleDisconnect);
       };
     }
-    function attachSolanaListeners(provider, onWalletsChanged) {
+    function attachSolanaListeners(provider, onUpdateState) {
       const cleanups = [];
       const walletEvents = provider?.features?.["standard:events"];
       if (walletEvents?.on) {
-        const offChange = walletEvents.on("change", _evt => {
-          onWalletsChanged();
+        const offChange = walletEvents.on("change", async _evt => {
+          await onUpdateState();
         });
         cleanups.push(offChange);
       }
       return () => cleanups.forEach(fn => fn());
     }
     ethProviders.forEach(p => {
-      const cleanup = attachEthereumListeners(p.provider, onWalletsChanged);
+      const cleanup = attachEthereumListeners(p.provider, onUpdateState);
       if (cleanup) cleanups.push(cleanup);
     });
     solProviders.forEach(p => {
-      const cleanup = attachSolanaListeners(p.provider, onWalletsChanged);
+      const cleanup = attachSolanaListeners(p.provider, onUpdateState);
       if (cleanup) cleanups.push(cleanup);
     });
-    wcProviders.forEach(p => {
-      const standardEvents = p.provider?.features?.["standard:events"];
+    if (wcProvider) {
+      const standardEvents = wcProvider.provider?.features?.["standard:events"];
       if (standardEvents?.on) {
-        const unsubscribe = standardEvents.on("change", onWalletsChanged);
-        cleanups.push(unsubscribe);
+        if (standardEvents?.on) {
+          const unsubscribe = standardEvents.on("change", async evt => {
+            // if the event is a proposalExpired, we want to re-fetch the providers
+            // to refresh the uri, there is no need to refresh the wallets state
+            if (evt?.type === "pairingExpired") {
+              debouncedFetchWalletProviders();
+            }
+            // any other event (disconnect, chain switch, accounts changed)
+            // we refresh the wallets state
+            await onUpdateState();
+          });
+          cleanups.push(unsubscribe);
+        }
       }
-    });
+    }
     return () => {
       cleanups.forEach(remove => remove());
     };
@@ -782,7 +821,7 @@ const ClientProvider = ({
     }
     return utils.withTurnkeyErrorHandling(() => client.createPasskey({
       ...params
-    }), callbacks, "Failed to create passkey");
+    }), () => logout(), callbacks, "Failed to create passkey");
   }, [client, callbacks]);
   const logout = react.useCallback(async params => {
     if (!client) {
@@ -795,7 +834,7 @@ 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);
-    }, callbacks, "Failed to logout");
+    }, () => logout(), callbacks, "Failed to logout");
     return;
   }, [client, callbacks]);
   const loginWithPasskey = react.useCallback(async params => {
@@ -806,7 +845,7 @@ const ClientProvider = ({
     const res = await utils.withTurnkeyErrorHandling(() => client.loginWithPasskey({
       ...params,
       expirationSeconds
-    }), callbacks, "Failed to login with passkey");
+    }), () => logout(), callbacks, "Failed to login with passkey");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Passkey,
@@ -845,7 +884,7 @@ const ClientProvider = ({
       ...params,
       passkeyDisplayName: passkeyName,
       expirationSeconds
-    }), callbacks, "Failed to sign up with passkey");
+    }), () => logout(), callbacks, "Failed to sign up with passkey");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Passkey,
@@ -871,26 +910,34 @@ const ClientProvider = ({
     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();
+    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]);
   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:
-    // 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();
-    }
+    // 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()`
   }, [client, callbacks]);
   const switchWalletAccountChain = react.useCallback(async params => {
     if (!client) {
@@ -909,7 +956,7 @@ const ClientProvider = ({
     const res = await utils.withTurnkeyErrorHandling(() => client.loginWithWallet({
       ...params,
       expirationSeconds
-    }), callbacks, "Failed to login with wallet");
+    }), () => logout(), callbacks, "Failed to login with wallet");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Wallet,
@@ -938,7 +985,7 @@ const ClientProvider = ({
     const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithWallet({
       ...params,
       expirationSeconds
-    }), callbacks, "Failed to sign up with wallet");
+    }), () => logout(), callbacks, "Failed to sign up with wallet");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Wallet,
@@ -967,7 +1014,7 @@ const ClientProvider = ({
     const res = await utils.withTurnkeyErrorHandling(() => client.loginOrSignupWithWallet({
       ...params,
       expirationSeconds
-    }), callbacks, "Failed to login or sign up with wallet");
+    }), () => logout(), callbacks, "Failed to login or sign up with wallet");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Wallet,
@@ -981,19 +1028,19 @@ const ClientProvider = ({
     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");
+    return utils.withTurnkeyErrorHandling(() => client.initOtp(params), () => logout(), 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), callbacks, "Failed to verify OTP");
+    return utils.withTurnkeyErrorHandling(() => client.verifyOtp(params), () => logout(), 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), callbacks, "Failed to login with OTP");
+    const res = await utils.withTurnkeyErrorHandling(() => client.loginWithOtp(params), () => logout(), callbacks, "Failed to login with OTP");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Otp,
@@ -1025,7 +1072,7 @@ const ClientProvider = ({
     } : {
       ...params
     };
-    const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithOtp(params), callbacks, "Failed to sign up with OTP");
+    const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithOtp(params), () => logout(), callbacks, "Failed to sign up with OTP");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Otp,
@@ -1057,7 +1104,7 @@ const ClientProvider = ({
     } : {
       ...params
     };
-    const res = await utils.withTurnkeyErrorHandling(() => client.completeOtp(params), callbacks, "Failed to complete OTP");
+    const res = await utils.withTurnkeyErrorHandling(() => client.completeOtp(params), () => logout(), callbacks, "Failed to complete OTP");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Otp,
@@ -1071,7 +1118,7 @@ const ClientProvider = ({
     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");
+    const res = await utils.withTurnkeyErrorHandling(() => client.loginWithOauth(params), () => logout(), callbacks, "Failed to login with OAuth");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Oauth,
@@ -1096,7 +1143,7 @@ const ClientProvider = ({
     } : {
       ...params
     };
-    const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithOauth(params), callbacks, "Failed to sign up with OAuth");
+    const res = await utils.withTurnkeyErrorHandling(() => client.signUpWithOauth(params), () => logout(), callbacks, "Failed to sign up with OAuth");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Oauth,
@@ -1121,7 +1168,7 @@ const ClientProvider = ({
     } : {
       ...params
     };
-    const res = await utils.withTurnkeyErrorHandling(() => client.completeOauth(params), callbacks, "Failed to complete OAuth");
+    const res = await utils.withTurnkeyErrorHandling(() => client.completeOauth(params), () => logout(), callbacks, "Failed to complete OAuth");
     if (res) {
       await handlePostAuth({
         method: base.AuthMethod.Oauth,
@@ -1135,23 +1182,23 @@ const ClientProvider = ({
     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");
+    return utils.withTurnkeyErrorHandling(() => client.fetchWallets(params), () => logout(), callbacks, "Failed to fetch wallets");
   }, [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");
+    return utils.withTurnkeyErrorHandling(() => client.fetchWalletAccounts(params), () => logout(), callbacks, "Failed to fetch wallet accounts");
   }, [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");
+    return utils.withTurnkeyErrorHandling(() => client.fetchPrivateKeys(params), () => logout(), 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");
+    return utils.withTurnkeyErrorHandling(() => client.signMessage(params), () => logout(), callbacks, "Failed to sign message");
   }, [client, callbacks]);
   const handleSignMessage = react.useCallback(async params => {
     const {
@@ -1181,6 +1228,9 @@ const ClientProvider = ({
           }),
           ...(params?.addEthereumPrefix && {
             addEthereumPrefix: params.addEthereumPrefix
+          }),
+          ...(params?.organizationId && {
+            organizationId: params.organizationId
           })
         })
       });
@@ -1188,153 +1238,230 @@ const ClientProvider = ({
   }, [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");
+    return utils.withTurnkeyErrorHandling(() => client.signTransaction(params), () => logout(), callbacks, "Failed to sign transaction");
   }, [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");
+    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), callbacks, "Failed to fetch user");
+    return utils.withTurnkeyErrorHandling(() => client.fetchUser(params), () => logout(), callbacks, "Failed to fetch user");
   }, [client, callbacks]);
   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), callbacks, "Failed to fetch or create delegated access user");
+    return utils.withTurnkeyErrorHandling(() => client.fetchOrCreateP256ApiKeyUser(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
   }, [client, callbacks]);
   const fetchOrCreatePolicies = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    return utils.withTurnkeyErrorHandling(() => client.fetchOrCreatePolicies(params), callbacks, "Failed to fetch or create delegated access user");
+    return utils.withTurnkeyErrorHandling(() => client.fetchOrCreatePolicies(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
   }, [client, callbacks]);
   const updateUserEmail = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    const res = await utils.withTurnkeyErrorHandling(() => client.updateUserEmail(params), callbacks, "Failed to update user email");
+    const res = await utils.withTurnkeyErrorHandling(() => client.updateUserEmail(params), () => logout(), callbacks, "Failed to update user email");
     if (res) await refreshUser({
-      stampWith: params?.stampWith
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
     });
     return res;
   }, [client, callbacks]);
   const removeUserEmail = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    const res = await utils.withTurnkeyErrorHandling(() => client.removeUserEmail(params), callbacks, "Failed to remove user email");
+    const res = await utils.withTurnkeyErrorHandling(() => client.removeUserEmail(params), () => logout(), callbacks, "Failed to remove user email");
     if (res) await refreshUser({
-      stampWith: params?.stampWith
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
     });
     return res;
   }, [client, callbacks]);
   const updateUserPhoneNumber = react.useCallback(async params => {
     if (!client) throw new sdkTypes.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");
+    const res = await utils.withTurnkeyErrorHandling(() => client.updateUserPhoneNumber(params), () => logout(), callbacks, "Failed to update user phone number");
     if (res) await refreshUser({
-      stampWith: params?.stampWith
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
     });
     return res;
   }, [client, callbacks]);
   const removeUserPhoneNumber = react.useCallback(async params => {
     if (!client) throw new sdkTypes.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");
+    const res = await utils.withTurnkeyErrorHandling(() => client.removeUserPhoneNumber(params), () => logout(), callbacks, "Failed to remove user phone number");
     if (res) await refreshUser({
-      stampWith: params?.stampWith
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
     });
     return res;
   }, [client, callbacks]);
   const updateUserName = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    const res = await utils.withTurnkeyErrorHandling(() => client.updateUserName(params), callbacks, "Failed to update user name");
+    const res = await utils.withTurnkeyErrorHandling(() => client.updateUserName(params), () => logout(), callbacks, "Failed to update user name");
     if (res) await refreshUser({
-      stampWith: params?.stampWith
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
     });
     return res;
   }, [client, callbacks]);
   const addOauthProvider = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    const res = await utils.withTurnkeyErrorHandling(() => client.addOauthProvider(params), callbacks, "Failed to add OAuth provider");
+    const res = await utils.withTurnkeyErrorHandling(() => client.addOauthProvider(params), () => logout(), callbacks, "Failed to add OAuth provider");
     if (res) await refreshUser({
-      stampWith: params?.stampWith
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
     });
     return res;
   }, [client, callbacks]);
   const removeOauthProviders = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    const res = await utils.withTurnkeyErrorHandling(() => client.removeOauthProviders(params), callbacks, "Failed to remove OAuth providers");
+    const res = await utils.withTurnkeyErrorHandling(() => client.removeOauthProviders(params), () => logout(), callbacks, "Failed to remove OAuth providers");
     if (res) await refreshUser({
-      stampWith: params?.stampWith
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
     });
     return res;
   }, [client, callbacks]);
   const addPasskey = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    const res = await utils.withTurnkeyErrorHandling(() => client.addPasskey(params), callbacks, "Failed to add passkey");
+    const res = await utils.withTurnkeyErrorHandling(() => client.addPasskey(params), () => logout(), callbacks, "Failed to add passkey");
     if (res) await refreshUser({
-      stampWith: params?.stampWith
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
     });
     return res;
   }, [client, callbacks]);
   const removePasskeys = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    const res = await utils.withTurnkeyErrorHandling(() => client.removePasskeys(params), callbacks, "Failed to remove passkeys");
+    const res = await utils.withTurnkeyErrorHandling(() => client.removePasskeys(params), () => logout(), callbacks, "Failed to remove passkeys");
     if (res) await refreshUser({
-      stampWith: params?.stampWith
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
     });
     return res;
   }, [client, callbacks]);
   const createWallet = react.useCallback(async params => {
     if (!client) throw new sdkTypes.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
+    const res = await utils.withTurnkeyErrorHandling(() => client.createWallet(params), () => logout(), callbacks, "Failed to create wallet");
+    const s = await getSession();
+    if (res && s) await refreshWallets({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, session, 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
+    const res = await utils.withTurnkeyErrorHandling(() => client.createWalletAccounts(params), () => logout(), callbacks, "Failed to create wallet accounts");
+    const s = await getSession();
+    if (res && s) await refreshWallets({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, session, 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
+    const res = await utils.withTurnkeyErrorHandling(() => client.exportWallet(params), () => logout(), callbacks, "Failed to export wallet");
+    const s = await getSession();
+    if (res && s) await refreshWallets({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      })
     });
     return res;
-  }, [client, callbacks]);
+  }, [client, session, 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");
+    const res = await utils.withTurnkeyErrorHandling(() => client.exportPrivateKey(params), () => logout(), callbacks, "Failed to export private key");
     return res;
   }, [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
+    const res = await utils.withTurnkeyErrorHandling(() => client.exportWalletAccount(params), () => logout(), callbacks, "Failed to export wallet accounts");
+    const s = await getSession();
+    if (res && s) await refreshWallets({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      })
     });
     return res;
   }, [client, callbacks, masterConfig, session, user]);
   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
+    const res = await utils.withTurnkeyErrorHandling(() => client.importWallet(params), () => logout(), callbacks, "Failed to import wallet");
+    const s = await getSession();
+    if (res && s) await refreshWallets({
+      stampWith: params?.stampWith,
+      ...(params?.organizationId && {
+        organizationId: params.organizationId
+      }),
+      ...(params?.userId && {
+        userId: params.userId
+      })
     });
     return res;
   }, [client, callbacks, masterConfig, session, user]);
   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");
+    const res = await utils.withTurnkeyErrorHandling(() => client.importPrivateKey(params), () => logout(), callbacks, "Failed to import private key");
     return res;
   }, [client, callbacks, masterConfig, session, user]);
   const deleteSubOrganization = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    return utils.withTurnkeyErrorHandling(() => client.deleteSubOrganization(params), callbacks, "Failed to delete sub-organization");
+    return utils.withTurnkeyErrorHandling(() => client.deleteSubOrganization(params), () => logout(), callbacks, "Failed to delete sub-organization");
   }, [client, callbacks, masterConfig, session, user]);
   const storeSession = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    await utils.withTurnkeyErrorHandling(() => client.storeSession(params), callbacks, "Failed to store session");
+    await utils.withTurnkeyErrorHandling(() => client.storeSession(params), () => logout(), callbacks, "Failed to store session");
     const sessionKey = await getActiveSessionKey();
     const session = await getSession({
       ...(sessionKey && {
@@ -1352,18 +1479,29 @@ const ClientProvider = ({
   }, [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(() => client.clearSession(params), callbacks, "Failed to clear session");
-    const session = await getSession();
-    const allSessions = await getAllSessions();
-    setSession(session);
-    setAllSessions(allSessions);
+    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]);
   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");
+    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) {
@@ -1376,7 +1514,7 @@ const ClientProvider = ({
     const sessionKey = params?.sessionKey ?? activeSessionKey;
     const res = await utils.withTurnkeyErrorHandling(() => client.refreshSession({
       ...params
-    }), callbacks, "Failed to refresh session");
+    }), () => logout(), callbacks, "Failed to refresh session");
     const session = await getSession({
       sessionKey
     });
@@ -1396,71 +1534,89 @@ const ClientProvider = ({
   }, [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), callbacks, "Failed to get session");
+    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(), callbacks, "Failed to get all sessions");
+    return utils.withTurnkeyErrorHandling(() => client.getAllSessions(), () => logout(), callbacks, "Failed to get all sessions");
   }, [client, callbacks, masterConfig, session, user]);
   const setActiveSession = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     const session = await utils.withTurnkeyErrorHandling(() => client.getSession({
       sessionKey: params.sessionKey
-    }), callbacks, "Failed to get session");
-    if (!session) {
+    }), () => logout(), callbacks, "Failed to get session");
+    const s = await getSession();
+    if (!s) {
       throw new sdkTypes.TurnkeyError("Session not found.", sdkTypes.TurnkeyErrorCodes.NOT_FOUND);
     }
-    await utils.withTurnkeyErrorHandling(() => client.setActiveSession(params), callbacks, "Failed to set active session");
+    await utils.withTurnkeyErrorHandling(() => client.setActiveSession(params), () => logout(), 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");
+    }, () => 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(), callbacks, "Failed to get active session key");
+    return utils.withTurnkeyErrorHandling(() => client.getActiveSessionKey(), () => logout(), callbacks, "Failed to get active session key");
   }, [client, callbacks, masterConfig, session, user]);
   const clearUnusedKeyPairs = react.useCallback(async () => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    return utils.withTurnkeyErrorHandling(() => client.clearUnusedKeyPairs(), callbacks, "Failed to clear unused key pairs");
+    return utils.withTurnkeyErrorHandling(() => client.clearUnusedKeyPairs(), () => logout(), callbacks, "Failed to clear unused key pairs");
   }, [client, callbacks, masterConfig, session, user]);
   const createApiKeyPair = react.useCallback(async params => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    return utils.withTurnkeyErrorHandling(() => client.createApiKeyPair(params), callbacks, "Failed to create API key pair");
+    return utils.withTurnkeyErrorHandling(() => client.createApiKeyPair(params), () => logout(), callbacks, "Failed to create API key pair");
   }, [client, callbacks, session, user, masterConfig]);
   const getProxyAuthConfig = react.useCallback(async () => {
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    return utils.withTurnkeyErrorHandling(() => client.getProxyAuthConfig(), callbacks, "Failed to get proxy auth config");
+    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
+      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
-    }), callbacks, "Failed to refresh user");
+      stampWith,
+      ...(organizationId && {
+        organizationId
+      }),
+      ...(userId && {
+        userId
+      })
+    }), () => logout(), callbacks, "Failed to refresh user");
     if (user) {
       setUser(user);
     }
   }, [client, callbacks, fetchUser, masterConfig, session, user]);
   const refreshWallets = react.useCallback(async params => {
-    if (!masterConfig?.autoRefreshManagedState) return;
+    if (!masterConfig?.autoRefreshManagedState) return [];
     const {
-      stampWith
+      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(), callbacks, "Failed to refresh wallets");
+    const walletProviders = await utils.withTurnkeyErrorHandling(() => fetchWalletProviders(), () => logout(), callbacks, "Failed to refresh wallets");
     const wallets = await utils.withTurnkeyErrorHandling(() => fetchWallets({
       stampWith,
-      walletProviders
-    }), callbacks, "Failed to refresh wallets");
+      walletProviders,
+      ...(organizationId && {
+        organizationId
+      }),
+      ...(userId && {
+        userId
+      })
+    }), () => logout(), callbacks, "Failed to refresh wallets");
     if (wallets) {
       setWallets(wallets);
     }
+    return wallets;
   }, [client, callbacks, fetchWalletProviders, fetchWallets, masterConfig, session, user]);
   const handleDiscordOauth = react.useCallback(async params => {
     const {
@@ -2135,86 +2291,112 @@ const ClientProvider = ({
     }
   }, [client, callbacks, masterConfig, client, session, user]);
   const handleLogin = react.useCallback(async params => {
+    const logo = masterConfig?.ui?.darkMode ? params?.logoDark ?? masterConfig?.ui?.logoDark : params?.logoLight ?? masterConfig?.ui?.logoLight;
     pushPage({
-      key: "Log in or sign up",
+      key: params?.title ?? "Log in or sign up",
       content: jsxRuntime.jsx(index.AuthComponent, {
-        sessionKey: params?.sessionKey
-      })
+        sessionKey: params?.sessionKey,
+        logo: logo,
+        logoClassName: params?.logoClassName,
+        title: params?.title
+      }),
+      showTitle: logo ? false : true
     });
   }, [pushPage, masterConfig, client, session, user]);
   const handleExportWallet = react.useCallback(async params => {
     const {
       walletId,
       targetPublicKey,
-      stampWith
+      stampWith,
+      organizationId
     } = params;
-    pushPage({
+    return new Promise((resolve, reject) => pushPage({
       key: "Export wallet",
       content: jsxRuntime.jsx(Export.ExportComponent, {
         target: walletId,
         exportType: base.ExportType.Wallet,
-        ...(targetPublicKey !== undefined ? {
+        ...(targetPublicKey !== undefined && {
           targetPublicKey
-        } : {}),
-        ...(stampWith !== undefined ? {
+        }),
+        ...(stampWith !== undefined && {
           stampWith
-        } : {})
+        }),
+        ...(organizationId !== undefined && {
+          organizationId
+        }),
+        onSuccess: () => resolve(),
+        onError: error => reject(error)
       })
-    });
+    }));
   }, [pushPage, masterConfig, client, session, user]);
   const handleExportPrivateKey = react.useCallback(async params => {
     const {
       privateKeyId,
       targetPublicKey,
       keyFormat,
-      stampWith
+      stampWith,
+      organizationId
     } = params;
-    pushPage({
+    return new Promise((resolve, reject) => pushPage({
       key: "Export private key",
       content: jsxRuntime.jsx(Export.ExportComponent, {
         target: privateKeyId,
         exportType: base.ExportType.PrivateKey,
-        ...(keyFormat !== undefined ? {
+        ...(keyFormat !== undefined && {
           keyFormat
-        } : {}),
-        ...(targetPublicKey !== undefined ? {
+        }),
+        ...(targetPublicKey !== undefined && {
           targetPublicKey
-        } : {}),
-        ...(stampWith !== undefined ? {
+        }),
+        ...(stampWith !== undefined && {
           stampWith
-        } : {})
+        }),
+        ...(organizationId !== undefined && {
+          organizationId
+        }),
+        onSuccess: () => resolve(),
+        onError: error => reject(error)
       })
-    });
+    }));
   }, [pushPage, masterConfig, client, session, user]);
   const handleExportWalletAccount = react.useCallback(async params => {
     const {
       address,
       targetPublicKey,
       keyFormat,
-      stampWith
+      stampWith,
+      organizationId
     } = params;
-    pushPage({
+    return new Promise((resolve, reject) => pushPage({
       key: "Export wallet account",
       content: jsxRuntime.jsx(Export.ExportComponent, {
         target: address,
         exportType: base.ExportType.WalletAccount,
-        ...(keyFormat !== undefined ? {
+        ...(keyFormat !== undefined && {
           keyFormat
-        } : {}),
-        ...(targetPublicKey !== undefined ? {
+        }),
+        ...(targetPublicKey !== undefined && {
           targetPublicKey
-        } : {}),
-        ...(stampWith !== undefined ? {
+        }),
+        ...(stampWith !== undefined && {
           stampWith
-        } : {})
+        }),
+        ...(organizationId !== undefined && {
+          organizationId
+        }),
+        onSuccess: () => resolve(),
+        onError: error => reject(error)
       })
-    });
+    }));
   }, [pushPage, masterConfig, client, session, user]);
   const handleImportWallet = react.useCallback(async params => {
     const {
       defaultWalletAccounts,
       successPageDuration = 2000,
-      stampWith
+      stampWith,
+      walletName,
+      organizationId,
+      userId
     } = params || {};
     try {
       return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => pushPage({
@@ -2233,9 +2415,18 @@ const ClientProvider = ({
           }),
           ...(stampWith !== undefined && {
             stampWith
+          }),
+          ...(walletName !== undefined && {
+            name: walletName
+          }),
+          ...(organizationId !== undefined && {
+            organizationId
+          }),
+          ...(userId !== undefined && {
+            userId
           })
         })
-      })));
+      })), () => logout());
     } catch (error) {
       if (error instanceof sdkTypes.TurnkeyError) {
         throw error;
@@ -2248,7 +2439,9 @@ const ClientProvider = ({
       curve,
       addressFormats,
       successPageDuration = 2000,
-      stampWith
+      stampWith,
+      keyName,
+      organizationId
     } = params || {};
     try {
       return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => pushPage({
@@ -2266,9 +2459,15 @@ const ClientProvider = ({
           }),
           ...(stampWith !== undefined && {
             stampWith
+          }),
+          ...(keyName !== undefined && {
+            name: keyName
+          }),
+          ...(organizationId !== undefined && {
+            organizationId
           })
         })
-      })));
+      })), () => logout());
     } catch (error) {
       if (error instanceof sdkTypes.TurnkeyError) {
         throw error;
@@ -2284,8 +2483,14 @@ const ClientProvider = ({
       stampWith
     } = params || {};
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    if (!session) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.TurnkeyError("A session or passed in organization ID is required.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || user?.userId;
+    if (!userId) {
+      throw new sdkTypes.TurnkeyError("A user ID is required to update a user name.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
     }
     const onSuccess = () => {
       if (!successPageDuration) return;
@@ -2316,21 +2521,26 @@ const ClientProvider = ({
               },
               successPageDuration: successPageDuration,
               stampWith: stampWith,
-              ...(title !== undefined ? {
+              ...(title !== undefined && {
                 title
-              } : {}),
-              ...(subTitle !== undefined ? {
+              }),
+              ...(subTitle !== undefined && {
                 subTitle
-              } : {})
+              }),
+              organizationId: organizationId,
+              userId: userId
             }),
             showTitle: false
           });
-        }));
+        }), () => logout());
       } else {
         const res = await updateUserName({
           userName: params.userName,
           userId: user.userId,
-          stampWith
+          stampWith,
+          ...(organizationId !== undefined && {
+            organizationId
+          })
         });
         onSuccess();
         return res;
@@ -2346,18 +2556,25 @@ const ClientProvider = ({
     const {
       successPageDuration = 2000,
       subTitle,
-      title
+      title,
+      stampWith
     } = params || {};
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    if (!session) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
-    }
     if (!masterConfig) {
       throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.CONFIG_NOT_INITIALIZED);
     }
     if (!masterConfig.auth?.methods?.smsOtpAuthEnabled) {
       throw new sdkTypes.TurnkeyError("SMS OTP authentication is not enabled in the configuration.", sdkTypes.TurnkeyErrorCodes.AUTH_METHOD_NOT_ENABLED);
     }
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.TurnkeyError("A session or passed in organization ID is required.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.TurnkeyError("A user ID is required to update a phone number.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
+    }
     const onSuccess = () => {
       if (!successPageDuration) return;
       pushPage({
@@ -2382,16 +2599,21 @@ const ClientProvider = ({
               successPageDuration: successPageDuration,
               onSuccess: userId => resolve(userId),
               onError: error => reject(error),
-              ...(title !== undefined ? {
+              organizationId: organizationId,
+              userId: userId,
+              ...(title !== undefined && {
                 title
-              } : {}),
-              ...(subTitle !== undefined ? {
+              }),
+              ...(subTitle !== undefined && {
                 subTitle
-              } : {})
+              }),
+              ...(stampWith !== undefined && {
+                stampWith
+              })
             }),
             showTitle: false
           });
-        }));
+        }), () => logout());
       } else {
         const otpId = await initOtp({
           otpType: core.OtpType.Sms,
@@ -2404,6 +2626,8 @@ const ClientProvider = ({
               otpType: core.OtpType.Sms,
               contact: params.phoneNumber,
               otpId: otpId,
+              otpLength: masterConfig.auth?.otpLength !== undefined ? Number(masterConfig.auth.otpLength) : undefined,
+              alphanumeric: masterConfig.auth?.otpAlphanumeric,
               onContinue: async otpCode => {
                 try {
                   const {
@@ -2417,7 +2641,11 @@ const ClientProvider = ({
                   const res = await updateUserPhoneNumber({
                     phoneNumber: params.phoneNumber,
                     verificationToken,
-                    userId: user.userId
+                    userId,
+                    organizationId,
+                    ...(stampWith !== undefined && {
+                      stampWith
+                    })
                   });
                   onSuccess();
                   resolve(res);
@@ -2437,7 +2665,7 @@ const ClientProvider = ({
             }),
             showTitle: false
           });
-        }), callbacks, "Failed to update phone number");
+        }), () => logout(), callbacks, "Failed to update phone number");
       }
     } catch (error) {
       if (error instanceof sdkTypes.TurnkeyError) {
@@ -2450,11 +2678,18 @@ const ClientProvider = ({
     const {
       successPageDuration = 2000,
       subTitle,
-      title
+      title,
+      stampWith
     } = params || {};
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    if (!session) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.TurnkeyError("A session or passed in organization ID is required.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.TurnkeyError("A user ID is required to update an email.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
     }
     const onSuccess = () => {
       if (!successPageDuration) return;
@@ -2482,16 +2717,21 @@ const ClientProvider = ({
                 resolve(userId);
               },
               onError: error => reject(error),
-              ...(title !== undefined ? {
+              organizationId: organizationId,
+              userId: userId,
+              ...(title !== undefined && {
                 title
-              } : {}),
-              ...(subTitle !== undefined ? {
+              }),
+              ...(subTitle !== undefined && {
                 subTitle
-              } : {})
+              }),
+              ...(stampWith !== undefined && {
+                stampWith
+              })
             }),
             showTitle: false
           });
-        }));
+        }), () => logout());
       } else {
         const otpId = await initOtp({
           otpType: core.OtpType.Email,
@@ -2504,6 +2744,8 @@ const ClientProvider = ({
               otpType: core.OtpType.Email,
               contact: params.email,
               otpId: otpId,
+              otpLength: masterConfig?.auth?.otpLength !== undefined ? Number(masterConfig.auth.otpLength) : undefined,
+              alphanumeric: masterConfig?.auth?.otpAlphanumeric,
               onContinue: async otpCode => {
                 try {
                   const {
@@ -2517,7 +2759,11 @@ const ClientProvider = ({
                   const res = await updateUserEmail({
                     email: params.email,
                     verificationToken,
-                    userId: user.userId
+                    userId,
+                    organizationId,
+                    ...(stampWith !== undefined && {
+                      stampWith
+                    })
                   });
                   onSuccess();
                   resolve(res);
@@ -2534,7 +2780,7 @@ const ClientProvider = ({
             }),
             showTitle: false
           });
-        }), callbacks, "Failed to update email");
+        }), () => logout(), callbacks, "Failed to update email");
       }
     } catch (error) {
       if (error instanceof sdkTypes.TurnkeyError) {
@@ -2547,13 +2793,20 @@ const ClientProvider = ({
     const {
       successPageDuration = 2000,
       subTitle,
-      title
+      title,
+      stampWith
     } = params || {};
     if (!client) {
       throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
     }
-    if (!session) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.TurnkeyError("A session or passed in organization ID is required.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.TurnkeyError("A user ID is required to add an email.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
     }
     const onSuccess = () => {
       if (!successPageDuration) return;
@@ -2586,11 +2839,14 @@ const ClientProvider = ({
               } : {}),
               ...(subTitle !== undefined ? {
                 subTitle
-              } : {})
+              } : {}),
+              organizationId: organizationId,
+              userId: userId,
+              stampWith: stampWith
             }),
             showTitle: false
           });
-        }));
+        }), () => logout());
       } else {
         const otpId = await initOtp({
           otpType: core.OtpType.Email,
@@ -2603,6 +2859,8 @@ const ClientProvider = ({
               otpType: core.OtpType.Email,
               contact: params.email,
               otpId: otpId,
+              otpLength: masterConfig?.auth?.otpLength !== undefined ? Number(masterConfig.auth.otpLength) : undefined,
+              alphanumeric: masterConfig?.auth?.otpAlphanumeric,
               onContinue: async otpCode => {
                 try {
                   const {
@@ -2616,7 +2874,9 @@ const ClientProvider = ({
                   const res = await updateUserEmail({
                     email: params.email,
                     verificationToken,
-                    userId: user.userId
+                    userId,
+                    organizationId,
+                    stampWith
                   });
                   onSuccess();
                   resolve(res);
@@ -2633,7 +2893,7 @@ const ClientProvider = ({
             }),
             showTitle: false
           });
-        }), callbacks, "Failed to add email");
+        }), () => logout(), callbacks, "Failed to add email");
       }
     } catch (error) {
       if (error instanceof sdkTypes.TurnkeyError) {
@@ -2646,18 +2906,25 @@ const ClientProvider = ({
     const {
       successPageDuration = 2000,
       subTitle,
-      title
+      title,
+      stampWith
     } = params || {};
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    if (!session) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
-    }
     if (!masterConfig) {
       throw new sdkTypes.TurnkeyError("Config is not ready yet!", sdkTypes.TurnkeyErrorCodes.CONFIG_NOT_INITIALIZED);
     }
     if (!masterConfig.auth?.methods?.smsOtpAuthEnabled) {
       throw new sdkTypes.TurnkeyError("SMS OTP authentication is not enabled in the configuration.", sdkTypes.TurnkeyErrorCodes.AUTH_METHOD_NOT_ENABLED);
     }
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.TurnkeyError("A session or passed in organization ID is required.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.TurnkeyError("A user ID is required to add a phone number.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
+    }
     const onSuccess = () => {
       if (!successPageDuration) return;
       pushPage({
@@ -2691,11 +2958,14 @@ const ClientProvider = ({
               }),
               ...(subTitle !== undefined && {
                 subTitle
-              })
+              }),
+              organizationId: organizationId,
+              userId: userId,
+              stampWith: stampWith
             }),
             showTitle: false
           });
-        }), callbacks, "Failed to add phone number");
+        }), () => logout(), callbacks, "Failed to add phone number");
       } else {
         const otpId = await initOtp({
           otpType: core.OtpType.Sms,
@@ -2708,6 +2978,8 @@ const ClientProvider = ({
               otpType: core.OtpType.Sms,
               contact: params.phoneNumber,
               otpId: otpId,
+              otpLength: masterConfig.auth?.otpLength !== undefined ? Number(masterConfig.auth.otpLength) : undefined,
+              alphanumeric: masterConfig?.auth?.otpAlphanumeric,
               onContinue: async otpCode => {
                 try {
                   const {
@@ -2721,7 +2993,9 @@ const ClientProvider = ({
                   const res = await updateUserPhoneNumber({
                     phoneNumber: params.phoneNumber,
                     verificationToken,
-                    userId: user.userId
+                    userId: user.userId,
+                    organizationId,
+                    stampWith
                   });
                   onSuccess();
                   resolve(res);
@@ -2741,7 +3015,7 @@ const ClientProvider = ({
             }),
             showTitle: false
           });
-        }), callbacks, "Failed to add phone number");
+        }), () => logout(), callbacks, "Failed to add phone number");
       }
     } catch (error) {
       if (error instanceof sdkTypes.TurnkeyError) {
@@ -2760,8 +3034,10 @@ const ClientProvider = ({
       userId
     } = params;
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    if (!session) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.TurnkeyError("A session or passed in organization ID is required.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
     }
     return utils.withTurnkeyErrorHandling(() => new Promise((resolve, reject) => {
       pushPage({
@@ -2784,12 +3060,15 @@ const ClientProvider = ({
           }),
           ...(subTitle !== undefined && {
             subTitle
+          }),
+          ...(organizationId !== undefined && {
+            organizationId
           })
         }),
         showTitle: false,
         preventBack: true
       });
-    }), callbacks, "Failed to remove passkey");
+    }), () => logout(), callbacks, "Failed to remove passkey");
   }, [pushPage, masterConfig, client, session, user]);
   const handleAddPasskey = react.useCallback(async params => {
     const {
@@ -2799,10 +3078,15 @@ const ClientProvider = ({
       stampWith
     } = params || {};
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    if (!session) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.TurnkeyError("A session or passed in organization ID is required.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.TurnkeyError("A user ID or a valid session is required to add a passkey.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
     }
-    const userId = params?.userId || session.userId;
     try {
       const resPromise = addPasskey({
         ...(name && {
@@ -2812,7 +3096,10 @@ const ClientProvider = ({
           displayName
         }),
         userId,
-        stampWith
+        stampWith,
+        ...(organizationId && {
+          organizationId
+        })
       });
       resPromise.then(() => {
         pushPage({
@@ -2845,8 +3132,10 @@ const ClientProvider = ({
       stampWith
     } = params;
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    if (!session) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.TurnkeyError("A session or passed in organization ID is required.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
     }
     try {
       return new Promise((resolve, reject) => {
@@ -2867,6 +3156,9 @@ const ClientProvider = ({
             }),
             ...(subTitle !== undefined && {
               subTitle
+            }),
+            ...(organizationId !== undefined && {
+              organizationId
             })
           }),
           showTitle: false,
@@ -2882,97 +3174,113 @@ const ClientProvider = ({
   }, [pushPage, masterConfig, client, session, user]);
   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);
-    }
     const {
       providerName,
-      stampWith
+      stampWith,
+      successPageDuration = 2000
     } = params;
-    const onOauthSuccess = async params => {
-      await addOauthProvider({
-        providerName: params.providerName,
-        oidcToken: params.oidcToken,
-        stampWith
-      });
-      pushPage({
-        key: "OAuth Provider Added",
-        content: jsxRuntime.jsx(Success.SuccessPage, {
-          text: `Successfully added ${params.providerName} OAuth provider!`,
-          duration: 3000,
-          onComplete: () => {
-            closeModal();
-          }
-        }),
-        preventBack: true,
-        showTitle: false
-      });
-    };
-    switch (providerName) {
-      case sdkTypes.OAuthProviders.DISCORD:
-        {
-          await handleDiscordOauth({
-            openInPage: false,
-            onOauthSuccess
-          });
-          break;
-        }
-      case sdkTypes.OAuthProviders.X:
-        {
-          await handleXOauth({
-            openInPage: false,
-            onOauthSuccess
-          });
-          break;
-        }
-      case sdkTypes.OAuthProviders.GOOGLE:
-        {
-          await handleGoogleOauth({
-            openInPage: false,
-            onOauthSuccess
-          });
-          break;
-        }
-      case sdkTypes.OAuthProviders.APPLE:
-        {
-          await handleAppleOauth({
-            openInPage: false,
-            onOauthSuccess
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.TurnkeyError("A session or passed in organization ID is required.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
+    }
+    const userId = params?.userId || s?.userId;
+    if (!userId) {
+      throw new sdkTypes.TurnkeyError("A user ID is required to add an OAuth provider.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
+    }
+    return new Promise(async (resolve, reject) => {
+      try {
+        const onOauthSuccess = async params => {
+          await addOauthProvider({
+            providerName: params.providerName,
+            oidcToken: params.oidcToken,
+            stampWith,
+            organizationId,
+            userId
           });
-          break;
-        }
-      case sdkTypes.OAuthProviders.FACEBOOK:
-        {
-          await handleFacebookOauth({
-            openInPage: false,
-            onOauthSuccess
+          resolve();
+          pushPage({
+            key: "OAuth Provider Added",
+            content: jsxRuntime.jsx(Success.SuccessPage, {
+              text: `Successfully added ${params.providerName} OAuth provider!`,
+              duration: successPageDuration,
+              onComplete: () => {
+                closeModal();
+              }
+            }),
+            preventBack: true,
+            showTitle: false
           });
-          break;
-        }
-      default:
-        {
-          throw new sdkTypes.TurnkeyError(`Unsupported OAuth provider: ${providerName}`, sdkTypes.TurnkeyErrorCodes.NOT_FOUND);
+        };
+        switch (providerName) {
+          case sdkTypes.OAuthProviders.DISCORD:
+            {
+              return await handleDiscordOauth({
+                openInPage: false,
+                onOauthSuccess
+              });
+            }
+          case sdkTypes.OAuthProviders.X:
+            {
+              return await handleXOauth({
+                openInPage: false,
+                onOauthSuccess
+              });
+            }
+          case sdkTypes.OAuthProviders.GOOGLE:
+            {
+              return await handleGoogleOauth({
+                openInPage: false,
+                onOauthSuccess
+              });
+            }
+          case sdkTypes.OAuthProviders.APPLE:
+            {
+              return await handleAppleOauth({
+                openInPage: false,
+                onOauthSuccess
+              });
+            }
+          case sdkTypes.OAuthProviders.FACEBOOK:
+            {
+              return await handleFacebookOauth({
+                openInPage: false,
+                onOauthSuccess
+              });
+            }
+          default:
+            {
+              throw new sdkTypes.TurnkeyError(`Unsupported OAuth provider: ${providerName}`, sdkTypes.TurnkeyErrorCodes.NOT_FOUND);
+            }
         }
-    }
+      } catch (error) {
+        reject(error);
+      }
+    });
   }, [pushPage, masterConfig, client, session, user]);
   const handleConnectExternalWallet = react.useCallback(async params => {
     const {
       successPageDuration = 2000
     } = params || {};
     if (!client) throw new sdkTypes.TurnkeyError("Client is not initialized.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
-    if (!session) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
-    }
     if (!masterConfig?.walletConfig?.features?.connecting) {
       throw new sdkTypes.TurnkeyError("Wallet connecting is not enabled.", sdkTypes.TurnkeyErrorCodes.FEATURE_NOT_ENABLED);
     }
     const providers = await fetchWalletProviders();
-    pushPage({
-      key: "Connect wallet",
-      content: jsxRuntime.jsx(ConnectWallet.ConnectWalletModal, {
-        providers: providers,
-        successPageDuration: successPageDuration
-      })
+    return new Promise((resolve, reject) => {
+      pushPage({
+        key: "Connect wallet",
+        content: jsxRuntime.jsx(ConnectWallet.ConnectWalletModal, {
+          providers: providers,
+          successPageDuration: successPageDuration,
+          onSuccess: () => {
+            resolve();
+          },
+          onError: error => {
+            reject(error);
+          }
+        })
+      });
     });
   }, [pushPage, masterConfig, client, session, user]);
   const handleRemoveUserEmail = react.useCallback(async params => {
@@ -2981,8 +3289,10 @@ const ClientProvider = ({
       stampWith,
       userId
     } = params || {};
-    if (!session) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.TurnkeyError("A session or passed in organization ID is required.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
     }
     try {
       return new Promise((resolve, reject) => {
@@ -3001,7 +3311,10 @@ const ClientProvider = ({
             },
             onError: error => {
               reject(error);
-            }
+            },
+            ...(organizationId !== undefined && {
+              organizationId
+            })
           }),
           showTitle: false,
           preventBack: true
@@ -3020,8 +3333,10 @@ const ClientProvider = ({
       stampWith,
       userId
     } = params || {};
-    if (!session) {
-      throw new sdkTypes.TurnkeyError("No active session found.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.TurnkeyError("A session or passed in organization ID is required.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
     }
     try {
       return new Promise((resolve, reject) => {
@@ -3040,7 +3355,10 @@ const ClientProvider = ({
             },
             onError: error => {
               reject(error);
-            }
+            },
+            ...(organizationId !== undefined && {
+              organizationId
+            })
           }),
           showTitle: false,
           preventBack: true
@@ -3089,23 +3407,29 @@ const ClientProvider = ({
    * 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
+   * listeners in `initializeWalletProviderListeners` share the same instance, instead of creating
    * a new one on every render.
    */
   const debouncedRefreshWallets = utils.useDebouncedCallback(refreshWallets, 100);
+  const debouncedFetchWalletProviders = utils.useDebouncedCallback(fetchWalletProviders, 100);
   react.useEffect(() => {
     if (!client) return;
-    const handleRefreshWallets = async () => {
+    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) {
-        // this will update our walletProvider state
+        // this updates both the wallets and walletProviders state
         await debouncedRefreshWallets();
+      } else {
+        // this updates only the walletProviders state
+        await debouncedFetchWalletProviders();
       }
     };
     let cleanup = () => {};
-    initializeWalletProviderListeners(walletProviders, handleRefreshWallets).then(fn => {
+    initializeWalletProviderListeners(walletProviders, handleUpdateState).then(fn => {
       cleanup = fn;
     }).catch(err => {
       console.error("Failed to init providers:", err);
@@ -3113,7 +3437,7 @@ const ClientProvider = ({
     return () => {
       cleanup();
     };
-  }, [client, walletProviders]);
+  }, [client, walletProviders, session]);
   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.
@@ -3128,6 +3452,11 @@ const ClientProvider = ({
     if (!client || !masterConfig) return;
     completeRedirectOauth().finally(() => {
       clearSessionTimeouts();
+      // if auth or wallet connecting features are enabled, we want to fetch
+      // the wallet providers to set the state
+      if (masterConfig.walletConfig?.features?.auth || masterConfig.walletConfig?.features?.connecting) {
+        fetchWalletProviders();
+      }
       initializeSessions().finally(() => {
         // Set the client state to ready only after all initializations are done.
         setClientState(base.ClientState.Ready);
@@ -3145,6 +3474,7 @@ const ClientProvider = ({
       authState,
       user,
       wallets,
+      walletProviders,
       config: masterConfig,
       httpClient: client?.httpClient,
       createPasskey,