feat: enhance keyless wallet functionality with new methods and improved ID generation

- Introduced a new method to save keyless wallet data to the database in ServiceKeylessWallet, enhancing data persistence.
- Updated keyless wallet pack generation to use a new method for creating pack set IDs, improving UUID handling.
- Added a utility function to build keyless wallet account IDs, streamlining account management.
- Refactored tests to accommodate changes in pack structure and ensure consistency across keyless wallet operations.

Author: sidmorizon

packages/kit-bg/src/services/ServiceKeylessWallet/ServiceKeylessWallet.ts

@@ -28,6 +28,7 @@ import stringUtils from '@onekeyhq/shared/src/utils/stringUtils';
 import timerUtils from '@onekeyhq/shared/src/utils/timerUtils';
 import { EPrimeTransferDataType } from '@onekeyhq/shared/types/prime/primeTransferTypes';
 
+import localDb from '../../dbs/local/localDb';
 import { primePersistAtom } from '../../states/jotai/atoms';
 import { devSettingsPersistAtom } from '../../states/jotai/atoms/devSettings';
 import ServiceBase from '../ServiceBase';
@@ -149,11 +150,17 @@ class ServiceKeylessWallet extends ServiceBase {
     const wallet = await keylessWalletUtils.generateKeylessWalletPacks({
       userInfo,
       mnemonicInfo,
-      packSetId: stringUtils.generateUUID(),
+      packSetId: keylessWalletUtils.generateKeylessWalletPackSetId(),
     });
     return wallet;
   }
 
