@onekeyfe/hd-core 1.2.0-alpha.9 → 1.2.0-alpha.90

package/__tests__/firmware-update/firmware-update-v2-download-before-boot.test.ts

@@ -0,0 +1,457 @@
+import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
+import { getBinary } from '../../src/api/firmware/getBinary';
+import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
+import * as utils from '../../src/utils';
+
+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/getBinary', () => ({
+  getBinary: jest.fn(),
+  getInfo: jest.fn(),
+  getSysResourceBinary: jest.fn(),
+}));
+
+jest.mock('../../src/api/firmware/uploadFirmware', () => ({
+  updateResources: jest.fn(),
+  updateResourcesFromSources: jest.fn(),
+  uploadFirmwareFromSource: jest.fn(),
+}));
+
+jest.mock('../../src/device/DevicePool', () => ({
+  DevicePool: {
+    clearDeviceCache: jest.fn(),
+    devicesCache: {},
+  },
+}));
+
+const mockGetBinary = getBinary as jest.MockedFunction<typeof getBinary>;
+const mockUploadFirmwareFromSource = uploadFirmwareFromSource as jest.MockedFunction<
+  typeof uploadFirmwareFromSource
+>;
+
+type DeviceType = 'CLASSIC1S' | 'PURE';
+
+const createCustomBuffer = (byteLength: number) => {
+  const customBuffer: {
+    [index: number]: number;
+    byteLength: number;
+    constructor: {
+      isBuffer: (value: unknown) => boolean;
+    };
+    length: number;
+  } = {
+    byteLength,
+    constructor: {
+      isBuffer: (value: unknown) => value === customBuffer,
+    },
+    length: byteLength,
+  };
+  for (let index = 0; index < byteLength; index += 1) {
+    customBuffer[index] = index + 1;
+  }
+  return customBuffer;
+};
+
+const countCommandCalls = (typedCall: jest.Mock, command: string) =>
+  typedCall.mock.calls.filter(([calledCommand]) => calledCommand === command).length;
+
+const expectNoFirmwareMutationCalls = (typedCall: jest.Mock) => {
+  expect(countCommandCalls(typedCall, 'DeviceBackToBoot')).toBe(0);
+  expect(countCommandCalls(typedCall, 'FirmwareErase')).toBe(0);
+  expect(countCommandCalls(typedCall, 'FirmwareErase_ex')).toBe(0);
+  expect(countCommandCalls(typedCall, 'FirmwareUpload')).toBe(0);
+  expect(countCommandCalls(typedCall, 'UpgradeFileHeader')).toBe(0);
+};
+
+const createMethod = ({
+  binary,
+  updateType = 'firmware',
+  isUpdateBootloader,
+  deviceType = 'CLASSIC1S',
+  bootloaderMode = false,
+}: {
+  binary?: unknown;
+  updateType?: 'firmware' | 'ble';
+  isUpdateBootloader?: boolean;
+  deviceType?: DeviceType;
+  bootloaderMode?: boolean;
+} = {}) => {
+  const method = new FirmwareUpdateV2({
+    id: 1,
+    payload: {
+      method: 'firmwareUpdateV2',
+      connectId: 'connect-id',
+      deviceId: 'device-id',
+      platform: 'desktop',
+      updateType,
+      isUpdateBootloader,
+      ...(binary !== undefined ? { binary } : { version: [3, 0, 0] }),
+    },
+  });
+  method.init();
+
+  const typedCall = jest.fn().mockResolvedValue({ type: 'Success' });
+  const checkDisposed = jest.fn();
+  const acquire = jest.fn().mockResolvedValue(undefined);
+  const commands = {
+    typedCall,
+    checkDisposed,
+    disposed: false,
+  };
+
+  method.device = {
+    features: {
+      onekey_device_type: deviceType,
+      onekey_serial_no: deviceType === 'PURE' ? 'CP123456' : 'CL123456',
+      bootloader_mode: bootloaderMode,
+      major_version: 3,
+      minor_version: 0,
+      patch_version: 0,
+      capabilities: [],
+    },
+    commands,
+    getCommands: () => commands,
+    getCurrentDeviceType: () =>
+      deviceType === 'PURE' ? EDeviceType.ClassicPure : EDeviceType.Classic1s,
+    getCurrentFirmwareType: () => EFirmwareType.Universal,
+    getCurrentFirmwareVersionString: () => '3.0.0',
+    getCurrentBootloaderVersionString: () => '0.0.0',
+    getCurrentSerialNo: () => (deviceType === 'PURE' ? 'CP123456' : 'CL123456'),
+    isBootloader: () => bootloaderMode,
+    isProtocolV2: () => false,
+    acquire,
+    toMessageObject: jest.fn(() => ({})),
+  } as any;
+  method.postMessage = jest.fn();
+  jest.spyOn(method, 'checkDeviceToBootloader').mockImplementation(() => {
+    method.checkPromise = {
+      promise: Promise.resolve(true),
+    } as any;
+  });
+
+  return {
+    method,
+    typedCall,
+    acquire,
+  };
+};
+
+describe('FirmwareUpdateV2 download-before-reboot safety', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(utils, 'wait').mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('rejects mixed binary and prepared artifact inputs during initialization', () => {
+    const method = new FirmwareUpdateV2({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV2',
+        connectId: 'connect-id',
+        platform: 'desktop',
+        updateType: 'firmware',
+        binary: new ArrayBuffer(4),
+        artifact: {
+          artifactRef: `fw:${'a'.repeat(64)}`,
+          size: 4,
+          sha256: 'a'.repeat(64),
+        },
+        preparedPlan: {},
+        hostBindingGeneration: 1,
+      },
+    });
+
+    expect(() => method.init()).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+        message: 'Firmware update binary and artifact are mutually exclusive',
+      })
+    );
+  });
+
+  it.each([
+    {
+      context: 'Classic 1S normal mode',
+      deviceType: 'CLASSIC1S' as const,
+      bootloaderMode: false,
+    },
+    {
+      context: 'Classic Pure normal mode',
+      deviceType: 'PURE' as const,
+      bootloaderMode: false,
+    },
+    {
+      context: 'initial bootloader mode',
+      deviceType: 'CLASSIC1S' as const,
+      bootloaderMode: true,
+    },
+  ])('blocks all firmware mutation after final download failure in $context', async options => {
+    mockGetBinary.mockRejectedValue(new Error('request failed'));
+    const { method, typedCall, acquire } = createMethod(options);
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
+    });
+
+    expect(mockGetBinary).toHaveBeenCalledTimes(1);
+    expectNoFirmwareMutationCalls(typedCall);
+    expect(acquire).not.toHaveBeenCalled();
+    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+  });
+
+  it('preserves structured preparation errors before any firmware mutation', async () => {
+    const preparationError = ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Firmware must be prepared by the external firmware host',
+      {
+        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+        artifactName: 'firmware',
+      }
+    );
+    mockGetBinary.mockRejectedValue(preparationError);
+    const { method, typedCall, acquire } = createMethod();
+
+    await expect(method.run()).rejects.toBe(preparationError);
+
+    expectNoFirmwareMutationCalls(typedCall);
+    expect(acquire).not.toHaveBeenCalled();
+    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    {
+      mode: 'firmware release.url',
+      updateType: 'firmware' as const,
+      isUpdateBootloader: undefined,
+      deviceType: 'CLASSIC1S' as const,
+      firmwareBinary: new ArrayBuffer(4),
+    },
+    {
+      mode: 'BLE webUpdate',
+      updateType: 'ble' as const,
+      isUpdateBootloader: undefined,
+      deviceType: 'PURE' as const,
+      firmwareBinary: Buffer.from([1, 2, 3, 4]),
+    },
+    {
+      mode: 'bootloaderResource',
+      updateType: 'firmware' as const,
+      isUpdateBootloader: true,
+      deviceType: 'CLASSIC1S' as const,
+      firmwareBinary: new ArrayBuffer(8),
+    },
+  ])(
+    'acquires $mode before rebooting and preserves the response shape',
+    async ({ updateType, isUpdateBootloader, deviceType = 'CLASSIC1S', firmwareBinary }) => {
+      const callOrder: string[] = [];
+      const expectedResponse = {
+        success: true,
+        payload: {
+          firmwareVersion: '3.0.0',
+        },
+      };
+      mockGetBinary.mockImplementation(() => {
+        callOrder.push('download');
+        return Promise.resolve({
+          binary: firmwareBinary,
+        } as Awaited<ReturnType<typeof getBinary>>);
+      });
+      mockUploadFirmwareFromSource.mockImplementation(() => {
+        callOrder.push('upload');
+        return Promise.resolve(
+          expectedResponse as Awaited<ReturnType<typeof uploadFirmwareFromSource>>
+        );
+      });
+      const { method, typedCall } = createMethod({
+        updateType,
+        isUpdateBootloader,
+        deviceType,
+      });
+      typedCall.mockImplementation(type => {
+        if (type === 'DeviceBackToBoot') {
+          callOrder.push('reboot');
+        }
+        return Promise.resolve({ type: 'Success' });
+      });
+
+      await expect(method.run()).resolves.toBe(expectedResponse);
+
+      expect(callOrder).toEqual(['download', 'reboot', 'upload']);
+      expect(mockGetBinary).toHaveBeenCalledWith(
+        expect.objectContaining({
+          updateType,
+          isUpdateBootloader,
+          requestOptions: {
+            connectTimeoutMs: 60_000,
+            readTimeoutMs: 60_000,
+            overallTimeoutMs: 180_000,
+            maxRetries: 2,
+            retryDelayMs: 500,
+          },
+        })
+      );
+      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+        updateType,
+        expect.any(Function),
+        expect.any(Function),
+        method.device,
+        expect.objectContaining({
+          size: firmwareBinary.byteLength,
+        }),
+        true,
+        isUpdateBootloader
+      );
+    }
+  );
+
+  it('downloads before acquiring and uploading when the device starts in bootloader mode', async () => {
+    const callOrder: string[] = [];
+    const firmwareBinary = new ArrayBuffer(4);
+    mockGetBinary.mockImplementation(() => {
+      callOrder.push('download');
+      return Promise.resolve({
+        binary: firmwareBinary,
+      } as Awaited<ReturnType<typeof getBinary>>);
+    });
+    mockUploadFirmwareFromSource.mockImplementation(() => {
+      callOrder.push('upload');
+      return Promise.resolve({
+        success: true,
+      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+    });
+    const { method, typedCall, acquire } = createMethod({
+      bootloaderMode: true,
+    });
+    acquire.mockImplementation(() => {
+      callOrder.push('acquire');
+      return Promise.resolve();
+    });
+
+    await method.run();
+
+    expect(callOrder).toEqual(['download', 'acquire', 'upload']);
+    expect(countCommandCalls(typedCall, 'DeviceBackToBoot')).toBe(0);
+  });
+
+  it('does not reboot while the firmware download is pending', async () => {
+    let resolveDownload!: (result: Awaited<ReturnType<typeof getBinary>>) => void;
+    const firmwareBinary = new ArrayBuffer(4);
+    mockGetBinary.mockImplementation(
+      () =>
+        new Promise(resolve => {
+          resolveDownload = resolve;
+        })
+    );
+    mockUploadFirmwareFromSource.mockResolvedValue({
+      success: true,
+    } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+    const { method, typedCall } = createMethod();
+
+    const runPromise = method.run();
+
+    expect(mockGetBinary).toHaveBeenCalledTimes(1);
+    expect(countCommandCalls(typedCall, 'DeviceBackToBoot')).toBe(0);
+
+    resolveDownload({
+      binary: firmwareBinary,
+    } as Awaited<ReturnType<typeof getBinary>>);
+    await runPromise;
+
+    expect(countCommandCalls(typedCall, 'DeviceBackToBoot')).toBe(1);
+  });
+
+  it.each([
+    ['ArrayBuffer', new ArrayBuffer(0)],
+    ['Buffer', Buffer.alloc(0)],
+  ])('does not reboot or upload an empty downloaded %s', async (_kind, firmwareBinary) => {
+    mockGetBinary.mockResolvedValue({
+      binary: firmwareBinary,
+    } as Awaited<ReturnType<typeof getBinary>>);
+    const { method, typedCall, acquire } = createMethod();
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
+    });
+
+    expectNoFirmwareMutationCalls(typedCall);
+    expect(acquire).not.toHaveBeenCalled();
+    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ['ArrayBuffer', new ArrayBuffer(4)],
+    ['Buffer', Buffer.from([1, 2, 3, 4])],
+  ])(
+    'keeps the non-empty %s binary overload and never downloads it again',
+    async (_kind, binary) => {
+      mockUploadFirmwareFromSource.mockResolvedValue({
+        success: true,
+      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+      const { method } = createMethod({ binary });
+
+      await method.run();
+
+      expect(mockGetBinary).not.toHaveBeenCalled();
+      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+        'firmware',
+        expect.any(Function),
+        expect.any(Function),
+        method.device,
+        expect.objectContaining({
+          size: binary.byteLength,
+        }),
+        true,
+        undefined
+      );
+    }
+  );
+
+  it.each([
+    ['Uint8Array subview', new Uint8Array([9, 1, 2, 9]).subarray(1, 3), [1, 2]],
+    ['DataView', new DataView(new Uint8Array([9, 3, 4, 9]).buffer, 1, 2), [3, 4]],
+    ['custom Buffer', createCustomBuffer(4), [1, 2, 3, 4]],
+  ])('normalizes a non-empty %s before rebooting', async (_kind, binary, expectedBytes) => {
+    let uploadedBytes: number[] = [];
+    mockUploadFirmwareFromSource.mockImplementation(
+      async (_updateType, _typedCall, _postMessage, _device, source) => {
+        uploadedBytes = Array.from(new Uint8Array(await source.readAt(0, source.size)));
+        return {
+          success: true,
+        } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>;
+      }
+    );
+    const { method } = createMethod({ binary });
+
+    await method.run();
+
+    expect(mockGetBinary).not.toHaveBeenCalled();
+    expect(uploadedBytes).toEqual(expectedBytes);
+  });
+
+  it.each([
+    ['ArrayBuffer', new ArrayBuffer(0)],
+    ['Buffer', Buffer.alloc(0)],
+    ['ArrayBufferView', new Uint8Array(0)],
+    ['custom Buffer', createCustomBuffer(0)],
+  ])('rejects an empty supplied %s before rebooting', async (_kind, binary) => {
+    const { method, typedCall, acquire } = createMethod({ binary });
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
+    });
+
+    expect(mockGetBinary).not.toHaveBeenCalled();
+    expectNoFirmwareMutationCalls(typedCall);
+    expect(acquire).not.toHaveBeenCalled();
+    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+  });
+});

