@onekeyfe/hd-core 1.2.0-alpha.183 → 1.2.0-alpha.185

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -95,7 +95,8 @@ describe('AllNetworkGetAddressBase tracing', () => {
       'hidden-state',
       false,
       undefined,
-      false
+      false,
+      undefined
     );
     expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
@@ -173,7 +174,13 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith('hidden-state', false, undefined, true);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(
+      'hidden-state',
+      false,
+      undefined,
+      true,
+      undefined
+    );
     expect(calls).toEqual(['resume-cardano-session', 'run-cardano-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });
@@ -212,7 +219,10 @@ describe('AllNetworkGetAddressBase tracing', () => {
         bundle: [],
       },
     });
-    method.protocolV2UnlockContext = { preflightCompleted: true };
+    method.protocolV2UnlockContext = {
+      preflightCompleted: true,
+      preflightMainPinSelected: true,
+    };
     const typedCall = jest.fn();
     method.device = {
       checkPassphraseStateSafety,
@@ -250,7 +260,13 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(undefined, true, undefined, false);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(
+      undefined,
+      true,
+      undefined,
+      false,
+      true
+    );
     expect(calls).toEqual(['resume-standard-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });

package/__tests__/DeviceCommands.test.ts

@@ -126,6 +126,19 @@ describe('DeviceCommands failure mapping', () => {
     );
   });
 
+  it('preserves the Protocol V2 peer-removed pairing error code', async () => {
+    const commands = createCommands();
+    const transportError = Object.assign(new Error('Peer removed pairing information'), {
+      errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
+    });
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockRejectedValue(transportError),
+    } as any;
+
+    await expect(commands._commonCall('DeviceInfoGet', {})).rejects.toBe(transportError);
+  });
+
   it('logs canonical DeviceStatus response fields without exposing the device ID', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);

package/__tests__/check-all-firmware-release-protocol-v2.test.ts

@@ -33,8 +33,6 @@ const validComponentIntegrity = {
 const release: IFirmwareReleaseInfo = {
   required: true,
   version: [2, 0, 0],
-  url: 'https://example.com/application-p1.bin',
-  fingerprint: 'release-fingerprint',
   changelog: {
     'zh-CN': '更新',
     'en-US': 'Update',

package/__tests__/check-firmware-release-protocol-v2.test.ts

@@ -16,8 +16,6 @@ jest.mock('../src/data/config', () => ({
 const release: IFirmwareReleaseInfo = {
   required: false,
   version: [2, 0, 0],
-  url: 'https://example.com/application-p1.okpkg',
-  fingerprint: 'release-fingerprint',
   changelog: {
     'zh-CN': '更新',
     'en-US': 'Update',

package/__tests__/device-lifecycle-events.test.ts

@@ -5,6 +5,7 @@ import {
   initConnector,
   initCore,
   isMissingDetectedProtocolV2Error,
+  isProtocolV2PeerRemovedPairingError,
   isRetryableBleConnectionError,
   isRetryableBleProtocolV2ProbeError,
 } from '../src/core';
@@ -278,6 +279,7 @@ describe('public device lifecycle events', () => {
   test.each([
     [HardwareErrorCode.RuntimeError, true],
     [HardwareErrorCode.BleDeviceBondError, false],
+    [HardwareErrorCode.BlePeerRemovedPairingInformation, false],
   ] as const)(
     'retries a Protocol V2 probe mismatch with error code %s: %s',
     (errorCode, expected) => {
@@ -297,6 +299,7 @@ describe('public device lifecycle events', () => {
     [HardwareErrorCode.BleTimeoutError, true],
     [HardwareErrorCode.PollingTimeout, false],
     [HardwareErrorCode.BleDeviceBondError, false],
+    [HardwareErrorCode.BlePeerRemovedPairingInformation, false],
   ] as const)('retries a BLE connection error with error code %s: %s', (errorCode, expected) => {
     const method = { payload: { connectProtocol: 'V2' } } as never;
     const error = {
@@ -307,6 +310,22 @@ describe('public device lifecycle events', () => {
     expect(isRetryableBleConnectionError(method, error)).toBe(expected);
   });
 
+  test.each([
+    ['V2', true],
+    ['V1', false],
+    [undefined, false],
+  ] as const)(
+    'treats peer-removed pairing as terminal only for Protocol %s: %s',
+    (connectProtocol, expected) => {
+      const method = { payload: { connectProtocol } } as never;
+      const error = {
+        errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
+      };
+
+      expect(isProtocolV2PeerRemovedPairingError(method, error)).toBe(expected);
+    }
+  );
+
   test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();

package/__tests__/firmware-update/firmware-update-v4-install-poll.test.ts

@@ -36,7 +36,12 @@ describe('FirmwareUpdateV4 install polling', () => {
           records: [
             {
               target_id: 4,
-              status: 'FW_MGMT_UPDATER_TASK_STATUS_PENDING',
+              status: 'FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS',
+              progress_percent: 42,
+              phase_info: {
+                phase: 'FW_MGMT_UPDATER_PHASE_INSTALL',
+                progress_percent: 60,
+              },
               path: 'vol0:/application_p1.bin',
             },
           ],
@@ -101,7 +106,20 @@ describe('FirmwareUpdateV4 install polling', () => {
     await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
 
     expect(typedCall.mock.calls[1]?.[0]).toBe('DeviceFirmwareUpdateStatusGet');
-    expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
+    expect(typedCall.mock.calls[1]?.[2]).toEqual({
+      fields: {
+        status: true,
+        progress_percent: true,
+        phase_info: true,
+        payload_version: true,
+        path: true,
+      },
+    });
+    expect(method.postProgressMessage).toHaveBeenCalledWith(42, 'installingFirmware', {
+      installTargetId: 4,
+      installPhase: 'install',
+      installPhaseProgress: 60,
+    });
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
     expect(call.mock.invocationCallOrder[0]).toBeLessThan(typedCall.mock.invocationCallOrder[1]);
     expect(setCancelableAction).toHaveBeenCalledTimes(2);
@@ -318,6 +336,88 @@ describe('FirmwareUpdateV4 install polling', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
+  test.each([
+    ['disconnect', new Error('device was disconnected')],
+    [
+      'response timeout',
+      ERRORS.TypedError(
+        HardwareErrorCode.BleTimeoutError,
+        'Lowlevel response timeout after 15000ms for DeviceFirmwareUpdateStatusGet'
+      ),
+    ],
+  ])(
+    'accepts stable finished BLE status after install %s hides in-progress',
+    async (_, error) => {
+      const method = new FirmwareUpdateV4({
+        id: 1,
+        payload: {
+          method: 'firmwareUpdateV4',
+          connectId: 'pro2-ble',
+        },
+      });
+      const targets = [{ target_id: 6, path: 'vol0:/coprocessor.bin' }];
+      const finishedStatus = {
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            {
+              target_id: 6,
+              status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+              payload_version: 65_556,
+              path: 'vol0:/coprocessor.bin',
+            },
+          ],
+        },
+      };
+      const typedCall = jest
+        .fn()
+        .mockResolvedValueOnce(finishedStatus)
+        .mockImplementationOnce(() => {
+          expect(method.postProgressMessage).not.toHaveBeenCalled();
+          throw error;
+        })
+        .mockResolvedValueOnce(finishedStatus)
+        .mockImplementationOnce(() => {
+          expect(method.postProgressMessage).toHaveBeenCalledTimes(1);
+          expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
+          return finishedStatus;
+        })
+        .mockResolvedValueOnce(finishedStatus)
+        .mockResolvedValueOnce(finishedStatus)
+        .mockRejectedValueOnce(ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
+      const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+
+      (method as any).params = {
+        expectedTargetVersions: { coprocessor: '1.0.20' },
+      };
+
+      method.device = {
+        getCommands: () => ({ typedCall }),
+        setCancelableAction: jest.fn(),
+      } as unknown as Device;
+      method.postProgressMessage = jest.fn();
+
+      const firmwareUpdate = method as unknown as {
+        waitForProtocolV2FirmwareUpdateComplete: (
+          value: typeof targets,
+          requireCurrentInstallStatus: boolean
+        ) => Promise<void>;
+        reconnectProtocolV2Device: (options: { skipProtocolProbe: boolean }) => Promise<void>;
+      };
+      firmwareUpdate.reconnectProtocolV2Device = reconnectProtocolV2Device;
+      (method as any).isBleReconnect = jest.fn(() => true);
+
+      await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
+
+      expect(reconnectProtocolV2Device).toHaveBeenCalledWith({ skipProtocolProbe: true });
+      expect(typedCall).toHaveBeenCalledTimes(6);
+      expect(method.postProgressMessage).toHaveBeenNthCalledWith(1, 1, 'installingFirmware');
+      expect(method.postProgressMessage).toHaveBeenNthCalledWith(2, 100, 'installingFirmware');
+      expect(method.postProgressMessage).toHaveBeenCalledTimes(2);
+    },
+    10_000
+  );
+
   test('confirms App mode when BLE status becomes empty after current install progress', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,

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-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 },
         },

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 () => {