@onekeyfe/hd-core 1.2.0-alpha.99 → 1.2.1-alpha.0

package/__tests__/firmware-update/firmware-update-v4-parameters.test.ts

@@ -0,0 +1,85 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import FirmwareUpdateV4 from '../../src/api/FirmwareUpdateV4';
+
+jest.mock('../../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+const createMethod = (params: Record<string, unknown>) =>
+  new FirmwareUpdateV4({
+    id: 1,
+    payload: {
+      method: 'firmwareUpdateV4',
+      platform: 'desktop',
+      ...params,
+    } as any,
+  });
+
+const captureInitError = (method: FirmwareUpdateV4): unknown => {
+  try {
+    method.init();
+  } catch (error) {
+    return error;
+  }
+  throw new Error('Expected FirmwareUpdateV4.init() to throw');
+};
+
+describe('FirmwareUpdateV4 parameter migration', () => {
+  test('rejects host binding generation when preparedPlan is absent', () => {
+    const error = captureInitError(
+      createMethod({
+        hostBindingGeneration: 1,
+        componentArtifacts: {
+          boot: {
+            artifactRef: 'bootloader',
+            size: 3,
+            sha256: 'a'.repeat(64),
+          },
+        },
+      })
+    );
+
+    expect(error).toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      message: expect.stringContaining(
+        'hostBindingGeneration requires preparedPlan for remote updates'
+      ),
+    });
+  });
+
+  test.each(['resourceFiles', 'resourceBundleArtifacts'])(
+    'rejects removed %s input with a Remote/Local migration hint',
+    removedInput => {
+      const error = captureInitError(
+        createMethod({
+          targetsToUpdate: ['resource'],
+          [removedInput]: [],
+        })
+      );
+
+      expect(error).toMatchObject({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+        message: expect.stringContaining(removedInput),
+      });
+      expect(error).toMatchObject({
+        message: expect.stringContaining('resourceArchiveBinary for local updates'),
+      });
+      expect(error).toMatchObject({
+        message: expect.stringContaining(
+          'preparedPlan with hostBindingGeneration for remote updates'
+        ),
+      });
+    }
+  );
+
+  test('keeps direct Local inputs independent from host bindings', () => {
+    const method = createMethod({
+      targetsToUpdate: ['boot'],
+      bootloaderBinary: new Uint8Array([1, 2, 3]).buffer,
+    });
+
+    expect(() => method.init()).not.toThrow();
+  });
+});

package/__tests__/get-device-state.test.ts

