@dynamic-labs-wallet/browser 0.0.32 → 0.0.34

package/index.cjs.js

@@ -63,6 +63,47 @@ const isHexString = (str)=>{
 const getClientKeyShareExportFileName = ({ thresholdSignatureScheme, accountAddress })=>{
     return `${CLIENT_KEYSHARE_EXPORT_FILENAME_PREFIX}-${thresholdSignatureScheme}-${accountAddress}.json`;
 };
+const getClientKeyShareBackupInfo = (params)=>{
+    var _params_walletProperties, _params_walletProperties_keyShares_;
+    const backups = {
+        [core.BackupLocation.DYNAMIC]: [],
+        [core.BackupLocation.GOOGLE_DRIVE]: [],
+        [core.BackupLocation.ICLOUD]: [],
+        [core.BackupLocation.USER]: [],
+        [core.BackupLocation.EXTERNAL]: []
+    };
+    if (!(params == null ? void 0 : (_params_walletProperties = params.walletProperties) == null ? void 0 : _params_walletProperties.keyShares)) {
+        return {
+            backups,
+            passwordEncrypted: false
+        };
+    }
+    params.walletProperties.keyShares.forEach((keyShare)=>{
+        if (backups[keyShare.backupLocation]) {
+            backups[keyShare.backupLocation].push(keyShare.id);
+        }
+    });
+    const passwordEncrypted = Boolean((_params_walletProperties_keyShares_ = params.walletProperties.keyShares[0]) == null ? void 0 : _params_walletProperties_keyShares_.passwordEncrypted);
+    return {
+        backups,
+        passwordEncrypted
+    };
+};
+/**
+ * Helper function to merge keyshares and remove duplicates based on pubkey and secretShare
+ * @param existingKeyShares - Array of existing keyshares
+ * @param newKeyShares - Array of new keyshares to merge
+ * @returns Array of merged unique keyshares
+ */ const mergeUniqueKeyShares = (existingKeyShares, newKeyShares)=>{
+    const uniqueKeyShares = newKeyShares.filter((newShare)=>!existingKeyShares.some((existingShare)=>{
+            if (!(newShare == null ? void 0 : newShare.pubkey) || !(existingShare == null ? void 0 : existingShare.pubkey)) return false;
+            return newShare.pubkey.toString() === existingShare.pubkey.toString() && newShare.secretShare === existingShare.secretShare;
+        }));
+    return [
+        ...existingKeyShares,
+        ...uniqueKeyShares
+    ];
+};
 
 const PBKDF2_ALGORITHM = 'PBKDF2';
 const PBKDF2_ITERATIONS = 100000;
@@ -307,6 +348,18 @@ const localStorageWriteTest = {
         }
     });
 
+var WalletOperation = /*#__PURE__*/ function(WalletOperation) {
+    WalletOperation["REACH_THRESHOLD"] = "REACH_THRESHOLD";
+    WalletOperation["REACH_ALL_PARTIES"] = "REACH_ALL_PARTIES";
+    WalletOperation["SIGN_MESSAGE"] = "SIGN_MESSAGE";
+    WalletOperation["SIGN_TRANSACTION"] = "SIGN_TRANSACTION";
+    WalletOperation["REFRESH"] = "REFRESH";
+    WalletOperation["RESHARE"] = "RESHARE";
+    WalletOperation["EXPORT_PRIVATE_KEY"] = "EXPORT_PRIVATE_KEY";
+    WalletOperation["NO_OPERATION"] = "NO_OPERATION";
+    return WalletOperation;
+}({});
+
 const logger = new logger$1.Logger('DynamicWaasWalletClient');
 
 class DynamicWalletClient {
@@ -473,9 +526,16 @@ class DynamicWalletClient {
         }
     }
     //todo: need to modify with imported flag
