@onekeyfe/hd-core 1.2.0-alpha.75 → 1.2.0-alpha.77

package/__tests__/connectSettings.test.ts

@@ -1,19 +1,59 @@
+import DataManager from '../src/data-manager/DataManager';
 import { parseConnectSettings } from '../src/data-manager/connectSettings';
 
+import type { RemoteConfigResponse } from '../src/types';
+
+jest.mock('axios', () => ({
+  get: jest.fn(),
+}));
+
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
+const mockAxiosGet: jest.Mock = jest.requireMock('axios').get;
+
 describe('parseConnectSettings', () => {
-  it('keeps custom configFetcher in parsed settings', () => {
-    const configFetcher = jest.fn();
+  const preloadedConfig = {
+    bridge: {},
+    classic: { firmware: [], ble: [] },
+    classic1s: { firmware: [], ble: [] },
+    classicpure: { firmware: [], ble: [] },
+    mini: { firmware: [], ble: [] },
+    touch: { firmware: [], ble: [] },
+    pro: { firmware: [], ble: [] },
+    pro2: { firmware: [], ble: [] },
+  } as unknown as RemoteConfigResponse;
+
+  it('keeps a serializable preloaded config in parsed settings', () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    expect(settings.firmwareManifestMode).toBe('sdk-managed');
+    expect(settings.preloadedConfig).toBe(preloadedConfig);
+  });
+
+  it('uses the preloaded config before the SDK network client', async () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    await DataManager.load(settings);
+
+    expect(mockAxiosGet).not.toHaveBeenCalled();
+    expect(DataManager.deviceMap.classic).toEqual({ firmware: [], ble: [] });
+  });
 
+  it('keeps the SDK offline and available without an external manifest snapshot', async () => {
     const settings = parseConnectSettings({
-      fetchConfig: true,
-      configFetcher,
+      firmwareManifestMode: 'external-only',
     });
 
-    expect(settings.configFetcher).toBe(configFetcher);
+    await expect(DataManager.load(settings)).resolves.toBe(false);
+    expect(mockAxiosGet).not.toHaveBeenCalled();
   });
 });

package/__tests__/device-initialize-timeout.test.ts

@@ -0,0 +1,56 @@
+import { Device } from '../src/device/Device';
+import TransportManager from '../src/data-manager/TransportManager';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+function buildV1Device() {
+  const device = Object.create(Device.prototype) as Device;
+  const typedCall = jest.fn(() => Promise.resolve({ message: { device_id: 'device' } }));
+  Object.assign(device, {
+    commands: { typedCall },
+    stateStore: { getState: () => undefined },
+    isProtocolV2: () => false,
+    _updateFeatures: jest.fn(),
+    getInternalState: jest.fn(() => undefined),
+  });
+  return { device, typedCall };
+}
+
+describe('Device.initialize Protocol V1 timeout', () => {
+  beforeEach(() => {
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('passes a custom Initialize timeout through to typedCall', async () => {
+    const { device, typedCall } = buildV1Device();
+
+    await device.initialize({ timeoutMs: 2500 });
+
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      expect.objectContaining({ is_contains_attach: true }),
+      { timeoutMs: 2500 }
+    );
+  });
+
+  test('keeps the 25s Initialize timeout by default', async () => {
+    const { device, typedCall } = buildV1Device();
+
+    await device.initialize();
+
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      expect.objectContaining({ is_contains_attach: true }),
+      { timeoutMs: 25 * 1000 }
+    );
+  });
+});

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

