@onekeyfe/hd-core 1.2.0-alpha.22 → 1.2.0-alpha.23

package/__tests__/DeviceCommands.test.ts

@@ -19,7 +19,7 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
-  it('does not log DeviceSessionOpen response secrets', async () => {
+  it('does not log DeviceSessionGet response secrets', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);
     log.messages.length = 0;
@@ -33,7 +33,7 @@ describe('DeviceCommands failure mapping', () => {
             btc_test_address: 'secret-wallet-address',
           },
         } as any,
-        'DeviceSessionOpen'
+        'DeviceSessionGet'
       )
     ).resolves.toMatchObject({ type: 'DeviceSession' });
 
@@ -41,7 +41,7 @@ describe('DeviceCommands failure mapping', () => {
     expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
   });
 
-  it('maps an invalid DeviceSessionOpen resume to WalletSessionInvalid', async () => {
+  it('maps an invalid DeviceSessionGet resume to WalletSessionInvalid', async () => {
     const commands = createCommands();
 
     await expect(
@@ -54,7 +54,7 @@ describe('DeviceCommands failure mapping', () => {
             message: 'Invalid session',
           },
         } as any,
-        'DeviceSessionOpen'
+        'DeviceSessionGet'
       )
     ).rejects.toMatchObject({
       errorCode: HardwareErrorCode.WalletSessionInvalid,
@@ -66,7 +66,7 @@ describe('DeviceCommands failure mapping', () => {
     });
   });
 
-  it('maps DeviceSessionOpen user cancellation to ActionCancelled', async () => {
+  it('maps wallet-session user cancellation to ActionCancelled', async () => {
     const commands = createCommands();
 
     await expect(
@@ -79,7 +79,7 @@ describe('DeviceCommands failure mapping', () => {
             message: 'Cancelled on device',
           },
         } as any,
-        'DeviceSessionOpen'
+        'DeviceSessionAskPassphrase'
       )
     ).rejects.toMatchObject({
       errorCode: HardwareErrorCode.ActionCancelled,
@@ -89,7 +89,7 @@ describe('DeviceCommands failure mapping', () => {
   it.each([
     [3, HardwareErrorCode.DeviceCheckUnlockTypeError],
     [4, HardwareErrorCode.DeviceNotOpenedPassphrase],
-  ])('maps DeviceSessionOpen subcode %s to its canonical wallet error', async (subcode, code) => {
+  ])('maps wallet-session subcode %s to its canonical wallet error', async (subcode, code) => {
     const commands = createCommands();
 
     await expect(
@@ -98,7 +98,7 @@ describe('DeviceCommands failure mapping', () => {
           type: 'Failure',
           message: { code: 'Failure_ProcessError', subcode, message: 'Session selection failed' },
         } as any,
-        'DeviceSessionOpen'
+        'DeviceSessionAskPin'
       )
     ).rejects.toMatchObject({ errorCode: code });
   });

package/__tests__/device-settings.test.ts

@@ -37,7 +37,6 @@ function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
 
 describe('DeviceSettings protocol routing', () => {
   it.each([
-    ['label', { label: 'Shared Label' }],
     ['language', { language: 'ja-JP' }],
     ['brightness', { brightness: 80 }],
     ['haptic feedback', { hapticFeedback: true }],
@@ -56,6 +55,7 @@ describe('DeviceSettings protocol routing', () => {
   });
 
   it.each([
+    ['label', { label: 'Shared Label' }],
     ['auto lock', { autoLockDelayMs: 60_000 }],
     ['auto shutdown', { autoShutdownDelayMs: 120_000 }],
     ['mixed settings', { brightness: 80, autoLockDelayMs: 60_000 }],

package/__tests__/device-wallet-session-store.test.ts

@@ -1,6 +1,7 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import ClearSessionCache from '../src/api/ClearSessionCache';
+import DeviceWipe from '../src/api/device/DeviceWipe';
 import {
   DeviceWalletSessionStore,
   deviceWalletSessionStore,
@@ -96,6 +97,46 @@ describe('DeviceWalletSessionStore', () => {
   });
 });
 
+describe('Device wipe lifecycle invalidation', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+  });
+
+  test('clears the old Protocol V2 identity and wallet sessions after wipe succeeds', async () => {
+    const device = Device.fromDescriptor({
+      id: 'pro2-descriptor',
+      path: 'pro2-path',
+      protocolType: 'V2',
+    } as never);
+    device.features = {
+      protocol: 'V2',
+      deviceId: 'old-device-id',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    device.passphraseState = 'hidden-a';
+    deviceWalletSessionStore.set('old-device-id', 'hidden-a', 'old-session');
+    deviceWalletSessionStore.set('pro2-path', 'hidden-a', 'temporary-session');
+    device.markPreInitialized({ passphraseState: 'hidden-a' });
+    device.commands = {
+      typedCall: jest.fn().mockResolvedValue({ message: { message: 'accepted' } }),
+    } as never;
+
+    const method = new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'accepted' });
+
+    expect(device.features).toBeUndefined();
+    expect(device.passphraseState).toBeUndefined();
+    expect(device.needReloadDevice).toBe(true);
+    expect(device.isPreInitializedValid(60_000)).toBe(false);
+    expect(deviceWalletSessionStore.get('old-device-id', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('pro2-path', 'hidden-a')).toBeUndefined();
+  });
+});
+
 describe('ClearSessionCache', () => {
   beforeEach(() => {
     deviceWalletSessionStore.clear();

package/__tests__/firmware-update/check-all-firmware-release.test.ts

@@ -0,0 +1,86 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import CheckAllFirmwareRelease from '../../src/api/CheckAllFirmwareRelease';
+import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+import {
+  getBleFirmwareReleaseInfo,
+  getBootloaderReleaseInfo,
+  getFirmwareReleaseInfo,
+} from '../../src/api/firmware/releaseHelper';
+
+jest.mock('../../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+jest.mock('../../src/api/firmware/FirmwareUpdatePlan', () => ({
+  buildFirmwareUpdatePlan: jest.fn(),
+}));
+
+jest.mock('../../src/api/firmware/releaseHelper', () => ({
+  getBleFirmwareReleaseInfo: jest.fn(),
+  getBootloaderReleaseInfo: jest.fn(),
+  getFirmwareReleaseInfo: jest.fn(),
+}));
+
+const mockBuildFirmwareUpdatePlan = buildFirmwareUpdatePlan as jest.MockedFunction<
+  typeof buildFirmwareUpdatePlan
+>;
+const mockGetBleFirmwareReleaseInfo = getBleFirmwareReleaseInfo as jest.MockedFunction<
+  typeof getBleFirmwareReleaseInfo
+>;
+const mockGetBootloaderReleaseInfo = getBootloaderReleaseInfo as jest.MockedFunction<
+  typeof getBootloaderReleaseInfo
+>;
+const mockGetFirmwareReleaseInfo = getFirmwareReleaseInfo as jest.MockedFunction<
+  typeof getFirmwareReleaseInfo
+>;
+
+describe('CheckAllFirmwareRelease', () => {
+  test('keeps release information available when an optional Plan cannot be built', async () => {
+    const firmware = {
+      status: 'outdated' as const,
+      release: {
+        url: 'https://firmware.onekey.so/classic/firmware.bin',
+        version: [3, 0, 0],
+      },
+    };
+    const noUpdate = {
+      status: 'valid' as const,
+      release: undefined,
+    };
+    mockGetFirmwareReleaseInfo.mockReturnValue(firmware);
+    mockGetBootloaderReleaseInfo.mockReturnValue(noUpdate);
+    mockGetBleFirmwareReleaseInfo.mockReturnValue(noUpdate);
+    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
+      throw new Error('FirmwarePlanInvalid');
+    });
+
+    const method = new CheckAllFirmwareRelease({
+      id: 1,
+      payload: {
+        method: 'checkAllFirmwareRelease',
+        platform: 'native',
+      },
+    });
+    method.init();
+    method.device = {
+      features: {
+        deviceType: EDeviceType.Classic1s,
+        serialNo: '',
+        firmwareType: EFirmwareType.Universal,
+        firmwareVersion: '1.0.0',
+        bootloaderVersion: '1.0.0',
+      },
+    } as typeof method.device;
+
+    await expect(method.run()).resolves.toEqual(
+      expect.objectContaining({
+        firmware,
+        bootloader: noUpdate,
+        ble: noUpdate,
+        firmwareUpdatePlan: undefined,
+      })
+    );
+  });
+});

package/__tests__/firmware-update/firmware-update-prepared-plan.test.ts

@@ -2,6 +2,7 @@ import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
 import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
 import {
+  assertFirmwareUpdatePreparedPlanDeviceIdentity,
   assertFirmwareUpdatePreparedPlanBinding,
   prepareFirmwareUpdatePlan,
   validateFirmwareUpdatePreparedPlan,
@@ -76,6 +77,18 @@ describe('FirmwareUpdatePreparedPlan', () => {
     expect(prepared.preparedPlanDigest).toMatch(/^[a-f0-9]{64}$/u);
     expect(JSON.stringify(prepared)).not.toContain('https://');
     expect(validateFirmwareUpdatePreparedPlan(prepared)).toEqual(prepared);
+    expect(
+      assertFirmwareUpdatePreparedPlanDeviceIdentity({
+        preparedPlan: prepared,
+        deviceIdentity: plan.deviceIdentity,
+      })
+    ).toEqual(prepared);
+    expect(() =>
+      assertFirmwareUpdatePreparedPlanDeviceIdentity({
+        preparedPlan: prepared,
+        deviceIdentity: 'different-device-id',
+      })
+    ).toThrow();
     expect(
       assertFirmwareUpdatePreparedPlanBinding({
         preparedPlan: prepared,

package/__tests__/logBlockEvent.test.ts

@@ -60,4 +60,21 @@ describe('getLogBlockLabel', () => {
       expect(getLogBlockLabel({ payload: { method, data: new Uint8Array(1024) } })).toBe(method);
     }
   );
+
+  it.each(['evmSignMessage', 'btcSignMessage', 'evmSignTransaction'])(
+    'blocks request and response payload logging for every API method including %s',
+    method => {
+      expect(getLogBlockLabel({ method, message: 'sensitive signing payload' })).toBe(method);
+      expect(
+        getLogBlockLabel({
+          event: 'iframe-call',
+          payload: { method, message: 'sensitive signing payload' },
+        })
+      ).toBe(method);
+    }
+  );
+
+  it('does not classify events without an API method as method calls', () => {
+    expect(getLogBlockLabel({ event: 'DEVICE_EVENT', type: 'device-connect' })).toBeUndefined();
+  });
 });

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

@@ -1,4 +1,5 @@
 import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import GetPassphraseState from '../src/api/GetPassphraseState';
 import OpenWalletSession from '../src/api/OpenWalletSession';
@@ -59,15 +60,42 @@ describe('openWalletSession', () => {
     deviceWalletSessionStore.clear();
   });
 
-  test('keeps getPassphraseState unsupported on Protocol V2', async () => {
+  test('keeps the legacy getPassphraseState App flow working on Protocol V2', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { eventless_wallet_session: true } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'pro2-wallet-state',
+          session_id: 'pro2-wallet-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'legacy app secret' });
     const method = new GetPassphraseState({
-      payload: { method: 'getPassphraseState', connectId: 'connect-id' },
+      payload: {
+        method: 'getPassphraseState',
+        connectId: 'connect-id',
+        initSession: true,
+        useEmptyPassphrase: false,
+      },
     });
-    method.device = createDevice() as any;
+    method.device = createDevice({ typedCall, promptPassphrase }) as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
-    });
+    await expect(method.run()).resolves.toBe('pro2-wallet-state');
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      expect.objectContaining({ deviceOnly: true }),
+      expect.anything()
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'DeviceSessionAskPassphrase',
+      'Success',
+      {},
+      { timeoutMs: 120_000 }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(JSON.stringify(typedCall.mock.calls)).not.toContain('legacy app secret');
   });
 
   test('keeps Legacy Protocol V1 getPassphraseState parameterless', async () => {
@@ -175,12 +203,26 @@ describe('openWalletSession', () => {
       walletType: 'hidden',
       passphraseState: 'hidden-state',
     });
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      expect.objectContaining({ deviceOnly: true }),
+      expect.anything()
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'DeviceSessionAskPassphrase',
+      'Success',
+      {},
+      { timeoutMs: 120_000 }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(JSON.stringify(typedCall.mock.calls)).not.toContain('hidden secret');
   });
 
   test('classifies the selected Pro2 wallet from the post-unlock device state', async () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'hidden-state-after-unlock',
@@ -210,7 +252,7 @@ describe('openWalletSession', () => {
       sessionId: 'hidden-session-after-unlock',
       resumed: false,
     });
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
     expect(promptPassphrase).toHaveBeenCalledTimes(1);
   });
 
@@ -246,9 +288,15 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { host_passphrase: { passphrase: 'new hidden secret' } },
-    });
+    expect(typedCall).toHaveBeenCalledWith(
+      'DeviceSessionAskPassphrase',
+      'Success',
+      {},
+      {
+        timeoutMs: 120_000,
+      }
+    );
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).toHaveBeenCalled();
     expect(deviceWalletSessionStore.get('device-1', 'stale-hidden-state')).toBeUndefined();
     expect(deviceWalletSessionStore.get('device-1', 'new-hidden-state')).toBe('new-hidden-session');
@@ -314,8 +362,8 @@ describe('openWalletSession', () => {
       sessionId: 'renewed-session',
       resumed: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      resume: { session_id: 'known-session' },
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'known-session',
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -530,15 +578,21 @@ describe('openWalletSession', () => {
       sessionId: 'hidden-session',
       resumed: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { host_passphrase: { passphrase: 'hidden secret' } },
-    });
+    expect(typedCall).toHaveBeenCalledWith(
+      'DeviceSessionAskPassphrase',
+      'Success',
+      {},
+      {
+        timeoutMs: 120_000,
+      }
+    );
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
   });
 
-  test('selects on-device passphrase entry through DeviceSessionOpen', async () => {
+  test('selects on-device passphrase entry before getting the prepared session', async () => {
     const typedCall = jest.fn().mockResolvedValue({
       message: { btc_test_address: 'device-state', session_id: 'device-session' },
     });
@@ -553,9 +607,15 @@ describe('openWalletSession', () => {
       walletType: 'hidden',
       passphraseState: 'device-state',
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { passphrase_on_device: {} },
-    });
+    expect(typedCall).toHaveBeenCalledWith(
+      'DeviceSessionAskPassphrase',
+      'Success',
+      {},
+      {
+        timeoutMs: 120_000,
+      }
+    );
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('selects Attach PIN only when the device reports an existing binding', async () => {
@@ -576,12 +636,11 @@ describe('openWalletSession', () => {
       passphraseState: 'attach-state',
     });
     expect(promptPassphrase).toHaveBeenCalledWith(
-      expect.objectContaining({ existsAttachPinUser: true }),
+      expect.objectContaining({ existsAttachPinUser: true, deviceOnly: true }),
       { cancelDeviceOnReject: false }
     );
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { attach_pin_on_device: {} },
-    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test.each([
@@ -607,7 +666,7 @@ describe('openWalletSession', () => {
 
       await expect(method.run()).rejects.toMatchObject({
         errorCode: HardwareErrorCode.RuntimeError,
-        message: 'DeviceSessionOpen returned an incomplete DeviceSession response.',
+        message: 'DeviceSessionGet returned an incomplete DeviceSession response.',
       });
       expect(device.clearInternalState).toHaveBeenCalled();
       expect(device.updateInternalState).not.toHaveBeenCalled();
@@ -643,8 +702,8 @@ describe('openWalletSession', () => {
       sessionId: 'renewed-session',
       resumed: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      resume: { session_id: 'known-session' },
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'known-session',
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -694,14 +753,14 @@ describe('openWalletSession', () => {
     });
     expect(device.unlockDevice).toHaveBeenCalledTimes(1);
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      resume: { session_id: 'known-session' },
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'known-session',
     });
-    const sessionOpenCall = typedCall.mock.calls.findIndex(
-      ([requestName]) => requestName === 'DeviceSessionOpen'
+    const sessionGetCall = typedCall.mock.calls.findIndex(
+      ([requestName]) => requestName === 'DeviceSessionGet'
     );
     expect(device.getDeviceState.mock.invocationCallOrder[1]).toBeLessThan(
-      typedCall.mock.invocationCallOrder[sessionOpenCall]
+      typedCall.mock.invocationCallOrder[sessionGetCall]
     );
   });