@dynamic-labs-wallet/browser 0.0.84 → 0.0.86

package/index.esm.js

@@ -1,4 +1,4 @@
-import { SigningAlgorithm, MPC_RELAY_PROD_API_URL, getMPCChainConfig, BackupLocation, getClientThreshold, MPC_CONFIG, getTSSConfig, WalletOperation, getReshareConfig, DynamicApiClient, getEnvironmentFromUrl, IFRAME_DOMAIN_MAP } from '@dynamic-labs-wallet/core';
+import { SigningAlgorithm, MPC_RELAY_PROD_API_URL, getMPCChainConfig, BackupLocation, getClientThreshold, MPC_CONFIG, AxiosError, handleAxiosError, getTSSConfig, WalletOperation, getReshareConfig, DynamicApiClient, getEnvironmentFromUrl, IFRAME_DOMAIN_MAP } from '@dynamic-labs-wallet/core';
 export * from '@dynamic-labs-wallet/core';
 import { BIP340, ExportableEd25519, Ecdsa, MessageHash, EcdsaKeygenResult, ExportableEd25519KeygenResult, BIP340KeygenResult } from './internal/web';
 export { BIP340, BIP340InitKeygenResult, BIP340KeygenResult, Ecdsa, EcdsaInitKeygenResult, EcdsaKeygenResult, EcdsaPublicKey, EcdsaSignature, Ed25519, Ed25519InitKeygenResult, Ed25519KeygenResult, MessageHash } from './internal/web';
@@ -520,6 +520,7 @@ class DynamicWalletClient {
             onError,
             onCeremonyComplete
         });
+        this.logger.debug(`[DynamicWaasWalletClient] Initialized client key generation with IDs: ${clientKeygenIds.join(', ')} for chain: ${chainName} using scheme: ${thresholdSignatureScheme}`);
         return data;
     }
     async clientInitializeKeyGen({ chainName, thresholdSignatureScheme }) {
@@ -591,12 +592,23 @@ class DynamicWalletClient {
                 thresholdSignatureScheme
             });
             const clientKeygenIds = clientKeygenInitResults.map((result)=>result.keygenId);
+            this.logger.debug('[DynamicWaasWalletClient] Initialized client key generation', {
+                clientKeygenIds: clientKeygenIds.join(', '),
+                chainName,
+                thresholdSignatureScheme
+            });
             const { roomId, serverKeygenIds } = await this.serverInitializeKeyGen({
                 chainName,
                 clientKeygenIds,
                 thresholdSignatureScheme,
                 onCeremonyComplete
             });
+            this.logger.debug('[DynamicWaasWalletClient] Server key generation initialized', {
+                roomId,
+                clientKeygenIds: clientKeygenIds.join(', '),
+                serverKeygenIds: serverKeygenIds.join(', '),
+                chainName
+            });
             const { rawPublicKey, clientKeygenResults: clientKeyShares } = await this.clientKeyGen({
                 chainName,
                 roomId,
@@ -604,60 +616,99 @@ class DynamicWalletClient {
                 clientKeygenInitResults,
                 thresholdSignatureScheme
             });
+            this.logger.debug('[DynamicWaasWalletClient] Client key generation completed', {
+                roomId,
+                serverKeygenIds: serverKeygenIds.join(', '),
+                clientKeygenIds: clientKeygenIds.join(', '),
+                chainName,
+                thresholdSignatureScheme,
+                rawPublicKey,
+                clientKeySharesCount: clientKeyShares.length
+            });
             return {
                 rawPublicKey,
                 clientKeyShares
             };
         } catch (error) {
-            this.logger.error('Error keygen', error);
+            this.logger.error('[DynamicWaasWalletClient]: Error keygen', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
+            }
             throw error;
         }
     }
     async importRawPrivateKey({ chainName, privateKey, thresholdSignatureScheme, onError, onCeremonyComplete }) {
-        const mpcSigner = getMPCSigner({
-            chainName,
-            baseRelayUrl: this.baseMPCRelayApiUrl
-        });
-        const clientKeygenInitResults = await this.clientInitializeKeyGen({
-            chainName,
-            thresholdSignatureScheme
-        });
-        const clientKeygenIds = clientKeygenInitResults.map((result)=>result.keygenId);
-        const { roomId, serverKeygenIds } = await this.apiClient.importPrivateKey({
-            chainName,
-            clientKeygenIds,
-            thresholdSignatureScheme,
-            onError,
-            onCeremonyComplete
-        });
-        const { threshold } = getTSSConfig(thresholdSignatureScheme);
-        const clientKeygenResults = await Promise.all(clientKeygenInitResults.map(async (currentInit, index)=>{
-            const otherClientKeygenIds = clientKeygenInitResults.filter((init)=>init.keygenId !== currentInit.keygenId).map((init)=>init.keygenId);
-            if (index === 0) {
-                const otherKeyGenIds = [
-                    ...serverKeygenIds,
-                    ...otherClientKeygenIds
-                ];
-                const importerKeygenResult = await mpcSigner.importPrivateKeyImporter(roomId, threshold, privateKey, currentInit, otherKeyGenIds);
-                return importerKeygenResult;
-            } else {
-                const recipientKeygenResult = await mpcSigner.importPrivateKeyRecipient(roomId, threshold, currentInit, [
-                    ...serverKeygenIds,
-                    ...otherClientKeygenIds
-                ]);
-                return recipientKeygenResult;
+        try {
+            const mpcSigner = getMPCSigner({
+                chainName,
+                baseRelayUrl: this.baseMPCRelayApiUrl
+            });
+            const clientKeygenInitResults = await this.clientInitializeKeyGen({
+                chainName,
+                thresholdSignatureScheme
+            });
+            const clientKeygenIds = clientKeygenInitResults.map((result)=>result.keygenId);
+            this.logger.debug('[DynamicWaasWalletClient] Client key generation initialized', {
+                clientKeygenIds: clientKeygenIds.join(', '),
+                chainName,
+                thresholdSignatureScheme
+            });
+            const { roomId, serverKeygenIds } = await this.apiClient.importPrivateKey({
+                chainName,
+                clientKeygenIds,
+                thresholdSignatureScheme,
+                onError,
+                onCeremonyComplete
+            });
+            this.logger.debug('[DynamicWaasWalletClient] Server key generation initialized', {
+                roomId,
+                clientKeygenIds: clientKeygenIds.join(', '),
+                serverKeygenIds: serverKeygenIds.join(', '),
+                chainName
+            });
+            const { threshold } = getTSSConfig(thresholdSignatureScheme);
+            const clientKeygenResults = await Promise.all(clientKeygenInitResults.map(async (currentInit, index)=>{
+                const otherClientKeygenIds = clientKeygenInitResults.filter((init)=>init.keygenId !== currentInit.keygenId).map((init)=>init.keygenId);
+                if (index === 0) {
+                    const otherKeyGenIds = [
+                        ...serverKeygenIds,
+                        ...otherClientKeygenIds
+                    ];
+                    const importerKeygenResult = await mpcSigner.importPrivateKeyImporter(roomId, threshold, privateKey, currentInit, otherKeyGenIds);
+                    return importerKeygenResult;
+                } else {
+                    const recipientKeygenResult = await mpcSigner.importPrivateKeyRecipient(roomId, threshold, currentInit, [
+                        ...serverKeygenIds,
+                        ...otherClientKeygenIds
+                    ]);
+                    return recipientKeygenResult;
+                }
+            }));
+            const [clientKeygenResult] = clientKeygenResults;
+            const rawPublicKey = await this.derivePublicKey({
+                chainName,
+                keyShare: clientKeygenResult,
+                derivationPath: undefined
+            });
+            this.logger.debug('[DynamicWaasWalletClient] Completed import of raw private key', {
+                rawPublicKey,
+                chainName,
+                thresholdSignatureScheme,
+                roomId,
+                serverKeygenIds: serverKeygenIds.join(', '),
+                clientKeygenIds: clientKeygenIds.join(', ')
+            });
+            return {
+                rawPublicKey,
+                clientKeyShares: clientKeygenResults
+            };
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in importRawPrivateKey', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
             }
-        }));
-        const [clientKeygenResult] = clientKeygenResults;
-        const rawPublicKey = await this.derivePublicKey({
-            chainName,
-            keyShare: clientKeygenResult,
-            derivationPath: undefined
-        });
-        return {
-            rawPublicKey,
-            clientKeyShares: clientKeygenResults
-        };
+            throw error;
+        }
     }
     async serverSign({ walletId, message, isFormatted }) {
         // Create the room and sign the message
@@ -678,87 +729,123 @@ class DynamicWalletClient {
                 baseRelayUrl: this.baseMPCRelayApiUrl
             });
             const formattedMessage = isFormatted ? new MessageHash(message) : formatMessage(chainName, message);