-    async sign({ accountAddress, message, chainName }) {
+    async sign({ accountAddress, message, chainName, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.SIGN_MESSAGE
+        });
         const wallet = await this.getWallet({
-            accountAddress
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.SIGN_MESSAGE
         });
         // Perform the server sign
         const data = await this.serverSign({
@@ -493,9 +553,16 @@ class DynamicWalletClient {
         });
         return signature;
     }
-    async refreshWalletAccountShares({ accountAddress, chainName }) {
+    async refreshWalletAccountShares({ accountAddress, chainName, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.REFRESH
+        });
         const wallet = await this.getWallet({
-            accountAddress
+            accountAddress,
+            walletOperation: WalletOperation.REFRESH,
+            password
         });
         const mpcSigner = getMPCSigner({
             chainName,
@@ -512,7 +579,7 @@ class DynamicWalletClient {
         });
         await this.storeEncryptedBackupByWallet({
             accountAddress,
-            password: undefined
+            password: password != null ? password : this.environmentId
         });
         return refreshResults;
     }
@@ -565,9 +632,21 @@ class DynamicWalletClient {
             existingClientKeyShares
         };
     }
-    async reshare({ chainName, accountAddress, oldThresholdSignatureScheme, newThresholdSignatureScheme }) {
+    async reshare({ chainName, accountAddress, oldThresholdSignatureScheme, newThresholdSignatureScheme, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.RESHARE
+        });
+        const { existingClientShareCount } = core.getReshareConfig({
+            oldThresholdSignatureScheme,
+            newThresholdSignatureScheme
+        });
         const wallet = await this.getWallet({
-            accountAddress
+            accountAddress,
+            walletOperation: WalletOperation.RESHARE,
+            shareCount: existingClientShareCount,
+            password
         });
         console.log(`Resharing from ${oldThresholdSignatureScheme} to ${newThresholdSignatureScheme}`);
         const { newClientInitKeygenResults, newClientKeygenIds, existingClientKeygenIds, existingClientKeyShares } = await this.reshareStrategy({
@@ -609,13 +688,15 @@ class DynamicWalletClient {
         });
         await this.storeEncryptedBackupByWallet({
             accountAddress,
-            password: undefined
+            password
         });
         return reshareResults;
     }
-    async exportKey({ accountAddress, chainName }) {
+    async exportKey({ accountAddress, chainName, password = undefined }) {
         const wallet = await this.getWallet({
-            accountAddress
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.EXPORT_PRIVATE_KEY
         });
         const mpcSigner = getMPCSigner({
             chainName,
@@ -690,9 +771,11 @@ class DynamicWalletClient {
         const serializedEncryptedKeyShare = Buffer.from(JSON.stringify(encryptedKeyShare)).toString('base64');
         return serializedEncryptedKeyShare;
     }
-    async storeEncryptedBackupByWallet({ accountAddress, password }) {
+    async storeEncryptedBackupByWallet({ accountAddress, password = undefined, walletOperation = WalletOperation.REACH_ALL_PARTIES }) {
         await this.getWallet({
-            accountAddress
+            accountAddress,
+            password,
+            walletOperation
         });
         const encryptedKeyShares = await Promise.all(this.walletMap[accountAddress].clientKeyShares.map((keyShare)=>this.encryptKeyShare({
                 keyShare,
@@ -705,6 +788,17 @@ class DynamicWalletClient {
         });
         return data;
     }
+    async updatePassword({ accountAddress, existingPassword, newPassword }) {
+        await this.getWallet({
+            accountAddress,
+            password: existingPassword,
+            walletOperation: WalletOperation.REACH_ALL_PARTIES
+        });
+        await this.storeEncryptedBackupByWallet({
+            accountAddress,
+            password: newPassword
+        });
+    }
     async decryptKeyShare({ keyShare, password }) {
         const decodedKeyShare = JSON.parse(Buffer.from(keyShare, 'base64').toString());
         const decryptedKeyShare = await decryptData({
@@ -714,28 +808,56 @@ class DynamicWalletClient {
         const deserializedKeyShare = JSON.parse(decryptedKeyShare);
         return deserializedKeyShare;
     }
-    async recoverEncryptedBackupByWallet({ accountAddress, password }) {
+    /**
+   * Helper function to determine keyshare recovery strategy for dynamic shares.
+   * For REFRESH operations, retrieves enough shares to meet the client threshold.
+   * For all other operations, retrieves just 1 share.
+   * 
+   * @param clientKeyShareBackupInfo - Information about backed up key shares
+   * @param thresholdSignatureScheme - The signature scheme being used (2-of-2, 2-of-3, etc)
+   * @param walletOperation - The operation being performed (REFRESH, SIGN_MESSAGE, etc)
+   * @param shareCount - The number of shares to recover if specified for reshare operations
+   * @returns @shares: Object mapping backup locations to arrays of share IDs to recover
+   * @returns @requiredShareCount: The number of shares required to recover
+   */ recoverStrategy({ clientKeyShareBackupInfo, thresholdSignatureScheme, walletOperation, shareCount = undefined }) {
+        const { backups } = clientKeyShareBackupInfo;
+        const { clientThreshold } = core.MPC_CONFIG[thresholdSignatureScheme];
+        let requiredShareCount = walletOperation === WalletOperation.REFRESH || walletOperation === WalletOperation.REACH_ALL_PARTIES || walletOperation === WalletOperation.RESHARE ? clientThreshold : 1;
+        // Override requiredShareCount if shareCount is provided
+        if (shareCount !== undefined) {
+            requiredShareCount = shareCount;
+        }
+        const dynamicShares = backups[core.BackupLocation.DYNAMIC].slice(0, requiredShareCount);
+        return {
+            shares: {
+                [core.BackupLocation.DYNAMIC]: dynamicShares
+            },
+            requiredShareCount
+        };
+    }
+    async recoverEncryptedBackupByWallet({ accountAddress, password, walletOperation, shareCount = undefined }) {
         const wallet = this.walletMap[accountAddress];
-        this.logger.debug('recoverEncryptedBackupByWallet wallet', wallet);
+        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
+            walletId: wallet.walletId,
+            keyShareIds: dynamicKeyShareIds
         });
-        // TODO: allow handling backup from other sources
-        const dynamicKeyShares = data.keyShares.filter((keyShare)=>keyShare.encryptedAccountCredential !== null && keyShare.backupLocation === 'dynamic');
+        const dynamicKeyShares = data.keyShares.filter((keyShare)=>keyShare.encryptedAccountCredential !== null && keyShare.backupLocation === core.BackupLocation.DYNAMIC);
         const decryptedKeyShares = await Promise.all(dynamicKeyShares.map((keyShare)=>this.decryptKeyShare({
                 keyShare: keyShare.encryptedAccountCredential,
                 password: password != null ? password : this.environmentId
             })));
-        decryptedKeyShares.forEach((keyShare)=>{
-            this.restoreBackupShare({
-                walletId: wallet.walletId,
-                accountAddress,
-                chainName: data.chainName,
-                keyShare,
-                thresholdSignatureScheme: wallet.thresholdSignatureScheme,
-                derivationPath: wallet.derivationPath
-            });
+        this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
+            clientKeyShares: mergeUniqueKeyShares(this.walletMap[accountAddress].clientKeyShares || [], decryptedKeyShares)
         });
+        await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
         return decryptedKeyShares;
     }
     async restoreWallets() {
@@ -746,33 +868,11 @@ class DynamicWalletClient {
         }
         this.walletMap = JSON.parse(wallets);
     }
-    async restoreBackupShare({ walletId, accountAddress, chainName, keyShare, thresholdSignatureScheme, derivationPath }) {
-        var _this_walletMap_accountAddress;
-        // Get existing shares if any
-        const existingShares = ((_this_walletMap_accountAddress = this.walletMap[accountAddress]) == null ? void 0 : _this_walletMap_accountAddress.clientKeyShares) || [];
-        // Check if this share already exists to prevent duplicates
-        const isDuplicate = existingShares.some((existingShare)=>{
-            var _existingShare_pubkey, _keyShare_pubkey;
-            return ((_existingShare_pubkey = existingShare.pubkey) == null ? void 0 : _existingShare_pubkey.toString()) === ((_keyShare_pubkey = keyShare.pubkey) == null ? void 0 : _keyShare_pubkey.toString()) && existingShare.secretShare === keyShare.secretShare;
-        });
-        // Only add the share if it's not a duplicate
-        const updatedShares = isDuplicate ? existingShares : [
-            ...existingShares,
-            keyShare
-        ];
-        this.walletMap[accountAddress] = {
-            walletId,
-            chainName,
-            accountAddress,
-            clientKeyShares: updatedShares,
-            thresholdSignatureScheme,
-            derivationPath
-        };
-        await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
-    }
     async backupKeySharesToGoogleDrive({ accountAddress, fileName, oauthAccountId, password }) {
         await this.getWallet({
-            accountAddress
+            accountAddress,
+            walletOperation: WalletOperation.REACH_ALL_PARTIES,
+            password
         });
         const clientKeyShares = this.walletMap[accountAddress].clientKeyShares;
         if (clientKeyShares.length === 0) {
@@ -857,16 +957,8 @@ class DynamicWalletClient {
                 keyShare,
                 password
             })));
-        const existingKeyShares = this.walletMap[accountAddress].clientKeyShares || [];
-        const uniqueKeyShares = decryptedKeyShares.filter((newShare)=>!existingKeyShares.some((existingShare)=>{
-                if (!(newShare == null ? void 0 : newShare.pubkey) || !(existingShare == null ? void 0 : existingShare.pubkey)) return false;
-                return newShare.pubkey.toString() === existingShare.pubkey.toString() && newShare.secretShare === existingShare.secretShare;
-            }));
         this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
-            clientKeyShares: [
-                ...existingKeyShares,
-                ...uniqueKeyShares
-            ]
+            clientKeyShares: mergeUniqueKeyShares(this.walletMap[accountAddress].clientKeyShares || [], decryptedKeyShares)
         });
         return decryptedKeyShares;
     }
@@ -914,9 +1006,20 @@ class DynamicWalletClient {
             clientKeyShares: clientKeygenResults
         };
     }
-    async exportClientKeyshares({ accountAddress }) {
+    async exportClientKeyshares({ accountAddress, password }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.REACH_ALL_PARTIES
+        });
+        await this.getWallet({
+            accountAddress,
+            walletOperation: WalletOperation.REACH_ALL_PARTIES,
+            password
+        });
         const clientKeyShares = await this.getClientKeyShares({
-            accountAddress
+            accountAddress,
+            password
         });
         if (!accountAddress) {
             throw new Error('Must provide an account address');
@@ -937,75 +1040,216 @@ class DynamicWalletClient {
         a.download = `${CLIENT_KEYSHARE_EXPORT_FILENAME_PREFIX}-${accountAddress}.txt`;
         a.click();
     }
-    async getClientKeyShares({ accountAddress }) {
+    async getClientKeyShares({ accountAddress, password }) {
         const wallet = await this.getWallet({
-            accountAddress
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.REACH_THRESHOLD
         });
         return wallet.clientKeyShares;
     }
-    async getWallet({ accountAddress }) {
-        if (accountAddress) {
-            if (this.walletMap[accountAddress] && this.walletMap[accountAddress].clientKeyShares.length > 0 && this.walletMap[accountAddress].thresholdSignatureScheme) {
-                this.logger.debug('Wallet already exists', this.walletMap[accountAddress]);
-                return this.walletMap[accountAddress];
-            } else {
-                var _user_verifiedCredentials;
-                this.logger.debug('Wallet needs to be restored', this.walletMap[accountAddress]);
-                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 clientShares = wallet.walletProperties.keyShares.filter((ks)=>ks.backupLocation === 'dynamic');
-                this.logger.debug('clientShares', clientShares);
-                const walletProperties = wallet.walletProperties;
-                this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
-                    walletId: wallet.id,
-                    chainName: wallet.chainName,
-                    accountAddress,
-                    thresholdSignatureScheme: walletProperties.thresholdSignatureScheme,
-                    derivationPath: walletProperties.derivationPath
-                });
-                // restore backup
-                const decryptedKeyShares = await this.recoverEncryptedBackupByWallet({
-                    accountAddress,
-                    password: this.environmentId
-                });
-                //todo: check to see if their are other backups ie google drive, etc
-                this.logger.debug('Recovered backup', decryptedKeyShares);
+    /**
+   * Helper function to check if the required wallet fields are present and valid
+   * @param accountAddress - The account address of the wallet to check
+   * @param walletOperation - The wallet operation that determines required fields
+   * @returns boolean indicating if wallet needs to be re-fetched and restored from server
+   */ async checkWalletFields({ accountAddress, walletOperation = WalletOperation.REACH_THRESHOLD, shareCount }) {
+        let keyshareCheck = false;
+        let walletCheck = false;
+        let thresholdSignatureSchemeCheck = false;
+        // check if wallet exists
+        const existingWallet = this.walletMap[accountAddress];
+        if (existingWallet) {
+            walletCheck = true;
+        }
+        // check if threshold signature scheme exists
+        if (existingWallet == null ? void 0 : existingWallet.thresholdSignatureScheme) {
+            thresholdSignatureSchemeCheck = true;
+        }
+        // check if wallet already exists with sufficient keyshares
+        if (existingWallet) {
+            var _existingWallet_clientKeyShares;
+            const { shares } = this.recoverStrategy({
+                clientKeyShareBackupInfo: existingWallet.clientKeySharesBackupInfo || {
+                    backups: getClientKeyShareBackupInfo()
+                },
+                thresholdSignatureScheme: existingWallet.thresholdSignatureScheme,
+                walletOperation,
+                shareCount
+            });
+            const { dynamic: requiredDynamicKeyShareIds = [] } = shares;
+            if (requiredDynamicKeyShareIds.length <= (((_existingWallet_clientKeyShares = existingWallet.clientKeyShares) == null ? void 0 : _existingWallet_clientKeyShares.length) || 0)) {
+                keyshareCheck = true;
             }
         }
+        return walletCheck && thresholdSignatureSchemeCheck && keyshareCheck;
+    }
+    /**
+   * verifyPassword attempts to recover and decrypt 1 client key share using the provided password
+   * if successful, the key share is encrypted with the new password and stored
+   * if unsuccessful, throws an error
+   */ async verifyPassword({ accountAddress, password = undefined, walletOperation = WalletOperation.NO_OPERATION }) {
+        await this.getWallet({
+            accountAddress,
+            password,
+            walletOperation
+        });
+        if (await this.requiresPasswordForOperation({
+            accountAddress,
+            walletOperation
+        }) && !password) {
+            throw new Error('Password is required for operation but not provided');
+        }
+        // silent return if no password is provided and operation does not require a password
+        if (!password) {
+            return;
+        }
+        const { backups } = await this.getWalletClientKeyShareBackupInfo({
+            accountAddress
+        });
+        const { dynamic: dynamicKeyShareIds = [] } = backups;
+        if (!dynamicKeyShareIds || dynamicKeyShareIds.length === 0) {
+            throw new Error('No dynamic key shares found');
+        }
+        try {
+            await this.recoverEncryptedBackupByWallet({
+                accountAddress,
+                password,
+                walletOperation: WalletOperation.NO_OPERATION
+            });
+        } catch (error) {
+            this.logger.error('Error in verifying password', error);
+            throw new Error('Incorrect password');
+        }
+    }
+    async isPasswordEncrypted({ accountAddress }) {
+        const clientKeySharesBackupInfo = await this.getWalletClientKeyShareBackupInfo({
+            accountAddress
+        });
+        return clientKeySharesBackupInfo == null ? void 0 : clientKeySharesBackupInfo.passwordEncrypted;
+    }
+    /**
+   * check if the operation requires a password
+   */ async requiresPasswordForOperation({ accountAddress, walletOperation = WalletOperation.REACH_THRESHOLD }) {
+        const isEncrypted = await this.isPasswordEncrypted({
+            accountAddress
+        });
+        if (!isEncrypted) {
+            return false;
+        }
+        return this.requiresRestoreBackupSharesForOperation({
+            accountAddress,
+            walletOperation
+        });
+    }
+    /**
+   * check if the operation requires restoring backup shares
+   */ async requiresRestoreBackupSharesForOperation({ accountAddress, walletOperation = WalletOperation.REACH_THRESHOLD }) {
+        const clientKeySharesBackupInfo = await this.getWalletClientKeyShareBackupInfo({
+            accountAddress
+        });
+        const clientKeyShares = this.walletMap[accountAddress].clientKeyShares || [];
+        if (walletOperation === WalletOperation.REACH_ALL_PARTIES || walletOperation === WalletOperation.REFRESH || walletOperation === WalletOperation.RESHARE) {
+            return true;
+        }
+        const { requiredShareCount } = this.recoverStrategy({
+            clientKeyShareBackupInfo: clientKeySharesBackupInfo,
+            thresholdSignatureScheme: this.walletMap[accountAddress].thresholdSignatureScheme,
+            walletOperation
+        });
+        if (clientKeyShares.length >= requiredShareCount) {
+            return false;
+        }
+        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[core.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
+        });
+    }
+    async getWallet({ accountAddress, walletOperation = WalletOperation.NO_OPERATION, shareCount = undefined, password = undefined }) {
+        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
+        })) {
+            const decryptedKeyShares = await this.recoverEncryptedBackupByWallet({
+                accountAddress,
+                password: password != null ? password : this.environmentId,
+                walletOperation: walletOperation,
+                shareCount
+            });
+            this.logger.debug('Recovered backup', decryptedKeyShares);
+        }
         const walletCount = Object.keys(this.walletMap).length;
-        // if there are no wallets, throw an error
         if (walletCount === 0) {
             throw new Error('No wallets found');
         }
-        // if there is only one wallet, return it by default
+        // Return the only wallet if there's just one
         if (walletCount === 1) {
             return Object.values(this.walletMap)[0];
         }
-        if (!accountAddress) {
-            throw new Error('Must provide an account address');
-        }
         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)=>({
+        const wallets = waasWallets.map((vc)=>{
+            var _vc_walletProperties;
+            return {
                 walletId: vc.id,
                 chainName: vc.chain,
-                accountAddress: vc.address
-            }));
+                accountAddress: vc.address,
+                clientKeySharesBackupInfo: getClientKeyShareBackupInfo({
+                    walletProperties: vc.walletProperties || {}
+                }),
+                thresholdSignatureScheme: (_vc_walletProperties = vc.walletProperties) == null ? void 0 : _vc_walletProperties.thresholdSignatureScheme
+            };
+        });
         this.walletMap = wallets.reduce((acc, wallet)=>{
-            var _acc_accountAddress, _acc_accountAddress1, _acc_accountAddress2;
+            var _acc_wallet_accountAddress, _acc_accountAddress;
             const accountAddress = wallet.accountAddress;
             acc[wallet.accountAddress] = {
                 walletId: wallet.walletId,
                 chainName: wallet.chainName,
-                accountAddress: accountAddress,
-                clientKeyShares: ((_acc_accountAddress = acc[accountAddress]) == null ? void 0 : _acc_accountAddress.clientKeyShares) || [],
-                thresholdSignatureScheme: ((_acc_accountAddress1 = acc[accountAddress]) == null ? void 0 : _acc_accountAddress1.thresholdSignatureScheme) || undefined,
-                derivationPath: ((_acc_accountAddress2 = acc[accountAddress]) == null ? void 0 : _acc_accountAddress2.derivationPath) || undefined
+                accountAddress: wallet.accountAddress,
+                clientKeyShares: ((_acc_wallet_accountAddress = acc[wallet.accountAddress]) == null ? void 0 : _acc_wallet_accountAddress.clientKeyShares) || [],
+                clientKeySharesBackupInfo: wallet.clientKeySharesBackupInfo,
+                derivationPath: ((_acc_accountAddress = acc[accountAddress]) == null ? void 0 : _acc_accountAddress.derivationPath) || undefined,
+                thresholdSignatureScheme: wallet.thresholdSignatureScheme
             };
             return acc;
         }, {});
@@ -1088,8 +1332,18 @@ Object.defineProperty(exports, "MessageHash", {
     get: function () { return web.MessageHash; }
 });
 exports.DynamicWalletClient = DynamicWalletClient;
+exports.WalletOperation = WalletOperation;
+exports.base64ToBytes = base64ToBytes;
+exports.bytesToBase64 = bytesToBase64;
+exports.ensureBase64Padding = ensureBase64Padding;
+exports.getClientKeyShareBackupInfo = getClientKeyShareBackupInfo;
+exports.getClientKeyShareExportFileName = getClientKeyShareExportFileName;
 exports.getMPCSignatureScheme = getMPCSignatureScheme;
 exports.getMPCSigner = getMPCSigner;
+exports.isBrowser = isBrowser;
+exports.isHexString = isHexString;
+exports.mergeUniqueKeyShares = mergeUniqueKeyShares;
+exports.stringToBytes = stringToBytes;
 Object.keys(core).forEach(function (k) {
     if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
         enumerable: true,