@onekeyfe/hd-core 1.2.2-alpha.100 → 1.2.2-alpha.3

package/__tests__/open-wallet-session.test.ts

@@ -142,13 +142,12 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: '',
       on_device: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       seed_domains: [],
     });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
-  test('opens the standard wallet directly when passphrase is disabled', async () => {
+  test('selects the Main PIN before opening the standard wallet when passphrase is disabled', async () => {
     const typedCall = jest.fn((request: string) => {
       if (request === 'ProtocolInfoRequest') {
         return { message: { version: 2 } };
@@ -167,14 +166,43 @@ describe('openWalletSession', () => {
 
     await getProtocolV2WalletSession(device as any, { onlyMainPin: true });
 
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'wallet-session-coordinator',
+      reason: 'open-wallet',
+      deviceOnly: true,
+    });
     expect(typedCall).not.toHaveBeenCalledWith(
       'DeviceSessionAskPassphrase',
       'Success',
       expect.anything()
     );
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+  });
+
+  test('reuses a Main PIN selected by the current preflight when passphrase is disabled', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({ passphraseProtection: false, typedCall });
+
+    await getProtocolV2WalletSession(device as any, {
+      onlyMainPin: true,
+      mainPinSelected: true,
     });
+
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('does not treat an Attach PIN DeviceStatus as the Main wallet', async () => {
@@ -301,10 +329,9 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
-    });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
       seed_domains: [],
     });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('keeps Legacy Protocol V1 getPassphraseState parameterless', async () => {
@@ -421,10 +448,9 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
-    });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
       seed_domains: [],
     });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('refreshes Pro2 status and unlocks before selecting a hidden wallet when locked', async () => {
@@ -698,9 +724,7 @@ describe('openWalletSession', () => {
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(device.commands.typedCall).not.toHaveBeenCalledWith(
       'DeviceSessionAskPassphrase',
       'Success',
@@ -796,10 +820,9 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       seed_domains: [],
     });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).toHaveBeenCalled();
     expect(deviceWalletSessionStore.get('device-1', 'new-hidden-state')).toBe('new-hidden-session');
   });
@@ -871,7 +894,6 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
       btc_test_address: 'hidden-state',
-      seed_domains: [],
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -1054,10 +1076,9 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: '',
       on_device: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       seed_domains: [],
     });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
   });
@@ -1114,6 +1135,68 @@ describe('openWalletSession', () => {
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
   });
 
+  test('does not restrict a locked hidden-wallet selection to the Main PIN', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'hidden-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    const device = createDevice({ typedCall, promptPassphrase });
+    device.features.unlocked = false;
+    device.getDeviceState = jest
+      .fn()
+      .mockResolvedValueOnce({
+        identity: { deviceId: undefined },
+        status: { unlocked: false, passphraseProtection: true },
+      })
+      .mockResolvedValueOnce({
+        identity: { deviceId: 'device-1' },
+        status: {
+          unlocked: true,
+          passphraseProtection: true,
+          unlockedAttachPin: false,
+        },
+      })
+      .mockResolvedValueOnce({
+        identity: { deviceId: 'device-1' },
+        status: {
+          unlocked: true,
+          passphraseProtection: true,
+          unlockedAttachPin: false,
+        },
+      });
+    device.unlockDevice = jest.fn().mockImplementation(() => {
+      device.features.unlocked = true;
+      return Promise.resolve(device.features);
+    });
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'hidden-state',
+    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Any, {
+      source: 'unlock-coordinator',
+      reason: 'device-locked',
+      deviceOnly: true,
+      method: 'openWalletSession',
+    });
+    expect(device.unlockDevice).not.toHaveBeenCalledWith(
+      DeviceSessionPinType.Main,
+      expect.anything()
+    );
+  });
+
   test('switches from Attach PIN to Main PIN before opening the standard wallet', async () => {
     const typedCall = jest
       .fn()
@@ -1164,9 +1247,7 @@ describe('openWalletSession', () => {
       reason: 'open-wallet',
       deviceOnly: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('selects a hidden wallet without exposing the internal device session', async () => {
@@ -1199,15 +1280,45 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       seed_domains: [],
     });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
   });
 
+  test('reuses the fresh unlock and wallet-selection statuses', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'hidden-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    method.protocolV2UnlockContext = {
+      preflightCompleted: true,
+      preflightStatusRefreshed: true,
+    };
+    const device = createDevice({ typedCall, promptPassphrase });
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'hidden-state',
+    });
+
+    expect(device.getDeviceState.mock.calls).toEqual([[], []]);
+  });
+
   test('gets the prepared session after host passphrase entry', async () => {
     const typedCall = jest
       .fn()
@@ -1230,10 +1341,9 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       seed_domains: [],
     });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('selects an on-device passphrase wallet with an explicit on_device request', async () => {
@@ -1278,10 +1388,9 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       on_device: true,
-    });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
       seed_domains: [],
     });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
     expect(device.createProtocolV2UiPhaseMetadata).toHaveBeenNthCalledWith(
       2,
       'passphrase-on-device',
@@ -1332,10 +1441,9 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
-    });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
       seed_domains: [],
     });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('normalizes a Unicode Host passphrase before sending it to Pro2 firmware', async () => {
@@ -1357,6 +1465,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'cafe\u0301',
       on_device: false,
+      seed_domains: [],
     });
   });
 
