@onekeyfe/hd-core 1.2.0-alpha.53 → 1.2.0-alpha.54

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

@@ -1,4 +1,3 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 
 import { initConnector, initCore } from '../src/core';
@@ -96,25 +95,7 @@ describe('public device lifecycle events', () => {
     expect(messages.filter(message => message.type === DEVICE.DISCONNECT)).toHaveLength(1);
   });
 
-  test('uses a verified cached protocol as a strict expected protocol', async () => {
-    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
-    const device = Device.fromDescriptor({
-      id: 'ble-id',
-      path: 'ble-id',
-      commType: 'ble',
-      protocolType: 'V1',
-    } as never);
-    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V1' });
-    device.deviceConnector = { acquire } as never;
-
-    await device.acquire();
-
-    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V1', undefined);
-    expect(device.getProtocol()).toBe('V1');
-    expect(device.originalDescriptor.protocolType).toBe('V1');
-  });
-
-  test('bypasses a cached protocol only for explicit active detection', async () => {
+  test('uses a cached protocol as a fallback-capable acquire hint', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     const device = Device.fromDescriptor({
       id: 'ble-id',
@@ -125,96 +106,13 @@ describe('public device lifecycle events', () => {
     const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
     device.deviceConnector = { acquire } as never;
 
-    await device.acquire(undefined, { forceProtocolDetection: true });
+    await device.acquire();
 
-    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, undefined);
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, 'V1');
     expect(device.getProtocol()).toBe('V2');
     expect(device.originalDescriptor.protocolType).toBe('V2');
   });
 
-  test('does not reuse a stale protocol when active detection returns no protocol', async () => {
-    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
-    const device = Device.fromDescriptor({
-      id: 'ble-id',
-      path: 'ble-id',
-      commType: 'ble',
-      protocolType: 'V1',
-    } as never);
-    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id' });
-    const release = jest.fn().mockResolvedValue(undefined);
-    device.deviceConnector = { acquire, release } as never;
-    await expect(
-      device.acquire(undefined, {
-        forceProtocolDetection: true,
-        throwOnRunPromiseError: true,
-      })
-    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.RuntimeError });
-    expect(device.originalDescriptor.protocolType).toBe('V1');
-    expect(device.hasDeviceAcquire()).toBe(false);
-    expect(release).toHaveBeenCalledWith('ble-id', false);
-  });
-
-  test('actively reacquires an already connected device without initializing it', async () => {
-    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
-    const device = Device.fromDescriptor({
-      id: 'usb-device',
-      path: 'usb-device',
-      session: 'old-session',
-      protocolType: 'V1',
-    } as never);
-    device.mainId = 'old-session';
-    device.commands = { disposed: false } as never;
-    const release = jest.spyOn(device, 'release').mockImplementation(() => {
-      device.mainId = null;
-      device.originalDescriptor.session = null;
-      device.commands.disposed = true;
-      return Promise.resolve();
-    });
-    const acquire = jest.spyOn(device, 'acquire').mockImplementation(() => {
-      device.mainId = 'new-session';
-      device.originalDescriptor.session = 'new-session';
-      device.originalDescriptor.protocolType = 'V2';
-      device.commands.disposed = false;
-      return Promise.resolve();
-    });
-    const initialize = jest.spyOn(device, 'initialize').mockResolvedValue(undefined);
-
-    await device.run(() => Promise.resolve(undefined), {
-      forceProtocolDetection: true,
-      skipInitialize: true,
-    });
-
-    expect(release).toHaveBeenCalled();
-    expect(acquire).toHaveBeenCalledWith(undefined, {
-      forceProtocolDetection: true,
-    });
-    expect(initialize).not.toHaveBeenCalled();
-    expect(device.getProtocol()).toBe('V2');
-  });
-
-  test('keeps the freshly probed React Native BLE session until the call completes', async () => {
-    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
-    const device = Device.fromDescriptor({
-      id: 'ble-device',
-      path: 'ble-device',
-      commType: 'ble',
-      protocolType: 'V1',
-    } as never);
-    device.mainId = 'ble-device';
-    device.commands = { disposed: false } as never;
-    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
-    const release = jest.spyOn(device, 'release').mockResolvedValue(undefined);
-    const run = jest.fn().mockResolvedValue(undefined);
-
-    await device.run(run, {
-      forceProtocolDetection: true,
-      skipInitialize: true,
-    });
-
-    expect(run).toHaveBeenCalledTimes(1);
-    expect(release).toHaveBeenCalledTimes(1);
-  });
-
   test('keeps an explicit connectProtocol as a strict expected protocol', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     const device = Device.fromDescriptor({

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/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',
+    });
+  });
+});