package/__tests__/firmware-update/firmware-update-v3-reconnect.test.ts

@@ -0,0 +1,121 @@
+import * as hdShared from '@onekeyfe/hd-shared';
+
+import FirmwareUpdateV3 from '../../src/api/FirmwareUpdateV3';
+import { DevicePool } from '../../src/device/DevicePool';
+
+import type { Device } from '../../src/device/Device';
+
+jest.mock('../../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('FirmwareUpdateV3 reconnect', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('keeps transient USB acquire failures inside the reconnect loop', async () => {
+    const acquire = jest.fn().mockResolvedValue(undefined);
+    const commands = {
+      disposed: true,
+      mainId: '',
+    };
+    const cachedDevice = {} as Device;
+    const updateFromCache = jest.fn();
+    jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
+      devices: {},
+      deviceList: [cachedDevice],
+    });
+
+    const method = new FirmwareUpdateV3({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV3',
+        connectId: 'usb-path',
+      },
+    });
+    method.isBleReconnect = jest.fn(() => false);
+    method.device = {
+      originalDescriptor: {
+        id: 'usb-path',
+        path: 'usb-path',
+        protocolType: 'V1',
+      },
+      deviceConnector: {
+        enumerate: jest.fn().mockResolvedValue({
+          descriptors: [{ path: 'usb-path' }],
+        }),
+      },
+      updateFromCache,
+      acquire,
+      commands,
+      getCommands: () => commands,
+      mainId: 'usb-session',
+    } as unknown as Device;
+
+    await method.waitForDeviceReconnect(1000);
+
+    expect(updateFromCache).toHaveBeenCalledWith(cachedDevice);
+    expect(acquire).toHaveBeenCalledWith(undefined, {
+      throwOnRunPromiseError: true,
+    });
+    expect(commands.disposed).toBe(false);
+    expect(commands.mainId).toBe('usb-session');
+  });
+
+  it('uses the BLE reconnect budget for a prepared BLE artifact', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    jest.spyOn(hdShared, 'wait').mockResolvedValue(undefined);
+    const method = new FirmwareUpdateV3({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV3',
+        connectId: 'ble-device',
+      },
+    });
+    const reconnectError = new Error('stop after reconnect budget assertion');
+    const waitForDeviceReconnect = jest
+      .spyOn(method, 'waitForDeviceReconnect')
+      .mockRejectedValue(reconnectError);
+    method.isBleReconnect = jest.fn(() => true);
+    method.params = {
+      platform: 'native',
+      artifacts: {
+        ble: {
+          artifactRef: `fw:${'a'.repeat(64)}`,
+          size: 4,
+          sha256: 'a'.repeat(64),
+        },
+      },
+    } as any;
+    const commands = {
+      typedCall: jest.fn().mockRejectedValue(new Error('device rebooting')),
+    };
+    method.device = {
+      features: {},
+      getCommands: () => commands,
+    } as unknown as Device;
+    (method as any).createUpdatesFolderIfNotExists = jest.fn().mockResolvedValue(undefined);
+    (method as any).startEmmcFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
+    method.postTipMessage = jest.fn();
+    method.postProcessingMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await expect(
+        (method as any).executeUpdate({
+          resourceBinary: null,
+          resourceEntries: [],
+          fwSources: [],
+          bootloaderSource: null,
+        })
+      ).rejects.toBe(reconnectError);
+
+      expect(waitForDeviceReconnect).toHaveBeenCalledWith(3 * 60 * 1000);
+    } finally {
+      jest.clearAllTimers();
+      jest.useRealTimers();
+    }
+  });
+});

