@onekeyfe/hd-core 1.2.2-alpha.0 → 1.2.2-alpha.10

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -95,7 +95,7 @@ describe('AllNetworkGetAddressBase tracing', () => {
       'hidden-state',
       false,
       undefined,
-      false,
+      undefined,
       undefined
     );
     expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
@@ -264,7 +264,7 @@ describe('AllNetworkGetAddressBase tracing', () => {
       undefined,
       true,
       undefined,
-      false,
+      undefined,
       true
     );
     expect(calls).toEqual(['resume-standard-session', 'run-chain-method']);

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

@@ -2,12 +2,14 @@ import { EDeviceType, ERRORS, HardwareErrorCode, createDeferred } from '@onekeyf
 import { DeviceType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 
 import {
+  cancel,
   initConnector,
   initCore,
   isMissingDetectedProtocolV2Error,
   isProtocolV2PeerRemovedPairingError,
   isRetryableBleConnectionError,
   isRetryableBleProtocolV2ProbeError,
+  resolveBleConnectProtocol,
 } from '../src/core';
 import { DataManager } from '../src/data-manager';
 import TransportManager from '../src/data-manager/TransportManager';
@@ -71,6 +73,19 @@ describe('public device lifecycle events', () => {
     jest.restoreAllMocks();
   });
 
+  test('prefers Protocol V2 only when the method contract is explicitly V2-only', () => {
+    const createMethod = (protocols: readonly ('V1' | 'V2')[], connectProtocol?: 'V1' | 'V2') =>
+      ({
+        payload: { connectProtocol },
+        getSupportedProtocols: () => protocols,
+      } as never);
+
+    expect(resolveBleConnectProtocol(createMethod(['V2']))).toBe('V2');
+    expect(resolveBleConnectProtocol(createMethod(['V1']))).toBeUndefined();
+    expect(resolveBleConnectProtocol(createMethod(['V1', 'V2']))).toBeUndefined();
+    expect(resolveBleConnectProtocol(createMethod(['V2'], 'V1'))).toBe('V1');
+  });
+
   test('registers the shared device lifecycle listeners exactly once', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();
@@ -106,6 +121,58 @@ describe('public device lifecycle events', () => {
     expect(context.getPrePendingCallPromise('device-a')).toBe(replacementCleanup.promise);
   });
 
+  test('cancels only requests associated with the requested connect id', () => {
+    core = initCore();
+    const context = (core as any).getCoreContext();
+    const deviceA = {
+      mainId: 'transport-session-a',
+      getConnectId: jest.fn(() => 'serial-a'),
+      interruptionFromUser: jest.fn().mockResolvedValue(undefined),
+    };
+    const deviceB = {
+      mainId: 'device-b',
+      getConnectId: jest.fn(() => 'serial-b'),
+      interruptionFromUser: jest.fn().mockResolvedValue(undefined),
+    };
+    const taskA = context.requestQueue.createTask({
+      responseID: 101,
+      connectId: '',
+      device: deviceA,
+    } as never);
+    const taskB = context.requestQueue.createTask({
+      responseID: 102,
+      connectId: 'device-b',
+      device: deviceB,
+    } as never);
+    const signalA = taskA.abortController?.signal;
+    const signalB = taskB.abortController?.signal;
+
+    cancel(context, 'serial-a');
+
+    expect(signalA?.aborted).toBe(true);
+    expect(context.requestQueue.getTask(taskA.id)).toBeUndefined();
+    expect(signalB?.aborted).toBe(false);
+    expect(context.requestQueue.getTask(taskB.id)).toBe(taskB);
+    expect(deviceA.interruptionFromUser).toHaveBeenCalledTimes(1);
+    expect(deviceB.interruptionFromUser).not.toHaveBeenCalled();
+  });
+
+  test('aborts every request before cancel-all rejects WebUSB tasks', () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    core = initCore();
+    const context = (core as any).getCoreContext();
+    const task = context.requestQueue.createTask({
+      responseID: 103,
+      connectId: 'webusb-device',
+    } as never);
+    const signal = task.abortController?.signal;
+
+    cancel(context);
+
+    expect(signal?.aborted).toBe(true);
+    expect(context.requestQueue.getTask(task.id)).toBeUndefined();
+  });
+
   test('keeps shared device lifecycle listeners across a device cache reset', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();

package/__tests__/deviceUploadNft.test.ts

@@ -54,6 +54,7 @@ const createMethod = ({
   });
   (method as any).device = {
     commands: { typedCall },
+    state: { versions: { firmware: firmwareVersion } },
     ensureProtocolV2RuntimeContext: jest.fn(() =>
       Promise.resolve({
         version: 2,
@@ -243,6 +244,32 @@ describe('DeviceUploadNft', () => {
     });
   });
 
+  test('keeps the legacy upload flow on a 1.0.1 prerelease', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemPathInfoQuery') {
+        return { message: { exist: true, directory: true } };
+      }
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: {} };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall, firmwareVersion: '1.0.1-beta.1' });
+
+    await method.run();
+
+    const requests = typedCall.mock.calls.map(call => call[0]);
+    expect(requests).toContain('FilesystemPathInfoQuery');
+    expect(requests).toContain('FilesystemDirList');
+    const paths = typedCall.mock.calls
+      .filter(call => call[0] === 'FilesystemFileWrite')
+      .map(call => call[2].file.path as string);
+    expect(paths.some(path => path.endsWith('.okpkg'))).toBe(false);
+    expect(paths).toContain('vol1:/nft/nft-deadbeef-1760000000000.bin');
+  });
+
   test('treats a missing NFT directory as empty before the first upload', async () => {
     const typedCall = jest.fn((request: string, _response: string, params: any) => {
       if (request === 'FilesystemPathInfoQuery') {

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

@@ -335,7 +335,97 @@ describe('FirmwareUpdateV4 install polling', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('accepts stable finished BLE status after an actual install disconnect hides in-progress', async () => {
+  test.each([
+    {
+      component: 'boot',
+      targets: [{ target_id: 3, path: 'vol0:/bootloader.bin' }],
+    },
+    {
+      component: 'P1',
+      targets: [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
+    },
+    {
+      component: 'P2',
+      targets: [{ target_id: 5, path: 'vol0:/application_p2.bin' }],
+    },
+    {
+      component: 'coprocessor',
+      targets: [{ target_id: 6, path: 'vol0:/coprocessor.bin' }],
+    },
+    {
+      component: 'SE',
+      targets: [
+        { target_id: 7, path: 'vol0:/se01.bin' },
+        { target_id: 8, path: 'vol0:/se02.bin' },
+        { target_id: 9, path: 'vol0:/se03.bin' },
+        { target_id: 10, path: 'vol0:/se04.bin' },
+      ],
+    },
+  ])(
+    'accepts stable finished BLE status for $component after an actual install disconnect hides in-progress',
+    async ({ targets }) => {
+      const method = new FirmwareUpdateV4({
+        id: 1,
+        payload: {
+          method: 'firmwareUpdateV4',
+          connectId: 'pro2-ble',
+        },
+      });
+      const finishedStatus = {
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: targets.map(target => ({
+            ...target,
+            status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+          })),
+        },
+      };
+      const typedCall = jest
+        .fn()
+        .mockResolvedValueOnce(finishedStatus)
+        .mockImplementationOnce(() => {
+          expect(method.postProgressMessage).not.toHaveBeenCalled();
+          throw new Error('device was disconnected');
+        })
+        .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.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('uses a real BLE disconnect while writing the Request as install evidence', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -343,49 +433,41 @@ describe('FirmwareUpdateV4 install polling', () => {
         connectId: 'pro2-ble',
       },
     });
-    const targets = [{ target_id: 6, path: 'vol0:/coprocessor.bin' }];
+    const targets = [{ target_id: 3, path: 'vol0:/bootloader.bin' }];
     const finishedStatus = {
       type: 'DeviceFirmwareUpdateStatus',
       message: {
         records: [
           {
-            target_id: 6,
+            ...targets[0],
             status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
-            payload_version: 65_556,
-            path: 'vol0:/coprocessor.bin',
           },
         ],
       },
     };
     const typedCall = jest
       .fn()
+      .mockResolvedValueOnce({ type: 'Success', message: {} })
       .mockResolvedValueOnce(finishedStatus)
-      .mockImplementationOnce(() => {
-        expect(method.postProgressMessage).not.toHaveBeenCalled();
-        throw new Error('device was disconnected');
-      })
       .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 call = jest.fn().mockRejectedValue(ERRORS.TypedError(HardwareErrorCode.BleTimeoutError));
     const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
 
-    (method as any).params = {
-      expectedTargetVersions: { coprocessor: '1.0.20' },
-    };
-
     method.device = {
-      getCommands: () => ({ typedCall }),
+      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
+      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-ble' }),
       setCancelableAction: jest.fn(),
+      clearCancelableAction: jest.fn(),
     } as unknown as Device;
+    method.postMessage = jest.fn();
     method.postProgressMessage = jest.fn();
 
     const firmwareUpdate = method as unknown as {
+      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
       waitForProtocolV2FirmwareUpdateComplete: (
         value: typeof targets,
         requireCurrentInstallStatus: boolean
@@ -395,15 +477,234 @@ describe('FirmwareUpdateV4 install polling', () => {
     firmwareUpdate.reconnectProtocolV2Device = reconnectProtocolV2Device;
     (method as any).isBleReconnect = jest.fn(() => true);
 
+    await firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
     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);
+    expect(typedCall).toHaveBeenCalledTimes(5);
+  }, 10_000);
+
+  test('does not use a Request response timeout as BLE install evidence', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        connectId: 'pro2-ble',
+      },
+    });
+    const targets = [{ target_id: 3, path: 'vol0:/bootloader.bin' }];
+    const finishedStatus = {
+      type: 'DeviceFirmwareUpdateStatus',
+      message: {
+        records: [
+          {
+            ...targets[0],
+            status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+          },
+        ],
+      },
+    };
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Success', message: {} })
+      .mockResolvedValueOnce(finishedStatus)
+      .mockResolvedValueOnce(finishedStatus)
+      .mockResolvedValueOnce(finishedStatus)
+      .mockResolvedValueOnce(finishedStatus)
+      .mockRejectedValueOnce(ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
+    const call = jest
+      .fn()
+      .mockRejectedValue(
+        ERRORS.TypedError(
+          HardwareErrorCode.BleTimeoutError,
+          'device was disconnected after Lowlevel response timeout'
+        )
+      );
+    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+
+    method.device = {
+      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
+      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-ble' }),
+      setCancelableAction: jest.fn(),
+      clearCancelableAction: jest.fn(),
+    } as unknown as Device;
+    method.postMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    const firmwareUpdate = method as unknown as {
+      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
+      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.protocolV2StartFirmwareUpdate({ targets });
+    await expect(
+      firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true)
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.ActionCancelled,
+    });
+
+    expect(reconnectProtocolV2Device).toHaveBeenCalledWith({ skipProtocolProbe: true });
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
   }, 10_000);
 
+  test('records a real BLE disconnect that occurs during install reconnect', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        connectId: 'pro2-ble',
+      },
+    });
+    const targets = [{ target_id: 3, path: 'vol0:/bootloader.bin' }];
+    const finishedStatus = {
+      type: 'DeviceFirmwareUpdateStatus',
+      message: {
+        records: [
+          {
+            ...targets[0],
+            status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+          },
+        ],
+      },
+    };
+    const typedCall = jest
+      .fn()
+      .mockRejectedValueOnce(
+        ERRORS.TypedError(
+          HardwareErrorCode.BleTimeoutError,
+          'Lowlevel response timeout after 15000ms for DeviceFirmwareUpdateStatusGet'
+        )
+      )
+      .mockResolvedValueOnce(finishedStatus)
+      .mockResolvedValueOnce(finishedStatus)
+      .mockResolvedValueOnce(finishedStatus)
+      .mockResolvedValueOnce(finishedStatus);
+    const reconnectProtocolV2Device = jest
+      .fn()
+      .mockRejectedValueOnce(ERRORS.TypedError(HardwareErrorCode.BleTimeoutError))
+      .mockResolvedValueOnce(undefined);
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    method.device = {
+      getCommands: () => ({ typedCall, cancelDevice: jest.fn() }),
+      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);
+
+    try {
+      await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(2);
+    expect(method.postProgressMessage).toHaveBeenNthCalledWith(1, 1, 'installingFirmware');
+    expect(method.postProgressMessage).toHaveBeenNthCalledWith(2, 100, 'installingFirmware');
+  });
+
+  test('does not use a reconnect response timeout as BLE install evidence', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        connectId: 'pro2-ble',
+      },
+    });
+    const targets = [{ target_id: 3, path: 'vol0:/bootloader.bin' }];
+    const finishedStatus = {
+      type: 'DeviceFirmwareUpdateStatus',
+      message: {
+        records: [
+          {
+            ...targets[0],
+            status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+          },
+        ],
+      },
+    };
+    const typedCall = jest
+      .fn()
+      .mockRejectedValueOnce(
+        ERRORS.TypedError(
+          HardwareErrorCode.BleTimeoutError,
+          'Lowlevel response timeout after 15000ms for DeviceFirmwareUpdateStatusGet'
+        )
+      )
+      .mockResolvedValueOnce(finishedStatus)
+      .mockResolvedValueOnce(finishedStatus)
+      .mockResolvedValueOnce(finishedStatus)
+      .mockResolvedValueOnce(finishedStatus)
+      .mockRejectedValueOnce(ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
+    const reconnectProtocolV2Device = jest
+      .fn()
+      .mockRejectedValueOnce(
+        ERRORS.TypedError(
+          HardwareErrorCode.BleTimeoutError,
+          'device was disconnected after Lowlevel response timeout'
+        )
+      )
+      .mockResolvedValueOnce(undefined);
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    method.device = {
+      getCommands: () => ({ typedCall, cancelDevice: jest.fn() }),
+      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);
+
+    try {
+      await expect(
+        firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true)
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.ActionCancelled,
+      });
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(2);
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
+  });
+
   test('rejects stable stale finished BLE status after a status response timeout', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,