@@ -1380,6 +1489,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase,
       on_device: false,
+      seed_domains: [],
     });
   });
 
@@ -1415,9 +1525,7 @@ describe('openWalletSession', () => {
     expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin, {
       emitUiEvent: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('uses the complete Attach PIN wire flow without a main PIN unlock', async () => {
@@ -1446,7 +1554,7 @@ describe('openWalletSession', () => {
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
       ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.AttachToPin }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
-      ['DeviceSessionGet', 'DeviceSession', { seed_domains: [] }],
+      ['DeviceSessionGet', 'DeviceSession', {}],
     ]);
     expect(device.commands.typedCall).not.toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
       type: DeviceSessionPinType.Main,
@@ -1658,7 +1766,6 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
       btc_test_address: 'hidden-state',
-      seed_domains: [],
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -1718,7 +1825,6 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
       btc_test_address: 'hidden-state',
-      seed_domains: [],
     });
     const sessionGetCall = typedCall.mock.calls.findIndex(
       ([requestName]) => requestName === 'DeviceSessionGet'
@@ -1816,7 +1922,6 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'expired-session',
       btc_test_address: 'hidden-state',
-      seed_domains: [],
     });
     expect(promptPassphrase).toHaveBeenCalledTimes(1);
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
@@ -1854,7 +1959,6 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       btc_test_address: 'hidden-state',
-      seed_domains: [],
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('new-session');
@@ -1889,11 +1993,14 @@ describe('openWalletSession', () => {
       walletType: 'hidden',
       passphraseState: 'hidden-state',
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+      passphrase: 'host hidden wallet',
+      on_device: false,
       seed_domains: [
         DeviceSessionSeedDomain.SeedDomain_Standard,
         ...(deriveCardano ? [DeviceSessionSeedDomain.SeedDomain_Cardano] : []),
       ],
     });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 });

package/__tests__/pro2HostAssetPackage.test.ts

@@ -0,0 +1,58 @@
+import { sha3_512 } from '@noble/hashes/sha3';
+
+import {
+  buildPro2HostAssetPackage,
+  supportsPro2HostAssetPackage,
+} from '../src/utils/pro2HostAssetPackage';
+
+describe('Pro2 host asset package', () => {
+  test('builds the unsigned RESOURCE container and LZ4-blocked archive expected by firmware', () => {
+    const raw = new TextEncoder().encode('123456789');
+    const packageData = buildPro2HostAssetPackage([{ name: 'wallpaper.bin', data: raw }]);
+    const headerSize = 0x5f90;
+    const payload = packageData.subarray(headerSize);
+    const packageView = new DataView(
+      packageData.buffer,
+      packageData.byteOffset,
+      packageData.byteLength
+    );
+
+    expect(packageView.getUint32(0, true)).toBe(0x50504b4f);
+    expect(packageView.getUint32(4, true)).toBe(1);
+    expect(packageView.getUint32(8, true)).toBe(0x43534552);
+    expect(packageView.getUint32(0x0c, true)).toBe(headerSize);
+    expect(packageView.getUint32(0x10, true)).toBe(1);
+    expect(packageView.getUint32(0x14, true)).toBe(payload.byteLength);
+    expect(packageData.subarray(0x200, 0x240)).toEqual(sha3_512(payload));
+    expect(packageData.subarray(0x240, 0x280)).toEqual(sha3_512(packageData.subarray(0, 0x240)));
+    expect(packageData[0x400]).toBe(0);
+    expect(packageView.getUint32(0x408, true)).toBe(0x71717171);
+
+    const archiveView = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    expect(archiveView.getUint32(0, true)).toBe(0x52414b4f);
+    expect(archiveView.getUint32(4, true)).toBe(1);
+    expect(archiveView.getUint16(8, true)).toBe(1);
+    expect(new TextDecoder().decode(payload.subarray(43, 56))).toBe('wallpaper.bin');
+    expect(archiveView.getUint32(42 + 0x100, true)).toBe(340);
+    expect(archiveView.getUint32(42 + 0x104, true)).toBe(raw.byteLength);
+    expect(archiveView.getUint32(42 + 0x10c, true)).toBe(0xcbf43926);
+    expect(payload[42 + 0x114]).toBe(1);
+
+    const compressedOffset = archiveView.getUint32(42 + 0x100, true);
+    expect(archiveView.getUint16(compressedOffset, true)).toBe(1);
+    expect(archiveView.getUint16(compressedOffset + 2, true)).toBe(12);
+    expect(archiveView.getUint32(compressedOffset + 4, true)).toBe(0);
+    expect(archiveView.getUint32(compressedOffset + 8, true)).toBe(10);
+    expect(payload.subarray(compressedOffset + 12)).toEqual(new Uint8Array([0x90, ...raw]));
+  });
+
+  test.each([
+    ['1.0.0', false],
+    ['1.0.1-beta.1', false],
+    ['1.0.1', true],
+    ['1.1.0', true],
+    [undefined, false],
+  ])('selects package uploads for firmware %s', (firmwareVersion, expected) => {
+    expect(supportsPro2HostAssetPackage(firmwareVersion)).toBe(expected);
+  });
+});