package/__tests__/firmware-update/firmware-upload-source.test.ts

@@ -0,0 +1,70 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
+
+import type { Device } from '../../src/device/Device';
+import type { FirmwareByteSource } from '../../src/api/firmware/FirmwareArtifactSource';
+
+jest.mock('../../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('uploadFirmwareFromSource', () => {
+  it('serves legacy Touch firmware requests without materializing the complete artifact', async () => {
+    const size = 700 * 1024;
+    const requestedRanges: Array<{ offset: number; length: number }> = [];
+    const source: FirmwareByteSource = {
+      size,
+      readAt: jest.fn((offset: number, length: number) => {
+        requestedRanges.push({ offset, length });
+        return Promise.resolve(new ArrayBuffer(length));
+      }),
+      close: jest.fn(() => Promise.resolve()),
+    };
+    let nextOffset = 0;
+    const requestedLength = 128 * 1024;
+    const typedCall = jest.fn((type: string) => {
+      if (type === 'FirmwareErase') {
+        return Promise.resolve({
+          type: 'FirmwareRequest',
+          message: {
+            offset: nextOffset,
+            length: Math.min(requestedLength, size - nextOffset),
+          },
+        });
+      }
+      if (type === 'FirmwareUpload') {
+        nextOffset += Math.min(requestedLength, size - nextOffset);
+        if (nextOffset < size) {
+          return Promise.resolve({
+            type: 'FirmwareRequest',
+            message: {
+              offset: nextOffset,
+              length: Math.min(requestedLength, size - nextOffset),
+            },
+          });
+        }
+        return Promise.resolve({
+          type: 'Success',
+          message: { message: 'installed' },
+        });
+      }
+      return Promise.reject(new Error(`Unexpected command: ${type}`));
+    });
+    const device = {
+      features: undefined,
+      emit: jest.fn(),
+      getCurrentDeviceType: () => EDeviceType.Touch,
+      toMessageObject: () => ({}),
+    } as unknown as Device;
+
+    await expect(
+      uploadFirmwareFromSource('firmware', typedCall as never, jest.fn(), device, source)
+    ).resolves.toEqual({ message: 'installed' });
+
+    expect(requestedRanges).toHaveLength(Math.ceil(size / requestedLength));
+    expect(requestedRanges.every(({ length }) => length <= 256 * 1024)).toBe(true);
+    expect(requestedRanges.some(({ length }) => length === size)).toBe(false);
+  });
+});