+            this.logger.debug('[DynamicWaasWalletClient] Starting client sign', {
+                chainName,
+                message,
+                roomId,
+                derivationPath,
+                isFormatted
+            });
             const signature = await mpcSigner.sign(roomId, keyShare, formattedMessage, derivationPath);
             return signature;
         } catch (error) {
-            this.logger.error('Error in clientSign:', error);
+            this.logger.error('[DynamicWaasWalletClient]: Error in clientSign', error);
             throw error;
         }
     }
     //todo: need to modify with imported flag
     async sign({ accountAddress, message, chainName, password = undefined, isFormatted = false, signedSessionId }) {
-        await this.verifyPassword({
-            accountAddress,
-            password,
-            walletOperation: WalletOperation.SIGN_MESSAGE,
-            signedSessionId
-        });
-        const wallet = await this.getWallet({
-            accountAddress,
-            password,
-            walletOperation: WalletOperation.SIGN_MESSAGE,
-            signedSessionId
-        });
-        // Perform the server sign
-        const data = await this.serverSign({
-            walletId: wallet.walletId,
-            message,
-            isFormatted
-        });
-        const derivationPath = wallet.derivationPath && wallet.derivationPath != '' ? new Uint32Array(Object.values(JSON.parse(wallet.derivationPath))) : undefined;
-        // Perform the client sign and return the signature
-        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
-            accountAddress
-        });
-        const signature = await this.clientSign({
-            chainName,
-            message,
-            roomId: data.roomId,
-            keyShare: clientKeyShares[0],
-            derivationPath,
-            isFormatted
-        });
-        return signature;
+        try {
+            await this.verifyPassword({
+                accountAddress,
+                password,
+                walletOperation: WalletOperation.SIGN_MESSAGE,
+                signedSessionId
+            });
+            const wallet = await this.getWallet({
+                accountAddress,
+                password,
+                walletOperation: WalletOperation.SIGN_MESSAGE,
+                signedSessionId
+            });
+            // Perform the server sign
+            const data = await this.serverSign({
+                walletId: wallet.walletId,
+                message,
+                isFormatted
+            });
+            this.logger.debug('[DynamicWaasWalletClient] Server sign completed', {
+                message,
+                accountAddress,
+                walletId: wallet.walletId,
+                roomId: data.roomId
+            });
+            const derivationPath = wallet.derivationPath && wallet.derivationPath != '' ? new Uint32Array(Object.values(JSON.parse(wallet.derivationPath))) : undefined;
+            // Perform the client sign and return the signature
+            const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+                accountAddress
+            });
+            const signature = await this.clientSign({
+                chainName,
+                message,
+                roomId: data.roomId,
+                keyShare: clientKeyShares[0],
+                derivationPath,
+                isFormatted
+            });
+            this.logger.debug('[DynamicWaasWalletClient] Client sign completed', {
+                chainName,
+                message,
+                roomId: data.roomId,
+                derivationPath,
+                isFormatted
+            });
+            return signature;
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in sign', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
+            }
+            throw error;
+        }
     }
     async refreshWalletAccountShares({ accountAddress, chainName, password = undefined, signedSessionId }) {
-        await this.verifyPassword({
-            accountAddress,
-            password,
-            walletOperation: WalletOperation.REFRESH,
-            signedSessionId
-        });
-        const wallet = await this.getWallet({
-            accountAddress,
-            walletOperation: WalletOperation.NO_OPERATION,
-            password,
-            signedSessionId
-        });
-        const mpcSigner = getMPCSigner({
-            chainName,
-            baseRelayUrl: this.baseMPCRelayApiUrl
-        });
-        // Create the room and refresh the shares
-        const data = await this.apiClient.refreshWalletAccountShares({
-            walletId: wallet.walletId
-        });
-        const roomId = data.roomId;
-        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
-            accountAddress
-        });
-        const refreshResults = await Promise.all(clientKeyShares.map((clientKeyShare)=>mpcSigner.refresh(roomId, clientKeyShare)));
-        this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
-            clientKeySharesBackupInfo: getClientKeyShareBackupInfo()
-        });
-        await this.setClientKeySharesToLocalStorage({
-            accountAddress,
-            clientKeyShares: refreshResults,
-            overwriteOrMerge: 'overwrite'
-        });
-        await this.storeEncryptedBackupByWallet({
-            accountAddress,
-            password: password != null ? password : this.environmentId,
-            signedSessionId
-        });
+        try {
+            await this.verifyPassword({
+                accountAddress,
+                password,
+                walletOperation: WalletOperation.REFRESH,
+                signedSessionId
+            });
+            const wallet = await this.getWallet({
+                accountAddress,
+                walletOperation: WalletOperation.NO_OPERATION,
+                password,
+                signedSessionId
+            });
+            const mpcSigner = getMPCSigner({
+                chainName,
+                baseRelayUrl: this.baseMPCRelayApiUrl
+            });
+            // Create the room and refresh the shares
+            const data = await this.apiClient.refreshWalletAccountShares({
+                walletId: wallet.walletId
+            });
+            const roomId = data.roomId;
+            const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+                accountAddress
+            });
+            const refreshResults = await Promise.all(clientKeyShares.map((clientKeyShare)=>mpcSigner.refresh(roomId, clientKeyShare)));
+            this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
+                clientKeySharesBackupInfo: getClientKeyShareBackupInfo()
+            });
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares: refreshResults,
+                overwriteOrMerge: 'overwrite'
+            });
+            await this.storeEncryptedBackupByWallet({
+                accountAddress,
+                password: password != null ? password : this.environmentId,
+                signedSessionId
+            });
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in refreshWalletAccountShares', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
+            }
+            throw error;
+        }
     }
     async getExportId({ chainName, clientKeyShare }) {
         const mpcSigner = getMPCSigner({
@@ -812,107 +899,137 @@ class DynamicWalletClient {
         };
     }
     async reshare({ chainName, accountAddress, oldThresholdSignatureScheme, newThresholdSignatureScheme, password = undefined, signedSessionId }) {
-        await this.verifyPassword({
-            accountAddress,
-            password,
-            walletOperation: WalletOperation.RESHARE,
-            signedSessionId
-        });
-        const { existingClientShareCount } = getReshareConfig({
-            oldThresholdSignatureScheme,
-            newThresholdSignatureScheme
-        });
-        const wallet = await this.getWallet({
-            accountAddress,
-            walletOperation: WalletOperation.NO_OPERATION,
-            shareCount: existingClientShareCount,
-            password,
-            signedSessionId
-        });
-        const { newClientInitKeygenResults, newClientKeygenIds, existingClientKeygenIds, existingClientKeyShares } = await this.reshareStrategy({
-            chainName,
-            accountAddress,
-            wallet,
-            oldThresholdSignatureScheme,
-            newThresholdSignatureScheme
-        });
-        const clientKeygenIds = [
-            ...newClientKeygenIds,
-            ...existingClientKeygenIds
-        ];
-        // Server to create the room and complete the server reshare logics
-        const data = await this.apiClient.reshare({
-            walletId: wallet.walletId,
-            clientKeygenIds: clientKeygenIds,
-            oldThresholdSignatureScheme,
-            newThresholdSignatureScheme
-        });
-        const { roomId, serverKeygenIds, newServerKeygenIds = [] } = data;
-        // Get the MPC config for the threshold signature scheme
-        const oldMpcConfig = MPC_CONFIG[oldThresholdSignatureScheme];
-        const newMpcConfig = MPC_CONFIG[newThresholdSignatureScheme];
-        const allPartyKeygenIds = [
-            ...clientKeygenIds,
-            ...serverKeygenIds,
-            ...newServerKeygenIds
-        ];
-        const mpcSigner = getMPCSigner({
-            chainName,
-            baseRelayUrl: this.baseMPCRelayApiUrl
-        });
-        const reshareResults = await Promise.all([
-            ...newClientInitKeygenResults.map((keygenResult)=>mpcSigner.reshareNewParty(roomId, oldMpcConfig.threshold, newMpcConfig.threshold, keygenResult, allPartyKeygenIds)),
-            ...existingClientKeyShares.map((keyShare)=>mpcSigner.reshareRemainingParty(roomId, newMpcConfig.threshold, keyShare, allPartyKeygenIds))
-        ]);
-        await this.setClientKeySharesToLocalStorage({
-            accountAddress,
-            clientKeyShares: reshareResults,
-            overwriteOrMerge: 'overwrite'
-        });
-        await this.storeEncryptedBackupByWallet({
-            accountAddress,
-            password,
-            signedSessionId
-        });
+        try {
+            await this.verifyPassword({
+                accountAddress,
+                password,
+                walletOperation: WalletOperation.RESHARE,
+                signedSessionId
+            });
+            const { existingClientShareCount } = getReshareConfig({
+                oldThresholdSignatureScheme,
+                newThresholdSignatureScheme
+            });
+            const wallet = await this.getWallet({
+                accountAddress,
+                walletOperation: WalletOperation.NO_OPERATION,
+                shareCount: existingClientShareCount,
+                password,
+                signedSessionId
+            });
+            const { newClientInitKeygenResults, newClientKeygenIds, existingClientKeygenIds, existingClientKeyShares } = await this.reshareStrategy({
+                chainName,
+                accountAddress,
+                wallet,
+                oldThresholdSignatureScheme,
+                newThresholdSignatureScheme
+            });
+            const clientKeygenIds = [
+                ...newClientKeygenIds,
+                ...existingClientKeygenIds
+            ];
+            // Server to create the room and complete the server reshare logics
+            const data = await this.apiClient.reshare({
+                walletId: wallet.walletId,
+                clientKeygenIds: clientKeygenIds,
+                oldThresholdSignatureScheme,
+                newThresholdSignatureScheme
+            });
+            const { roomId, serverKeygenIds, newServerKeygenIds = [] } = data;
+            // Get the MPC config for the threshold signature scheme
+            const oldMpcConfig = MPC_CONFIG[oldThresholdSignatureScheme];
+            const newMpcConfig = MPC_CONFIG[newThresholdSignatureScheme];
+            const allPartyKeygenIds = [
+                ...clientKeygenIds,
+                ...serverKeygenIds,
+                ...newServerKeygenIds
+            ];
+            const mpcSigner = getMPCSigner({
+                chainName,
+                baseRelayUrl: this.baseMPCRelayApiUrl
+            });
+            const reshareResults = await Promise.all([
+                ...newClientInitKeygenResults.map((keygenResult)=>mpcSigner.reshareNewParty(roomId, oldMpcConfig.threshold, newMpcConfig.threshold, keygenResult, allPartyKeygenIds)),
+                ...existingClientKeyShares.map((keyShare)=>mpcSigner.reshareRemainingParty(roomId, newMpcConfig.threshold, keyShare, allPartyKeygenIds))
+            ]);
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares: reshareResults,
+                overwriteOrMerge: 'overwrite'
+            });
+            await this.storeEncryptedBackupByWallet({
+                accountAddress,
+                password,
+                signedSessionId
+            });
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in reshare', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
+            }
+            throw error;
+        }
     }
     async exportKey({ accountAddress, chainName, password = undefined, signedSessionId }) {
-        const wallet = await this.getWallet({
-            accountAddress,
-            password,
-            walletOperation: WalletOperation.EXPORT_PRIVATE_KEY,
-            signedSessionId
-        });
-        const mpcSigner = getMPCSigner({
-            chainName,
-            baseRelayUrl: this.baseMPCRelayApiUrl
-        });
-        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
-            accountAddress
-        });
-        const exportId = await this.getExportId({
-            chainName,
-            clientKeyShare: clientKeyShares[0]
-        });
-        const data = await this.apiClient.exportKey({
-            walletId: wallet.walletId,
-            exportId
-        });
-        const keyExportRaw = await mpcSigner.exportFullPrivateKey(data.roomId, clientKeyShares[0], exportId);
-        if (!keyExportRaw) {
-            throw new Error('Error exporting private key');
-        }
-        const derivationPath = wallet.derivationPath && wallet.derivationPath != '' ? new Uint32Array(Object.values(JSON.parse(wallet.derivationPath))) : undefined;
-        let derivedPrivateKey;
-        if (mpcSigner instanceof Ecdsa) {
-            derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
-        } else if (mpcSigner instanceof ExportableEd25519) {
-            derivedPrivateKey = keyExportRaw;
-        } else if (mpcSigner instanceof BIP340) {
-            derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
+        try {
+            const wallet = await this.getWallet({
+                accountAddress,
+                password,
+                walletOperation: WalletOperation.EXPORT_PRIVATE_KEY,
+                signedSessionId
+            });
+            const mpcSigner = getMPCSigner({
+                chainName,
+                baseRelayUrl: this.baseMPCRelayApiUrl
+            });
+            const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+                accountAddress
+            });
+            const exportId = await this.getExportId({
+                chainName,
+                clientKeyShare: clientKeyShares[0]
+            });
+            const data = await this.apiClient.exportKey({
+                walletId: wallet.walletId,
+                exportId
+            });
+            this.logger.debug('[DynamicWaasWalletClient] Starting export of private key', {
+                accountAddress,
+                chainName,
+                walletId: wallet.walletId,
+                exportId,
+                roomId: data.roomId
+            });
+            const keyExportRaw = await mpcSigner.exportFullPrivateKey(data.roomId, clientKeyShares[0], exportId);
+            if (!keyExportRaw) {
+                throw new Error('Error exporting private key');
+            }
+            this.logger.debug('[DynamicWaasWalletClient] Completed export of private key', {
+                accountAddress,
+                chainName,
+                walletId: wallet.walletId,
+                exportId,
+                roomId: data.roomId
+            });
+            const derivationPath = wallet.derivationPath && wallet.derivationPath != '' ? new Uint32Array(Object.values(JSON.parse(wallet.derivationPath))) : undefined;
+            let derivedPrivateKey;
+            if (mpcSigner instanceof Ecdsa) {
+                derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
+            } else if (mpcSigner instanceof ExportableEd25519) {
+                derivedPrivateKey = keyExportRaw;
+            } else if (mpcSigner instanceof BIP340) {
+                derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
+            }
+            return {
+                derivedPrivateKey
+            };
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in exportKey', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
+            }
+            throw error;
         }