@@ -0,0 +1,175 @@
+import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } 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(),
+  validateFirmwareUpdatePlanForceTargets: jest.fn(value => value ?? []),
+}));
+
+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
+>;
+
+const noUpdate = {
+  status: 'valid' as const,
+  release: undefined,
+};
+
+const createMethod = (serialNo = 'device-id') => {
+  const method = new CheckAllFirmwareRelease({
+    id: 1,
+    payload: {
+      method: 'checkAllFirmwareRelease',
+      platform: 'native',
+    },
+  });
+  method.init();
+  method.device = {
+    isProtocolV2: jest.fn(() => false),
+    features: {
+      deviceType: EDeviceType.Classic1s,
+      serialNo,
+      firmwareType: EFirmwareType.Universal,
+      firmwareVersion: '1.0.0',
+      bootloaderVersion: '1.0.0',
+    },
+  } as typeof method.device;
+  return method;
+};
+
+const createMethodWithForceTargets = () => {
+  const method = createMethod();
+  method.payload = {
+    ...method.payload,
+    forceUpdateTargets: ['firmware', 'resource'],
+  };
+  return method;
+};
+
+describe('CheckAllFirmwareRelease', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockGetFirmwareReleaseInfo.mockReturnValue(noUpdate);
+    mockGetBootloaderReleaseInfo.mockReturnValue(noUpdate);
+    mockGetBleFirmwareReleaseInfo.mockReturnValue(noUpdate);
+  });
+
+  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],
+      },
+    };
+    mockGetFirmwareReleaseInfo.mockReturnValue(firmware);
+    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Plan cannot be built', {
+        firmwareUpdateCode: 'FirmwarePlanInvalid',
+      });
+    });
+
+    await expect(createMethod('').run()).resolves.toEqual(
+      expect.objectContaining({
+        firmware,
+        bootloader: noUpdate,
+        ble: noUpdate,
+        firmwareUpdatePlan: undefined,
+      })
+    );
+  });
+
+  test('returns an optional Plan when the builder succeeds', async () => {
+    const plan = {
+      schemaVersion: 2 as const,
+      planDigest: 'a'.repeat(64),
+      executor: 'v3' as const,
+      deviceIdentity: 'device-id',
+      deviceModel: EDeviceType.Classic1s,
+      firmwareType: EFirmwareType.Universal,
+      platform: 'native' as const,
+      artifacts: [],
+      targetsToUpdate: [],
+    };
+    mockBuildFirmwareUpdatePlan.mockReturnValue(plan);
+
+    await expect(createMethod().run()).resolves.toEqual(
+      expect.objectContaining({
+        firmwareUpdatePlan: plan,
+      })
+    );
+  });
+
+  test('passes host-selected update targets to the Plan builder', async () => {
+    mockBuildFirmwareUpdatePlan.mockReturnValue({
+      schemaVersion: 2,
+      planDigest: 'a'.repeat(64),
+      executor: 'v2',
+      deviceIdentity: 'device-id',
+      deviceModel: EDeviceType.Classic1s,
+      firmwareType: EFirmwareType.Universal,
+      platform: 'native',
+      artifacts: [],
+      targetsToUpdate: [],
+    });
+
+    await createMethodWithForceTargets().run();
+
+    expect(mockBuildFirmwareUpdatePlan).toHaveBeenCalledWith(
+      expect.objectContaining({
+        forceUpdateTargets: ['firmware', 'resource'],
+      })
+    );
+  });
+
+  test('does not hide a Plan failure for an explicitly forced target', async () => {
+    const planError = ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Forced firmware target is unavailable',
+      {
+        firmwareUpdateCode: 'FirmwarePlanInvalid',
+      }
+    );
+    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
+      throw planError;
+    });
+
+    await expect(createMethodWithForceTargets().run()).rejects.toBe(planError);
+  });
+
+  test('does not hide unexpected Plan builder failures', async () => {
+    const unexpectedError = new Error('unexpected builder failure');
+    mockBuildFirmwareUpdatePlan.mockImplementation(() => {
+      throw unexpectedError;
+    });
+
+    await expect(createMethod().run()).rejects.toBe(unexpectedError);
+  });
+});

package/__tests__/firmware-update/device-update-bootloader.test.ts

