@dynamic-labs-wallet/node 0.0.0-beta.291.7 → 0.0.0-beta.292.0

package/index.cjs.js

@@ -160,12 +160,33 @@ const formatMessage = (chainName, message)=>{
     }
 };
 
+const ENCRYPTION_VERSION_LEGACY = 'v1';
+const ENCRYPTION_VERSION_CURRENT = 'v2';
 const PBKDF2_ALGORITHM = 'PBKDF2';
-const PBKDF2_ITERATIONS = 100000;
 const PBKDF2_HASH_ALGORITHM = 'SHA-256';
 const AES_GCM_ALGORITHM = 'AES-GCM';
 const AES_GCM_LENGTH = 256;
-const getKey = async ({ password, salt })=>{
+const ENCRYPTION_VERSIONS = {
+    [ENCRYPTION_VERSION_LEGACY]: {
+        version: ENCRYPTION_VERSION_LEGACY,
+        algorithm: AES_GCM_ALGORITHM,
+        keyDerivation: PBKDF2_ALGORITHM,
+        iterations: 100000,
+        hashAlgorithm: PBKDF2_HASH_ALGORITHM,
+        algorithmLength: AES_GCM_LENGTH
+    },
+    [ENCRYPTION_VERSION_CURRENT]: {
+        version: ENCRYPTION_VERSION_CURRENT,
+        algorithm: AES_GCM_ALGORITHM,
+        keyDerivation: PBKDF2_ALGORITHM,
+        iterations: 1000000,
+        hashAlgorithm: PBKDF2_HASH_ALGORITHM,
+        algorithmLength: AES_GCM_LENGTH
+    }
+};
+ENCRYPTION_VERSIONS[ENCRYPTION_VERSION_CURRENT].iterations;
+ENCRYPTION_VERSIONS[ENCRYPTION_VERSION_LEGACY].iterations;
+const getKey = async ({ password, salt, encryptionConfig })=>{
     const passwordBytes = stringToBytes(password);
     const initialKey = await crypto.subtle.importKey('raw', passwordBytes, {
         name: 'PBKDF2'
@@ -173,26 +194,34 @@ const getKey = async ({ password, salt })=>{
         'deriveKey'
     ]);
     return crypto.subtle.deriveKey({
-        name: PBKDF2_ALGORITHM,
-        salt,
-        iterations: PBKDF2_ITERATIONS,
-        hash: PBKDF2_HASH_ALGORITHM
+        name: encryptionConfig.keyDerivation,
+        salt: salt,
+        iterations: encryptionConfig.iterations,
+        hash: encryptionConfig.hashAlgorithm
     }, initialKey, {
-        name: AES_GCM_ALGORITHM,
-        length: AES_GCM_LENGTH
+        name: encryptionConfig.algorithm,
+        length: encryptionConfig.algorithmLength
     }, false, [
         'encrypt',
         'decrypt'
     ]);
 };
-const encryptData = async ({ data, password })=>{
+/**
+ * Encrypts data using the specified encryption version.
+ * Always uses the latest encryption configuration for new encryptions by default.
+ */ const encryptData = async ({ data, password, version = ENCRYPTION_VERSION_CURRENT })=>{
+    const encryptionConfig = ENCRYPTION_VERSIONS[version];
+    if (!encryptionConfig) {
+        throw new Error(`Unsupported encryption version: ${version}`);
+    }
     try {
         // Generate a random salt and IV
         const salt = crypto.getRandomValues(new Uint8Array(16));
         const iv = crypto.getRandomValues(new Uint8Array(12)); // AES-GCM requires 12 bytes
         const key = await getKey({
             password,
-            salt
+            salt,
+            encryptionConfig
         });
         // Convert the input string to bytes
         const dataBytes = new TextEncoder().encode(data);
@@ -205,25 +234,39 @@ const encryptData = async ({ data, password })=>{
         return {
             salt: bytesToBase64(salt),
             iv: bytesToBase64(iv),
-            cipher: bytesToBase64(new Uint8Array(encryptedData))
+            cipher: bytesToBase64(new Uint8Array(encryptedData)),
+            version
         };
     } catch (error) {
         throw new Error('Error encrypting data');
     }
 };
-const decryptData = async ({ data, password })=>{
+/**
+ * Decrypts data with version-based configuration.
+ * Uses the version field from the data to determine encryption parameters.
+ * Falls back to legacy version for backward compatibility if no version is specified.
+ */ const decryptData = async ({ data, password })=>{
+    const { salt, iv, cipher, version } = data;
+    // Ensure proper base64 padding for all values
+    const paddedSalt = ensureBase64Padding(salt);
+    const paddedIv = ensureBase64Padding(iv);
+    const paddedCipher = ensureBase64Padding(cipher);
+    const saltBytes = base64ToBytes(paddedSalt);
+    const ivBytes = base64ToBytes(paddedIv);
+    const cipherBytes = base64ToBytes(paddedCipher);
+    let encryptionConfig;
+    // Use version-based configuration if available, otherwise fallback to legacy
+    if (version && ENCRYPTION_VERSIONS[version]) {
+        encryptionConfig = ENCRYPTION_VERSIONS[version];
+    } else {
+        // Fallback to legacy version for backward compatibility
+        encryptionConfig = ENCRYPTION_VERSIONS[ENCRYPTION_VERSION_LEGACY];
+    }
     try {
-        const { salt, iv, cipher } = data;
-        // Ensure proper base64 padding for all values
-        const paddedSalt = ensureBase64Padding(salt);
-        const paddedIv = ensureBase64Padding(iv);
-        const paddedCipher = ensureBase64Padding(cipher);
-        const saltBytes = base64ToBytes(paddedSalt);
-        const ivBytes = base64ToBytes(paddedIv);
-        const cipherBytes = base64ToBytes(paddedCipher);
         const key = await getKey({
             password,
-            salt: saltBytes
+            salt: saltBytes,
+            encryptionConfig
         });
         const decryptedData = await crypto.subtle.decrypt({
             name: AES_GCM_ALGORITHM,
@@ -231,7 +274,7 @@ const decryptData = async ({ data, password })=>{
         }, key, cipherBytes);
         return new TextDecoder().decode(decryptedData);
     } catch (error) {
-        throw new Error('Decryption failed');
+        throw new Error('Decryption failed: ' + error);
     }
 };
 
@@ -464,20 +507,21 @@ class DynamicWalletClient {
             throw error;
         }
     }
-    //todo: need to modify with imported flag
-    async sign({ accountAddress, externalServerKeyShares, message, chainName, password = undefined, isFormatted = false, signedSessionId }) {
+    async sign({ accountAddress, externalServerKeyShares, message, chainName, password = undefined, isFormatted = false }) {
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: core.WalletOperation.SIGN_MESSAGE,
-            signedSessionId
+            walletOperation: core.WalletOperation.SIGN_MESSAGE
         });
         const wallet = await this.getWallet({
             accountAddress,
             walletOperation: core.WalletOperation.SIGN_MESSAGE,
-            password,
-            signedSessionId
+            password
         });
+        externalServerKeyShares = externalServerKeyShares != null ? externalServerKeyShares : wallet.externalServerKeyShares;
+        if (!externalServerKeyShares) {
+            throw new Error('External server key shares are required to sign a message');
+        }
         // Perform the dynamic server sign
         const data = await this.dynamicServerSign({
             walletId: wallet.walletId,
@@ -496,19 +540,17 @@ class DynamicWalletClient {
         });
         return signature;
     }
-    async refreshWalletAccountShares({ accountAddress, chainName, password = undefined, signedSessionId }) {
+    async refreshWalletAccountShares({ accountAddress, chainName, password = undefined, externalServerKeyShares, backUpToClientShareService = false }) {
         this.ensureApiClientAuthenticated();
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: core.WalletOperation.REFRESH,
-            signedSessionId
+            walletOperation: core.WalletOperation.REFRESH
         });
         const wallet = await this.getWallet({
             accountAddress,
             walletOperation: core.WalletOperation.REFRESH,
-            password,
-            signedSessionId
+            password
         });
         const mpcSigner = getMPCSigner({
             chainName,
@@ -519,7 +561,11 @@ class DynamicWalletClient {
             walletId: wallet.walletId
         });
         const roomId = data.roomId;
-        const refreshResults = await Promise.all(wallet.externalServerKeyShares.map((serverKeyShare)=>mpcSigner.refresh(roomId, serverKeyShare)));
+        externalServerKeyShares = externalServerKeyShares != null ? externalServerKeyShares : wallet.externalServerKeyShares;
+        if (!externalServerKeyShares) {
+            throw new Error('External server key shares are required to refresh');
+        }
+        const refreshResults = await Promise.all(externalServerKeyShares.map((serverKeyShare)=>mpcSigner.refresh(roomId, serverKeyShare)));
         this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
             externalServerKeyShares: refreshResults,
             externalServerKeySharesBackupInfo: getExternalServerKeyShareBackupInfo()
@@ -527,7 +573,7 @@ class DynamicWalletClient {
         await this.storeEncryptedBackupByWallet({
             accountAddress,
             password: password != null ? password : this.environmentId,
-            signedSessionId
+            backUpToClientShareService
         });
         return refreshResults;
     }
@@ -580,13 +626,12 @@ class DynamicWalletClient {
             existingExternalServerKeyShares
         };
     }
-    async reshare({ chainName, accountAddress, oldThresholdSignatureScheme, newThresholdSignatureScheme, password = undefined, signedSessionId }) {
+    async reshare({ chainName, accountAddress, oldThresholdSignatureScheme, newThresholdSignatureScheme, password = undefined, externalServerKeyShares, backUpToClientShareService = false }) {
         this.ensureApiClientAuthenticated();
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: core.WalletOperation.RESHARE,
-            signedSessionId
+            walletOperation: core.WalletOperation.RESHARE
         });
         const { existingExternalServerShareCount } = core.getServerWalletReshareConfig({
             oldThresholdSignatureScheme,
@@ -596,12 +641,17 @@ class DynamicWalletClient {
             accountAddress,
             walletOperation: core.WalletOperation.RESHARE,
             shareCount: existingExternalServerShareCount,
-            password,
-            signedSessionId
+            password
         });
+        externalServerKeyShares = externalServerKeyShares != null ? externalServerKeyShares : wallet.externalServerKeyShares;
+        if (!externalServerKeyShares) {
+            throw new Error('External server key shares are required to reshare');
+        }
         const { newExternalServerInitKeygenResults, newExternalServerKeygenIds, existingExternalServerKeygenIds, existingExternalServerKeyShares } = await this.reshareStrategy({
             chainName,
-            wallet,
+            wallet: _extends({}, wallet, {
+                externalServerKeyShares
+            }),
             oldThresholdSignatureScheme,
             newThresholdSignatureScheme
         });
@@ -640,24 +690,26 @@ class DynamicWalletClient {
         await this.storeEncryptedBackupByWallet({
             accountAddress,
             password,
-            signedSessionId
+            backUpToClientShareService
         });
         return reshareResults;
     }
-    async exportKey({ accountAddress, chainName, password = undefined, signedSessionId, externalServerKeyShares }) {
+    async exportKey({ accountAddress, chainName, password = undefined, externalServerKeyShares }) {
         this.ensureApiClientAuthenticated();
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: core.WalletOperation.EXPORT_PRIVATE_KEY,
-            signedSessionId
+            walletOperation: core.WalletOperation.EXPORT_PRIVATE_KEY
         });
         const wallet = await this.getWallet({
             accountAddress,
             password,
-            walletOperation: core.WalletOperation.EXPORT_PRIVATE_KEY,
-            signedSessionId
+            walletOperation: core.WalletOperation.EXPORT_PRIVATE_KEY
         });
+        externalServerKeyShares = externalServerKeyShares != null ? externalServerKeyShares : wallet.externalServerKeyShares;
+        if (!externalServerKeyShares) {
+            throw new Error('External server key shares are required to export a private key');
+        }
         const mpcSigner = getMPCSigner({
             chainName,
             baseRelayUrl: this.baseMPCRelayApiUrl
@@ -742,7 +794,7 @@ class DynamicWalletClient {
             throw new Error('Ceremony completion timeout');
         }
     }
-    async storeEncryptedBackupByWallet({ accountAddress, externalServerKeyShares = undefined, password = undefined, signedSessionId }) {
+    async storeEncryptedBackupByWallet({ accountAddress, externalServerKeyShares = undefined, password = undefined, backUpToClientShareService }) {
         this.ensureApiClientAuthenticated();
         //add retry logic for ceremony completion to prevent race condition
         await this.ensureCeremonyCompletionBeforeBackup({
@@ -751,7 +803,7 @@ class DynamicWalletClient {
         try {
             const keySharesToBackup = externalServerKeyShares != null ? externalServerKeyShares : await this.getExternalServerKeyShares({
                 accountAddress,
-                signedSessionId
+                password
             });
             if (!keySharesToBackup || keySharesToBackup.length === 0) {
                 throw new Error(`Key shares not found for accountAddress: ${accountAddress}`);
@@ -763,27 +815,42 @@ class DynamicWalletClient {
             if (!this.walletMap[accountAddress] || !this.walletMap[accountAddress].walletId) {
                 throw new Error(`WalletId not found for accountAddress: ${accountAddress}`);
             }
-            await this.apiClient.markKeySharesAsBackedUp({
+            const locations = [];
+            if (backUpToClientShareService) {
+                const data = await this.apiClient.storeEncryptedBackupByWallet({
+                    walletId: this.walletMap[accountAddress].walletId,
+                    encryptedKeyShares: encryptedKeyShares,
+                    passwordEncrypted: Boolean(password) && password !== this.environmentId,
+                    encryptionVersion: ENCRYPTION_VERSION_CURRENT,
+                    requiresSignedSessionId: false
+                });
+                locations.push({
+                    location: core.BackupLocation.DYNAMIC,
+                    externalKeyShareId: data.keyShareIds[0]
+                });
+            } else {
+                locations.push({
+                    location: core.BackupLocation.EXTERNAL
+                });
+            }
+            const backupData = await this.apiClient.markKeySharesAsBackedUp({
                 walletId: this.walletMap[accountAddress].walletId,
-                locations: [
-                    {
-                        location: core.BackupLocation.EXTERNAL
-                    }
-                ]
+                locations
+            });
+            const updatedBackupInfo = getExternalServerKeyShareBackupInfo({
+                walletProperties: {
+                    derivationPath: this.walletMap[accountAddress].derivationPath,
+                    keyShares: backupData.locationsWithKeyShares.map((ks)=>({
+                            id: ks.keyShareId,
+                            backupLocation: ks.location,
+                            externalKeyShareId: ks.externalKeyShareId,
+                            passwordEncrypted: Boolean(password) && password !== this.environmentId
+                        })),
+                    thresholdSignatureScheme: this.walletMap[accountAddress].thresholdSignatureScheme
+                }
             });
             this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
-                externalServerKeySharesBackupInfo: getExternalServerKeyShareBackupInfo({
-                    walletProperties: {
-                        derivationPath: this.walletMap[accountAddress].derivationPath,
-                        keyShares: encryptedKeyShares.map((encryptedKeyShare)=>({
-                                id: uuid.v4(),
-                                encryptedKeyShare,
-                                backupLocation: core.BackupLocation.EXTERNAL,
-                                passwordEncrypted: Boolean(password) && password !== this.environmentId
-                            })),
-                        thresholdSignatureScheme: this.walletMap[accountAddress].thresholdSignatureScheme
-                    }
-                })
+                externalServerKeySharesBackupInfo: updatedBackupInfo
             });
             return encryptedKeyShares;
         } catch (error) {
@@ -791,43 +858,37 @@ class DynamicWalletClient {
             throw error;
         }
     }
-    async storeEncryptedBackupByWalletWithRetry({ accountAddress, externalServerKeyShares, password, signedSessionId }) {
+    async storeEncryptedBackupByWalletWithRetry({ accountAddress, externalServerKeyShares, password, backUpToClientShareService }) {
         await retryPromise(()=>this.storeEncryptedBackupByWallet({
                 accountAddress,
                 externalServerKeyShares,
                 password,
-                signedSessionId
+                backUpToClientShareService
             }), {
             operationName: 'store encrypted backup',
             logContext: {
-                walletAddress: accountAddress,
-                keyShares: externalServerKeyShares == null ? void 0 : externalServerKeyShares.map((keyShare)=>this.encryptKeyShare({
-                        keyShare,
-                        password
-                    }))
+                walletAddress: accountAddress
             }
         });
     }
-    async getExternalServerKeyShares({ accountAddress, password, signedSessionId }) {
+    async getExternalServerKeyShares({ accountAddress, password }) {
         const wallet = await this.getWallet({
             accountAddress,
             password,
-            walletOperation: core.WalletOperation.REACH_THRESHOLD,
-            signedSessionId
+            walletOperation: core.WalletOperation.REACH_THRESHOLD
         });
         return wallet.externalServerKeyShares;
     }
-    async updatePassword({ accountAddress, existingPassword, newPassword, signedSessionId }) {
+    async updatePassword({ accountAddress, existingPassword, newPassword, backUpToClientShareService }) {
         await this.getWallet({
             accountAddress,
             password: existingPassword,
-            walletOperation: core.WalletOperation.REACH_ALL_PARTIES,
-            signedSessionId
+            walletOperation: core.WalletOperation.REACH_ALL_PARTIES
         });
         await this.storeEncryptedBackupByWallet({
             accountAddress,
             password: newPassword,
-            signedSessionId
+            backUpToClientShareService
         });
     }
     async decryptKeyShare({ keyShare, password }) {
@@ -869,7 +930,7 @@ class DynamicWalletClient {
             requiredShareCount
         };
     }
-    async recoverEncryptedBackupByWallet({ accountAddress, password, walletOperation, signedSessionId, shareCount = undefined, storeRecoveredShares = true }) {
+    async recoverEncryptedBackupByWallet({ accountAddress, password, walletOperation, shareCount = undefined, storeRecoveredShares = true }) {
         this.ensureApiClientAuthenticated();
         const wallet = this.walletMap[accountAddress];
         this.logger.debug(`recoverEncryptedBackupByWallet wallet: ${walletOperation}`, wallet);
@@ -883,7 +944,7 @@ class DynamicWalletClient {
         const data = await this.apiClient.recoverEncryptedBackupByWallet({
             walletId: wallet.walletId,
             keyShareIds: dynamicKeyShareIds,
-            signedSessionId
+            requiresSignedSessionId: false
         });
         const dynamicKeyShares = data.keyShares.filter((keyShare)=>keyShare.encryptedAccountCredential !== null && keyShare.backupLocation === core.BackupLocation.DYNAMIC);
         const decryptedKeyShares = await Promise.all(dynamicKeyShares.map((keyShare)=>this.decryptKeyShare({
@@ -897,17 +958,15 @@ class DynamicWalletClient {
         }
         return decryptedKeyShares;
     }
-    async exportExternalServerKeyShares({ accountAddress, password, signedSessionId }) {
+    async exportExternalServerKeyShares({ accountAddress, password }) {
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: core.WalletOperation.REACH_ALL_PARTIES,
-            signedSessionId
+            walletOperation: core.WalletOperation.REACH_ALL_PARTIES
         });
         const externalServerKeyShares = await this.getExternalServerKeyShares({
             accountAddress,
-            password,
-            signedSessionId
+            password
         });
         return externalServerKeyShares;
     }
@@ -956,12 +1015,11 @@ class DynamicWalletClient {
    * verifyPassword attempts to recover and decrypt a single client key share using the provided password.
    * If successful, the key share is encrypted with the new password. This method solely performs the recovery
    * and decryption without storing the restored key shares. If unsuccessful, it throws an error.
-   */ async verifyPassword({ accountAddress, password = undefined, walletOperation = core.WalletOperation.NO_OPERATION, signedSessionId }) {
+   */ async verifyPassword({ accountAddress, password = undefined, walletOperation = core.WalletOperation.NO_OPERATION }) {
         await this.getWallet({
             accountAddress,
             password,
-            walletOperation,
-            signedSessionId
+            walletOperation
         });
         if (await this.requiresPasswordForOperation({
             accountAddress,
@@ -981,12 +1039,10 @@ class DynamicWalletClient {
             throw new Error('No dynamic key shares found');
         }
         try {
-            // TODO(zfaizal2): throw error if signedSessionId is not provided after service deploy
             await this.recoverEncryptedBackupByWallet({
                 accountAddress,
                 password,
                 walletOperation,
-                signedSessionId,
                 shareCount: 1,
                 storeRecoveredShares: false
             });
@@ -1049,43 +1105,61 @@ class DynamicWalletClient {
             walletProperties: wallet == null ? void 0 : wallet.walletProperties
         });
     }
-    async getWallet({ accountAddress, walletOperation = core.WalletOperation.NO_OPERATION, shareCount = undefined }) {
-        var _user_verifiedCredentials;
-        this.ensureApiClientAuthenticated();
-        const existingWalletCheck = await this.checkWalletFields({
-            accountAddress,
-            walletOperation,
-            shareCount
-        });
-        if (existingWalletCheck) {
-            this.logger.debug(`Wallet ${accountAddress} already exists`);
+    async getWallet({ accountAddress, walletOperation = core.WalletOperation.NO_OPERATION, shareCount = undefined, password = undefined }) {
+        try {
+            var _user_verifiedCredentials;
+            this.ensureApiClientAuthenticated();
+            const existingWalletCheck = await this.checkWalletFields({
+                accountAddress,
+                walletOperation,
+                shareCount
+            });
+            if (existingWalletCheck) {
+                this.logger.debug(`Wallet ${accountAddress} already exists`);
+                return this.walletMap[accountAddress];
+            }
+            //todo: Question - why don't we just call getWallets here? so then all are preloaded
+            // 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,
+                externalServerKeySharesBackupInfo: getExternalServerKeyShareBackupInfo({
+                    walletProperties
+                })
+            });
+            if (walletOperation !== core.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('[DynamicWaasWalletClient] Recovered backup', decryptedKeyShares);
+            }
+            // externalServerKeyShares
+            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('Error in getWallet', error);
+            throw error;
         }
-        //todo: Question - why don't we just call getWallets here? so then all are preloaded
-        // 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,
-            externalServerKeySharesBackupInfo: getExternalServerKeyShareBackupInfo({
-                walletProperties
-            })
-        });
-        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];
     }
     async getWallets() {
         var _user_verifiedCredentials;