-        return {
-            derivedPrivateKey
-        };
     }
     async offlineExportKey({ chainName, keyShares, derivationPath }) {
         try {
@@ -950,7 +1067,7 @@ class DynamicWalletClient {
                 rawPublicKey
             };
         } catch (error) {
-            this.logger.error('Error in offlineExportKey:', error);
+            this.logger.error('[DynamicWaasWalletClient]: Error in offlineExportKey', error);
             throw error;
         }
     }
@@ -1015,47 +1132,55 @@ class DynamicWalletClient {
    * @param {string} params.accountAddress - The account address of the wallet to backup
    * @param {string} [params.password] - Optional password for encrypting the key shares
    */ async storeEncryptedBackupByWallet({ accountAddress, clientKeyShares = undefined, password = undefined, signedSessionId }) {
-        const keySharesToBackup = clientKeyShares != null ? clientKeyShares : await this.getClientKeySharesFromLocalStorage({
-            accountAddress
-        });
-        const encryptedKeyShares = await Promise.all(keySharesToBackup.map((keyShare)=>this.encryptKeyShare({
-                keyShare,
-                password
-            })));
-        if (!this.walletMap[accountAddress].walletId) {
-            throw new Error(`WalletId not found for accountAddress: ${accountAddress}`);
-        }
-        // TODO(zfaizal2): throw error if signedSessionId is not provided after service deploy
-        const data = await this.apiClient.storeEncryptedBackupByWallet({
-            walletId: this.walletMap[accountAddress].walletId,
-            encryptedKeyShares,
-            passwordEncrypted: Boolean(password) && password !== this.environmentId,
-            signedSessionId
-        });
-        const hasGoogleDriveBackup = this.walletMap[accountAddress].clientKeySharesBackupInfo.backups[BackupLocation.GOOGLE_DRIVE].length > 0;
-        if (hasGoogleDriveBackup) {
-            const googleDriveKeyShareIds = await this.backupKeySharesToGoogleDrive({
-                accountAddress,
-                password,
+        try {
+            const keySharesToBackup = clientKeyShares != null ? clientKeyShares : await this.getClientKeySharesFromLocalStorage({
+                accountAddress
+            });
+            const encryptedKeyShares = await Promise.all(keySharesToBackup.map((keyShare)=>this.encryptKeyShare({
+                    keyShare,
+                    password
+                })));
+            if (!this.walletMap[accountAddress].walletId) {
+                throw new Error(`WalletId not found for accountAddress: ${accountAddress}`);
+            }
+            // TODO(zfaizal2): throw error if signedSessionId is not provided after service deploy
+            const data = await this.apiClient.storeEncryptedBackupByWallet({
+                walletId: this.walletMap[accountAddress].walletId,
+                encryptedKeyShares,
+                passwordEncrypted: Boolean(password) && password !== this.environmentId,
                 signedSessionId
             });
-            data.keyShares.push({
-                backupLocation: BackupLocation.GOOGLE_DRIVE,
-                id: googleDriveKeyShareIds
+            const hasGoogleDriveBackup = this.walletMap[accountAddress].clientKeySharesBackupInfo.backups[BackupLocation.GOOGLE_DRIVE].length > 0;
+            if (hasGoogleDriveBackup) {
+                const googleDriveKeyShareIds = await this.backupKeySharesToGoogleDrive({
+                    accountAddress,
+                    password,
+                    signedSessionId
+                });
+                data.keyShares.push({
+                    backupLocation: BackupLocation.GOOGLE_DRIVE,
+                    id: googleDriveKeyShareIds
+                });
+            }
+            const updatedBackupInfo = getClientKeyShareBackupInfo({
+                walletProperties: {
+                    derivationPath: this.walletMap[accountAddress].derivationPath,
+                    keyShares: data.keyShares,
+                    thresholdSignatureScheme: this.walletMap[accountAddress].thresholdSignatureScheme
+                }
             });
-        }
-        const updatedBackupInfo = getClientKeyShareBackupInfo({
-            walletProperties: {
-                derivationPath: this.walletMap[accountAddress].derivationPath,
-                keyShares: data.keyShares,
-                thresholdSignatureScheme: this.walletMap[accountAddress].thresholdSignatureScheme
+            this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
+                clientKeySharesBackupInfo: updatedBackupInfo
+            });
+            await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
+            return data;
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in storeEncryptedBackupByWallet', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
             }
-        });
-        this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
-            clientKeySharesBackupInfo: updatedBackupInfo
-        });
-        await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
-        return data;
+            throw error;
+        }
     }
     async storeEncryptedBackupByWalletWithRetry({ accountAddress, clientKeyShares, password, signedSessionId }) {
         await retryPromise(()=>this.storeEncryptedBackupByWallet({
@@ -1102,16 +1227,24 @@ class DynamicWalletClient {
    * @returns The Google OAuth Account ID
    * @throws Error if no Google OAuth account ID is found
    */ async getGoogleOauthAccountIdOrThrow(accountAddress) {
-        const user = await this.apiClient.getUser();
-        const oauthAccountId = getGoogleOAuthAccountId(user == null ? void 0 : user.verifiedCredentials);
-        if (!oauthAccountId) {
-            this.logger.error('No Google OAuth account ID found', {
-                user,
-                accountAddress
-            });
-            throw new Error('No Google OAuth account ID found');
+        try {
+            const user = await this.apiClient.getUser();
+            const oauthAccountId = getGoogleOAuthAccountId(user == null ? void 0 : user.verifiedCredentials);
+            if (!oauthAccountId) {
+                this.logger.error('No Google OAuth account ID found', {
+                    user,
+                    accountAddress
+                });
+                throw new Error('No Google OAuth account ID found');
+            }
+            return oauthAccountId;
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in getGoogleOauthAccountIdOrThrow', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
+            }
+            throw error;
         }
-        return oauthAccountId;
     }
     /**
    * Helper function to determine keyshare recovery strategy for dynamic shares.
@@ -1141,34 +1274,39 @@ class DynamicWalletClient {
         };
     }
     async recoverEncryptedBackupByWallet({ accountAddress, password, walletOperation, signedSessionId, shareCount = undefined, storeRecoveredShares = true }) {
-        const wallet = this.walletMap[accountAddress];
-        this.logger.debug(`recoverEncryptedBackupByWallet wallet: ${walletOperation}`, wallet);
-        const { shares } = this.recoverStrategy({
-            clientKeyShareBackupInfo: wallet.clientKeySharesBackupInfo,
-            thresholdSignatureScheme: wallet.thresholdSignatureScheme,
-            walletOperation,
-            shareCount
-        });
-        const { dynamic: dynamicKeyShareIds } = shares;
-        const data = await this.apiClient.recoverEncryptedBackupByWallet({
-            walletId: wallet.walletId,
-            keyShareIds: dynamicKeyShareIds,
-            signedSessionId
-        });
-        const dynamicKeyShares = data.keyShares.filter((keyShare)=>keyShare.encryptedAccountCredential !== null && keyShare.backupLocation === BackupLocation.DYNAMIC);
-        const decryptedKeyShares = await Promise.all(dynamicKeyShares.map((keyShare)=>this.decryptKeyShare({
-                keyShare: keyShare.encryptedAccountCredential,
-                password: password != null ? password : this.environmentId
-            })));
-        if (storeRecoveredShares) {
-            await this.setClientKeySharesToLocalStorage({
-                accountAddress,
-                clientKeyShares: decryptedKeyShares,
-                overwriteOrMerge: 'merge'
+        try {
+            const wallet = this.walletMap[accountAddress];
+            this.logger.debug(`recoverEncryptedBackupByWallet wallet: ${walletOperation}`, wallet);
+            const { shares } = this.recoverStrategy({
+                clientKeyShareBackupInfo: wallet.clientKeySharesBackupInfo,
+                thresholdSignatureScheme: wallet.thresholdSignatureScheme,
+                walletOperation,
+                shareCount
             });
-            await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
+            const { dynamic: dynamicKeyShareIds } = shares;
+            const data = await this.apiClient.recoverEncryptedBackupByWallet({
+                walletId: wallet.walletId,
+                keyShareIds: dynamicKeyShareIds,
+                signedSessionId
+            });
+            const dynamicKeyShares = data.keyShares.filter((keyShare)=>keyShare.encryptedAccountCredential !== null && keyShare.backupLocation === BackupLocation.DYNAMIC);
+            const decryptedKeyShares = await Promise.all(dynamicKeyShares.map((keyShare)=>this.decryptKeyShare({
+                    keyShare: keyShare.encryptedAccountCredential,
+                    password: password != null ? password : this.environmentId
+                })));
+            if (storeRecoveredShares) {
+                await this.setClientKeySharesToLocalStorage({
+                    accountAddress,
+                    clientKeyShares: decryptedKeyShares,
+                    overwriteOrMerge: 'merge'
+                });
+                await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
+            }
+            return decryptedKeyShares;
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in recoverEncryptedBackupByWallet', error);
+            throw error;
         }
-        return decryptedKeyShares;
     }
     async restoreWallets() {
         const wallets = await this.storage.getItem(this.storageKey);
@@ -1178,107 +1316,123 @@ class DynamicWalletClient {
         this.walletMap = JSON.parse(wallets);
     }
     async backupKeySharesToGoogleDrive({ accountAddress, password, signedSessionId }) {
-        await this.getWallet({
-            accountAddress,
-            walletOperation: WalletOperation.REACH_ALL_PARTIES,
-            password,
-            signedSessionId
-        });
-        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
-            accountAddress
-        });
-        if (clientKeyShares.length === 0) {
-            throw new Error('No key shares found');
-        }
-        const encryptedKeyShares = await Promise.all(clientKeyShares.map((keyShare)=>this.encryptKeyShare({
-                keyShare,
-                password
-            })));
-        const oauthAccountId = await this.getGoogleOauthAccountIdOrThrow(accountAddress);
-        const accessToken = await this.apiClient.getAccessToken({
-            oauthAccountId
-        });
-        const thresholdSignatureScheme = this.walletMap[accountAddress].thresholdSignatureScheme;
-        const fileName = getClientKeyShareExportFileName({
-            thresholdSignatureScheme,
-            accountAddress
-        });
-        const backupData = createBackupData({
-            encryptedKeyShares,
-            accountAddress,
-            thresholdSignatureScheme
-        });
-        await uploadBackupToGoogleDrive({
-            accessToken,
-            fileName,
-            backupData,
-            accountAddress
-        });
-        const data = await this.apiClient.markKeySharesAsBackedUpGoogleDrive({
-            walletId: this.walletMap[accountAddress].walletId
-        });
-        await updateWalletMapWithBackupInfo({
-            data,
-            walletMap: this.walletMap,
-            accountAddress,
-            storage: this.storage,
-            storageKey: this.storageKey
-        });
-    }
-    async restoreBackupFromGoogleDrive({ accountAddress, password, signedSessionId }) {
-        await this.getWallet({
-            accountAddress,
-            signedSessionId
-        });
-        const oauthAccountId = await this.getGoogleOauthAccountIdOrThrow(accountAddress);
-        const accessToken = await this.apiClient.getAccessToken({
-            oauthAccountId
-        });
-        const thresholdSignatureScheme = this.walletMap[accountAddress].thresholdSignatureScheme;
-        const fileName = getClientKeyShareExportFileName({
-            thresholdSignatureScheme,
-            accountAddress
-        });
-        let backupData = null;
         try {
-            backupData = await retryPromise(()=>downloadFileFromGoogleDrive({
-                    accessToken,
-                    fileName
-                }));
-        } catch (error) {
-            this.logger.error('Failed to download backup from Google Drive', {
+            await this.getWallet({
                 accountAddress,
+                walletOperation: WalletOperation.REACH_ALL_PARTIES,
+                password,
+                signedSessionId
+            });
+            const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+                accountAddress
+            });
+            if (clientKeyShares.length === 0) {
+                throw new Error('No key shares found');
+            }
+            const encryptedKeyShares = await Promise.all(clientKeyShares.map((keyShare)=>this.encryptKeyShare({
+                    keyShare,
+                    password
+                })));
+            const oauthAccountId = await this.getGoogleOauthAccountIdOrThrow(accountAddress);
+            const accessToken = await this.apiClient.getAccessToken({
+                oauthAccountId
+            });
+            const thresholdSignatureScheme = this.walletMap[accountAddress].thresholdSignatureScheme;
+            const fileName = getClientKeyShareExportFileName({
+                thresholdSignatureScheme,
+                accountAddress
+            });
+            const backupData = createBackupData({
+                encryptedKeyShares,
+                accountAddress,
+                thresholdSignatureScheme
+            });
+            await uploadBackupToGoogleDrive({
+                accessToken,
                 fileName,
-                error
+                backupData,
+                accountAddress
             });
-            throw new Error('Failed to restore backup from Google Drive');
-        }
-        if (!backupData) {
-            this.logger.error('No backup file found', {
+            const data = await this.apiClient.markKeySharesAsBackedUpGoogleDrive({
+                walletId: this.walletMap[accountAddress].walletId
+            });
+            await updateWalletMapWithBackupInfo({
+                data,
+                walletMap: this.walletMap,
                 accountAddress,
-                fileName
+                storage: this.storage,
+                storageKey: this.storageKey
             });
-            throw new Error('No backup file found');
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in backupKeySharesToGoogleDrive', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
+            }
+            throw error;
         }
-        // Validate the backup data structure
-        if (!backupData.keyShares || !backupData.metadata) {
-            this.logger.error('Invalid backup format: missing keyShares or metadata', {
+    }
+    async restoreBackupFromGoogleDrive({ accountAddress, password, signedSessionId }) {
+        try {
+            await this.getWallet({
+                accountAddress,
+                signedSessionId
+            });
+            const oauthAccountId = await this.getGoogleOauthAccountIdOrThrow(accountAddress);
+            const accessToken = await this.apiClient.getAccessToken({
+                oauthAccountId
+            });
+            const thresholdSignatureScheme = this.walletMap[accountAddress].thresholdSignatureScheme;
+            const fileName = getClientKeyShareExportFileName({
+                thresholdSignatureScheme,
+                accountAddress
+            });
+            let backupData = null;
+            try {
+                backupData = await retryPromise(()=>downloadFileFromGoogleDrive({
+                        accessToken,
+                        fileName
+                    }));
+            } catch (error) {
+                this.logger.error('Failed to download backup from Google Drive', {
+                    accountAddress,
+                    fileName,
+                    error
+                });
+                throw new Error('Failed to restore backup from Google Drive');
+            }
+            if (!backupData) {
+                this.logger.error('No backup file found', {
+                    accountAddress,
+                    fileName
+                });
+                throw new Error('No backup file found');
+            }
+            // Validate the backup data structure
+            if (!backupData.keyShares || !backupData.metadata) {
+                this.logger.error('Invalid backup format: missing keyShares or metadata', {
+                    accountAddress,
+                    fileName
+                });
+                throw new Error('Invalid backup format: missing keyShares or metadata');
+            }
+            const { keyShares } = backupData;
+            const decryptedKeyShares = await Promise.all(keyShares.map((keyShare)=>this.decryptKeyShare({
+                    keyShare,
+                    password
+                })));
+            await this.setClientKeySharesToLocalStorage({
                 accountAddress,
-                fileName
+                clientKeyShares: decryptedKeyShares,
+                overwriteOrMerge: 'merge'
             });
-            throw new Error('Invalid backup format: missing keyShares or metadata');
+            return decryptedKeyShares;
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in restoreBackupFromGoogleDrive', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
+            }
+            throw error;
         }
-        const { keyShares } = backupData;
-        const decryptedKeyShares = await Promise.all(keyShares.map((keyShare)=>this.decryptKeyShare({
-                keyShare,
-                password
-            })));
-        await this.setClientKeySharesToLocalStorage({
-            accountAddress,
-            clientKeyShares: decryptedKeyShares,
-            overwriteOrMerge: 'merge'
-        });
-        return decryptedKeyShares;
     }
     async exportClientKeyshares({ accountAddress, password, signedSessionId }) {
         await this.verifyPassword({
@@ -1449,107 +1603,131 @@ class DynamicWalletClient {
         return true;
     }
     async getWalletClientKeyShareBackupInfo({ accountAddress }) {
-        var _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups_BackupLocation_DYNAMIC, _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups, _this_walletMap_accountAddress_clientKeySharesBackupInfo, _this_walletMap_accountAddress, _user_verifiedCredentials;
-        // Return existing backup info if it exists
-        if (((_this_walletMap_accountAddress = this.walletMap[accountAddress]) == null ? void 0 : (_this_walletMap_accountAddress_clientKeySharesBackupInfo = _this_walletMap_accountAddress.clientKeySharesBackupInfo) == null ? void 0 : (_this_walletMap_accountAddress_clientKeySharesBackupInfo_backups = _this_walletMap_accountAddress_clientKeySharesBackupInfo.backups) == null ? void 0 : (_this_walletMap_accountAddress_clientKeySharesBackupInfo_backups_BackupLocation_DYNAMIC = _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups[BackupLocation.DYNAMIC]) == null ? void 0 : _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups_BackupLocation_DYNAMIC.length) > 0) {
-            return this.walletMap[accountAddress].clientKeySharesBackupInfo;
+        try {
+            var _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups_BackupLocation_DYNAMIC, _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups, _this_walletMap_accountAddress_clientKeySharesBackupInfo, _this_walletMap_accountAddress, _user_verifiedCredentials;
+            // Return existing backup info if it exists
+            if (((_this_walletMap_accountAddress = this.walletMap[accountAddress]) == null ? void 0 : (_this_walletMap_accountAddress_clientKeySharesBackupInfo = _this_walletMap_accountAddress.clientKeySharesBackupInfo) == null ? void 0 : (_this_walletMap_accountAddress_clientKeySharesBackupInfo_backups = _this_walletMap_accountAddress_clientKeySharesBackupInfo.backups) == null ? void 0 : (_this_walletMap_accountAddress_clientKeySharesBackupInfo_backups_BackupLocation_DYNAMIC = _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups[BackupLocation.DYNAMIC]) == null ? void 0 : _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups_BackupLocation_DYNAMIC.length) > 0) {
+                return this.walletMap[accountAddress].clientKeySharesBackupInfo;
+            }
+            // Get backup info from server
+            const user = await this.apiClient.getUser();
+            const wallet = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.find((vc)=>vc.address.toLowerCase() === accountAddress.toLowerCase());
+            return getClientKeyShareBackupInfo({
+                walletProperties: wallet == null ? void 0 : wallet.walletProperties
+            });
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in getWalletClientKeyShareBackupInfo', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
+            }
+            throw error;
         }
-        // Get backup info from server
-        const user = await this.apiClient.getUser();
-        const wallet = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.find((vc)=>vc.address.toLowerCase() === accountAddress.toLowerCase());
-        return getClientKeyShareBackupInfo({
-            walletProperties: wallet == null ? void 0 : wallet.walletProperties
-        });
     }
     async getWallet({ accountAddress, walletOperation = WalletOperation.NO_OPERATION, shareCount = undefined, password = undefined, signedSessionId }) {
-        var _user_verifiedCredentials;
-        const existingWalletCheck = await this.checkWalletFields({
-            accountAddress,
-            walletOperation,
-            shareCount
-        });
-        if (existingWalletCheck) {
-            this.logger.debug(`Wallet ${accountAddress} already exists`);
-            return this.walletMap[accountAddress];
-        }
-        // Fetch and restore wallet from server
-        const user = await this.apiClient.getUser();
-        const wallet = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.find((vc)=>vc.address.toLowerCase() === accountAddress.toLowerCase());
-        this.logger.debug('Restoring wallet', wallet);
-        const walletProperties = wallet.walletProperties;
-        this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
-            walletId: wallet.id,
-            chainName: wallet.chainName,
-            accountAddress,
-            thresholdSignatureScheme: walletProperties.thresholdSignatureScheme,
-            derivationPath: walletProperties.derivationPath,
-            clientKeySharesBackupInfo: getClientKeyShareBackupInfo({
-                walletProperties
-            })
-        });
-        if (walletOperation !== WalletOperation.NO_OPERATION && await this.requiresRestoreBackupSharesForOperation({
-            accountAddress,
-            walletOperation
-        })) {
-            // TODO(zfaizal2): throw error if signedSessionId is not provided after service deploy
-            const decryptedKeyShares = await this.recoverEncryptedBackupByWallet({
+        try {
+            var _user_verifiedCredentials;
+            const existingWalletCheck = await this.checkWalletFields({
                 accountAddress,
-                password: password != null ? password : this.environmentId,
-                walletOperation: walletOperation,
-                signedSessionId,
+                walletOperation,
                 shareCount
             });
-            const existingKeyShares = await this.getClientKeySharesFromLocalStorage({
-                accountAddress
-            });
-            await this.setClientKeySharesToLocalStorage({
+            if (existingWalletCheck) {
+                this.logger.debug(`Wallet ${accountAddress} already exists`);
+                return this.walletMap[accountAddress];
+            }
+            // Fetch and restore wallet from server
+            const user = await this.apiClient.getUser();
+            const wallet = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.find((vc)=>vc.address.toLowerCase() === accountAddress.toLowerCase());
+            this.logger.debug('Restoring wallet', wallet);
+            const walletProperties = wallet.walletProperties;
+            this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
+                walletId: wallet.id,
+                chainName: wallet.chainName,
                 accountAddress,
-                clientKeyShares: mergeUniqueKeyShares(existingKeyShares, decryptedKeyShares)
+                thresholdSignatureScheme: walletProperties.thresholdSignatureScheme,
+                derivationPath: walletProperties.derivationPath,
+                clientKeySharesBackupInfo: getClientKeyShareBackupInfo({
+                    walletProperties
+                })
             });
-            this.logger.debug('Recovered backup', decryptedKeyShares);
-        }
-        const walletCount = Object.keys(this.walletMap).length;
-        if (walletCount === 0) {
-            throw new Error('No wallets found');
-        }
-        // Return the only wallet if there's just one
-        if (walletCount === 1) {
-            return Object.values(this.walletMap)[0];
+            if (walletOperation !== WalletOperation.NO_OPERATION && await this.requiresRestoreBackupSharesForOperation({
+                accountAddress,
+                walletOperation
+            })) {
+                // TODO(zfaizal2): throw error if signedSessionId is not provided after service deploy
+                const decryptedKeyShares = await this.recoverEncryptedBackupByWallet({
+                    accountAddress,
+                    password: password != null ? password : this.environmentId,
+                    walletOperation: walletOperation,
+                    signedSessionId,
+                    shareCount
+                });
+                const existingKeyShares = await this.getClientKeySharesFromLocalStorage({
+                    accountAddress
+                });
+                await this.setClientKeySharesToLocalStorage({
+                    accountAddress,
+                    clientKeyShares: mergeUniqueKeyShares(existingKeyShares, decryptedKeyShares)
+                });
+                this.logger.debug('Recovered backup', decryptedKeyShares);
+            }
+            const walletCount = Object.keys(this.walletMap).length;
+            if (walletCount === 0) {
+                throw new Error('No wallets found');
+            }
+            // Return the only wallet if there's just one
+            if (walletCount === 1) {
+                return Object.values(this.walletMap)[0];
+            }
+            return this.walletMap[accountAddress];
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in getWallet', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
+            }
+            throw error;
         }
-        return this.walletMap[accountAddress];
     }
     async getWallets() {
-        var _user_verifiedCredentials;
-        const user = await this.apiClient.getUser();
-        const waasWallets = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.filter((vc)=>vc.walletName === 'dynamicwaas');
-        const wallets = waasWallets.map((vc)=>{
-            var _this_walletMap_vc_address, _vc_walletProperties;
-            var _this_walletMap_vc_address_derivationPath;
-            return {
-                walletId: vc.id,
-                chainName: vc.chain,
-                accountAddress: vc.address,
-                clientKeySharesBackupInfo: getClientKeyShareBackupInfo({
-                    walletProperties: vc.walletProperties || {}
-                }),
-                derivationPath: (_this_walletMap_vc_address_derivationPath = (_this_walletMap_vc_address = this.walletMap[vc.address]) == null ? void 0 : _this_walletMap_vc_address.derivationPath) != null ? _this_walletMap_vc_address_derivationPath : undefined,
-                thresholdSignatureScheme: (_vc_walletProperties = vc.walletProperties) == null ? void 0 : _vc_walletProperties.thresholdSignatureScheme
-            };
-        });
-        this.walletMap = wallets.reduce((acc, wallet)=>{
-            var _acc_accountAddress;
-            const accountAddress = wallet.accountAddress;
-            acc[wallet.accountAddress] = {
-                walletId: wallet.walletId,
-                chainName: wallet.chainName,
-                accountAddress: wallet.accountAddress,
-                clientKeySharesBackupInfo: wallet.clientKeySharesBackupInfo,
-                derivationPath: ((_acc_accountAddress = acc[accountAddress]) == null ? void 0 : _acc_accountAddress.derivationPath) || undefined,
-                thresholdSignatureScheme: wallet.thresholdSignatureScheme
-            };
-            return acc;
-        }, {});
-        return wallets;
+        try {
+            var _user_verifiedCredentials;
+            const user = await this.apiClient.getUser();
+            const waasWallets = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.filter((vc)=>vc.walletName === 'dynamicwaas');
+            const wallets = waasWallets.map((vc)=>{
+                var _this_walletMap_vc_address, _vc_walletProperties;
+                var _this_walletMap_vc_address_derivationPath;
+                return {
+                    walletId: vc.id,
+                    chainName: vc.chain,
+                    accountAddress: vc.address,
+                    clientKeySharesBackupInfo: getClientKeyShareBackupInfo({
+                        walletProperties: vc.walletProperties || {}
+                    }),
+                    derivationPath: (_this_walletMap_vc_address_derivationPath = (_this_walletMap_vc_address = this.walletMap[vc.address]) == null ? void 0 : _this_walletMap_vc_address.derivationPath) != null ? _this_walletMap_vc_address_derivationPath : undefined,
+                    thresholdSignatureScheme: (_vc_walletProperties = vc.walletProperties) == null ? void 0 : _vc_walletProperties.thresholdSignatureScheme
+                };
+            });
+            this.walletMap = wallets.reduce((acc, wallet)=>{
+                var _acc_accountAddress;
+                const accountAddress = wallet.accountAddress;
+                acc[wallet.accountAddress] = {
+                    walletId: wallet.walletId,
+                    chainName: wallet.chainName,
+                    accountAddress: wallet.accountAddress,
+                    clientKeySharesBackupInfo: wallet.clientKeySharesBackupInfo,
+                    derivationPath: ((_acc_accountAddress = acc[accountAddress]) == null ? void 0 : _acc_accountAddress.derivationPath) || undefined,
+                    thresholdSignatureScheme: wallet.thresholdSignatureScheme
+                };
+                return acc;
+            }, {});
+            return wallets;
+        } catch (error) {
+            this.logger.error('[DynamicWaasWalletClient]: Error in getWallets', error);
+            if (error instanceof AxiosError) {
+                handleAxiosError(error);
+            }
+            throw error;
+        }
     }
     constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug }){
         this.initializePromise = null;
@@ -1584,4 +1762,13 @@ class DynamicWalletClient {
     }
 }
 
-export { DynamicWalletClient, base64ToBytes, bytesToBase64, createBackupData, ensureBase64Padding, formatEvmMessage, formatMessage, getClientKeyShareBackupInfo, getClientKeyShareExportFileName, getGoogleOAuthAccountId, getMPCSignatureScheme, getMPCSigner, isBrowser, isHexString, mergeUniqueKeyShares, retryPromise, stringToBytes, timeoutPromise };
+const ERROR_KEYGEN_FAILED = '[DynamicWaasWalletClient]: Error with keygen';
+const ERROR_CREATE_WALLET_ACCOUNT = '[DynamicWaasWalletClient]: Error creating evm wallet account';
+const ERROR_SIGN_MESSAGE = '[DynamicWaasWalletClient]: Error signing message';
+const ERROR_ACCOUNT_ADDRESS_REQUIRED = '[DynamicWaasWalletClient]: Account address is required';
+const ERROR_VERIFY_MESSAGE_SIGNATURE = '[DynamicWaasWalletClient]: Error verifying message signature';
+const ERROR_VERIFY_TRANSACTION_SIGNATURE = '[DynamicWaasWalletClient]: Error verifying transaction signature';
+const ERROR_EXPORT_PRIVATE_KEY = '[DynamicWaasWalletClient]: Error exporting private key';
+const ERROR_IMPORT_PRIVATE_KEY = '[DynamicWaasWalletClient]: Error importing private key';
+
+export { DynamicWalletClient, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_CREATE_WALLET_ACCOUNT, ERROR_EXPORT_PRIVATE_KEY, ERROR_IMPORT_PRIVATE_KEY, ERROR_KEYGEN_FAILED, ERROR_SIGN_MESSAGE, ERROR_VERIFY_MESSAGE_SIGNATURE, ERROR_VERIFY_TRANSACTION_SIGNATURE, base64ToBytes, bytesToBase64, createBackupData, ensureBase64Padding, formatEvmMessage, formatMessage, getClientKeyShareBackupInfo, getClientKeyShareExportFileName, getGoogleOAuthAccountId, getMPCSignatureScheme, getMPCSigner, isBrowser, isHexString, mergeUniqueKeyShares, retryPromise, stringToBytes, timeoutPromise };