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

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

@@ -1,56 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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',
-    });
-  });
-});