+  @backgroundMethod()
+  async saveKeylessWalletToDB({ packSetId }: { packSetId: string }) {
+    // localDb.createHDWallet()
+    void this.backgroundApi.serviceAccount.createHDWallet;
+  }
+
   @backgroundMethod()
   @toastIfError()
   async restoreKeylessWallet(params: {
@@ -178,6 +185,7 @@ class ServiceKeylessWallet extends ServiceBase {
     // Recover mnemonic from any 2 of 3 packs
     if (deviceKeyPack && authKeyPack) {
       checkPackSetId(deviceKeyPack, authKeyPack);
+
       return keylessWalletUtils.restoreFromDeviceAndAuth({
         deviceKeyPack,
         authKeyPack,
@@ -193,13 +201,12 @@ class ServiceKeylessWallet extends ServiceBase {
     }
     if (authKeyPack && cloudKeyPack) {
       checkPackSetId(authKeyPack, cloudKeyPack);
-      const cloudAccountInfo =
-        await this.backgroundApi.serviceCloudBackupV2.getCloudAccountInfo();
-      const cloudKeyUserId = cloudAccountInfo.userId;
+      // const cloudAccountInfo =
+      //   await this.backgroundApi.serviceCloudBackupV2.getCloudAccountInfo();
+      // const cloudKeyUserId = cloudAccountInfo.userId;
       return keylessWalletUtils.restoreFromAuthAndCloud({
         authKeyPack,
         cloudKeyPack,
-        cloudKeyUserId,
       });
     }
 

packages/shared/src/keylessWallet/keylessWalletUtils.test.ts

@@ -7,6 +7,7 @@ import keylessWalletUtils from './keylessWalletUtils';
 
 import type {
   IKeylessWalletPacks,
+  IKeylessWalletRestoredData,
   IKeylessWalletUserInfo,
 } from './keylessWalletTypes';
 
@@ -89,6 +90,13 @@ function printPacksDiff(
   }
 }
 
+// Helper function to extract IKeylessWalletPacks from either type
+function getPacks(
+  packs: IKeylessWalletPacks | IKeylessWalletRestoredData,
+): IKeylessWalletPacks {
+  return 'packs' in packs ? packs.packs : packs;
+}
+
 describe('keylessWalletUtils', () => {
   describe('generateKeylessMnemonic and restoreMnemonicFromShareKey', () => {
     it('should generate mnemonic with 3 share keys', async () => {
@@ -225,7 +233,7 @@ describe('keylessWalletUtils', () => {
       const packs = await keylessWalletUtils.generateKeylessWalletPacks({
         userInfo: mockUserInfo,
         mnemonicInfo,
-        packSetId: stringUtils.generateUUID(),
+        packSetId: keylessWalletUtils.generateKeylessWalletPackSetId(),
       });
 
       // Verify mnemonic info is preserved
@@ -252,7 +260,7 @@ describe('keylessWalletUtils', () => {
         {
           userInfo: mockUserInfo,
           mnemonicInfo,
-          packSetId: stringUtils.generateUUID(),
+          packSetId: keylessWalletUtils.generateKeylessWalletPackSetId(),
         },
       );
 
@@ -263,18 +271,18 @@ describe('keylessWalletUtils', () => {
       });
 
       // Step 3: Verify mnemonic is restored correctly
-      expect(restoredPacks.mnemonic).toBe(originalPacks.mnemonic);
+      expect(restoredPacks.packs.mnemonic).toBe(originalPacks.mnemonic);
 
       // Step 4: Verify user info fields are preserved in packs
-      expect(restoredPacks.deviceKeyPack.cloudKeyProvider).toBe(
+      expect(restoredPacks.packs.deviceKeyPack.cloudKeyProvider).toBe(
         mockUserInfo.cloudKeyProvider,
       );
 
       // Step 5: Verify comparable fields are equal (excluding encrypted and re-generated keys)
-      if (!isPacksEqual(originalPacks, restoredPacks)) {
-        printPacksDiff(originalPacks, restoredPacks);
+      if (!isPacksEqual(originalPacks, restoredPacks.packs)) {
+        printPacksDiff(originalPacks, restoredPacks.packs);
       }
-      expect(isPacksEqual(originalPacks, restoredPacks)).toBe(true);
+      expect(isPacksEqual(originalPacks, restoredPacks.packs)).toBe(true);
     });
 
     it('should restore from restoredPacks cloudPack + devicePack consistently', async () => {
@@ -284,7 +292,7 @@ describe('keylessWalletUtils', () => {
         {
           userInfo: mockUserInfo,
           mnemonicInfo,
-          packSetId: stringUtils.generateUUID(),
+          packSetId: keylessWalletUtils.generateKeylessWalletPackSetId(),
         },
       );
 
@@ -299,15 +307,20 @@ describe('keylessWalletUtils', () => {
       const restoredFromDeviceAndCloud =
         await keylessWalletUtils.restoreFromDeviceAndCloud({
           deviceKeyPack: originalPacks.deviceKeyPack,
-          cloudKeyPack: restoredFromDeviceAndAuth.cloudKeyPack,
+          cloudKeyPack: restoredFromDeviceAndAuth.packs.cloudKeyPack,
         });
 
       // Step 4: Verify mnemonic is the same
-      expect(restoredFromDeviceAndCloud.mnemonic).toBe(originalPacks.mnemonic);
+      expect(restoredFromDeviceAndCloud.packs.mnemonic).toBe(
+        originalPacks.mnemonic,
+      );
 
       // Step 5: Compare comparable fields between the two restored packs
       expect(
-        isPacksEqual(restoredFromDeviceAndAuth, restoredFromDeviceAndCloud),
+        isPacksEqual(
+          restoredFromDeviceAndAuth.packs,
+          restoredFromDeviceAndCloud.packs,
+        ),
       ).toBe(true);
     });
 
@@ -318,7 +331,7 @@ describe('keylessWalletUtils', () => {
         {
           userInfo: mockUserInfo,
           mnemonicInfo,
-          packSetId: stringUtils.generateUUID(),
+          packSetId: keylessWalletUtils.generateKeylessWalletPackSetId(),
         },
       );
 
@@ -333,16 +346,20 @@ describe('keylessWalletUtils', () => {
       const restoredFromAuthAndCloud =
         await keylessWalletUtils.restoreFromAuthAndCloud({
           authKeyPack: originalPacks.authKeyPack,
-          cloudKeyPack: restoredFromDeviceAndAuth.cloudKeyPack,
-          cloudKeyUserId: mockUserInfo.cloudKeyUserId,
+          cloudKeyPack: restoredFromDeviceAndAuth.packs.cloudKeyPack,
         });
 
       // Step 4: Verify mnemonic is the same
-      expect(restoredFromAuthAndCloud.mnemonic).toBe(originalPacks.mnemonic);
+      expect(restoredFromAuthAndCloud.packs.mnemonic).toBe(
+        originalPacks.mnemonic,
+      );
 
       // Step 5: Compare comparable fields between the two restored packs
       expect(
-        isPacksEqual(restoredFromDeviceAndAuth, restoredFromAuthAndCloud),
+        isPacksEqual(
+          restoredFromDeviceAndAuth.packs,
+          restoredFromAuthAndCloud.packs,
+        ),
       ).toBe(true);
     });
 
@@ -353,7 +370,7 @@ describe('keylessWalletUtils', () => {
         {
           userInfo: mockUserInfo,
           mnemonicInfo,
-          packSetId: stringUtils.generateUUID(),
+          packSetId: keylessWalletUtils.generateKeylessWalletPackSetId(),
         },
       );
 
@@ -374,7 +391,6 @@ describe('keylessWalletUtils', () => {
         await keylessWalletUtils.restoreFromAuthAndCloud({
           authKeyPack: originalPacks.authKeyPack,
           cloudKeyPack: originalPacks.cloudKeyPack,
-          cloudKeyUserId: mockUserInfo.cloudKeyUserId,
         });
 
       // Step 3: Collect all pack sources
@@ -387,50 +403,56 @@ describe('keylessWalletUtils', () => {
 
       // Step 4: All packs should have the same mnemonic and be equal
       for (const source of allPackSources) {
-        expect(source.packs.mnemonic).toBe(originalPacks.mnemonic);
+        const packs = getPacks(source.packs);
+        expect(packs.mnemonic).toBe(originalPacks.mnemonic);
       }
       for (let i = 0; i < allPackSources.length; i += 1) {
         for (let j = i + 1; j < allPackSources.length; j += 1) {
-          expect(
-            isPacksEqual(allPackSources[i].packs, allPackSources[j].packs),
-          ).toBe(true);
+          const packsI = getPacks(allPackSources[i].packs);
+          const packsJ = getPacks(allPackSources[j].packs);
+          expect(isPacksEqual(packsI, packsJ)).toBe(true);
         }
       }
 
       // Step 5: Test all combinations for restoreFromDeviceAndAuth (4x4=16 combinations)
       for (const deviceSource of allPackSources) {
         for (const authSource of allPackSources) {
+          const devicePacks = getPacks(deviceSource.packs);
+          const authPacks = getPacks(authSource.packs);
           const restored = await keylessWalletUtils.restoreFromDeviceAndAuth({
-            deviceKeyPack: deviceSource.packs.deviceKeyPack,
-            authKeyPack: authSource.packs.authKeyPack,
+            deviceKeyPack: devicePacks.deviceKeyPack,
+            authKeyPack: authPacks.authKeyPack,
           });
-          expect(restored.mnemonic).toBe(originalPacks.mnemonic);
-          expect(isPacksEqual(restored, originalPacks)).toBe(true);
+          expect(restored.packs.mnemonic).toBe(originalPacks.mnemonic);
+          expect(isPacksEqual(restored.packs, originalPacks)).toBe(true);
         }
       }
 
       // Step 6: Test all combinations for restoreFromDeviceAndCloud (4x4=16 combinations)
       for (const deviceSource of allPackSources) {
         for (const cloudSource of allPackSources) {
+          const devicePacks = getPacks(deviceSource.packs);
+          const cloudPacks = getPacks(cloudSource.packs);
           const restored = await keylessWalletUtils.restoreFromDeviceAndCloud({
-            deviceKeyPack: deviceSource.packs.deviceKeyPack,
-            cloudKeyPack: cloudSource.packs.cloudKeyPack,
+            deviceKeyPack: devicePacks.deviceKeyPack,
+            cloudKeyPack: cloudPacks.cloudKeyPack,
           });
-          expect(restored.mnemonic).toBe(originalPacks.mnemonic);
-          expect(isPacksEqual(restored, originalPacks)).toBe(true);
+          expect(restored.packs.mnemonic).toBe(originalPacks.mnemonic);
+          expect(isPacksEqual(restored.packs, originalPacks)).toBe(true);
         }
       }
 
       // Step 7: Test all combinations for restoreFromAuthAndCloud (4x4=16 combinations)
       for (const authSource of allPackSources) {
         for (const cloudSource of allPackSources) {
+          const authPacks = getPacks(authSource.packs);
+          const cloudPacks = getPacks(cloudSource.packs);
           const restored = await keylessWalletUtils.restoreFromAuthAndCloud({
-            authKeyPack: authSource.packs.authKeyPack,
-            cloudKeyPack: cloudSource.packs.cloudKeyPack,
-            cloudKeyUserId: mockUserInfo.cloudKeyUserId,
+            authKeyPack: authPacks.authKeyPack,
+            cloudKeyPack: cloudPacks.cloudKeyPack,
           });
-          expect(restored.mnemonic).toBe(originalPacks.mnemonic);
-          expect(isPacksEqual(restored, originalPacks)).toBe(true);
+          expect(restored.packs.mnemonic).toBe(originalPacks.mnemonic);
+          expect(isPacksEqual(restored.packs, originalPacks)).toBe(true);
         }
       }
     });

packages/shared/src/keylessWallet/keylessWalletUtils.ts

@@ -74,7 +74,8 @@ function deriveCloudKeyPwd(
 
 function deriveAuthKeyPwd(
   authKeyPwdSlice: string,
-  _cloudKeyUserId: string, // TODO remove this param, 假如 cloudKeyUserId 会导致切换 Cloud 存储后，其余的旧 deviceKey 都失效
+  // TODO remove this param, 假如 cloudKeyUserId 会导致切换 Cloud 存储后，其余的旧 deviceKey 都失效
+  // _cloudKeyUserId: string,
 ): Promise<string> {
   return deriveKeyPwd({
     pwdSlice: authKeyPwdSlice,
@@ -190,12 +191,22 @@ async function generateKeylessMnemonic(): Promise<IKeylessMnemonicInfo> {
   };
 }
 
+function generateKeylessWalletPackSetId(): string {
+  return stringUtils.generateUUID({ removeDashes: true });
+}
+
 async function generateKeylessWalletPacks(params: {
   userInfo: IKeylessWalletUserInfo;
   mnemonicInfo: IKeylessMnemonicInfo;
   packSetId: string;
 }): Promise<IKeylessWalletPacks> {
   const { userInfo, mnemonicInfo, packSetId } = params;
+  // Validate the packSetId with regex: must match UUID (v4) without dashes (32 lowercase hex characters)
+  if (!/^[0-9a-f]{32}$/.test(packSetId)) {
+    throw new OneKeyLocalError(
+      'Invalid packSetId: must be a 32-character lowercase hex string (UUID with dashes removed)',
+    );
+  }
   const { onekeyIdEmail, onekeyIdUserId, cloudKeyProvider, cloudKeyUserId } =
     userInfo;
 
@@ -241,7 +252,7 @@ async function generateKeylessWalletPacks(params: {
   // 4. Derive Passwords
   const deviceKeyPwd = await deriveDeviceKeyPwd(deviceKeyPwdSlice);
   const cloudKeyPwd = await deriveCloudKeyPwd(cloudKeyPwdSlice, onekeyIdUserId);
-  const authKeyPwd = await deriveAuthKeyPwd(authKeyPwdSlice, cloudKeyUserId);
+  const authKeyPwd = await deriveAuthKeyPwd(authKeyPwdSlice);
 
   // 5. Hash Passwords (for storage/verification, spec has *Hash fields)
   const deviceKeyPwdHash = await hashPassword(deviceKeyPwd);
@@ -544,22 +555,16 @@ async function restoreFromDeviceAndCloud(params: {
 async function restoreFromAuthAndCloud(params: {
   authKeyPack: IAuthKeyPack;
   cloudKeyPack: ICloudKeyPack;
-  cloudKeyUserId: string;
 }): Promise<IKeylessWalletRestoredData> {
   // Step 1: Get cloudKeyUserId to derive authKeyPwd
-  const { authKeyPack, cloudKeyPack, cloudKeyUserId } = params;
-  if (!cloudKeyUserId) {
-    throw new OneKeyLocalError(
-      'restoreFromAuthAndCloud ERROR: cloudKeyUserId is required',
-    );
-  }
+  const { authKeyPack, cloudKeyPack } = params;
 
   // Step 2: Use authKeyPwdSlice from CloudKeyPack to derive authKeyPwd
   const authKeyPwdSlice = cloudKeyPack.authKeyPwdSlice;
   if (!authKeyPwdSlice) {
     throw new OneKeyLocalError('CloudKeyPack does not contain authKeyPwdSlice');
   }
-  const authKeyPwd = await deriveAuthKeyPwd(authKeyPwdSlice, cloudKeyUserId);
+  const authKeyPwd = await deriveAuthKeyPwd(authKeyPwdSlice);
 
   // Step 3: Decrypt AuthKeyPack to get authKey
   const authKeyPackData = await decryptPackData<IAuthKeyPackEncryptedData>({
@@ -635,6 +640,7 @@ async function restoreFromAuthAndCloud(params: {
 
 export default {
   getShareXCoordinate,
+  generateKeylessWalletPackSetId,
   generateKeylessWalletPacks,
   restoreFromDeviceAndAuth,
   restoreFromDeviceAndCloud,

packages/shared/src/utils/accountUtils.ts

@@ -912,8 +912,17 @@ function isEnabledBtcFreshAddress({
   return false;
 }
 
+function buildKeylessWalletAccountId({
+  sharePackSetId,
+}: {
+  sharePackSetId: string;
+}) {
+  return `${WALLET_TYPE_HD}-keyless--${sharePackSetId}`;
+}
+
 export default {
   URL_ACCOUNT_ID,
+  buildKeylessWalletAccountId,
   buildAccountValueKey,
   parseAccountValueKey,
   buildUtxoAddressRelPath,

packages/shared/src/utils/miscUtils.ts

@@ -5,8 +5,9 @@ import type {
   IDBUtxoAccount,
 } from '@onekeyhq/kit-bg/src/dbs/local/types';
 
-export function generateUUID() {
-  return uuid.v4() as string;
+export function generateUUID(options?: { removeDashes?: boolean }) {
+  const uuidString = uuid.v4() as string;
+  return options?.removeDashes ? uuidString.replace(/-/g, '') : uuidString;
 }
 
 export function generateLocalIndexedIdFunc() {