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

package/dist/__clients__/core.mjs

@@ -1,7 +1,7 @@
 import { TurnkeySDKClientBase } from '../__generated__/sdk-client-base.mjs';
-import { TurnkeyError, TurnkeyErrorCodes, TurnkeyNetworkError } from '@turnkey/sdk-types';
-import { SessionKey, DEFAULT_SESSION_EXPIRATION_IN_SECONDS, StamperType, Chain, FilterType, OtpTypeToFilterTypeMap, TurnkeyRequestError, OtpType, WalletSource, Curve } from '../__types__/base.mjs';
-import { isWeb, isReactNative, buildSignUpBody, isEthereumWallet, getPublicKeyFromStampHeader, toExternalTimestamp, isSolanaWallet, getWalletAccountMethods, getHashFunction, getEncodingType, getEncodedMessage, splitSignature, broadcastTransaction, googleISS, isWalletAccountArray, generateWalletAccountsFromAddressFormat } from '../utils.mjs';
+import { TurnkeyErrorCodes, TurnkeyError, TurnkeyNetworkError } from '@turnkey/sdk-types';
+import { SessionKey, DEFAULT_SESSION_EXPIRATION_IN_SECONDS, StamperType, WalletSource, Chain, FilterType, OtpTypeToFilterTypeMap, OtpType, Curve, SignIntent } from '../__types__/base.mjs';
+import { withTurnkeyErrorHandling, isWeb, isReactNative, buildSignUpBody, findWalletProviderFromAddress, isEthereumProvider, getPublicKeyFromStampHeader, toExternalTimestamp, isSolanaProvider, getHashFunction, getEncodingType, getEncodedMessage, splitSignature, broadcastTransaction, googleISS, isWalletAccountArray, generateWalletAccountsFromAddressFormat } from '../utils.mjs';
 import { createStorageManager } from '../__storage__/base.mjs';
 import { CrossPlatformApiKeyStamper } from '../__stampers__/api/base.mjs';
 import { CrossPlatformPasskeyStamper } from '../__stampers__/passkey/base.mjs';