@@ -0,0 +1,87 @@
+import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import DeviceUpdateBootloader from '../../src/api/device/DeviceUpdateBootloader';
+import {
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from '../../src/api/firmware/FirmwareHostBinding';
+
+jest.mock('../../src/api/firmware/FirmwareUpdatePreparedPlan', () => ({
+  assertFirmwareUpdatePreparedPlanBinding: jest.fn(),
+  assertFirmwareUpdatePreparedPlanDeviceIdentity: jest.fn(),
+}));
+
+jest.mock('../../src/data-manager', () => ({
+  DataManager: {
+    getSettings: jest.fn(),
+    isBleConnect: jest.fn(),
+  },
+}));
+
+jest.mock('../../src/device/DevicePool', () => ({
+  DevicePool: {},
+}));
+
+const artifact = {
+  artifactRef: `fw:${'a'.repeat(64)}`,
+  size: 4,
+  sha256: 'a'.repeat(64),
+};
+
+const createMethod = () => {
+  const closeError = new Error('artifact reader close failed');
+  const close = jest.fn().mockRejectedValue(closeError);
+  const artifactReader = {
+    open: jest.fn().mockResolvedValue({ readerId: 'reader-1', size: artifact.size }),
+    read: jest.fn(),
+    close,
+  };
+  const hostBindingGeneration = registerFirmwareUpdateHostBinding({ artifactReader });
+  const method = new DeviceUpdateBootloader({
+    id: 1,
+    payload: {
+      method: 'deviceUpdateBootloader',
+      artifact,
+      hostBindingGeneration,
+      preparedPlan: {},
+    },
+  });
+  (method as any).device = {
+    features: {
+      deviceType: EDeviceType.Touch,
+      serialNo: 'touch-device-id',
+    },
+    getCurrentDeviceType: () => EDeviceType.Touch,
+    getCurrentFirmwareType: () => EFirmwareType.Universal,
+  };
+  return { close, closeError, method };
+};
+
+describe('DeviceUpdateBootloader artifact source cleanup', () => {
+  afterEach(() => {
+    unregisterFirmwareUpdateHostBinding();
+    jest.restoreAllMocks();
+  });
+
+  test('does not replace a successful update result when source close fails', async () => {
+    const { close, method } = createMethod();
+    jest.spyOn(method, 'updateTouchBootloader').mockResolvedValue(true);
+
+    await expect(method.run()).resolves.toBe(true);
+
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+  });
+
+  test('does not replace the original hardware error when source close fails', async () => {
+    const { close, method } = createMethod();
+    const hardwareError = ERRORS.TypedError(
+      HardwareErrorCode.FirmwareError,
+      'original bootloader hardware error'
+    );
+    jest.spyOn(method, 'updateTouchBootloader').mockRejectedValue(hardwareError);
+
+    await expect(method.run()).rejects.toBe(hardwareError);
+
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+  });
+});

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

@@ -0,0 +1,119 @@
+import {
+  MAX_FIRMWARE_ARTIFACT_READ_BYTES,
+  openFirmwareByteSource,
+  writeFirmwareByteSource,
+} from '../../src/api/firmware/FirmwareArtifactSource';
+
+import type { FirmwareArtifactReader } from '../../src/types/api/firmwareUpdate';
+
+const artifact = {
+  artifactRef: `fw:${'a'.repeat(64)}`,
+  size: 6,
+  sha256: 'b'.repeat(64),
+};
+
+const createReader = () => {
+  const open = jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: artifact.size }));
+  const read = jest.fn(({ offset, length }: { readerId: string; offset: number; length: number }) =>
+    Promise.resolve({
+      data: Uint8Array.from([1, 2, 3, 4, 5, 6]).slice(offset, offset + length).buffer,
+      bytesRead: length,
+      eof: offset + length === artifact.size,
+    })
+  );
+  const close = jest.fn(() => Promise.resolve());
+  const reader: FirmwareArtifactReader = { open, read, close };
+  return { reader, open, read, close };
+};
+
+describe('FirmwareArtifactSource', () => {
+  it('reads an opaque artifact through bounded sequential reads', async () => {
+    const { reader, close } = createReader();
+    const source = await openFirmwareByteSource({ artifact, reader });
+    if (!source) {
+      throw new Error('Expected a firmware byte source');
+    }
+
+    const writes: Array<{ offset: number; data: number[] }> = [];
+    await writeFirmwareByteSource({
+      source,
+      chunkSize: 4,
+      write: ({ data, sourceOffset, length }) => {
+        writes.push({
+          offset: sourceOffset,
+          data: Array.from(new Uint8Array(data)),
+        });
+        return Promise.resolve(length);
+      },
+    });
+    await source.close();
+
+    expect(writes).toEqual([
+      { offset: 0, data: [1, 2, 3, 4] },
+      { offset: 4, data: [5, 6] },
+    ]);
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+  });
+
+  it('rejects a reader whose opened size differs from the receipt', async () => {
+    const { reader, open, close } = createReader();
+    open.mockResolvedValue({
+      readerId: 'reader-1',
+      size: artifact.size + 1,
+    });
+
+    await expect(openFirmwareByteSource({ artifact, reader })).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+      },
+    });
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+  });
+
+  it('rejects paths and over-limit reads before invoking the host', async () => {
+    const { reader, read } = createReader();
+    await expect(
+      openFirmwareByteSource({
+        artifact: { ...artifact, artifactRef: '/tmp/firmware.bin' },
+        reader,
+      })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+      },
+    });
+
+    const source = await openFirmwareByteSource({ artifact, reader });
+    if (!source) {
+      throw new Error('Expected a firmware byte source');
+    }
+    await expect(
+      writeFirmwareByteSource({
+        source,
+        chunkSize: MAX_FIRMWARE_ARTIFACT_READ_BYTES + 1,
+        write: ({ length }) => Promise.resolve(length),
+      })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReadTooLarge',
+      },
+    });
+    expect(read).not.toHaveBeenCalled();
+    await source.close();
+  });
+
+  it('closes stale readers when open returns invalid metadata', async () => {
+    const { reader, open, close } = createReader();
+    open.mockResolvedValue({
+      readerId: '',
+      size: artifact.size,
+    });
+
+    await expect(openFirmwareByteSource({ artifact, reader })).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+      },
+    });
+    expect(close).not.toHaveBeenCalled();
+  });
+});

