@turnkey/core 1.0.0-beta.2 → 1.0.0-beta.5

package/dist/__clients__/core.js

@@ -32,7 +32,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error during passkey creation, or if the platform is unsupported.
          */
         this.createPasskey = async (params) => {
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const name = params?.name || "A Passkey";
                 const displayName = params?.displayName || "A Passkey";
                 let passkey;
@@ -70,16 +70,16 @@ class TurnkeyClient {
                     throw new sdkTypes.TurnkeyError("Unsupported platform for passkey creation", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
                 }
                 return passkey;
-            }
-            catch (error) {
-                if (error?.message?.includes("timed out or was not allowed")) {
-                    throw new sdkTypes.TurnkeyError("Passkey creation was cancelled by the user.", sdkTypes.TurnkeyErrorCodes.SELECT_PASSKEY_CANCELLED, error);
-                }
-                else if (error instanceof sdkTypes.TurnkeyError) {
-                    throw error;
-                }
-                throw new sdkTypes.TurnkeyError(`Failed to create passkey`, sdkTypes.TurnkeyErrorCodes.CREATE_PASSKEY_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to create passkey",
+                errorCode: sdkTypes.TurnkeyErrorCodes.CREATE_PASSKEY_ERROR,
+                customMessageByMessages: {
+                    "timed out or was not allowed": {
+                        message: "Passkey creation was cancelled by the user.",
+                        code: sdkTypes.TurnkeyErrorCodes.SELECT_PASSKEY_CANCELLED,
+                    },
+                },
+            });
         };
         /**
          * Logs out the current client session.
@@ -93,7 +93,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is no active session or if there is an error during the logout process.
          */
         this.logout = async (params) => {
-            try {
+            utils.withTurnkeyErrorHandling(async () => {
                 if (params?.sessionKey) {
                     const session = await this.storageManager.getSession(params.sessionKey);
                     this.storageManager.clearSession(params.sessionKey);
@@ -110,12 +110,10 @@ class TurnkeyClient {
                         throw new sdkTypes.TurnkeyError("No active session found to log out from.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
                     }
                 }
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to log out`, sdkTypes.TurnkeyErrorCodes.LOGOUT_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to log out",
+                errorCode: sdkTypes.TurnkeyErrorCodes.LOGOUT_ERROR,
+            });
         };
         /**
          * Logs in a user using a passkey, optionally specifying the public key, session key, and session expiration.
@@ -133,16 +131,17 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error during the passkey login process or if the user cancels the passkey prompt.
          */
         this.loginWithPasskey = async (params) => {
-            let generatedKeyPair = null;
-            try {
-                const publicKey = params?.publicKey || (await this.apiKeyStamper?.createKeyPair());
+            let generatedKeyPair = undefined;
+            return await utils.withTurnkeyErrorHandling(async () => {
+                generatedKeyPair =
+                    params?.publicKey || (await this.apiKeyStamper?.createKeyPair());
                 const sessionKey = params?.sessionKey || base.SessionKey.DefaultSessionkey;
                 const expirationSeconds = params?.expirationSeconds || base.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
-                if (!publicKey) {
+                if (!generatedKeyPair) {
                     throw new sdkTypes.TurnkeyError("A publickey could not be found or generated.", sdkTypes.TurnkeyErrorCodes.INTERNAL_ERROR);
                 }
                 const sessionResponse = await this.httpClient.stampLogin({
-                    publicKey,
+                    publicKey: generatedKeyPair,
                     organizationId: this.config.organizationId,
                     expirationSeconds,
                 }, base.StamperType.Passkey);
@@ -150,28 +149,29 @@ class TurnkeyClient {
                     sessionToken: sessionResponse.session,
                     sessionKey,
                 });
-                // Key pair was successfully used, set to null to prevent cleanup
-                generatedKeyPair = null;
+                generatedKeyPair = undefined; // Key pair was successfully used, set to null to prevent cleanup
                 return sessionResponse.session;
-            }
-            catch (error) {
-                if (error?.message?.includes("timed out or was not allowed"))
-                    throw new sdkTypes.TurnkeyError("Passkey login was cancelled by the user.", sdkTypes.TurnkeyErrorCodes.SELECT_PASSKEY_CANCELLED, error);
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Unable to log in with the provided passkey`, sdkTypes.TurnkeyErrorCodes.PASSKEY_LOGIN_AUTH_ERROR, error);
-            }
-            finally {
-                // Clean up the generated key pair if it wasn't successfully used
-                if (generatedKeyPair) {
-                    try {
-                        await this.apiKeyStamper?.deleteKeyPair(generatedKeyPair);
-                    }
-                    catch (cleanupError) {
-                        throw new sdkTypes.TurnkeyError(`Failed to clean up generated key pair`, sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+            }, {
+                errorMessage: "Unable to log in with the provided passkey",
+                errorCode: sdkTypes.TurnkeyErrorCodes.PASSKEY_LOGIN_AUTH_ERROR,
+                customMessageByMessages: {
+                    "timed out or was not allowed": {
+                        message: "Passkey login was cancelled by the user.",
+                        code: sdkTypes.TurnkeyErrorCodes.SELECT_PASSKEY_CANCELLED,
+                    },
+                },
+            }, {
+                finallyFn: async () => {
+                    if (generatedKeyPair) {
+                        try {
+                            await this.apiKeyStamper?.deleteKeyPair(generatedKeyPair);
+                        }
+                        catch (cleanupError) {
+                            throw new sdkTypes.TurnkeyError(`Failed to clean up generated key pair`, sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
                     }
-                }
-            }
+                },
+            });
         };
         /**
          * Signs up a user using a passkey, creating a new sub-organization and session.
@@ -191,8 +191,8 @@ class TurnkeyClient {
          */
         this.signUpWithPasskey = async (params) => {
             const { createSubOrgParams, passkeyDisplayName, sessionKey = base.SessionKey.DefaultSessionkey, expirationSeconds = base.DEFAULT_SESSION_EXPIRATION_IN_SECONDS, } = params || {};
-            let generatedKeyPair = null;
-            try {
+            let generatedKeyPair = undefined;
+            return utils.withTurnkeyErrorHandling(async () => {
                 generatedKeyPair = await this.apiKeyStamper?.createKeyPair();
                 const passkeyName = passkeyDisplayName || `passkey-${Date.now()}`;
                 // A passkey will be created automatically when you call this function. The name is passed in
@@ -241,26 +241,24 @@ class TurnkeyClient {
                     sessionToken: sessionResponse.session,
                     sessionKey,
                 });
-                generatedKeyPair = null; // Key pair was successfully used, set to null to prevent cleanup
+                generatedKeyPair = undefined; // Key pair was successfully used, set to null to prevent cleanup
                 return sessionResponse.session;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to sign up with passkey`, sdkTypes.TurnkeyErrorCodes.PASSKEY_SIGNUP_AUTH_ERROR, error);
-            }
-            finally {
-                // Clean up the generated key pair if it wasn't successfully used
-                this.apiKeyStamper?.clearPublicKeyOverride();
-                if (generatedKeyPair) {
-                    try {
-                        await this.apiKeyStamper?.deleteKeyPair(generatedKeyPair);
-                    }
-                    catch (cleanupError) {
-                        throw new sdkTypes.TurnkeyError(`Failed to clean up generated key pair`, sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+            }, {
+                errorCode: sdkTypes.TurnkeyErrorCodes.PASSKEY_SIGNUP_AUTH_ERROR,
+                errorMessage: "Failed to sign up with passkey",
+            }, {
+                finallyFn: async () => {
+                    this.apiKeyStamper?.clearPublicKeyOverride();
+                    if (generatedKeyPair) {
+                        try {
+                            await this.apiKeyStamper?.deleteKeyPair(generatedKeyPair);
+                        }
+                        catch (cleanupError) {
+                            throw new sdkTypes.TurnkeyError(`Failed to clean up generated key pair`, sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
                     }
-                }
-            }
+                },
+            });
         };
         /**
          * Retrieves wallet providers from the initialized wallet manager.
@@ -273,15 +271,15 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If the wallet manager is uninitialized or provider retrieval fails.
          */
         this.getWalletProviders = async (chain) => {
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 if (!this.walletManager) {
                     throw new sdkTypes.TurnkeyError("Wallet manager is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
                 }
                 return await this.walletManager.getProviders(chain);
-            }
-            catch (error) {
-                throw new sdkTypes.TurnkeyError(`Unable to get wallet providers`, sdkTypes.TurnkeyErrorCodes.FETCH_WALLETS_ERROR, error);
-            }
+            }, {
+                errorMessage: "Unable to get wallet providers",
+                errorCode: sdkTypes.TurnkeyErrorCodes.FETCH_WALLETS_ERROR,
+            });
         };
         /**
          * Connects the specified wallet account.
@@ -293,15 +291,15 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If the wallet manager is uninitialized or the connection fails.
          */
         this.connectWalletAccount = async (walletProvider) => {
-            if (!this.walletManager?.connector) {
-                throw new sdkTypes.TurnkeyError("Wallet connector is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.connector) {
+                    throw new sdkTypes.TurnkeyError("Wallet connector is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
+                }
                 await this.walletManager.connector.connectWalletAccount(walletProvider);
-            }
-            catch (error) {
-                throw new sdkTypes.TurnkeyError("Unable to connect wallet account", sdkTypes.TurnkeyErrorCodes.CONNECT_WALLET_ACCOUNT_ERROR, error);
-            }
+            }, {
+                errorMessage: "Unable to connect wallet account",
+                errorCode: sdkTypes.TurnkeyErrorCodes.CONNECT_WALLET_ACCOUNT_ERROR,
+            });
         };
         /**
          * Disconnects the specified wallet account.
@@ -313,45 +311,55 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If the wallet manager is uninitialized or the disconnection fails.
          */
         this.disconnectWalletAccount = async (walletProvider) => {
-            if (!this.walletManager?.connector) {
-                throw new sdkTypes.TurnkeyError("Wallet connector is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.connector) {
+                    throw new sdkTypes.TurnkeyError("Wallet connector is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
+                }
                 await this.walletManager.connector.disconnectWalletAccount(walletProvider);
-            }
-            catch (error) {
-                throw new sdkTypes.TurnkeyError("Unable to disconnect wallet account", sdkTypes.TurnkeyErrorCodes.DISCONNECT_WALLET_ACCOUNT_ERROR, error);
-            }
+            }, {
+                errorMessage: "Unable to disconnect wallet account",
+                errorCode: sdkTypes.TurnkeyErrorCodes.DISCONNECT_WALLET_ACCOUNT_ERROR,
+            });
         };
         /**
-         * Switches the specified wallet provider to a different blockchain chain.
+         * Switches the wallet provider associated with a given wallet account
+         * to a different chain.
          *
-         * - Requires the wallet manager and its connector to be initialized.
-         * - The wallet provider must have at least one connected address.
-         * - Does nothing if the wallet provider is already on the desired chain.
+         * - Requires the wallet manager and its connector to be initialized
+         * - Only works for connected wallet accounts
+         * - Looks up the provider for the given account address
+         * - Does nothing if the provider is already on the desired chain.
          *
-         * @param walletProvider - wallet provider to switch.
-         * @param chainOrId - target chain as a chain ID string or SwitchableChain object.
+         * @param params.walletAccount - The wallet account whose provider should be switched.
+         * @param params.chainOrId - The target chain, specified as a chain ID string or a SwitchableChain object.
+         * @param params.walletProviders - Optional list of wallet providers to search; falls back to `getWalletProviders()` if omitted.
          * @returns A promise that resolves once the chain switch is complete.
+         *
          * @throws {TurnkeyError} If the wallet manager is uninitialized, the provider is not connected, or the switch fails.
          */
-        this.switchWalletProviderChain = async (walletProvider, chainOrId) => {
-            if (!this.walletManager?.connector) {
-                throw new sdkTypes.TurnkeyError("Wallet connector is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
-            if (walletProvider.connectedAddresses.length === 0) {
-                throw new sdkTypes.TurnkeyError("You can not switch chains for a provider that is not connected", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
-            }
-            // if the wallet provider is already on the desired chain, do nothing
-            if (walletProvider.chainInfo.namespace === chainOrId) {
-                return;
-            }
-            try {
+        this.switchWalletAccountChain = async (params) => {
+            const { walletAccount, chainOrId, walletProviders } = params;
+            return utils.withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.connector) {
+                    throw new sdkTypes.TurnkeyError("Wallet connector is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
+                }
+                if (walletAccount.source === base.WalletSource.Embedded) {
+                    throw new sdkTypes.TurnkeyError("You can only switch chains for connected wallet accounts", sdkTypes.TurnkeyErrorCodes.NOT_FOUND);
+                }
+                const providers = walletProviders ?? (await this.getWalletProviders());
+                const walletProvider = utils.findWalletProviderFromAddress(walletAccount.address, providers);
+                if (!walletProvider) {
+                    throw new sdkTypes.TurnkeyError("Wallet provider not found", sdkTypes.TurnkeyErrorCodes.SWITCH_WALLET_CHAIN_ERROR);
+                }
+                // if the wallet provider is already on the desired chain, do nothing
+                if (walletProvider.chainInfo.namespace === chainOrId) {
+                    return;
+                }
                 await this.walletManager.connector.switchChain(walletProvider, chainOrId);
-            }
-            catch (error) {
-                throw new sdkTypes.TurnkeyError("Unable to switch wallet account chain", sdkTypes.TurnkeyErrorCodes.SWITCH_WALLET_CHAIN_ERROR, error);
-            }
+            }, {
+                errorMessage: "Unable to switch wallet account chain",
+                errorCode: sdkTypes.TurnkeyErrorCodes.SWITCH_WALLET_CHAIN_ERROR,
+            });
         };
         /**
          * Logs in a user using the specified wallet provider.
@@ -370,11 +378,11 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If the wallet stamper is uninitialized, a public key cannot be found or generated, or login fails.
          */
         this.loginWithWallet = async (params) => {
-            if (!this.walletManager?.stamper) {
-                throw new sdkTypes.TurnkeyError("Wallet stamper is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
-            try {
-                const publicKey = params.publicKey || (await this.apiKeyStamper?.createKeyPair());
+            let publicKey = params.publicKey || (await this.apiKeyStamper?.createKeyPair());
+            return utils.withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.stamper) {
+                    throw new sdkTypes.TurnkeyError("Wallet stamper is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
+                }
                 const sessionKey = params.sessionKey || base.SessionKey.DefaultSessionkey;
                 const walletProvider = params.walletProvider;
                 const expirationSeconds = params?.expirationSeconds || base.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
@@ -392,12 +400,23 @@ class TurnkeyClient {
                     sessionKey,
                 });
                 return sessionResponse.session;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Unable to log in with the provided wallet`, sdkTypes.TurnkeyErrorCodes.WALLET_LOGIN_AUTH_ERROR, error);
-            }
+            }, {
+                errorMessage: "Unable to log in with the provided wallet",
+                errorCode: sdkTypes.TurnkeyErrorCodes.WALLET_LOGIN_AUTH_ERROR,
+            }, {
+                finallyFn: async () => {
+                    // Clean up the generated key pair if it wasn't successfully used
+                    this.apiKeyStamper?.clearPublicKeyOverride();
+                    if (publicKey) {
+                        try {
+                            await this.apiKeyStamper?.deleteKeyPair(publicKey);
+                        }
+                        catch (cleanupError) {
+                            throw new sdkTypes.TurnkeyError("Failed to clean up generated key pair", sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
+                    }
+                },
+            });
         };
         /**
          * Signs up a user using a wallet, creating a new sub-organization and session.
@@ -417,11 +436,11 @@ class TurnkeyClient {
          */
         this.signUpWithWallet = async (params) => {
             const { walletProvider, createSubOrgParams, sessionKey = base.SessionKey.DefaultSessionkey, expirationSeconds = base.DEFAULT_SESSION_EXPIRATION_IN_SECONDS, } = params;
-            if (!this.walletManager?.stamper) {
-                throw new sdkTypes.TurnkeyError("Wallet stamper is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
-            let generatedKeyPair = null;
-            try {
+            let generatedKeyPair = undefined;
+            return utils.withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.stamper) {
+                    throw new sdkTypes.TurnkeyError("Wallet stamper is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
+                }
                 generatedKeyPair = await this.apiKeyStamper?.createKeyPair();
                 this.walletManager.stamper.setProvider(walletProvider.interfaceType, walletProvider);
                 const publicKey = await this.walletManager.stamper.getPublicKey(walletProvider.interfaceType, walletProvider);
@@ -435,7 +454,7 @@ class TurnkeyClient {
                             {
                                 apiKeyName: `wallet-auth:${publicKey}`,
                                 publicKey: publicKey,
-                                curveType: utils.isEthereumWallet(walletProvider)
+                                curveType: utils.isEthereumProvider(walletProvider)
                                     ? "API_KEY_CURVE_SECP256K1"
                                     : "API_KEY_CURVE_ED25519",
                             },
@@ -464,24 +483,25 @@ class TurnkeyClient {
                     sessionToken: sessionResponse.session,
                     sessionKey,
                 });
-                generatedKeyPair = null; // Key pair was successfully used, set to null to prevent cleanup
+                generatedKeyPair = undefined; // Key pair was successfully used, set to null to prevent cleanup
                 return sessionResponse.session;
-            }
-            catch (error) {
-                throw new sdkTypes.TurnkeyError("Failed to sign up with wallet", sdkTypes.TurnkeyErrorCodes.WALLET_SIGNUP_AUTH_ERROR, error);
-            }
-            finally {
-                // Clean up the generated key pair if it wasn't successfully used
-                this.apiKeyStamper?.clearPublicKeyOverride();
-                if (generatedKeyPair) {
-                    try {
-                        await this.apiKeyStamper?.deleteKeyPair(generatedKeyPair);
-                    }
-                    catch (cleanupError) {
-                        throw new sdkTypes.TurnkeyError("Failed to clean up generated key pair", sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+            }, {
+                errorMessage: "Failed to sign up with wallet",
+                errorCode: sdkTypes.TurnkeyErrorCodes.WALLET_SIGNUP_AUTH_ERROR,
+            }, {
+                finallyFn: async () => {
+                    // Clean up the generated key pair if it wasn't successfully used
+                    this.apiKeyStamper?.clearPublicKeyOverride();
+                    if (generatedKeyPair) {
+                        try {
+                            await this.apiKeyStamper?.deleteKeyPair(generatedKeyPair);
+                        }
+                        catch (cleanupError) {
+                            throw new sdkTypes.TurnkeyError("Failed to clean up generated key pair", sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
                     }
-                }
-            }
+                },
+            });
         };
         /**
          * Logs in an existing user or signs up a new user using a wallet, creating a new sub-organization if needed.
@@ -501,25 +521,36 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error during wallet authentication, sub-organization creation, or session storage.
          */
         this.loginOrSignupWithWallet = async (params) => {
-            if (!this.walletManager?.stamper) {
-                throw new sdkTypes.TurnkeyError("Wallet stamper is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
             const createSubOrgParams = params.createSubOrgParams;
             const sessionKey = params.sessionKey || base.SessionKey.DefaultSessionkey;
             const walletProvider = params.walletProvider;
             const expirationSeconds = params.expirationSeconds || base.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
-            let generatedKeyPair = null;
-            try {
+            let generatedKeyPair = undefined;
+            return utils.withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.stamper) {
+                    throw new sdkTypes.TurnkeyError("Wallet stamper is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
+                }
                 generatedKeyPair = await this.apiKeyStamper?.createKeyPair();
                 this.walletManager.stamper.setProvider(walletProvider.interfaceType, walletProvider);
                 // here we sign the request with the wallet, but we don't send it to the Turnkey yet
                 // this is because we need to check if the subOrg exists first, and create one if it doesn't
                 // once we have the subOrg for the publicKey, we then can send the request to the Turnkey
-                const signedRequest = await this.httpClient.stampStampLogin({
-                    publicKey: generatedKeyPair,
-                    organizationId: this.config.organizationId,
-                    expirationSeconds,
-                }, base.StamperType.Wallet);
+                const signedRequest = await utils.withTurnkeyErrorHandling(async () => {
+                    return this.httpClient.stampStampLogin({
+                        publicKey: generatedKeyPair,
+                        organizationId: this.config.organizationId,
+                        expirationSeconds,
+                    }, base.StamperType.Wallet);
+                }, {
+                    errorMessage: "Failed to create stamped request for wallet login",
+                    errorCode: sdkTypes.TurnkeyErrorCodes.WALLET_LOGIN_OR_SIGNUP_ERROR,
+                    customMessageByMessages: {
+                        "Failed to sign the message": {
+                            message: "Wallet auth was cancelled by the user.",
+                            code: sdkTypes.TurnkeyErrorCodes.CONNECT_WALLET_CANCELLED,
+                        },
+                    },
+                });
                 if (!signedRequest) {
                     throw new sdkTypes.TurnkeyError("Failed to create stamped request for wallet login", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
                 }
@@ -561,7 +592,7 @@ class TurnkeyClient {
                                 {
                                     apiKeyName: `wallet-auth:${publicKey}`,
                                     publicKey: publicKey,
-                                    curveType: utils.isEthereumWallet(walletProvider)
+                                    curveType: utils.isEthereumProvider(walletProvider)
                                         ? "API_KEY_CURVE_SECP256K1"
                                         : "API_KEY_CURVE_ED25519",
                                 },
@@ -597,10 +628,20 @@ class TurnkeyClient {
                     sessionKey,
                 });
                 return sessionToken;
-            }
-            catch (error) {
-                throw new sdkTypes.TurnkeyError(`Unable to log in or signup with the provided wallet`, sdkTypes.TurnkeyErrorCodes.WALLET_LOGIN_OR_SIGNUP_ERROR, error);
-            }
+            }, {
+                errorCode: sdkTypes.TurnkeyErrorCodes.WALLET_LOGIN_OR_SIGNUP_ERROR,
+                errorMessage: "Failed to log in or sign up with wallet",
+                catchFn: async () => {
+                    if (generatedKeyPair) {
+                        try {
+                            await this.apiKeyStamper?.deleteKeyPair(generatedKeyPair);
+                        }
+                        catch (cleanupError) {
+                            throw new sdkTypes.TurnkeyError(`Failed to clean up generated key pair`, sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
+                    }
+                },
+            });
         };
         /**
          * Initializes the OTP process by sending an OTP code to the provided contact.
@@ -615,23 +656,22 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error during the OTP initialization process or if the maximum number of OTPs has been reached.
          */
         this.initOtp = async (params) => {
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const initOtpRes = await this.httpClient.proxyInitOtp(params);
                 if (!initOtpRes || !initOtpRes.otpId) {
                     throw new sdkTypes.TurnkeyError("Failed to initialize OTP: otpId is missing", sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR);
                 }
                 return initOtpRes.otpId;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyNetworkError) {
-                    if (error.message.includes("Max number of OTPs have been initiated")) {
-                        throw new sdkTypes.TurnkeyError("Max number of OTPs have been initiated", sdkTypes.TurnkeyErrorCodes.MAX_OTP_INITIATED_ERROR);
-                    }
-                }
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to initialize OTP`, sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to initialize OTP",
+                errorCode: sdkTypes.TurnkeyErrorCodes.INIT_OTP_ERROR,
+                customMessageByMessages: {
+                    "Max number of OTPs have been initiated": {
+                        message: "Maximum number of OTPs has been reached for this contact.",
+                        code: sdkTypes.TurnkeyErrorCodes.MAX_OTP_INITIATED_ERROR,
+                    },
+                },
+            });
         };
         /**
          * Verifies the OTP code sent to the user.
@@ -652,7 +692,7 @@ class TurnkeyClient {
          */
         this.verifyOtp = async (params) => {
             const { otpId, otpCode, contact, otpType } = params;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const verifyOtpRes = await this.httpClient.proxyVerifyOtp({
                     otpId: otpId,
                     otpCode: otpCode,
@@ -672,16 +712,16 @@ class TurnkeyClient {
                     subOrganizationId: subOrganizationId,
                     verificationToken: verifyOtpRes.verificationToken,
                 };
-            }
-            catch (error) {
-                if (error instanceof base.TurnkeyRequestError &&
-                    error.message.includes("Invalid OTP code")) {
-                    throw new sdkTypes.TurnkeyError("Invalid OTP code provided", sdkTypes.TurnkeyErrorCodes.INVALID_OTP_CODE, error.message);
-                }
-                else if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to verify OTP`, sdkTypes.TurnkeyErrorCodes.VERIFY_OTP_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to verify OTP",
+                errorCode: sdkTypes.TurnkeyErrorCodes.VERIFY_OTP_ERROR,
+                customMessageByMessages: {
+                    "Invalid OTP code": {
+                        message: "The provided OTP code is invalid.",
+                        code: sdkTypes.TurnkeyErrorCodes.INVALID_OTP_CODE,
+                    },
+                },
+            });
         };
         /**
          * Logs in a user using an OTP verification token.
@@ -701,7 +741,7 @@ class TurnkeyClient {
          */
         this.loginWithOtp = async (params) => {
             const { verificationToken, invalidateExisting = false, publicKey = await this.apiKeyStamper?.createKeyPair(), sessionKey = base.SessionKey.DefaultSessionkey, } = params;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.proxyOtpLogin({
                     verificationToken,
                     publicKey: publicKey,
@@ -719,21 +759,21 @@ class TurnkeyClient {
                     sessionKey,
                 });
                 return loginRes.session;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                // Clean up the generated key pair if it wasn't successfully used
-                if (publicKey) {
-                    try {
-                        await this.apiKeyStamper?.deleteKeyPair(publicKey);
-                    }
-                    catch (cleanupError) {
-                        throw new sdkTypes.TurnkeyError(`Failed to clean up generated key pair`, sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+            }, {
+                errorMessage: "Failed to log in with OTP",
+                errorCode: sdkTypes.TurnkeyErrorCodes.OTP_LOGIN_ERROR,
+                catchFn: async () => {
+                    // Clean up the generated key pair if it wasn't successfully used
+                    if (publicKey) {
+                        try {
+                            await this.apiKeyStamper?.deleteKeyPair(publicKey);
+                        }
+                        catch (cleanupError) {
+                            throw new sdkTypes.TurnkeyError(`Failed to clean up generated key pair`, sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
                     }
-                }
-                throw new sdkTypes.TurnkeyError(`Failed to log in with OTP`, sdkTypes.TurnkeyErrorCodes.OTP_LOGIN_ERROR, error);
-            }
+                },
+            });
         };
         /**
          * Signs up a user using an OTP verification token.
@@ -764,8 +804,8 @@ class TurnkeyClient {
                     verificationToken,
                 },
             });
-            const generatedKeyPair = await this.apiKeyStamper?.createKeyPair();
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
+                const generatedKeyPair = await this.apiKeyStamper?.createKeyPair();
                 const res = await this.httpClient.proxySignup(signUpBody);
                 if (!res) {
                     throw new sdkTypes.TurnkeyError(`Auth proxy OTP sign up failed`, sdkTypes.TurnkeyErrorCodes.OTP_SIGNUP_ERROR);
@@ -776,12 +816,10 @@ class TurnkeyClient {
                     ...(invalidateExisting && { invalidateExisting }),
                     ...(sessionKey && { sessionKey }),
                 });
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to sign up with OTP`, sdkTypes.TurnkeyErrorCodes.OTP_SIGNUP_ERROR, error);
-            }
+            }, {
+                errorCode: sdkTypes.TurnkeyErrorCodes.OTP_SIGNUP_ERROR,
+                errorMessage: "Failed to sign up with OTP",
+            });
         };
         /**
          * Completes the OTP authentication flow by verifying the OTP code and then either signing up or logging in the user.
@@ -805,7 +843,7 @@ class TurnkeyClient {
          */
         this.completeOtp = async (params) => {
             const { otpId, otpCode, contact, otpType, publicKey, invalidateExisting = false, sessionKey, createSubOrgParams, } = params;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const { subOrganizationId, verificationToken } = await this.verifyOtp({
                     otpId: otpId,
                     otpCode: otpCode,
@@ -835,12 +873,10 @@ class TurnkeyClient {
                         ...(sessionKey && { sessionKey }),
                     });
                 }
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to complete OTP process`, sdkTypes.TurnkeyErrorCodes.OTP_COMPLETION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to complete OTP process",
+                errorCode: sdkTypes.TurnkeyErrorCodes.OTP_COMPLETION_ERROR,
+            });
         };
         /**
          * Completes the OAuth authentication flow by either signing up or logging in the user, depending on whether a sub-organization already exists for the provided OIDC token.
@@ -862,7 +898,7 @@ class TurnkeyClient {
          */
         this.completeOauth = async (params) => {
             const { oidcToken, publicKey, createSubOrgParams, providerName = "OpenID Connect Provider" + Date.now(), sessionKey = base.SessionKey.DefaultSessionkey, invalidateExisting = false, } = params;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const accountRes = await this.httpClient.proxyGetAccount({
                     filterType: "OIDC_TOKEN",
                     filterValue: oidcToken,
@@ -889,12 +925,10 @@ class TurnkeyClient {
                         }),
                     });
                 }
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to handle Google OAuth login`, sdkTypes.TurnkeyErrorCodes.OAUTH_LOGIN_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to complete OAuth process",
+                errorCode: sdkTypes.TurnkeyErrorCodes.OAUTH_LOGIN_ERROR,
+            });
         };
         /**
          * Logs in a user using OAuth authentication.
@@ -913,10 +947,10 @@ class TurnkeyClient {
          */
         this.loginWithOauth = async (params) => {
             const { oidcToken, invalidateExisting = false, publicKey, sessionKey = base.SessionKey.DefaultSessionkey, } = params;
-            if (!publicKey) {
-                throw new sdkTypes.TurnkeyError("Public key must be provided to log in with OAuth. Please create a key pair first.", sdkTypes.TurnkeyErrorCodes.MISSING_PARAMS);
-            }
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
+                if (!publicKey) {
+                    throw new sdkTypes.TurnkeyError("Public key must be provided to log in with OAuth. Please create a key pair first.", sdkTypes.TurnkeyErrorCodes.MISSING_PARAMS);
+                }
                 const loginRes = await this.httpClient.proxyOAuthLogin({
                     oidcToken,
                     publicKey,
@@ -933,21 +967,27 @@ class TurnkeyClient {
                     sessionKey,
                 });
                 return loginRes.session;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                // Clean up the generated key pair if it wasn't successfully used
-                if (publicKey) {
-                    try {
-                        await this.apiKeyStamper?.deleteKeyPair(publicKey);
-                    }
-                    catch (cleanupError) {
-                        throw new sdkTypes.TurnkeyError(`Failed to clean up generated key pair`, sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+            }, {
+                errorMessage: "Failed to complete OAuth login",
+                errorCode: sdkTypes.TurnkeyErrorCodes.OAUTH_LOGIN_ERROR,
+                customMessageByMessages: {
+                    "OAUTH disallowed": {
+                        message: "OAuth is disabled on the dashboard for this organization.",
+                        code: sdkTypes.TurnkeyErrorCodes.AUTH_METHOD_NOT_ENABLED,
+                    },
+                },
+                catchFn: async () => {
+                    // Clean up the generated key pair if it wasn't successfully used
+                    if (publicKey) {
+                        try {
+                            await this.apiKeyStamper?.deleteKeyPair(publicKey);
+                        }
+                        catch (cleanupError) {
+                            throw new sdkTypes.TurnkeyError(`Failed to clean up generated key pair`, sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
                     }
-                }
-                throw new sdkTypes.TurnkeyError(`Failed to log in with oauth`, sdkTypes.TurnkeyErrorCodes.OAUTH_LOGIN_ERROR, error);
-            }
+                },
+            });
         };
         /**
          * Signs up a user using OAuth authentication.
@@ -967,7 +1007,7 @@ class TurnkeyClient {
          */
         this.signUpWithOauth = async (params) => {
             const { oidcToken, publicKey, providerName, createSubOrgParams } = params;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const signUpBody = utils.buildSignUpBody({
                     createSubOrgParams: {
                         ...createSubOrgParams,
@@ -987,12 +1027,10 @@ class TurnkeyClient {
                     oidcToken,
                     publicKey: publicKey,
                 });
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to sign up with OAuth`, sdkTypes.TurnkeyErrorCodes.OAUTH_SIGNUP_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to sign up with OAuth",
+                errorCode: sdkTypes.TurnkeyErrorCodes.OAUTH_SIGNUP_ERROR,
+            });
         };
         /**
          * Fetches all wallets for the current user, including both embedded and connected wallets.
@@ -1008,12 +1046,12 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If no active session is found or if there is an error fetching wallets.
          */
         this.fetchWallets = async (params) => {
-            const { stampWith } = params || {};
+            const { stampWith, walletProviders } = params || {};
             const session = await this.storageManager.getActiveSession();
             if (!session) {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.getWallets({ organizationId: session.organizationId }, stampWith);
                 if (!res || !res.wallets) {
                     throw new sdkTypes.TurnkeyError("No wallets found in the response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
@@ -1034,10 +1072,11 @@ class TurnkeyClient {
                 // if wallet connecting is disabled we return only embedded wallets
                 if (!this.walletManager?.connector)
                     return embedded;
-                const providers = await this.getWalletProviders();
+                const providers = walletProviders ?? (await this.getWalletProviders());
                 const groupedProviders = new Map();
                 for (const provider of providers) {
-                    const walletId = provider.info?.name?.toLowerCase().replace(/\s+/g, "-") || "unknown";
+                    const walletId = provider.info?.name?.toLowerCase().replace(/\s+/g, "-") ||
+                        "unknown";
                     const group = groupedProviders.get(walletId) || [];
                     group.push(provider);
                     groupedProviders.set(walletId, group);
@@ -1063,12 +1102,10 @@ class TurnkeyClient {
                     return wallet;
                 }))).filter((wallet) => wallet.accounts.length > 0);
                 return [...embedded, ...connected];
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError("Failed to fetch wallets", sdkTypes.TurnkeyErrorCodes.FETCH_WALLETS_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to fetch wallets",
+                errorCode: sdkTypes.TurnkeyErrorCodes.FETCH_WALLETS_ERROR,
+            });
         };
         /**
          * Fetches all accounts for a specific wallet, including both embedded and connected wallet accounts.
@@ -1092,58 +1129,90 @@ class TurnkeyClient {
             if (!session) {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            // this is an embedded wallet so we fetch accounts from Turnkey
-            if (wallet.source === base.WalletSource.Embedded) {
-                const embedded = [];
-                const res = await this.httpClient.getWalletAccounts({
-                    walletId: wallet.walletId,
-                    organizationId: session.organizationId,
-                    paginationOptions: paginationOptions || { limit: "100" },
-                }, stampWith);
-                if (!res || !res.accounts) {
-                    throw new sdkTypes.TurnkeyError("No wallet accounts found in the response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
-                }
-                for (const account of res.accounts) {
-                    embedded.push({
-                        ...account,
-                        source: base.WalletSource.Embedded,
-                    });
-                }
-                return embedded;
-            }
-            // this is an external wallet so we fetch accounts from the connected wallet provider
-            // if wallet connecting is disabled we return only embedded wallets
-            // we should never reach this point if wallet connecting is disabled
-            if (!this.walletManager?.connector)
-                return [];
-            const connected = [];
-            const providers = walletProviders ?? (await this.getWalletProviders());
-            const matching = providers.filter((p) => p.info?.name?.toLowerCase().replace(/\s+/g, "-") === wallet.walletId &&
-                p.connectedAddresses.length > 0);
-            for (const provider of matching) {
-                const timestamp = utils.toExternalTimestamp();
-                for (const address of provider.connectedAddresses) {
-                    const account = {
-                        walletAccountId: `${wallet.walletId}-${provider.interfaceType}-${address}`,
-                        organizationId: session.organizationId,
+            return utils.withTurnkeyErrorHandling(async () => {
+                // this is an embedded wallet so we fetch accounts from Turnkey
+                if (wallet.source === base.WalletSource.Embedded) {
+                    const embedded = [];
+                    const res = await this.httpClient.getWalletAccounts({
                         walletId: wallet.walletId,
-                        curve: utils.isEthereumWallet(provider) ? base.Curve.SECP256K1 : base.Curve.ED25519,
-                        pathFormat: "PATH_FORMAT_BIP32",
-                        path: base.WalletSource.Connected,
-                        source: base.WalletSource.Connected,
-                        addressFormat: utils.isEthereumWallet(provider)
-                            ? "ADDRESS_FORMAT_ETHEREUM"
-                            : "ADDRESS_FORMAT_SOLANA",
-                        address,
-                        createdAt: timestamp,
-                        updatedAt: timestamp,
-                        ...utils.getWalletAccountMethods(this.walletManager.connector.sign.bind(this.walletManager.connector), provider),
-                        ...(utils.isSolanaWallet(provider) && { publicKey: address }),
-                    };
-                    connected.push(account);
+                        organizationId: session.organizationId,
+                        paginationOptions: paginationOptions || { limit: "100" },
+                    }, stampWith);
+                    if (!res || !res.accounts) {
+                        throw new sdkTypes.TurnkeyError("No wallet accounts found in the response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
+                    }
+                    for (const account of res.accounts) {
+                        embedded.push({
+                            ...account,
+                            source: base.WalletSource.Embedded,
+                        });
+                    }
+                    return embedded;
                 }
-            }
-            return connected;
+                // this is an external wallet so we fetch accounts from the connected wallet provider
+                // if wallet connecting is disabled we return only embedded wallets
+                // we should never reach this point if wallet connecting is disabled
+                if (!this.walletManager?.connector)
+                    return [];
+                const connected = [];
+                const providers = walletProviders ?? (await this.getWalletProviders());
+                const matching = providers.filter((p) => p.info?.name?.toLowerCase().replace(/\s+/g, "-") ===
+                    wallet.walletId && p.connectedAddresses.length > 0);
+                const sign = this.walletManager.connector.sign.bind(this.walletManager.connector);
+                for (const provider of matching) {
+                    const timestamp = utils.toExternalTimestamp();
+                    for (const address of provider.connectedAddresses) {
+                        if (utils.isEthereumProvider(provider)) {
+                            const evmAccount = {
+                                walletAccountId: `${wallet.walletId}-${provider.interfaceType}-${address}`,
+                                organizationId: session.organizationId,
+                                walletId: wallet.walletId,
+                                pathFormat: "PATH_FORMAT_BIP32",
+                                path: base.WalletSource.Connected,
+                                source: base.WalletSource.Connected,
+                                address,
+                                createdAt: timestamp,
+                                updatedAt: timestamp,
+                                // ethereum specific
+                                curve: base.Curve.SECP256K1,
+                                addressFormat: "ADDRESS_FORMAT_ETHEREUM",
+                                chainInfo: provider.chainInfo,
+                                signMessage: (msg) => sign(msg, provider, base.SignIntent.SignMessage),
+                                signAndSendTransaction: (tx) => sign(tx, provider, base.SignIntent.SignAndSendTransaction),
+                            };
+                            connected.push(evmAccount);
+                            continue;
+                        }
+                        if (utils.isSolanaProvider(provider)) {
+                            const solAccount = {
+                                walletAccountId: `${wallet.walletId}-${provider.interfaceType}-${address}`,
+                                organizationId: session.organizationId,
+                                walletId: wallet.walletId,
+                                pathFormat: "PATH_FORMAT_BIP32",
+                                path: base.WalletSource.Connected,
+                                source: base.WalletSource.Connected,
+                                address,
+                                createdAt: timestamp,
+                                updatedAt: timestamp,
+                                // solana specific
+                                publicKey: address,
+                                curve: base.Curve.ED25519,
+                                addressFormat: "ADDRESS_FORMAT_SOLANA",
+                                chainInfo: provider.chainInfo,
+                                signMessage: (msg) => sign(msg, provider, base.SignIntent.SignMessage),
+                                signTransaction: (tx) => sign(tx, provider, base.SignIntent.SignTransaction),
+                            };
+                            connected.push(solAccount);
+                            continue;
+                        }
+                        throw new Error(`Unsupported wallet chain: ${provider.chainInfo}. Supported chains are Ethereum and Solana.`);
+                    }
+                }
+                return connected;
+            }, {
+                errorMessage: "Failed to fetch wallet accounts",
+                errorCode: sdkTypes.TurnkeyErrorCodes.FETCH_WALLET_ACCOUNTS_ERROR,
+            });
         };
         /**
          * Signs a message using the specified wallet account.
@@ -1177,7 +1246,7 @@ class TurnkeyClient {
             const { message, walletAccount, stampWith, addEthereumPrefix } = params;
             const hashFunction = params.hashFunction || utils.getHashFunction(walletAccount.addressFormat);
             const payloadEncoding = params.encoding || utils.getEncodingType(walletAccount.addressFormat);
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const isEthereum = walletAccount.addressFormat === "ADDRESS_FORMAT_ETHEREUM";
                 if (walletAccount.source === base.WalletSource.Connected) {
                     // this is a connected wallet
@@ -1209,12 +1278,10 @@ class TurnkeyClient {
                 }
                 return response.activity.result
                     .signRawPayloadResult;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to sign message - ${error?.message ? error.message : "Unknown error"}`, sdkTypes.TurnkeyErrorCodes.SIGN_MESSAGE_ERROR);
-            }
+            }, {
+                errorMessage: "Failed to sign message",
+                errorCode: sdkTypes.TurnkeyErrorCodes.SIGN_MESSAGE_ERROR,
+            });
         };
         /**
          * Signs a transaction using the specified wallet account.
@@ -1234,17 +1301,18 @@ class TurnkeyClient {
          */
         this.signTransaction = async (params) => {
             const { walletAccount, unsignedTransaction, transactionType, stampWith } = params;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 if (walletAccount.source === base.WalletSource.Connected) {
-                    // this is a connected wallet account
-                    if (!walletAccount.signTransaction) {
-                        const isEthereum = walletAccount.addressFormat === "ADDRESS_FORMAT_ETHEREUM";
-                        const reason = isEthereum
-                            ? "Ethereum connected wallets do not support raw transaction signing due to EIP-1193 limitations."
-                            : "This connected wallet does not support raw transaction signing.";
-                        throw new sdkTypes.TurnkeyError(`Failed to sign transaction: ${reason} ${isEthereum ? "Use signAndSendTransaction instead." : ""}`, sdkTypes.TurnkeyErrorCodes.SIGN_TRANSACTION_ERROR);
+                    switch (walletAccount.chainInfo.namespace) {
+                        case base.Chain.Ethereum:
+                            throw new sdkTypes.TurnkeyError("Ethereum connected wallets do not support raw transaction signing. Use signAndSendTransaction instead.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
+                        case base.Chain.Solana:
+                            // not sure why typescript isn't inferring the type here
+                            // if namespace is Chain.Solana, then it must be a ConnectedSolanaWalletAccount
+                            return walletAccount.signTransaction(unsignedTransaction);
+                        default:
+                            throw new sdkTypes.TurnkeyError("Unsupported connected wallet type.", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
                     }
-                    return await walletAccount?.signTransaction(unsignedTransaction);
                 }
                 // this is an embedded wallet account
                 const signTransaction = await this.httpClient.signTransaction({
@@ -1253,12 +1321,10 @@ class TurnkeyClient {
                     type: transactionType,
                 }, stampWith);
                 return signTransaction.signedTransaction;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to sign transaction`, sdkTypes.TurnkeyErrorCodes.SIGN_TRANSACTION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to sign transaction",
+                errorCode: sdkTypes.TurnkeyErrorCodes.SIGN_TRANSACTION_ERROR,
+            });
         };
         /**
          * Signs and broadcasts a transaction using the specified wallet account.
@@ -1282,22 +1348,20 @@ class TurnkeyClient {
          */
         this.signAndSendTransaction = async (params) => {
             const { walletAccount, unsignedTransaction, transactionType, rpcUrl, stampWith, } = params;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 if (walletAccount.source === base.WalletSource.Connected) {
                     // this is a connected wallet account
-                    switch (transactionType) {
-                        case "TRANSACTION_TYPE_ETHEREUM":
-                            if (!walletAccount.signAndSendTransaction) {
-                                throw new sdkTypes.TurnkeyError("This connected wallet does not support signAndSendTransaction.", sdkTypes.TurnkeyErrorCodes.SIGN_AND_SEND_TRANSACTION_ERROR);
-                            }
+                    switch (walletAccount.chainInfo.namespace) {
+                        case base.Chain.Ethereum:
+                            // not sure why typescript isn't inferring the type here
+                            // if namespace is Chain.Ethereum, then it must be a ConnectedEthereumWalletAccount
                             return await walletAccount.signAndSendTransaction(unsignedTransaction);
-                        case "TRANSACTION_TYPE_SOLANA":
+                        case base.Chain.Solana:
                             if (!rpcUrl) {
                                 throw new sdkTypes.TurnkeyError("Missing rpcUrl: connected Solana wallets require an RPC URL to broadcast transactions.", sdkTypes.TurnkeyErrorCodes.SIGN_AND_SEND_TRANSACTION_ERROR);
                             }
-                            if (!walletAccount.signTransaction) {
-                                throw new sdkTypes.TurnkeyError("This connected wallet does not support signAndSendTransaction.", sdkTypes.TurnkeyErrorCodes.SIGN_AND_SEND_TRANSACTION_ERROR);
-                            }
+                            // not sure why typescript isn't inferring the type here
+                            // if namespace is Chain.Solana, then it must be a ConnectedSolanaWalletAccount
                             const signature = await walletAccount.signTransaction(unsignedTransaction);
                             return await utils.broadcastTransaction({
                                 signedTransaction: signature,
@@ -1326,12 +1390,10 @@ class TurnkeyClient {
                     transactionType,
                 });
                 return txHash;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to sign and send transaction`, sdkTypes.TurnkeyErrorCodes.SIGN_AND_SEND_TRANSACTION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to sign and send transaction",
+                errorCode: sdkTypes.TurnkeyErrorCodes.SIGN_AND_SEND_TRANSACTION_ERROR,
+            });
         };
         /**
          * Fetches the user details for the current session or a specified user.
@@ -1359,18 +1421,16 @@ class TurnkeyClient {
                 throw new sdkTypes.TurnkeyError("User ID must be provided to fetch user", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
             }
             const organizationId = params?.organizationId || session.organizationId;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const userResponse = await this.httpClient.getUser({ organizationId, userId }, stampWith);
                 if (!userResponse || !userResponse.user) {
                     throw new sdkTypes.TurnkeyError("No user found in the response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return userResponse.user;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to fetch user`, sdkTypes.TurnkeyErrorCodes.FETCH_USER_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to fetch user",
+                errorCode: sdkTypes.TurnkeyErrorCodes.FETCH_USER_ERROR,
+            });
         };
         /**
          * Updates the user's email address.
@@ -1395,7 +1455,7 @@ class TurnkeyClient {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
             const userId = params?.userId || session.userId;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const existingUser = await this.httpClient.proxyGetAccount({
                     filterType: base.FilterType.Email,
                     filterValue: email,
@@ -1412,12 +1472,10 @@ class TurnkeyClient {
                     throw new sdkTypes.TurnkeyError("No user ID found in the update user email response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.userId;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to update user email`, sdkTypes.TurnkeyErrorCodes.UPDATE_USER_EMAIL_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to update user email",
+                errorCode: sdkTypes.TurnkeyErrorCodes.UPDATE_USER_EMAIL_ERROR,
+            });
         };
         /**
          * Removes the user's email address.
@@ -1438,15 +1496,20 @@ class TurnkeyClient {
             if (!session) {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            const userId = params?.userId || session.userId;
-            const res = await this.httpClient.updateUserEmail({
-                userId: userId,
-                userEmail: "",
-            }, stampWith);
-            if (!res || !res.userId) {
-                throw new sdkTypes.TurnkeyError("No user ID found in the remove user email response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
-            }
-            return res.userId;
+            return utils.withTurnkeyErrorHandling(async () => {
+                const userId = params?.userId || session.userId;
+                const res = await this.httpClient.updateUserEmail({
+                    userId: userId,
+                    userEmail: "",
+                }, stampWith);
+                if (!res || !res.userId) {
+                    throw new sdkTypes.TurnkeyError("No user ID found in the remove user email response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
+                }
+                return res.userId;
+            }, {
+                errorMessage: "Failed to remove user email",
+                errorCode: sdkTypes.TurnkeyErrorCodes.UPDATE_USER_EMAIL_ERROR,
+            });
         };
         /**
          * Updates the user's phone number.
@@ -1471,7 +1534,7 @@ class TurnkeyClient {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
             const userId = params?.userId || session.userId;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.updateUserPhoneNumber({
                     userId,
                     userPhoneNumber: phoneNumber,
@@ -1481,12 +1544,10 @@ class TurnkeyClient {
                     throw new sdkTypes.TurnkeyError("Failed to update user phone number", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR);
                 }
                 return res.userId;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to update user phone number`, sdkTypes.TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to update user phone number",
+                errorCode: sdkTypes.TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR,
+            });
         };
         /**
          * Removes the user's phone number.
@@ -1508,14 +1569,19 @@ class TurnkeyClient {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
             const userId = params?.userId || session.userId;
-            const res = await this.httpClient.updateUserPhoneNumber({
-                userId,
-                userPhoneNumber: "",
-            }, stampWith);
-            if (!res || !res.userId) {
-                throw new sdkTypes.TurnkeyError("Failed to remove user phone number", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR);
-            }
-            return res.userId;
+            return utils.withTurnkeyErrorHandling(async () => {
+                const res = await this.httpClient.updateUserPhoneNumber({
+                    userId,
+                    userPhoneNumber: "",
+                }, stampWith);
+                if (!res || !res.userId) {
+                    throw new sdkTypes.TurnkeyError("Failed to remove user phone number", sdkTypes.TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR);
+                }
+                return res.userId;
+            }, {
+                errorMessage: "Failed to remove user phone number",
+                errorCode: sdkTypes.TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR,
+            });
         };
         /**
          * Updates the user's name.
@@ -1539,7 +1605,7 @@ class TurnkeyClient {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
             const userId = params?.userId || session.userId;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.updateUserName({
                     userId,
                     userName,
@@ -1548,12 +1614,10 @@ class TurnkeyClient {
                     throw new sdkTypes.TurnkeyError("No user ID found in the update user name response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.userId;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to update user name`, sdkTypes.TurnkeyErrorCodes.UPDATE_USER_NAME_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to update user name",
+                errorCode: sdkTypes.TurnkeyErrorCodes.UPDATE_USER_NAME_ERROR,
+            });
         };
         /**
          * Adds an OAuth provider to the user.
@@ -1578,7 +1642,7 @@ class TurnkeyClient {
             if (!session) {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const accountRes = await this.httpClient.proxyGetAccount({
                     filterType: "OIDC_TOKEN",
                     filterValue: oidcToken,
@@ -1622,12 +1686,10 @@ class TurnkeyClient {
                     throw new sdkTypes.TurnkeyError("Failed to create OAuth provider", sdkTypes.TurnkeyErrorCodes.ADD_OAUTH_PROVIDER_ERROR);
                 }
                 return createProviderRes?.providerIds || [];
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to fetch account for OAuth provider`, sdkTypes.TurnkeyErrorCodes.ACCOUNT_FETCH_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to add OAuth provider",
+                errorCode: sdkTypes.TurnkeyErrorCodes.ADD_OAUTH_PROVIDER_ERROR,
+            });
         };
         /**
          * Removes a list of OAuth providers from the user.
@@ -1651,14 +1713,19 @@ class TurnkeyClient {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
             const userId = params?.userId || session.userId;
-            const res = await this.httpClient.deleteOauthProviders({
-                userId,
-                providerIds,
-            }, stampWith);
-            if (!res) {
-                throw new sdkTypes.TurnkeyError("Failed to remove OAuth provider", sdkTypes.TurnkeyErrorCodes.REMOVE_OAUTH_PROVIDER_ERROR);
-            }
-            return res.providerIds;
+            return utils.withTurnkeyErrorHandling(async () => {
+                const res = await this.httpClient.deleteOauthProviders({
+                    userId,
+                    providerIds,
+                }, stampWith);
+                if (!res) {
+                    throw new sdkTypes.TurnkeyError("Failed to remove OAuth provider", sdkTypes.TurnkeyErrorCodes.REMOVE_OAUTH_PROVIDER_ERROR);
+                }
+                return res.providerIds;
+            }, {
+                errorMessage: "Failed to remove OAuth provider",
+                errorCode: sdkTypes.TurnkeyErrorCodes.REMOVE_OAUTH_PROVIDER_ERROR,
+            });
         };
         /**
          * Adds a new passkey authenticator for the user.
@@ -1680,7 +1747,7 @@ class TurnkeyClient {
             const { stampWith } = params || {};
             const name = params?.name || `Turnkey Passkey-${Date.now()}`;
             const displayName = params?.displayName || name;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const session = await this.storageManager.getActiveSession();
                 if (!session) {
                     throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
@@ -1705,12 +1772,10 @@ class TurnkeyClient {
                     ],
                 }, stampWith);
                 return res?.authenticatorIds || [];
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to add passkey`, sdkTypes.TurnkeyErrorCodes.ADD_PASSKEY_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to add passkey",
+                errorCode: sdkTypes.TurnkeyErrorCodes.ADD_PASSKEY_ERROR,
+            });
         };
         /**
          * Removes passkeys (authenticator) from the user.
@@ -1734,14 +1799,19 @@ class TurnkeyClient {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
             const userId = params?.userId || session.userId;
-            const res = await this.httpClient.deleteAuthenticators({
-                userId,
-                authenticatorIds,
-            }, stampWith);
-            if (!res) {
-                throw new sdkTypes.TurnkeyError("Failed to remove passkey", sdkTypes.TurnkeyErrorCodes.REMOVE_PASSKEY_ERROR);
-            }
-            return res.authenticatorIds;
+            return utils.withTurnkeyErrorHandling(async () => {
+                const res = await this.httpClient.deleteAuthenticators({
+                    userId,
+                    authenticatorIds,
+                }, stampWith);
+                if (!res) {
+                    throw new sdkTypes.TurnkeyError("No response found in the remove passkey response", sdkTypes.TurnkeyErrorCodes.REMOVE_PASSKEY_ERROR);
+                }
+                return res.authenticatorIds;
+            }, {
+                errorMessage: "Failed to remove passkey",
+                errorCode: sdkTypes.TurnkeyErrorCodes.REMOVE_PASSKEY_ERROR,
+            });
         };
         /**
          * Creates a new wallet for sub-organization.
@@ -1780,7 +1850,7 @@ class TurnkeyClient {
                     ...turnkeyHelpers.DEFAULT_SOLANA_ACCOUNTS,
                 ];
             }
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.createWallet({
                     organizationId: organizationId || session.organizationId,
                     walletName,
@@ -1791,12 +1861,10 @@ class TurnkeyClient {
                     throw new sdkTypes.TurnkeyError("No wallet found in the create wallet response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.walletId;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to create wallet`, sdkTypes.TurnkeyErrorCodes.CREATE_WALLET_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to create wallet",
+                errorCode: sdkTypes.TurnkeyErrorCodes.CREATE_WALLET_ERROR,
+            });
         };
         /**
          * Creates new accounts in the specified wallet.
@@ -1821,7 +1889,7 @@ class TurnkeyClient {
             if (!session) {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 let walletAccounts = [];
                 if (accounts && !utils.isWalletAccountArray(accounts)) {
                     // Query existing wallet accounts to avoid duplicates
@@ -1847,12 +1915,10 @@ class TurnkeyClient {
                     throw new sdkTypes.TurnkeyError("No account found in the create wallet account response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.addresses;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to create wallet account`, sdkTypes.TurnkeyErrorCodes.CREATE_WALLET_ACCOUNT_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to create wallet account",
+                errorCode: sdkTypes.TurnkeyErrorCodes.CREATE_WALLET_ACCOUNT_ERROR,
+            });
         };
         /**
          * Exports a wallet as an encrypted bundle.
@@ -1877,7 +1943,7 @@ class TurnkeyClient {
             if (!session) {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.exportWallet({
                     walletId,
                     targetPublicKey,
@@ -1887,12 +1953,85 @@ class TurnkeyClient {
                     throw new sdkTypes.TurnkeyError("No export bundle found in the response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.exportBundle;
+            }, {
+                errorMessage: "Failed to export wallet",
+                errorCode: sdkTypes.TurnkeyErrorCodes.EXPORT_WALLET_ERROR,
+            });
+        };
+        /**
+         * Exports a private key as an encrypted bundle.
+         *
+         * - This function exports the specified private key as an encrypted bundle, suitable for backup or transfer.
+         * - The exported bundle contains the private key's key material, encrypted to the provided target public key.
+         * - If a targetPublicKey is provided, the bundle will be encrypted to that public key; otherwise, an error will be thrown.
+         * - If an organizationId is provided, the private key will be exported under that sub-organization; otherwise, the current session's organizationId is used.
+         * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+         *
+         * @param params.privateKeyId - ID of the private key to export.
+         * @param params.targetPublicKey - public key to encrypt the bundle to (required).
+         * @param params.organizationId - organization ID to export the private key under a specific sub
+         * @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 `ExportBundle` object containing the encrypted private key and metadata.
+         * @throws {TurnkeyError} If there is no active session, if the targetPublicKey is missing, or if there is an error exporting the private key.
+         */
+        this.exportPrivateKey = async (params) => {
+            const { privateKeyId, targetPublicKey, stampWith, organizationId } = params;
+            const session = await this.storageManager.getActiveSession();
+            if (!session) {
+                throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to export wallet`, sdkTypes.TurnkeyErrorCodes.EXPORT_WALLET_ERROR, error);
+            return utils.withTurnkeyErrorHandling(async () => {
+                const res = await this.httpClient.exportPrivateKey({
+                    privateKeyId,
+                    targetPublicKey,
+                    organizationId: organizationId || session.organizationId,
+                }, stampWith);
+                if (!res.exportBundle) {
+                    throw new sdkTypes.TurnkeyError("No export bundle found in the response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
+                }
+                return res.exportBundle;
+            }, {
+                errorMessage: "Failed to export private key",
+                errorCode: sdkTypes.TurnkeyErrorCodes.EXPORT_PRIVATE_KEY_ERROR,
+            });
+        };
+        /**
+         * Exports a wallet account as an encrypted bundle.
+         *
+         * - This function exports the specified wallet account as an encrypted bundle, suitable for backup or transfer.
+         * - The exported bundle contains the wallet account's key material, encrypted to the provided target public key.
+         * - If a targetPublicKey is provided, the bundle will be encrypted to that public key; otherwise, an error will be thrown.
+         * - If an organizationId is provided, the wallet account will be exported under that sub-organization; otherwise, the current session's organizationId is used.
+         * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+         *
+         * @param params.address - address of the wallet account to export.
+         * @param params.targetPublicKey - public key to encrypt the bundle to.
+         * @param params.organizationId - organization ID to export the wallet account under a specific sub-organization.
+         * @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 `ExportBundle` object containing the encrypted wallet account and metadata.
+         * @throws {TurnkeyError} If there is no active session, if the targetPublicKey is missing, or if there is an error exporting the wallet account.
+         *
+         */
+        this.exportWalletAccount = async (params) => {
+            const { address, targetPublicKey, stampWith, organizationId } = params;
+            const session = await this.storageManager.getActiveSession();
+            if (!session) {
+                throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
+            return utils.withTurnkeyErrorHandling(async () => {
+                const res = await this.httpClient.exportWalletAccount({
+                    address,
+                    targetPublicKey,
+                    organizationId: organizationId || session.organizationId,
+                }, stampWith);
+                if (!res.exportBundle) {
+                    throw new sdkTypes.TurnkeyError("No export bundle found in the response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
+                }
+                return res.exportBundle;
+            }, {
+                errorMessage: "Failed to export wallet account",
+                errorCode: sdkTypes.TurnkeyErrorCodes.EXPORT_WALLET_ACCOUNT_ERROR,
+            });
         };
         /**
          * Imports a wallet from an encrypted bundle.
@@ -1900,7 +2039,7 @@ class TurnkeyClient {
          * - This function imports a wallet using the provided encrypted bundle and creates accounts based on the provided parameters.
          * - If a userId is provided, the wallet will be imported for that specific user; otherwise, it uses the current session's userId.
          * - If an accounts array is provided, those accounts will be created in the imported wallet; otherwise, default Ethereum and Solana accounts will be created.
-         * - The encrypted bunlde MUST be encrypted to
+         * - The encrypted bundle MUST be encrypted to
          * - Automatically ensures an active session exists before making the request.
          * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
          *
@@ -1918,7 +2057,7 @@ class TurnkeyClient {
             if (!session) {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.importWallet({
                     organizationId: session.organizationId,
                     userId: userId || session.userId,
@@ -1933,12 +2072,66 @@ class TurnkeyClient {
                     throw new sdkTypes.TurnkeyError("No wallet ID found in the import response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.walletId;
+            }, {
+                errorMessage: "Failed to import wallet",
+                errorCode: sdkTypes.TurnkeyErrorCodes.IMPORT_WALLET_ERROR,
+                customMessageByMessages: {
+                    "invalid mnemonic": {
+                        message: "Invalid mnemonic input",
+                        code: sdkTypes.TurnkeyErrorCodes.BAD_REQUEST,
+                    },
+                },
+            });
+        };
+        /**
+         * Imports a private key from an encrypted bundle.
+         *
+         * - This function imports a private key using the provided encrypted bundle.
+         * - If a userId is provided, the private key will be imported for that specific user; otherwise, it uses the current session's userId.
+         * - Requires address formats to
+         * - Automatically infers the cryptographic curve used to generate the private key based on the address format (can be optionally overriden if needed).
+         * - The encrypted bundle MUST be encrypted to ensure security.
+         * - Automatically ensures an active session exists before making the request.
+         * - Optionally allows stamping the request with a specific stamper (StamperType.Passkey, StamperType.ApiKey, or StamperType.Wallet).
+         *
+         * @param params.encryptedBundle - encrypted bundle containing the private key key material and metadata.
+         * @param params.privateKeyName - name of the private key to create upon import.
+         * @param params.curve - the cryptographic curve used to generate a given private key
+         * @param params.addressFormat - address format of the private key to import.
+         * @param params.userId - user ID to import the wallet for a specific user (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 the ID of the imported wallet.
+         * @throws {TurnkeyError} If there is no active session, if the encrypted bundle is invalid, or if there is an error importing the wallet.
+         */
+        this.importPrivateKey = async (params) => {
+            const { encryptedBundle, privateKeyName, addressFormats, curve, userId, stampWith, } = params;
+            const session = await this.storageManager.getActiveSession();
+            if (!session) {
+                throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to import wallet`, sdkTypes.TurnkeyErrorCodes.IMPORT_WALLET_ERROR, error);
-            }
+            return utils.withTurnkeyErrorHandling(async () => {
+                const res = await this.httpClient.importPrivateKey({
+                    organizationId: session.organizationId,
+                    userId: userId || session.userId,
+                    encryptedBundle,
+                    privateKeyName,
+                    curve,
+                    addressFormats,
+                }, stampWith);
+                if (!res || !res.privateKeyId) {
+                    throw new sdkTypes.TurnkeyError("No wallet ID found in the import response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
+                }
+                return res.privateKeyId;
+            }, {
+                errorMessage: "Failed to import wallet",
+                errorCode: sdkTypes.TurnkeyErrorCodes.IMPORT_WALLET_ERROR,
+                customMessageByMessages: {
+                    "invalid mnemonic": {
+                        message: "Invalid mnemonic input",
+                        code: sdkTypes.TurnkeyErrorCodes.BAD_REQUEST,
+                    },
+                },
+            });
         };
         /**
          * Deletes the current sub-organization (sub-org) for the active session.
@@ -1960,14 +2153,12 @@ class TurnkeyClient {
             if (!session) {
                 throw new sdkTypes.TurnkeyError("No active session found. Please log in first.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 return await this.httpClient.deleteSubOrganization({ deleteWithoutExport }, stampWith);
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to delete sub-organization`, sdkTypes.TurnkeyErrorCodes.DELETE_SUB_ORGANIZATION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to delete sub-organization",
+                errorCode: sdkTypes.TurnkeyErrorCodes.DELETE_SUB_ORGANIZATION_ERROR,
+            });
         };
         /**
          * Stores a session token and updates the session associated with the specified session key, or by default the active session.
@@ -1987,21 +2178,14 @@ class TurnkeyClient {
             const { sessionToken, sessionKey = base.SessionKey.DefaultSessionkey } = params;
             if (!sessionToken)
                 return;
-            try {
-                const sessionToReplace = await this.storageManager.getSession(sessionKey);
+            utils.withTurnkeyErrorHandling(async () => {
                 await this.storageManager.storeSession(sessionToken, sessionKey);
-                if (sessionToReplace) {
-                    await this.apiKeyStamper?.deleteKeyPair(sessionToReplace.publicKey);
-                }
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to store session`, sdkTypes.TurnkeyErrorCodes.STORE_SESSION_ERROR, error);
-            }
-            finally {
-                await this.clearUnusedKeyPairs();
-            }
+            }, {
+                errorMessage: "Failed to store session",
+                errorCode: sdkTypes.TurnkeyErrorCodes.STORE_SESSION_ERROR,
+            }, {
+                finallyFn: async () => await this.clearUnusedKeyPairs(),
+            });
         };
         /**
          * Clears the session associated with the specified session key, or the active session by default.
@@ -2017,7 +2201,7 @@ class TurnkeyClient {
          */
         this.clearSession = async (params) => {
             const { sessionKey = base.SessionKey.DefaultSessionkey } = params || {};
-            try {
+            utils.withTurnkeyErrorHandling(async () => {
                 const session = await this.storageManager.getSession(sessionKey);
                 if (session) {
                     await this.apiKeyStamper?.deleteKeyPair(session.publicKey);
@@ -2026,12 +2210,10 @@ class TurnkeyClient {
                 else {
                     throw new sdkTypes.TurnkeyError(`No session found with key: ${sessionKey}`, sdkTypes.TurnkeyErrorCodes.NOT_FOUND);
                 }
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to delete session`, sdkTypes.TurnkeyErrorCodes.CLEAR_SESSION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to delete session",
+                errorCode: sdkTypes.TurnkeyErrorCodes.CLEAR_SESSION_ERROR,
+            });
         };
         /**
          * Clears all sessions and resets the active session state.
@@ -2045,7 +2227,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If no sessions exist or if there is an error clearing all sessions.
          */
         this.clearAllSessions = async () => {
-            try {
+            utils.withTurnkeyErrorHandling(async () => {
                 const sessionKeys = await this.storageManager.listSessionKeys();
                 if (sessionKeys.length === 0) {
                     throw new sdkTypes.TurnkeyError("No sessions found to clear.", sdkTypes.TurnkeyErrorCodes.NO_SESSION_FOUND);
@@ -2053,12 +2235,10 @@ class TurnkeyClient {
                 for (const sessionKey of sessionKeys) {
                     this.clearSession({ sessionKey });
                 }
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to clear all sessions`, sdkTypes.TurnkeyErrorCodes.CLEAR_ALL_SESSIONS_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to clear all sessions",
+                errorCode: sdkTypes.TurnkeyErrorCodes.CLEAR_ALL_SESSIONS_ERROR,
+            });
         };
         /**
          * Refreshes the session associated with the specified session key, or the active session by default.
@@ -2093,7 +2273,7 @@ class TurnkeyClient {
                 throw new sdkTypes.TurnkeyError("HTTP client is not initialized. Please initialize the client before refreshing the session.", sdkTypes.TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
             }
             let keyPair;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 keyPair = publicKey ?? (await this.apiKeyStamper?.createKeyPair());
                 if (!keyPair) {
                     throw new sdkTypes.TurnkeyError("Failed to create new key pair.", sdkTypes.TurnkeyErrorCodes.INTERNAL_ERROR);
@@ -2111,12 +2291,10 @@ class TurnkeyClient {
                     ...(sessionKey && { sessionKey }),
                 });
                 return res;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to refresh session`, sdkTypes.TurnkeyErrorCodes.REFRESH_SESSION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to refresh session",
+                errorCode: sdkTypes.TurnkeyErrorCodes.REFRESH_SESSION_ERROR,
+            });
         };
         /**
          * Retrieves the session associated with the specified session key, or the active session by default.
@@ -2130,15 +2308,13 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error retrieving the session from storage.
          */
         this.getSession = async (params) => {
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const { sessionKey = await this.storageManager.getActiveSessionKey() } = params || {};
                 return this.storageManager.getSession(sessionKey);
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to get session with key`, sdkTypes.TurnkeyErrorCodes.GET_SESSION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to get session with key " + params?.sessionKey,
+                errorCode: sdkTypes.TurnkeyErrorCodes.GET_SESSION_ERROR,
+            });
         };
         /**
          * Retrieves all sessions stored in persistent storage.
@@ -2152,7 +2328,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error retrieving sessions from storage.
          */
         this.getAllSessions = async () => {
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const sessionKeys = await this.storageManager.listSessionKeys();
                 if (!sessionKeys || sessionKeys.length === 0) {
                     return undefined;
@@ -2164,13 +2340,11 @@ class TurnkeyClient {
                         sessions[sessionKey] = session;
                     }
                 }
-                return sessions;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to get all sessions`, sdkTypes.TurnkeyErrorCodes.GET_ALL_SESSIONS_ERROR, error);
-            }
+                return sessions || undefined;
+            }, {
+                errorMessage: "Failed to get all sessions",
+                errorCode: sdkTypes.TurnkeyErrorCodes.GET_ALL_SESSIONS_ERROR,
+            });
         };
         /**
          * Sets the active session to the specified session key.
@@ -2186,14 +2360,12 @@ class TurnkeyClient {
          */
         this.setActiveSession = async (params) => {
             const { sessionKey } = params;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 await this.storageManager.setActiveSessionKey(sessionKey);
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to set active session`, sdkTypes.TurnkeyErrorCodes.SET_ACTIVE_SESSION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to set active session",
+                errorCode: sdkTypes.TurnkeyErrorCodes.SET_ACTIVE_SESSION_ERROR,
+            });
         };
         /**
          * Retrieves the active session key currently set in persistent storage.
@@ -2207,14 +2379,12 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error retrieving the active session key from storage.
          */
         this.getActiveSessionKey = async () => {
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 return await this.storageManager.getActiveSessionKey();
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to get active session key`, sdkTypes.TurnkeyErrorCodes.GET_ACTIVE_SESSION_KEY_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to get active session key",
+                errorCode: sdkTypes.TurnkeyErrorCodes.GET_ACTIVE_SESSION_KEY_ERROR,
+            });
         };
         /**
          * Clears any unused API key pairs from persistent storage.
@@ -2228,7 +2398,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error listing, checking, or deleting unused key pairs.
          */
         this.clearUnusedKeyPairs = async () => {
-            try {
+            utils.withTurnkeyErrorHandling(async () => {
                 const publicKeys = await this.apiKeyStamper?.listKeyPairs();
                 if (!publicKeys || publicKeys.length === 0) {
                     return;
@@ -2251,12 +2421,10 @@ class TurnkeyClient {
                         }
                     }
                 }
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to clear unused key pairs`, sdkTypes.TurnkeyErrorCodes.CLEAR_UNUSED_KEY_PAIRS_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to clear unused key pairs",
+                errorCode: sdkTypes.TurnkeyErrorCodes.CLEAR_UNUSED_KEY_PAIRS_ERROR,
+            });
         };
         /**
          * Creates a new API key pair and returns the public key.
@@ -2273,23 +2441,21 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If the API key stamper is not initialized or if there is an error during key pair creation or storage.
          */
         this.createApiKeyPair = async (params) => {
-            if (!this.apiKeyStamper) {
-                throw new sdkTypes.TurnkeyError("API Key Stamper is not initialized.", sdkTypes.TurnkeyErrorCodes.INTERNAL_ERROR);
-            }
-            const externalKeyPair = params?.externalKeyPair;
-            const storeOverride = params?.storeOverride ?? false;
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
+                const externalKeyPair = params?.externalKeyPair;
+                const storeOverride = params?.storeOverride ?? false;
+                if (!this.apiKeyStamper) {
+                    throw new sdkTypes.TurnkeyError("API Key Stamper is not initialized.", sdkTypes.TurnkeyErrorCodes.INTERNAL_ERROR);
+                }
                 const publicKey = await this.apiKeyStamper.createKeyPair(externalKeyPair ? externalKeyPair : undefined);
                 if (storeOverride && publicKey) {
                     await this.apiKeyStamper.setPublicKeyOverride(publicKey);
                 }
                 return publicKey;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to create API key pair`, sdkTypes.TurnkeyErrorCodes.CREATE_API_KEY_PAIR_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to create API key pair",
+                errorCode: sdkTypes.TurnkeyErrorCodes.CREATE_API_KEY_PAIR_ERROR,
+            });
         };
         /**
          * Fetches the WalletKit proxy authentication configuration from the auth proxy.
@@ -2303,18 +2469,16 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error retrieving the proxy authentication configuration from the auth proxy.
          */
         this.getProxyAuthConfig = async () => {
-            try {
+            return utils.withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.proxyGetWalletKitConfig({});
                 if (!res) {
                     throw new sdkTypes.TurnkeyError(`Failed to fetch auth proxy config`, sdkTypes.TurnkeyErrorCodes.GET_PROXY_AUTH_CONFIG_ERROR);
                 }
                 return res;
-            }
-            catch (error) {
-                if (error instanceof sdkTypes.TurnkeyError)
-                    throw error;
-                throw new sdkTypes.TurnkeyError(`Failed to get auth proxy config`, sdkTypes.TurnkeyErrorCodes.GET_PROXY_AUTH_CONFIG_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to get auth proxy config",
+                errorCode: sdkTypes.TurnkeyErrorCodes.GET_PROXY_AUTH_CONFIG_ERROR,
+            });
         };
         this.config = config;
         // Just store any explicitly provided stampers