package/__tests__/protocol-v2-resources.test.ts

@@ -66,8 +66,6 @@ const createRemoteConfig = (): RemoteConfigResponse =>
         {
           required: false,
           version: [1, 0, 0],
-          url: 'https://example.com/pro2.okpkg',
-          fingerprint: 'a'.repeat(64),
           changelog: { 'zh-CN': 'Pro2', 'en-US': 'Pro2' },
           resources: { source: resourceSource },
         },
@@ -79,8 +77,6 @@ const createRemoteConfig = (): RemoteConfigResponse =>
         {
           required: false,
           version: [1, 0, 0],
-          url: 'https://example.com/neo.okpkg',
-          fingerprint: 'b'.repeat(64),
           changelog: { 'zh-CN': 'Neo', 'en-US': 'Neo' },
           resources: { source: neoResourceSource },
         },
@@ -109,6 +105,11 @@ describe('Pro2 resource configuration', () => {
     expect(
       isProtocolV2ResourceArchiveEntryName('bundles/firmware_logo-pro2-prod_resource-signed.okpkg')
     ).toBe(true);
+    expect(
+      isProtocolV2ResourceArchiveEntryName(
+        'pro2-prod_resource/bundles/firmware_logo-pro2-prod_resource-signed.okpkg'
+      )
+    ).toBe(true);
     expect(
       isProtocolV2ResourceArchiveEntryName(
         '__MACOSX/pro2-prod_resource 2/bundles/._firmware_logo-pro2-prod_resource-signed.okpkg'
@@ -119,6 +120,8 @@ describe('Pro2 resource configuration', () => {
         'bundles/._firmware_logo-pro2-prod_resource-signed.okpkg'
       )
     ).toBe(false);
+    expect(isProtocolV2ResourceArchiveEntryName('pro2-prod_resource/manifest.json')).toBe(false);
+    expect(isProtocolV2ResourceArchiveEntryName('pro2-prod_resource/.DS_Store')).toBe(false);
   });
 
   test('reads the version, hashes, and direct device path from a RESC package', () => {

package/__tests__/protocol-v2-unlock-policy.test.ts

@@ -151,8 +151,42 @@ describe('Protocol V2 unlock semantics', () => {
     });
 
     expect(method.unlockPolicy).toBe('unlock-before-run');
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, expect.any(Object));
     expect(run).toHaveBeenCalledTimes(1);
+    expect(method.protocolV2UnlockContext).toMatchObject({
+      preflightCompleted: true,
+      preflightStatusRefreshed: true,
+      preflightMainPinSelected: true,
+    });
+  });
+
+  test('allows either PIN type when pre-unlocking hidden-wallet selection', async () => {
+    const method = new OpenWalletSession({
+      id: 1,
+      payload: { method: 'openWalletSession', mode: 'select-hidden' },
+    });
+    method.init();
+    method.run = jest.fn().mockResolvedValue({ walletType: 'hidden' }) as any;
+    const features = { unlocked: false };
+    const device = {
+      features,
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: false } }),
+      },
+      isProtocolV2: () => true,
+      isBootloader: () => false,
+      isRomloader: () => false,
+      updateProtocolV2Status: jest.fn(() => features),
+      unlockDevice: jest.fn().mockImplementation(() => {
+        features.unlocked = true;
+        return Promise.resolve(features);
+      }),
+    };
+
+    await runMethodWithUnlockPolicy(method, device as any);
+
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Any, expect.any(Object));
+    expect(method.protocolV2UnlockContext?.preflightMainPinSelected).toBe(false);
   });
 
   test('pre-unlocks an unregistered wallet business method', async () => {