@@ -30,7 +30,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 withTurnkeyErrorHandling(async () => {
                 const name = params?.name || "A Passkey";
                 const displayName = params?.displayName || "A Passkey";
                 let passkey;
@@ -68,16 +68,16 @@ class TurnkeyClient {
                     throw new TurnkeyError("Unsupported platform for passkey creation", TurnkeyErrorCodes.INVALID_REQUEST);
                 }
                 return passkey;
-            }
-            catch (error) {
-                if (error?.message?.includes("timed out or was not allowed")) {
-                    throw new TurnkeyError("Passkey creation was cancelled by the user.", TurnkeyErrorCodes.SELECT_PASSKEY_CANCELLED, error);
-                }
-                else if (error instanceof TurnkeyError) {
-                    throw error;
-                }
-                throw new TurnkeyError(`Failed to create passkey`, TurnkeyErrorCodes.CREATE_PASSKEY_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to create passkey",
+                errorCode: TurnkeyErrorCodes.CREATE_PASSKEY_ERROR,
+                customMessageByMessages: {
+                    "timed out or was not allowed": {
+                        message: "Passkey creation was cancelled by the user.",
+                        code: TurnkeyErrorCodes.SELECT_PASSKEY_CANCELLED,
+                    },
+                },
+            });
         };
         /**
          * Logs out the current client session.
@@ -91,7 +91,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 {
+            withTurnkeyErrorHandling(async () => {
                 if (params?.sessionKey) {
                     const session = await this.storageManager.getSession(params.sessionKey);
                     this.storageManager.clearSession(params.sessionKey);
@@ -108,12 +108,10 @@ class TurnkeyClient {
                         throw new TurnkeyError("No active session found to log out from.", TurnkeyErrorCodes.NO_SESSION_FOUND);
                     }
                 }
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to log out`, TurnkeyErrorCodes.LOGOUT_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to log out",
+                errorCode: TurnkeyErrorCodes.LOGOUT_ERROR,
+            });
         };
         /**
          * Logs in a user using a passkey, optionally specifying the public key, session key, and session expiration.
@@ -131,16 +129,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 withTurnkeyErrorHandling(async () => {
+                generatedKeyPair =
+                    params?.publicKey || (await this.apiKeyStamper?.createKeyPair());
                 const sessionKey = params?.sessionKey || SessionKey.DefaultSessionkey;
                 const expirationSeconds = params?.expirationSeconds || DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
-                if (!publicKey) {
+                if (!generatedKeyPair) {
                     throw new TurnkeyError("A publickey could not be found or generated.", TurnkeyErrorCodes.INTERNAL_ERROR);
                 }
                 const sessionResponse = await this.httpClient.stampLogin({
-                    publicKey,
+                    publicKey: generatedKeyPair,
                     organizationId: this.config.organizationId,
                     expirationSeconds,
                 }, StamperType.Passkey);
@@ -148,28 +147,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 TurnkeyError("Passkey login was cancelled by the user.", TurnkeyErrorCodes.SELECT_PASSKEY_CANCELLED, error);
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Unable to log in with the provided passkey`, 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 TurnkeyError(`Failed to clean up generated key pair`, TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+            }, {
+                errorMessage: "Unable to log in with the provided passkey",
+                errorCode: TurnkeyErrorCodes.PASSKEY_LOGIN_AUTH_ERROR,
+                customMessageByMessages: {
+                    "timed out or was not allowed": {
+                        message: "Passkey login was cancelled by the user.",
+                        code: TurnkeyErrorCodes.SELECT_PASSKEY_CANCELLED,
+                    },
+                },
+            }, {
+                finallyFn: async () => {
+                    if (generatedKeyPair) {
+                        try {
+                            await this.apiKeyStamper?.deleteKeyPair(generatedKeyPair);
+                        }
+                        catch (cleanupError) {
+                            throw new TurnkeyError(`Failed to clean up generated key pair`, TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
                     }
-                }
-            }
+                },
+            });
         };
         /**
          * Signs up a user using a passkey, creating a new sub-organization and session.
@@ -189,8 +189,8 @@ class TurnkeyClient {
          */
         this.signUpWithPasskey = async (params) => {
             const { createSubOrgParams, passkeyDisplayName, sessionKey = SessionKey.DefaultSessionkey, expirationSeconds = DEFAULT_SESSION_EXPIRATION_IN_SECONDS, } = params || {};
-            let generatedKeyPair = null;
-            try {
+            let generatedKeyPair = undefined;
+            return 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
@@ -239,26 +239,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 TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to sign up with passkey`, 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 TurnkeyError(`Failed to clean up generated key pair`, TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+            }, {
+                errorCode: 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 TurnkeyError(`Failed to clean up generated key pair`, TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
                     }
-                }
-            }
+                },
+            });
         };
         /**
          * Retrieves wallet providers from the initialized wallet manager.
@@ -271,15 +269,15 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If the wallet manager is uninitialized or provider retrieval fails.
          */
         this.getWalletProviders = async (chain) => {
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 if (!this.walletManager) {
                     throw new TurnkeyError("Wallet manager is not initialized", TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
                 }
                 return await this.walletManager.getProviders(chain);
-            }
-            catch (error) {
-                throw new TurnkeyError(`Unable to get wallet providers`, TurnkeyErrorCodes.FETCH_WALLETS_ERROR, error);
-            }
+            }, {
+                errorMessage: "Unable to get wallet providers",
+                errorCode: TurnkeyErrorCodes.FETCH_WALLETS_ERROR,
+            });
         };
         /**
          * Connects the specified wallet account.
@@ -291,15 +289,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 TurnkeyError("Wallet connector is not initialized", TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
-            try {
+            return withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.connector) {
+                    throw new TurnkeyError("Wallet connector is not initialized", TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
+                }
                 await this.walletManager.connector.connectWalletAccount(walletProvider);
-            }
-            catch (error) {
-                throw new TurnkeyError("Unable to connect wallet account", TurnkeyErrorCodes.CONNECT_WALLET_ACCOUNT_ERROR, error);
-            }
+            }, {
+                errorMessage: "Unable to connect wallet account",
+                errorCode: TurnkeyErrorCodes.CONNECT_WALLET_ACCOUNT_ERROR,
+            });
         };
         /**
          * Disconnects the specified wallet account.
@@ -311,45 +309,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 TurnkeyError("Wallet connector is not initialized", TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
-            try {
+            return withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.connector) {
+                    throw new TurnkeyError("Wallet connector is not initialized", TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
+                }
                 await this.walletManager.connector.disconnectWalletAccount(walletProvider);
-            }
-            catch (error) {
-                throw new TurnkeyError("Unable to disconnect wallet account", TurnkeyErrorCodes.DISCONNECT_WALLET_ACCOUNT_ERROR, error);
-            }
+            }, {
+                errorMessage: "Unable to disconnect wallet account",
+                errorCode: 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 TurnkeyError("Wallet connector is not initialized", TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
-            if (walletProvider.connectedAddresses.length === 0) {
-                throw new TurnkeyError("You can not switch chains for a provider that is not connected", 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 withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.connector) {
+                    throw new TurnkeyError("Wallet connector is not initialized", TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
+                }
+                if (walletAccount.source === WalletSource.Embedded) {
+                    throw new TurnkeyError("You can only switch chains for connected wallet accounts", TurnkeyErrorCodes.NOT_FOUND);
+                }
+                const providers = walletProviders ?? (await this.getWalletProviders());
+                const walletProvider = findWalletProviderFromAddress(walletAccount.address, providers);
+                if (!walletProvider) {
+                    throw new TurnkeyError("Wallet provider not found", 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 TurnkeyError("Unable to switch wallet account chain", TurnkeyErrorCodes.SWITCH_WALLET_CHAIN_ERROR, error);
-            }
+            }, {
+                errorMessage: "Unable to switch wallet account chain",
+                errorCode: TurnkeyErrorCodes.SWITCH_WALLET_CHAIN_ERROR,
+            });
         };
         /**
          * Logs in a user using the specified wallet provider.
@@ -368,11 +376,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 TurnkeyError("Wallet stamper is not initialized", TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
-            try {
-                const publicKey = params.publicKey || (await this.apiKeyStamper?.createKeyPair());
+            let publicKey = params.publicKey || (await this.apiKeyStamper?.createKeyPair());
+            return withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.stamper) {
+                    throw new TurnkeyError("Wallet stamper is not initialized", TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
+                }
                 const sessionKey = params.sessionKey || SessionKey.DefaultSessionkey;
                 const walletProvider = params.walletProvider;
                 const expirationSeconds = params?.expirationSeconds || DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
@@ -390,12 +398,23 @@ class TurnkeyClient {
                     sessionKey,
                 });
                 return sessionResponse.session;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Unable to log in with the provided wallet`, TurnkeyErrorCodes.WALLET_LOGIN_AUTH_ERROR, error);
-            }
+            }, {
+                errorMessage: "Unable to log in with the provided wallet",
+                errorCode: 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 TurnkeyError("Failed to clean up generated key pair", TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
+                    }
+                },
+            });
         };
         /**
          * Signs up a user using a wallet, creating a new sub-organization and session.
@@ -415,11 +434,11 @@ class TurnkeyClient {
          */
         this.signUpWithWallet = async (params) => {
             const { walletProvider, createSubOrgParams, sessionKey = SessionKey.DefaultSessionkey, expirationSeconds = DEFAULT_SESSION_EXPIRATION_IN_SECONDS, } = params;
-            if (!this.walletManager?.stamper) {
-                throw new TurnkeyError("Wallet stamper is not initialized", TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
-            let generatedKeyPair = null;
-            try {
+            let generatedKeyPair = undefined;
+            return withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.stamper) {
+                    throw new TurnkeyError("Wallet stamper is not initialized", 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);
@@ -433,7 +452,7 @@ class TurnkeyClient {
                             {
                                 apiKeyName: `wallet-auth:${publicKey}`,
                                 publicKey: publicKey,
-                                curveType: isEthereumWallet(walletProvider)
+                                curveType: isEthereumProvider(walletProvider)
                                     ? "API_KEY_CURVE_SECP256K1"
                                     : "API_KEY_CURVE_ED25519",
                             },
@@ -462,24 +481,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 TurnkeyError("Failed to sign up with wallet", 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 TurnkeyError("Failed to clean up generated key pair", TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+            }, {
+                errorMessage: "Failed to sign up with wallet",
+                errorCode: 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 TurnkeyError("Failed to clean up generated key pair", 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.
@@ -499,25 +519,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 TurnkeyError("Wallet stamper is not initialized", TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-            }
             const createSubOrgParams = params.createSubOrgParams;
             const sessionKey = params.sessionKey || SessionKey.DefaultSessionkey;
             const walletProvider = params.walletProvider;
             const expirationSeconds = params.expirationSeconds || DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
-            let generatedKeyPair = null;
-            try {
+            let generatedKeyPair = undefined;
+            return withTurnkeyErrorHandling(async () => {
+                if (!this.walletManager?.stamper) {
+                    throw new TurnkeyError("Wallet stamper is not initialized", 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,
-                }, StamperType.Wallet);
+                const signedRequest = await withTurnkeyErrorHandling(async () => {
+                    return this.httpClient.stampStampLogin({
+                        publicKey: generatedKeyPair,
+                        organizationId: this.config.organizationId,
+                        expirationSeconds,
+                    }, StamperType.Wallet);
+                }, {
+                    errorMessage: "Failed to create stamped request for wallet login",
+                    errorCode: TurnkeyErrorCodes.WALLET_LOGIN_OR_SIGNUP_ERROR,
+                    customMessageByMessages: {
+                        "Failed to sign the message": {
+                            message: "Wallet auth was cancelled by the user.",
+                            code: TurnkeyErrorCodes.CONNECT_WALLET_CANCELLED,
+                        },
+                    },
+                });
                 if (!signedRequest) {
                     throw new TurnkeyError("Failed to create stamped request for wallet login", TurnkeyErrorCodes.BAD_RESPONSE);
                 }
@@ -559,7 +590,7 @@ class TurnkeyClient {
                                 {
                                     apiKeyName: `wallet-auth:${publicKey}`,
                                     publicKey: publicKey,
-                                    curveType: isEthereumWallet(walletProvider)
+                                    curveType: isEthereumProvider(walletProvider)
                                         ? "API_KEY_CURVE_SECP256K1"
                                         : "API_KEY_CURVE_ED25519",
                                 },
@@ -595,10 +626,20 @@ class TurnkeyClient {
                     sessionKey,
                 });
                 return sessionToken;
-            }
-            catch (error) {
-                throw new TurnkeyError(`Unable to log in or signup with the provided wallet`, TurnkeyErrorCodes.WALLET_LOGIN_OR_SIGNUP_ERROR, error);
-            }
+            }, {
+                errorCode: 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 TurnkeyError(`Failed to clean up generated key pair`, TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
+                    }
+                },
+            });
         };
         /**
          * Initializes the OTP process by sending an OTP code to the provided contact.
@@ -613,23 +654,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 withTurnkeyErrorHandling(async () => {
                 const initOtpRes = await this.httpClient.proxyInitOtp(params);
                 if (!initOtpRes || !initOtpRes.otpId) {
                     throw new TurnkeyError("Failed to initialize OTP: otpId is missing", TurnkeyErrorCodes.INIT_OTP_ERROR);
                 }
                 return initOtpRes.otpId;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyNetworkError) {
-                    if (error.message.includes("Max number of OTPs have been initiated")) {
-                        throw new TurnkeyError("Max number of OTPs have been initiated", TurnkeyErrorCodes.MAX_OTP_INITIATED_ERROR);
-                    }
-                }
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to initialize OTP`, TurnkeyErrorCodes.INIT_OTP_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to initialize OTP",
+                errorCode: TurnkeyErrorCodes.INIT_OTP_ERROR,
+                customMessageByMessages: {
+                    "Max number of OTPs have been initiated": {
+                        message: "Maximum number of OTPs has been reached for this contact.",
+                        code: TurnkeyErrorCodes.MAX_OTP_INITIATED_ERROR,
+                    },
+                },
+            });
         };
         /**
          * Verifies the OTP code sent to the user.
@@ -650,7 +690,7 @@ class TurnkeyClient {
          */
         this.verifyOtp = async (params) => {
             const { otpId, otpCode, contact, otpType } = params;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const verifyOtpRes = await this.httpClient.proxyVerifyOtp({
                     otpId: otpId,
                     otpCode: otpCode,
@@ -670,16 +710,16 @@ class TurnkeyClient {
                     subOrganizationId: subOrganizationId,
                     verificationToken: verifyOtpRes.verificationToken,
                 };
-            }
-            catch (error) {
-                if (error instanceof TurnkeyRequestError &&
-                    error.message.includes("Invalid OTP code")) {
-                    throw new TurnkeyError("Invalid OTP code provided", TurnkeyErrorCodes.INVALID_OTP_CODE, error.message);
-                }
-                else if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to verify OTP`, TurnkeyErrorCodes.VERIFY_OTP_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to verify OTP",
+                errorCode: TurnkeyErrorCodes.VERIFY_OTP_ERROR,
+                customMessageByMessages: {
+                    "Invalid OTP code": {
+                        message: "The provided OTP code is invalid.",
+                        code: TurnkeyErrorCodes.INVALID_OTP_CODE,
+                    },
+                },
+            });
         };
         /**
          * Logs in a user using an OTP verification token.
@@ -699,7 +739,7 @@ class TurnkeyClient {
          */
         this.loginWithOtp = async (params) => {
             const { verificationToken, invalidateExisting = false, publicKey = await this.apiKeyStamper?.createKeyPair(), sessionKey = SessionKey.DefaultSessionkey, } = params;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.proxyOtpLogin({
                     verificationToken,
                     publicKey: publicKey,
@@ -717,21 +757,21 @@ class TurnkeyClient {
                     sessionKey,
                 });
                 return loginRes.session;
-            }
-            catch (error) {
-                if (error instanceof 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 TurnkeyError(`Failed to clean up generated key pair`, TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+            }, {
+                errorMessage: "Failed to log in with OTP",
+                errorCode: 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 TurnkeyError(`Failed to clean up generated key pair`, TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
                     }
-                }
-                throw new TurnkeyError(`Failed to log in with OTP`, TurnkeyErrorCodes.OTP_LOGIN_ERROR, error);
-            }
+                },
+            });
         };
         /**
          * Signs up a user using an OTP verification token.
@@ -762,8 +802,8 @@ class TurnkeyClient {
                     verificationToken,
                 },
             });
-            const generatedKeyPair = await this.apiKeyStamper?.createKeyPair();
-            try {
+            return withTurnkeyErrorHandling(async () => {
+                const generatedKeyPair = await this.apiKeyStamper?.createKeyPair();
                 const res = await this.httpClient.proxySignup(signUpBody);
                 if (!res) {
                     throw new TurnkeyError(`Auth proxy OTP sign up failed`, TurnkeyErrorCodes.OTP_SIGNUP_ERROR);
@@ -774,12 +814,10 @@ class TurnkeyClient {
                     ...(invalidateExisting && { invalidateExisting }),
                     ...(sessionKey && { sessionKey }),
                 });
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to sign up with OTP`, TurnkeyErrorCodes.OTP_SIGNUP_ERROR, error);
-            }
+            }, {
+                errorCode: 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.
@@ -803,7 +841,7 @@ class TurnkeyClient {
          */
         this.completeOtp = async (params) => {
             const { otpId, otpCode, contact, otpType, publicKey, invalidateExisting = false, sessionKey, createSubOrgParams, } = params;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const { subOrganizationId, verificationToken } = await this.verifyOtp({
                     otpId: otpId,
                     otpCode: otpCode,
@@ -833,12 +871,10 @@ class TurnkeyClient {
                         ...(sessionKey && { sessionKey }),
                     });
                 }
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to complete OTP process`, TurnkeyErrorCodes.OTP_COMPLETION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to complete OTP process",
+                errorCode: 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.
@@ -860,7 +896,7 @@ class TurnkeyClient {
          */
         this.completeOauth = async (params) => {
             const { oidcToken, publicKey, createSubOrgParams, providerName = "OpenID Connect Provider" + Date.now(), sessionKey = SessionKey.DefaultSessionkey, invalidateExisting = false, } = params;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const accountRes = await this.httpClient.proxyGetAccount({
                     filterType: "OIDC_TOKEN",
                     filterValue: oidcToken,
@@ -887,12 +923,10 @@ class TurnkeyClient {
                         }),
                     });
                 }
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to handle Google OAuth login`, TurnkeyErrorCodes.OAUTH_LOGIN_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to complete OAuth process",
+                errorCode: TurnkeyErrorCodes.OAUTH_LOGIN_ERROR,
+            });
         };
         /**
          * Logs in a user using OAuth authentication.
@@ -911,10 +945,10 @@ class TurnkeyClient {
          */
         this.loginWithOauth = async (params) => {
             const { oidcToken, invalidateExisting = false, publicKey, sessionKey = SessionKey.DefaultSessionkey, } = params;
-            if (!publicKey) {
-                throw new TurnkeyError("Public key must be provided to log in with OAuth. Please create a key pair first.", TurnkeyErrorCodes.MISSING_PARAMS);
-            }
-            try {
+            return withTurnkeyErrorHandling(async () => {
+                if (!publicKey) {
+                    throw new TurnkeyError("Public key must be provided to log in with OAuth. Please create a key pair first.", TurnkeyErrorCodes.MISSING_PARAMS);
+                }
                 const loginRes = await this.httpClient.proxyOAuthLogin({
                     oidcToken,
                     publicKey,
@@ -931,21 +965,27 @@ class TurnkeyClient {
                     sessionKey,
                 });
                 return loginRes.session;
-            }
-            catch (error) {
-                if (error instanceof 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 TurnkeyError(`Failed to clean up generated key pair`, TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+            }, {
+                errorMessage: "Failed to complete OAuth login",
+                errorCode: TurnkeyErrorCodes.OAUTH_LOGIN_ERROR,
+                customMessageByMessages: {
+                    "OAUTH disallowed": {
+                        message: "OAuth is disabled on the dashboard for this organization.",
+                        code: 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 TurnkeyError(`Failed to clean up generated key pair`, TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
                     }
-                }
-                throw new TurnkeyError(`Failed to log in with oauth`, TurnkeyErrorCodes.OAUTH_LOGIN_ERROR, error);
-            }
+                },
+            });
         };
         /**
          * Signs up a user using OAuth authentication.
@@ -965,7 +1005,7 @@ class TurnkeyClient {
          */
         this.signUpWithOauth = async (params) => {
             const { oidcToken, publicKey, providerName, createSubOrgParams } = params;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const signUpBody = buildSignUpBody({
                     createSubOrgParams: {
                         ...createSubOrgParams,
@@ -985,12 +1025,10 @@ class TurnkeyClient {
                     oidcToken,
                     publicKey: publicKey,
                 });
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to sign up with OAuth`, TurnkeyErrorCodes.OAUTH_SIGNUP_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to sign up with OAuth",
+                errorCode: TurnkeyErrorCodes.OAUTH_SIGNUP_ERROR,
+            });
         };
         /**
          * Fetches all wallets for the current user, including both embedded and connected wallets.
@@ -1006,12 +1044,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 TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.getWallets({ organizationId: session.organizationId }, stampWith);
                 if (!res || !res.wallets) {
                     throw new TurnkeyError("No wallets found in the response", TurnkeyErrorCodes.BAD_RESPONSE);
@@ -1032,10 +1070,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);
@@ -1061,12 +1100,10 @@ class TurnkeyClient {
                     return wallet;
                 }))).filter((wallet) => wallet.accounts.length > 0);
                 return [...embedded, ...connected];
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError("Failed to fetch wallets", TurnkeyErrorCodes.FETCH_WALLETS_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to fetch wallets",
+                errorCode: TurnkeyErrorCodes.FETCH_WALLETS_ERROR,
+            });
         };
         /**
          * Fetches all accounts for a specific wallet, including both embedded and connected wallet accounts.
@@ -1090,58 +1127,90 @@ class TurnkeyClient {
             if (!session) {
                 throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            // this is an embedded wallet so we fetch accounts from Turnkey
-            if (wallet.source === 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 TurnkeyError("No wallet accounts found in the response", TurnkeyErrorCodes.BAD_RESPONSE);
-                }
-                for (const account of res.accounts) {
-                    embedded.push({
-                        ...account,
-                        source: 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 = toExternalTimestamp();
-                for (const address of provider.connectedAddresses) {
-                    const account = {
-                        walletAccountId: `${wallet.walletId}-${provider.interfaceType}-${address}`,
-                        organizationId: session.organizationId,
+            return withTurnkeyErrorHandling(async () => {
+                // this is an embedded wallet so we fetch accounts from Turnkey
+                if (wallet.source === WalletSource.Embedded) {
+                    const embedded = [];
+                    const res = await this.httpClient.getWalletAccounts({
                         walletId: wallet.walletId,
-                        curve: isEthereumWallet(provider) ? Curve.SECP256K1 : Curve.ED25519,
-                        pathFormat: "PATH_FORMAT_BIP32",
-                        path: WalletSource.Connected,
-                        source: WalletSource.Connected,
-                        addressFormat: isEthereumWallet(provider)
-                            ? "ADDRESS_FORMAT_ETHEREUM"
-                            : "ADDRESS_FORMAT_SOLANA",
-                        address,
-                        createdAt: timestamp,
-                        updatedAt: timestamp,
-                        ...getWalletAccountMethods(this.walletManager.connector.sign.bind(this.walletManager.connector), provider),
-                        ...(isSolanaWallet(provider) && { publicKey: address }),
-                    };
-                    connected.push(account);
+                        organizationId: session.organizationId,
+                        paginationOptions: paginationOptions || { limit: "100" },
+                    }, stampWith);
+                    if (!res || !res.accounts) {
+                        throw new TurnkeyError("No wallet accounts found in the response", TurnkeyErrorCodes.BAD_RESPONSE);
+                    }
+                    for (const account of res.accounts) {
+                        embedded.push({
+                            ...account,
+                            source: 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 = toExternalTimestamp();
+                    for (const address of provider.connectedAddresses) {
+                        if (isEthereumProvider(provider)) {
+                            const evmAccount = {
+                                walletAccountId: `${wallet.walletId}-${provider.interfaceType}-${address}`,
+                                organizationId: session.organizationId,
+                                walletId: wallet.walletId,
+                                pathFormat: "PATH_FORMAT_BIP32",
+                                path: WalletSource.Connected,
+                                source: WalletSource.Connected,
+                                address,
+                                createdAt: timestamp,
+                                updatedAt: timestamp,
+                                // ethereum specific
+                                curve: Curve.SECP256K1,
+                                addressFormat: "ADDRESS_FORMAT_ETHEREUM",
+                                chainInfo: provider.chainInfo,
+                                signMessage: (msg) => sign(msg, provider, SignIntent.SignMessage),
+                                signAndSendTransaction: (tx) => sign(tx, provider, SignIntent.SignAndSendTransaction),
+                            };
+                            connected.push(evmAccount);
+                            continue;
+                        }
+                        if (isSolanaProvider(provider)) {
+                            const solAccount = {
+                                walletAccountId: `${wallet.walletId}-${provider.interfaceType}-${address}`,
+                                organizationId: session.organizationId,
+                                walletId: wallet.walletId,
+                                pathFormat: "PATH_FORMAT_BIP32",
+                                path: WalletSource.Connected,
+                                source: WalletSource.Connected,
+                                address,
+                                createdAt: timestamp,
+                                updatedAt: timestamp,
+                                // solana specific
+                                publicKey: address,
+                                curve: Curve.ED25519,
+                                addressFormat: "ADDRESS_FORMAT_SOLANA",
+                                chainInfo: provider.chainInfo,
+                                signMessage: (msg) => sign(msg, provider, SignIntent.SignMessage),
+                                signTransaction: (tx) => sign(tx, provider, 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: TurnkeyErrorCodes.FETCH_WALLET_ACCOUNTS_ERROR,
+            });
         };
         /**
          * Signs a message using the specified wallet account.
@@ -1175,7 +1244,7 @@ class TurnkeyClient {
             const { message, walletAccount, stampWith, addEthereumPrefix } = params;
             const hashFunction = params.hashFunction || getHashFunction(walletAccount.addressFormat);
             const payloadEncoding = params.encoding || getEncodingType(walletAccount.addressFormat);
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const isEthereum = walletAccount.addressFormat === "ADDRESS_FORMAT_ETHEREUM";
                 if (walletAccount.source === WalletSource.Connected) {
                     // this is a connected wallet
@@ -1207,12 +1276,10 @@ class TurnkeyClient {
                 }
                 return response.activity.result
                     .signRawPayloadResult;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to sign message - ${error?.message ? error.message : "Unknown error"}`, TurnkeyErrorCodes.SIGN_MESSAGE_ERROR);
-            }
+            }, {
+                errorMessage: "Failed to sign message",
+                errorCode: TurnkeyErrorCodes.SIGN_MESSAGE_ERROR,
+            });
         };
         /**
          * Signs a transaction using the specified wallet account.
@@ -1232,17 +1299,18 @@ class TurnkeyClient {
          */
         this.signTransaction = async (params) => {
             const { walletAccount, unsignedTransaction, transactionType, stampWith } = params;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 if (walletAccount.source === 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 TurnkeyError(`Failed to sign transaction: ${reason} ${isEthereum ? "Use signAndSendTransaction instead." : ""}`, TurnkeyErrorCodes.SIGN_TRANSACTION_ERROR);
+                    switch (walletAccount.chainInfo.namespace) {
+                        case Chain.Ethereum:
+                            throw new TurnkeyError("Ethereum connected wallets do not support raw transaction signing. Use signAndSendTransaction instead.", TurnkeyErrorCodes.INVALID_REQUEST);
+                        case 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 TurnkeyError("Unsupported connected wallet type.", TurnkeyErrorCodes.INVALID_REQUEST);
                     }
-                    return await walletAccount?.signTransaction(unsignedTransaction);
                 }
                 // this is an embedded wallet account
                 const signTransaction = await this.httpClient.signTransaction({
@@ -1251,12 +1319,10 @@ class TurnkeyClient {
                     type: transactionType,
                 }, stampWith);
                 return signTransaction.signedTransaction;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to sign transaction`, TurnkeyErrorCodes.SIGN_TRANSACTION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to sign transaction",
+                errorCode: TurnkeyErrorCodes.SIGN_TRANSACTION_ERROR,
+            });
         };
         /**
          * Signs and broadcasts a transaction using the specified wallet account.
@@ -1280,22 +1346,20 @@ class TurnkeyClient {
          */
         this.signAndSendTransaction = async (params) => {
             const { walletAccount, unsignedTransaction, transactionType, rpcUrl, stampWith, } = params;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 if (walletAccount.source === WalletSource.Connected) {
                     // this is a connected wallet account
-                    switch (transactionType) {
-                        case "TRANSACTION_TYPE_ETHEREUM":
-                            if (!walletAccount.signAndSendTransaction) {
-                                throw new TurnkeyError("This connected wallet does not support signAndSendTransaction.", TurnkeyErrorCodes.SIGN_AND_SEND_TRANSACTION_ERROR);
-                            }
+                    switch (walletAccount.chainInfo.namespace) {
+                        case 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 Chain.Solana:
                             if (!rpcUrl) {
                                 throw new TurnkeyError("Missing rpcUrl: connected Solana wallets require an RPC URL to broadcast transactions.", TurnkeyErrorCodes.SIGN_AND_SEND_TRANSACTION_ERROR);
                             }
-                            if (!walletAccount.signTransaction) {
-                                throw new TurnkeyError("This connected wallet does not support signAndSendTransaction.", 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 broadcastTransaction({
                                 signedTransaction: signature,
@@ -1324,12 +1388,10 @@ class TurnkeyClient {
                     transactionType,
                 });
                 return txHash;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to sign and send transaction`, TurnkeyErrorCodes.SIGN_AND_SEND_TRANSACTION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to sign and send transaction",
+                errorCode: TurnkeyErrorCodes.SIGN_AND_SEND_TRANSACTION_ERROR,
+            });
         };
         /**
          * Fetches the user details for the current session or a specified user.
@@ -1357,18 +1419,16 @@ class TurnkeyClient {
                 throw new TurnkeyError("User ID must be provided to fetch user", TurnkeyErrorCodes.INVALID_REQUEST);
             }
             const organizationId = params?.organizationId || session.organizationId;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const userResponse = await this.httpClient.getUser({ organizationId, userId }, stampWith);
                 if (!userResponse || !userResponse.user) {
                     throw new TurnkeyError("No user found in the response", TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return userResponse.user;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to fetch user`, TurnkeyErrorCodes.FETCH_USER_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to fetch user",
+                errorCode: TurnkeyErrorCodes.FETCH_USER_ERROR,
+            });
         };
         /**
          * Updates the user's email address.
@@ -1393,7 +1453,7 @@ class TurnkeyClient {
                 throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
             const userId = params?.userId || session.userId;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const existingUser = await this.httpClient.proxyGetAccount({
                     filterType: FilterType.Email,
                     filterValue: email,
@@ -1410,12 +1470,10 @@ class TurnkeyClient {
                     throw new TurnkeyError("No user ID found in the update user email response", TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.userId;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to update user email`, TurnkeyErrorCodes.UPDATE_USER_EMAIL_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to update user email",
+                errorCode: TurnkeyErrorCodes.UPDATE_USER_EMAIL_ERROR,
+            });
         };
         /**
          * Removes the user's email address.
@@ -1436,15 +1494,20 @@ class TurnkeyClient {
             if (!session) {
                 throw new TurnkeyError("No active session found. Please log in first.", 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 TurnkeyError("No user ID found in the remove user email response", TurnkeyErrorCodes.BAD_RESPONSE);
-            }
-            return res.userId;
+            return withTurnkeyErrorHandling(async () => {
+                const userId = params?.userId || session.userId;
+                const res = await this.httpClient.updateUserEmail({
+                    userId: userId,
+                    userEmail: "",
+                }, stampWith);
+                if (!res || !res.userId) {
+                    throw new TurnkeyError("No user ID found in the remove user email response", TurnkeyErrorCodes.BAD_RESPONSE);
+                }
+                return res.userId;
+            }, {
+                errorMessage: "Failed to remove user email",
+                errorCode: TurnkeyErrorCodes.UPDATE_USER_EMAIL_ERROR,
+            });
         };
         /**
          * Updates the user's phone number.
@@ -1469,7 +1532,7 @@ class TurnkeyClient {
                 throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
             const userId = params?.userId || session.userId;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.updateUserPhoneNumber({
                     userId,
                     userPhoneNumber: phoneNumber,
@@ -1479,12 +1542,10 @@ class TurnkeyClient {
                     throw new TurnkeyError("Failed to update user phone number", TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR);
                 }
                 return res.userId;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to update user phone number`, TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to update user phone number",
+                errorCode: TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR,
+            });
         };
         /**
          * Removes the user's phone number.
@@ -1506,14 +1567,19 @@ class TurnkeyClient {
                 throw new TurnkeyError("No active session found. Please log in first.", 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 TurnkeyError("Failed to remove user phone number", TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR);
-            }
-            return res.userId;
+            return withTurnkeyErrorHandling(async () => {
+                const res = await this.httpClient.updateUserPhoneNumber({
+                    userId,
+                    userPhoneNumber: "",
+                }, stampWith);
+                if (!res || !res.userId) {
+                    throw new TurnkeyError("Failed to remove user phone number", TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR);
+                }
+                return res.userId;
+            }, {
+                errorMessage: "Failed to remove user phone number",
+                errorCode: TurnkeyErrorCodes.UPDATE_USER_PHONE_NUMBER_ERROR,
+            });
         };
         /**
          * Updates the user's name.
@@ -1537,7 +1603,7 @@ class TurnkeyClient {
                 throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
             const userId = params?.userId || session.userId;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.updateUserName({
                     userId,
                     userName,
@@ -1546,12 +1612,10 @@ class TurnkeyClient {
                     throw new TurnkeyError("No user ID found in the update user name response", TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.userId;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to update user name`, TurnkeyErrorCodes.UPDATE_USER_NAME_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to update user name",
+                errorCode: TurnkeyErrorCodes.UPDATE_USER_NAME_ERROR,
+            });
         };
         /**
          * Adds an OAuth provider to the user.
@@ -1576,7 +1640,7 @@ class TurnkeyClient {
             if (!session) {
                 throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const accountRes = await this.httpClient.proxyGetAccount({
                     filterType: "OIDC_TOKEN",
                     filterValue: oidcToken,
@@ -1620,12 +1684,10 @@ class TurnkeyClient {
                     throw new TurnkeyError("Failed to create OAuth provider", TurnkeyErrorCodes.ADD_OAUTH_PROVIDER_ERROR);
                 }
                 return createProviderRes?.providerIds || [];
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to fetch account for OAuth provider`, TurnkeyErrorCodes.ACCOUNT_FETCH_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to add OAuth provider",
+                errorCode: TurnkeyErrorCodes.ADD_OAUTH_PROVIDER_ERROR,
+            });
         };
         /**
          * Removes a list of OAuth providers from the user.
@@ -1649,14 +1711,19 @@ class TurnkeyClient {
                 throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
             const userId = params?.userId || session.userId;
-            const res = await this.httpClient.deleteOauthProviders({
-                userId,
-                providerIds,
-            }, stampWith);
-            if (!res) {
-                throw new TurnkeyError("Failed to remove OAuth provider", TurnkeyErrorCodes.REMOVE_OAUTH_PROVIDER_ERROR);
-            }
-            return res.providerIds;
+            return withTurnkeyErrorHandling(async () => {
+                const res = await this.httpClient.deleteOauthProviders({
+                    userId,
+                    providerIds,
+                }, stampWith);
+                if (!res) {
+                    throw new TurnkeyError("Failed to remove OAuth provider", TurnkeyErrorCodes.REMOVE_OAUTH_PROVIDER_ERROR);
+                }
+                return res.providerIds;
+            }, {
+                errorMessage: "Failed to remove OAuth provider",
+                errorCode: TurnkeyErrorCodes.REMOVE_OAUTH_PROVIDER_ERROR,
+            });
         };
         /**
          * Adds a new passkey authenticator for the user.
@@ -1678,7 +1745,7 @@ class TurnkeyClient {
             const { stampWith } = params || {};
             const name = params?.name || `Turnkey Passkey-${Date.now()}`;
             const displayName = params?.displayName || name;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const session = await this.storageManager.getActiveSession();
                 if (!session) {
                     throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
@@ -1703,12 +1770,10 @@ class TurnkeyClient {
                     ],
                 }, stampWith);
                 return res?.authenticatorIds || [];
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to add passkey`, TurnkeyErrorCodes.ADD_PASSKEY_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to add passkey",
+                errorCode: TurnkeyErrorCodes.ADD_PASSKEY_ERROR,
+            });
         };
         /**
          * Removes passkeys (authenticator) from the user.
@@ -1732,14 +1797,19 @@ class TurnkeyClient {
                 throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
             const userId = params?.userId || session.userId;
-            const res = await this.httpClient.deleteAuthenticators({
-                userId,
-                authenticatorIds,
-            }, stampWith);
-            if (!res) {
-                throw new TurnkeyError("Failed to remove passkey", TurnkeyErrorCodes.REMOVE_PASSKEY_ERROR);
-            }
-            return res.authenticatorIds;
+            return withTurnkeyErrorHandling(async () => {
+                const res = await this.httpClient.deleteAuthenticators({
+                    userId,
+                    authenticatorIds,
+                }, stampWith);
+                if (!res) {
+                    throw new TurnkeyError("No response found in the remove passkey response", TurnkeyErrorCodes.REMOVE_PASSKEY_ERROR);
+                }
+                return res.authenticatorIds;
+            }, {
+                errorMessage: "Failed to remove passkey",
+                errorCode: TurnkeyErrorCodes.REMOVE_PASSKEY_ERROR,
+            });
         };
         /**
          * Creates a new wallet for sub-organization.
@@ -1778,7 +1848,7 @@ class TurnkeyClient {
                     ...DEFAULT_SOLANA_ACCOUNTS,
                 ];
             }
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.createWallet({
                     organizationId: organizationId || session.organizationId,
                     walletName,
@@ -1789,12 +1859,10 @@ class TurnkeyClient {
                     throw new TurnkeyError("No wallet found in the create wallet response", TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.walletId;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to create wallet`, TurnkeyErrorCodes.CREATE_WALLET_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to create wallet",
+                errorCode: TurnkeyErrorCodes.CREATE_WALLET_ERROR,
+            });
         };
         /**
          * Creates new accounts in the specified wallet.
@@ -1819,7 +1887,7 @@ class TurnkeyClient {
             if (!session) {
                 throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 let walletAccounts = [];
                 if (accounts && !isWalletAccountArray(accounts)) {
                     // Query existing wallet accounts to avoid duplicates
@@ -1845,12 +1913,10 @@ class TurnkeyClient {
                     throw new TurnkeyError("No account found in the create wallet account response", TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.addresses;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to create wallet account`, TurnkeyErrorCodes.CREATE_WALLET_ACCOUNT_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to create wallet account",
+                errorCode: TurnkeyErrorCodes.CREATE_WALLET_ACCOUNT_ERROR,
+            });
         };
         /**
          * Exports a wallet as an encrypted bundle.
@@ -1875,7 +1941,7 @@ class TurnkeyClient {
             if (!session) {
                 throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.exportWallet({
                     walletId,
                     targetPublicKey,
@@ -1885,12 +1951,85 @@ class TurnkeyClient {
                     throw new TurnkeyError("No export bundle found in the response", TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.exportBundle;
+            }, {
+                errorMessage: "Failed to export wallet",
+                errorCode: 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 TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to export wallet`, TurnkeyErrorCodes.EXPORT_WALLET_ERROR, error);
+            return withTurnkeyErrorHandling(async () => {
+                const res = await this.httpClient.exportPrivateKey({
+                    privateKeyId,
+                    targetPublicKey,
+                    organizationId: organizationId || session.organizationId,
+                }, stampWith);
+                if (!res.exportBundle) {
+                    throw new TurnkeyError("No export bundle found in the response", TurnkeyErrorCodes.BAD_RESPONSE);
+                }
+                return res.exportBundle;
+            }, {
+                errorMessage: "Failed to export private key",
+                errorCode: 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 TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
+            return withTurnkeyErrorHandling(async () => {
+                const res = await this.httpClient.exportWalletAccount({
+                    address,
+                    targetPublicKey,
+                    organizationId: organizationId || session.organizationId,
+                }, stampWith);
+                if (!res.exportBundle) {
+                    throw new TurnkeyError("No export bundle found in the response", TurnkeyErrorCodes.BAD_RESPONSE);
+                }
+                return res.exportBundle;
+            }, {
+                errorMessage: "Failed to export wallet account",
+                errorCode: TurnkeyErrorCodes.EXPORT_WALLET_ACCOUNT_ERROR,
+            });
         };
         /**
          * Imports a wallet from an encrypted bundle.
@@ -1898,7 +2037,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).
          *
@@ -1916,7 +2055,7 @@ class TurnkeyClient {
             if (!session) {
                 throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.importWallet({
                     organizationId: session.organizationId,
                     userId: userId || session.userId,
@@ -1931,12 +2070,66 @@ class TurnkeyClient {
                     throw new TurnkeyError("No wallet ID found in the import response", TurnkeyErrorCodes.BAD_RESPONSE);
                 }
                 return res.walletId;
+            }, {
+                errorMessage: "Failed to import wallet",
+                errorCode: TurnkeyErrorCodes.IMPORT_WALLET_ERROR,
+                customMessageByMessages: {
+                    "invalid mnemonic": {
+                        message: "Invalid mnemonic input",
+                        code: 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 TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to import wallet`, TurnkeyErrorCodes.IMPORT_WALLET_ERROR, error);
-            }
+            return 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 TurnkeyError("No wallet ID found in the import response", TurnkeyErrorCodes.BAD_RESPONSE);
+                }
+                return res.privateKeyId;
+            }, {
+                errorMessage: "Failed to import wallet",
+                errorCode: TurnkeyErrorCodes.IMPORT_WALLET_ERROR,
+                customMessageByMessages: {
+                    "invalid mnemonic": {
+                        message: "Invalid mnemonic input",
+                        code: TurnkeyErrorCodes.BAD_REQUEST,
+                    },
+                },
+            });
         };
         /**
          * Deletes the current sub-organization (sub-org) for the active session.
@@ -1958,14 +2151,12 @@ class TurnkeyClient {
             if (!session) {
                 throw new TurnkeyError("No active session found. Please log in first.", TurnkeyErrorCodes.NO_SESSION_FOUND);
             }
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 return await this.httpClient.deleteSubOrganization({ deleteWithoutExport }, stampWith);
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to delete sub-organization`, TurnkeyErrorCodes.DELETE_SUB_ORGANIZATION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to delete sub-organization",
+                errorCode: 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.
@@ -1985,21 +2176,14 @@ class TurnkeyClient {
             const { sessionToken, sessionKey = SessionKey.DefaultSessionkey } = params;
             if (!sessionToken)
                 return;
-            try {
-                const sessionToReplace = await this.storageManager.getSession(sessionKey);
+            withTurnkeyErrorHandling(async () => {
                 await this.storageManager.storeSession(sessionToken, sessionKey);
-                if (sessionToReplace) {
-                    await this.apiKeyStamper?.deleteKeyPair(sessionToReplace.publicKey);
-                }
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to store session`, TurnkeyErrorCodes.STORE_SESSION_ERROR, error);
-            }
-            finally {
-                await this.clearUnusedKeyPairs();
-            }
+            }, {
+                errorMessage: "Failed to store session",
+                errorCode: TurnkeyErrorCodes.STORE_SESSION_ERROR,
+            }, {
+                finallyFn: async () => await this.clearUnusedKeyPairs(),
+            });
         };
         /**
          * Clears the session associated with the specified session key, or the active session by default.
@@ -2015,7 +2199,7 @@ class TurnkeyClient {
          */
         this.clearSession = async (params) => {
             const { sessionKey = SessionKey.DefaultSessionkey } = params || {};
-            try {
+            withTurnkeyErrorHandling(async () => {
                 const session = await this.storageManager.getSession(sessionKey);
                 if (session) {
                     await this.apiKeyStamper?.deleteKeyPair(session.publicKey);
@@ -2024,12 +2208,10 @@ class TurnkeyClient {
                 else {
                     throw new TurnkeyError(`No session found with key: ${sessionKey}`, TurnkeyErrorCodes.NOT_FOUND);
                 }
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to delete session`, TurnkeyErrorCodes.CLEAR_SESSION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to delete session",
+                errorCode: TurnkeyErrorCodes.CLEAR_SESSION_ERROR,
+            });
         };
         /**
          * Clears all sessions and resets the active session state.
@@ -2043,7 +2225,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If no sessions exist or if there is an error clearing all sessions.
          */
         this.clearAllSessions = async () => {
-            try {
+            withTurnkeyErrorHandling(async () => {
                 const sessionKeys = await this.storageManager.listSessionKeys();
                 if (sessionKeys.length === 0) {
                     throw new TurnkeyError("No sessions found to clear.", TurnkeyErrorCodes.NO_SESSION_FOUND);
@@ -2051,12 +2233,10 @@ class TurnkeyClient {
                 for (const sessionKey of sessionKeys) {
                     this.clearSession({ sessionKey });
                 }
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to clear all sessions`, TurnkeyErrorCodes.CLEAR_ALL_SESSIONS_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to clear all sessions",
+                errorCode: TurnkeyErrorCodes.CLEAR_ALL_SESSIONS_ERROR,
+            });
         };
         /**
          * Refreshes the session associated with the specified session key, or the active session by default.
@@ -2091,7 +2271,7 @@ class TurnkeyClient {
                 throw new TurnkeyError("HTTP client is not initialized. Please initialize the client before refreshing the session.", TurnkeyErrorCodes.CLIENT_NOT_INITIALIZED);
             }
             let keyPair;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 keyPair = publicKey ?? (await this.apiKeyStamper?.createKeyPair());
                 if (!keyPair) {
                     throw new TurnkeyError("Failed to create new key pair.", TurnkeyErrorCodes.INTERNAL_ERROR);
@@ -2109,12 +2289,10 @@ class TurnkeyClient {
                     ...(sessionKey && { sessionKey }),
                 });
                 return res;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to refresh session`, TurnkeyErrorCodes.REFRESH_SESSION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to refresh session",
+                errorCode: TurnkeyErrorCodes.REFRESH_SESSION_ERROR,
+            });
         };
         /**
          * Retrieves the session associated with the specified session key, or the active session by default.
@@ -2128,15 +2306,13 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error retrieving the session from storage.
          */
         this.getSession = async (params) => {
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const { sessionKey = await this.storageManager.getActiveSessionKey() } = params || {};
                 return this.storageManager.getSession(sessionKey);
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to get session with key`, TurnkeyErrorCodes.GET_SESSION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to get session with key " + params?.sessionKey,
+                errorCode: TurnkeyErrorCodes.GET_SESSION_ERROR,
+            });
         };
         /**
          * Retrieves all sessions stored in persistent storage.
@@ -2150,7 +2326,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error retrieving sessions from storage.
          */
         this.getAllSessions = async () => {
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const sessionKeys = await this.storageManager.listSessionKeys();
                 if (!sessionKeys || sessionKeys.length === 0) {
                     return undefined;
@@ -2162,13 +2338,11 @@ class TurnkeyClient {
                         sessions[sessionKey] = session;
                     }
                 }
-                return sessions;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to get all sessions`, TurnkeyErrorCodes.GET_ALL_SESSIONS_ERROR, error);
-            }
+                return sessions || undefined;
+            }, {
+                errorMessage: "Failed to get all sessions",
+                errorCode: TurnkeyErrorCodes.GET_ALL_SESSIONS_ERROR,
+            });
         };
         /**
          * Sets the active session to the specified session key.
@@ -2184,14 +2358,12 @@ class TurnkeyClient {
          */
         this.setActiveSession = async (params) => {
             const { sessionKey } = params;
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 await this.storageManager.setActiveSessionKey(sessionKey);
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to set active session`, TurnkeyErrorCodes.SET_ACTIVE_SESSION_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to set active session",
+                errorCode: TurnkeyErrorCodes.SET_ACTIVE_SESSION_ERROR,
+            });
         };
         /**
          * Retrieves the active session key currently set in persistent storage.
@@ -2205,14 +2377,12 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error retrieving the active session key from storage.
          */
         this.getActiveSessionKey = async () => {
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 return await this.storageManager.getActiveSessionKey();
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to get active session key`, TurnkeyErrorCodes.GET_ACTIVE_SESSION_KEY_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to get active session key",
+                errorCode: TurnkeyErrorCodes.GET_ACTIVE_SESSION_KEY_ERROR,
+            });
         };
         /**
          * Clears any unused API key pairs from persistent storage.
@@ -2226,7 +2396,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error listing, checking, or deleting unused key pairs.
          */
         this.clearUnusedKeyPairs = async () => {
-            try {
+            withTurnkeyErrorHandling(async () => {
                 const publicKeys = await this.apiKeyStamper?.listKeyPairs();
                 if (!publicKeys || publicKeys.length === 0) {
                     return;
@@ -2249,12 +2419,10 @@ class TurnkeyClient {
                         }
                     }
                 }
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to clear unused key pairs`, TurnkeyErrorCodes.CLEAR_UNUSED_KEY_PAIRS_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to clear unused key pairs",
+                errorCode: TurnkeyErrorCodes.CLEAR_UNUSED_KEY_PAIRS_ERROR,
+            });
         };
         /**
          * Creates a new API key pair and returns the public key.
@@ -2271,23 +2439,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 TurnkeyError("API Key Stamper is not initialized.", TurnkeyErrorCodes.INTERNAL_ERROR);
-            }
-            const externalKeyPair = params?.externalKeyPair;
-            const storeOverride = params?.storeOverride ?? false;
-            try {
+            return withTurnkeyErrorHandling(async () => {
+                const externalKeyPair = params?.externalKeyPair;
+                const storeOverride = params?.storeOverride ?? false;
+                if (!this.apiKeyStamper) {
+                    throw new TurnkeyError("API Key Stamper is not initialized.", 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 TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to create API key pair`, TurnkeyErrorCodes.CREATE_API_KEY_PAIR_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to create API key pair",
+                errorCode: TurnkeyErrorCodes.CREATE_API_KEY_PAIR_ERROR,
+            });
         };
         /**
          * Fetches the WalletKit proxy authentication configuration from the auth proxy.
@@ -2301,18 +2467,16 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error retrieving the proxy authentication configuration from the auth proxy.
          */
         this.getProxyAuthConfig = async () => {
-            try {
+            return withTurnkeyErrorHandling(async () => {
                 const res = await this.httpClient.proxyGetWalletKitConfig({});
                 if (!res) {
                     throw new TurnkeyError(`Failed to fetch auth proxy config`, TurnkeyErrorCodes.GET_PROXY_AUTH_CONFIG_ERROR);
                 }
                 return res;
-            }
-            catch (error) {
-                if (error instanceof TurnkeyError)
-                    throw error;
-                throw new TurnkeyError(`Failed to get auth proxy config`, TurnkeyErrorCodes.GET_PROXY_AUTH_CONFIG_ERROR, error);
-            }
+            }, {
+                errorMessage: "Failed to get auth proxy config",
+                errorCode: TurnkeyErrorCodes.GET_PROXY_AUTH_CONFIG_ERROR,
+            });
         };
         this.config = config;
         // Just store any explicitly provided stampers