package/__tests__/firmware-update/firmware-host-binding.test.ts

@@ -0,0 +1,70 @@
+import {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  resolveFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from '../../src/api/firmware/FirmwareHostBinding';
+
+const createBinding = () => ({
+  artifactReader: {
+    open: jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: 4 })),
+    read: jest.fn(() =>
+      Promise.resolve({
+        data: new ArrayBuffer(4),
+        bytesRead: 4,
+        eof: true,
+      })
+    ),
+    close: jest.fn(() => Promise.resolve()),
+  },
+});
+
+describe('firmware host binding generation', () => {
+  afterEach(() => {
+    unregisterFirmwareUpdateHostBinding();
+  });
+
+  test('invalidates callbacks from a replaced generation', async () => {
+    const staleBinding = createBinding();
+    const staleGeneration = registerFirmwareUpdateHostBinding(staleBinding);
+    const stale = resolveFirmwareUpdateHostBinding(staleGeneration);
+    const activeGeneration = registerFirmwareUpdateHostBinding(createBinding());
+
+    expect(activeGeneration).toBeGreaterThan(staleGeneration);
+    expect(getFirmwareUpdateHostBindingGeneration()).toBe(activeGeneration);
+    await expect(
+      stale.artifactReader.read({
+        readerId: 'reader-1',
+        offset: 0,
+        length: 4,
+      })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
+      },
+    });
+    expect(unregisterFirmwareUpdateHostBinding(staleGeneration)).toBe(false);
+    expect(getFirmwareUpdateHostBindingGeneration()).toBe(activeGeneration);
+  });
+
+  test('closes an artifact opened during a generation race', async () => {
+    const binding = createBinding();
+    binding.artifactReader.open.mockImplementationOnce(() => {
+      registerFirmwareUpdateHostBinding(createBinding());
+      return Promise.resolve({ readerId: 'stale-reader', size: 4 });
+    });
+    const generation = registerFirmwareUpdateHostBinding(binding);
+    const guarded = resolveFirmwareUpdateHostBinding(generation);
+
+    await expect(
+      guarded.artifactReader.open({ artifactRef: `fw:${'a'.repeat(64)}` })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
+      },
+    });
+    expect(binding.artifactReader.close).toHaveBeenCalledWith({
+      readerId: 'stale-reader',
+    });
+  });
+});

package/__tests__/firmware-update/firmware-preparation-error.test.ts

@@ -0,0 +1,27 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { normalizeFirmwarePreparationError } from '../../src/api/firmware/FirmwarePreparationError';
+
+describe('normalizeFirmwarePreparationError', () => {
+  test('preserves structured firmware invariant errors', () => {
+    const error = ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Firmware must be prepared by the external firmware host',
+      {
+        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+        artifactName: 'firmware',
+      }
+    );
+
+    expect(normalizeFirmwarePreparationError(error)).toBe(error);
+  });
+
+  test('wraps ordinary preparation failures as firmware download errors', () => {
+    const error = normalizeFirmwarePreparationError(new Error('request failed'));
+
+    expect(error).toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
+      message: 'request failed',
+    });
+  });
+});