@@ -123,7 +123,7 @@ describe('getDeviceState', () => {
           message: {
             protocol_version: 2,
             hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0' } },
+            main_mcu: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -150,7 +150,7 @@ describe('getDeviceState', () => {
           message: {
             protocol_version: 2,
             hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0', hash: 'HASH-1' } },
+            main_mcu: { application: { version: '5.0.0', hash: 'HASH-1' } },
           },
         };
       }
@@ -182,7 +182,7 @@ describe('getDeviceState', () => {
       message: {
         protocol_version: 2,
         hw: { serial_no: 'SERIAL-1' },
-        fw: { application: { version: '5.0.0' } },
+        main_mcu: { application: { version: '5.0.0' } },
         se1: { application: { version: '1.0.0' } },
       },
     });
@@ -202,25 +202,61 @@ describe('getDeviceState', () => {
     expect(state.versions.se01).toBe('1.0.0');
   });
 
-  test.each(['bootloader', 'romloader'] as const)(
-    'uses ProtocolInfo to preserve %s mode without DeviceStatusGet',
-    async mode => {
+  test.each([
+    ['bootloader', EDeviceType.Pro2, DeviceType.PRO2],
+    ['romloader', EDeviceType.Pro2, DeviceType.PRO2],
+    ['bootloader', EDeviceType.Neo, DeviceType.NEO],
+    ['romloader', EDeviceType.Neo, DeviceType.NEO],
+  ] as const)(
+    'refreshes cached %s state after %s reboots into the application',
+    async (mode, deviceType, protocolV2DeviceType) => {
       const typedCall = jest.fn().mockImplementation((requestType: string) => {
-        if (requestType === 'DeviceInfoGet') {
+        if (requestType === 'ProtocolInfoRequest') {
+          return { message: protocolV2ApplicationInfo };
+        }
+        if (requestType === 'DeviceStatusGet') {
           return {
-            message: {
-              hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
-              fw:
+            message: { init_states: true, unlocked: true, device_id: 'wallet-1' },
+          };
+        }
+        throw new Error(`Unexpected request: ${requestType}`);
+      });
+      const device = createV2Device(typedCall);
+      device.updateState(
+        {
+          protocol: 'V2',
+          identity: { deviceType },
+          status: { mode },
+          raw: {
+            protocolV2DeviceInfo: {
+              hw: { Device_type: protocolV2DeviceType, serial_no: 'SERIAL-1' },
+              main_mcu:
                 mode === 'romloader'
                   ? { romloader: { version: '1.0.0' } }
                   : { bootloader: { version: '1.0.0' } },
             },
-          };
-        }
-        if (requestType === 'ProtocolInfoRequest') {
-          return { message: getProtocolV2LoaderInfo(mode) };
-        }
-        throw new Error(`Unexpected request: ${requestType}`);
+            protocolV2ProtocolInfo: getProtocolV2LoaderInfo(mode),
+          },
+        },
+        'initialize'
+      );
+
+      const state = await device.getDeviceState({ refreshSections: ['status'] });
+
+      expect(state.status.mode).toBe('normal');
+      expect(state.identity.deviceId).toBe('wallet-1');
+      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+        'ProtocolInfoRequest',
+        'DeviceStatusGet',
+      ]);
+    }
+  );
+
+  test.each(['bootloader', 'romloader'] as const)(
+    'keeps live %s mode after refreshing cached loader state',
+    async mode => {
+      const typedCall = jest.fn().mockResolvedValue({
+        message: getProtocolV2LoaderInfo(mode),
       });
       const device = createV2Device(typedCall);
       device.updateState(
@@ -236,7 +272,10 @@ describe('getDeviceState', () => {
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
       expect(state.status.mode).toBe(mode);
-      expect(typedCall).not.toHaveBeenCalled();
+      expect(typedCall).toHaveBeenCalledTimes(1);
+      expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+        eventless_wallet_session: true,
+      });
     }
   );
 
@@ -246,7 +285,7 @@ describe('getDeviceState', () => {
         return {
           message: {
             hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0' } },
+            main_mcu: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -315,7 +354,7 @@ describe('getDeviceState', () => {
         return {
           message: {
             hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0' } },
+            main_mcu: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -358,7 +397,7 @@ describe('getDeviceState', () => {
         return {
           message: {
             hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0' } },
+            main_mcu: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -543,7 +582,7 @@ describe('getDeviceState', () => {
           message: {
             protocol_version: 1,
             hw: { serial_no: 'SERIAL-1' },
-            fw: { bootloader: { version: '1.0.0' } },
+            main_mcu: { bootloader: { version: '1.0.0' } },
             se1: {},
           },
         };

package/__tests__/logBlockEvent.test.ts

@@ -104,7 +104,19 @@ describe('getLogBlockLabel', () => {
     });
   });
 
-  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
+  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio'])(
+    'skips large Base64 resource payload logging for %s',
+    method => {
+      const request = { method, path: 'resource.bin', data: 'A'.repeat(1024 * 1024) };
+      expect(getLogBlockLabel(request)).toBe(method);
+      expect(getSafeLogPayload(request, method)).toEqual({
+        method,
+        payload: '[REDACTED]',
+      });
+    }
+  );
+
+  it.each(['fileWrite', 'fileRead'])(
     'keeps metadata and replaces binary payloads with their size for %s',
     method => {
       const request = { method, path: 'resource.bin', data: new Uint8Array(1024) };

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

@@ -148,7 +148,7 @@ describe('openWalletSession', () => {
     });
   });
 
-  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,6 +167,11 @@ 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',
@@ -177,6 +182,34 @@ describe('openWalletSession', () => {
     });
   });
 
+  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', {
+      seed_domains: [],
+    });
+  });
+
   test('does not treat an Attach PIN DeviceStatus as the Main wallet', async () => {
     const typedCall = jest.fn((request: string) => {
       if (request === 'ProtocolInfoRequest') {
@@ -1114,6 +1147,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()
@@ -1208,6 +1303,37 @@ describe('openWalletSession', () => {
     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()

package/__tests__/protocol-v2-firmware-targets.test.ts

@@ -11,6 +11,12 @@ jest.mock('../src/data/config', () => ({
   getSDKVersion: () => '0.0.0-test',
 }));
 
+const componentArtifact = {
+  artifactRef: `fw:${'a'.repeat(64)}`,
+  size: 1,
+  sha256: 'b'.repeat(64),
+};
+
 describe('Protocol V2 firmware target contract', () => {
   test('matches the current firmware-pro2 target ids', () => {
     expect(ProtocolV2FirmwareTargetType).toEqual({
@@ -63,6 +69,10 @@ describe('Protocol V2 firmware target contract', () => {
       targetsToUpdate: ['app_v1'] as Array<'app_v1'>,
       se03Binary: new ArrayBuffer(1),
       se04Binary: new ArrayBuffer(1),
+      componentArtifacts: {
+        se03: componentArtifact,
+        se04: componentArtifact,
+      },
     };
 
     expect(() =>
@@ -73,12 +83,25 @@ describe('Protocol V2 firmware target contract', () => {
     );
   });
 
+  test('rejects Neo SE03 and SE04 componentArtifacts without a target list', () => {
+    expect(() =>
+      assertProtocolV2FirmwareTargetsSupported(EDeviceType.Neo, {
+        platform: 'web',
+        componentArtifacts: {
+          se03: componentArtifact,
+          se04: componentArtifact,
+        },
+      })
+    ).toThrow('Neo only supports SE01 and SE02; unsupported firmware targets: se03, se04');
+  });
+
   test('keeps all four SE firmware targets available on Pro2', () => {
     expect(() =>
       assertProtocolV2FirmwareTargetsSupported(EDeviceType.Pro2, {
         platform: 'web',
         targetsToUpdate: ['se03'],
         se04Binary: new ArrayBuffer(1),
+        componentArtifacts: { se04: componentArtifact },
       })
     ).not.toThrow();
   });