@onekeyfe/hd-core 1.1.34-alpha.3 → 1.1.34-alpha.4

package/__tests__/device-utils.test.ts

@@ -1,106 +0,0 @@
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
-
-import {
-  getDeviceSerialNo,
-  getDeviceType,
-  getDeviceUUID,
-  getFirmwareType,
-} from '../src/utils/deviceInfoUtils';
-import {
-  getDeviceBLEFirmwareVersion,
-  getDeviceBoardloaderVersion,
-  getDeviceBootloaderVersion,
-  getDeviceFirmwareVersion,
-} from '../src/utils/deviceVersionUtils';
-import {
-  buildProtocolV1FeaturesPayload,
-  buildProtocolV2FeaturesPayload,
-} from '../src/deviceProfile';
-
-import type { PROTO } from '../src/constants';
-
-describe('device feature selectors', () => {
-  test('reads legacy Protocol V1 features without exposing the internal builder', () => {
-    const features = {
-      onekey_device_type: 'CLASSIC1S',
-      onekey_serial_no: 'CP123456',
-      fw_vendor: 'OneKey Bitcoin-only',
-      onekey_firmware_version: 'v3.5.0',
-      onekey_boot_version: '2.8.0-alpha.1',
-      onekey_board_version: '1.2.3+board',
-      onekey_ble_version: '1.4.0+ble',
-    } as PROTO.Features;
-
-    expect(getDeviceType(features)).toBe(EDeviceType.Classic1s);
-    expect(getDeviceSerialNo(features)).toBe('CP123456');
-    expect(getFirmwareType(features)).toBe(EFirmwareType.BitcoinOnly);
-    expect(getDeviceFirmwareVersion(features)).toEqual([3, 5, 0]);
-    expect(getDeviceBootloaderVersion(features)).toEqual([2, 8, 0]);
-    expect(getDeviceBoardloaderVersion(features)).toEqual([1, 2, 3]);
-    expect(getDeviceBLEFirmwareVersion(features)).toEqual([1, 4, 0]);
-  });
-
-  test('keeps getDeviceUUID as a compatibility alias', () => {
-    const features = {
-      onekey_serial_no: 'PR123456',
-      fw_vendor: 'OneKey Bitcoin-only',
-      onekey_board_version: '1.2.3',
-      onekey_ble_version: '2.3.4',
-    } as PROTO.Features;
-
-    expect(getDeviceUUID(features)).toBe(getDeviceSerialNo(features));
-  });
-
-  test('uses bootloader version parts from old Protocol V1 firmware', () => {
-    const features = {
-      bootloader_mode: true,
-      major_version: 1,
-      minor_version: 8,
-      patch_version: 3,
-      model: '1',
-    } as PROTO.Features;
-
-    expect(getDeviceType(features)).toBe(EDeviceType.Classic);
-    expect(getDeviceBootloaderVersion(features)).toEqual([1, 8, 3]);
-  });
-
-  test('shares Protocol V1 compatibility semantics with the internal builder', () => {
-    const rawFeatures = {
-      onekey_device_type: 'PRO',
-      onekey_serial_no: 'PR123456',
-      onekey_firmware_version: '4.16.0',
-      onekey_boot_version: '2.8.0',
-      fw_vendor: 'OneKey Bitcoin-only',
-    } as PROTO.Features;
-    const normalized = buildProtocolV1FeaturesPayload(rawFeatures);
-
-    expect(getDeviceType(normalized)).toBe(getDeviceType(rawFeatures));
-    expect(getDeviceSerialNo(normalized)).toBe(getDeviceSerialNo(rawFeatures));
-    expect(getFirmwareType(normalized)).toBe(getFirmwareType(rawFeatures));
-    expect(getDeviceFirmwareVersion(normalized)).toEqual(getDeviceFirmwareVersion(rawFeatures));
-    expect(getDeviceBootloaderVersion(normalized)).toEqual(getDeviceBootloaderVersion(rawFeatures));
-  });
-
-  test('reads normalized Protocol V2 features through the same public selectors', () => {
-    const features = buildProtocolV2FeaturesPayload({
-      deviceInfo: {
-        hw: { serial_no: 'P2-001' },
-        fw: {
-          application: { version: '5.0.0' },
-          bootloader: { version: '2.0.0' },
-          romloader: { version: '1.0.0' },
-        },
-        coprocessor: {
-          application: { version: '3.0.0' },
-        },
-      },
-    });
-
-    expect(getDeviceType(features)).toBe(EDeviceType.Pro2);
-    expect(getDeviceSerialNo(features)).toBe('P2-001');
-    expect(getDeviceFirmwareVersion(features)).toEqual([5, 0, 0]);
-    expect(getDeviceBootloaderVersion(features)).toEqual([2, 0, 0]);
-    expect(getDeviceBoardloaderVersion(features)).toEqual([1, 0, 0]);
-    expect(getDeviceBLEFirmwareVersion(features)).toEqual([3, 0, 0]);
-  });
-});

package/__tests__/device-wallet-session-store.test.ts

@@ -1,191 +0,0 @@
-import ClearSessionCache from '../src/api/ClearSessionCache';
-import {
-  DeviceWalletSessionStore,
-  deviceWalletSessionStore,
-} from '../src/device/DeviceWalletSessionStore';
-import { Device } from '../src/device/Device';
-import { createCoreApi } from '../src/inject';
-
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-describe('DeviceWalletSessionStore', () => {
-  test('requires passphraseState for wallet session lookup', () => {
-    const store = new DeviceWalletSessionStore();
-    store.set('device-1', 'hidden-a', 'session-a');
-
-    expect(store.get('device-1', undefined)).toBeUndefined();
-    expect(store.get('device-1', 'hidden-a')).toBe('session-a');
-  });
-
-  test('isolates wallets and devices', () => {
-    const store = new DeviceWalletSessionStore();
-    store.set('device-1', 'hidden-a', 'session-a');
-    store.set('device-1', 'hidden-b', 'session-b');
-    store.set('device-2', 'hidden-a', 'session-c');
-
-    expect(store.get('device-1', 'hidden-a')).toBe('session-a');
-    expect(store.get('device-1', 'hidden-b')).toBe('session-b');
-    expect(store.get('device-2', 'hidden-a')).toBe('session-c');
-  });
-
-  test('keeps pending sessions unreadable until wallet binding', () => {
-    const store = new DeviceWalletSessionStore();
-    store.setPending('device-1', 'pending-session');
-
-    expect(store.get('device-1', undefined)).toBeUndefined();
-    expect(store.getPending('device-1')).toBe('pending-session');
-  });
-
-  test('migrates descriptor keys to stable device ids', () => {
-    const store = new DeviceWalletSessionStore();
-    store.set('ble-path', 'hidden-a', 'session-a');
-    store.setPending('ble-path', 'pending-session');
-
-    store.migrateDeviceKey('ble-path', 'stable-device-id');
-
-    expect(store.get('ble-path', 'hidden-a')).toBeUndefined();
-    expect(store.get('stable-device-id', 'hidden-a')).toBe('session-a');
-    expect(store.getPending('ble-path')).toBeUndefined();
-    expect(store.getPending('stable-device-id')).toBe('pending-session');
-  });
-
-  test('clears one wallet, one device, or all sessions', () => {
-    const store = new DeviceWalletSessionStore();
-    store.set('device-1', 'hidden-a', 'session-a');
-    store.set('device-1', 'hidden-b', 'session-b');
-    store.set('device-2', 'hidden-a', 'session-c');
-
-    store.delete('device-1', 'hidden-a');
-    expect(store.get('device-1', 'hidden-a')).toBeUndefined();
-    expect(store.get('device-1', 'hidden-b')).toBe('session-b');
-
-    store.deleteDevice('device-1');
-    expect(store.get('device-1', 'hidden-b')).toBeUndefined();
-    expect(store.get('device-2', 'hidden-a')).toBe('session-c');
-
-    store.clear();
-    expect(store.get('device-2', 'hidden-a')).toBeUndefined();
-  });
-});
-
-describe('ClearSessionCache', () => {
-  beforeEach(() => {
-    deviceWalletSessionStore.clear();
-  });
-
-  test('uses DeviceWalletSessionStore as the only cache source', async () => {
-    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
-    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
-
-    const method = new ClearSessionCache({
-      payload: {
-        method: 'clearSessionCache',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-a',
-      },
-    });
-    method.init();
-    await method.run();
-
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
-    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
-  });
-
-  test('keeps legacy Features session fields as projections of the store', async () => {
-    const device = Device.fromDescriptor({ id: 'one', path: 'one' } as never);
-    device.features = {
-      protocol: 'V1',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-a',
-      sessionId: 'session-a',
-      session_id: 'session-a',
-      raw: {
-        protocolV1Features: {
-          sessionId: 'session-a',
-          session_id: 'session-a',
-        },
-      },
-    } as never;
-
-    expect(device.state).not.toHaveProperty('session');
-    expect(device.features).toMatchObject({
-      sessionId: 'session-a',
-      session_id: 'session-a',
-      passphraseState: 'hidden-a',
-    });
-
-    const method = new ClearSessionCache({
-      payload: {
-        method: 'clearSessionCache',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-a',
-      },
-    });
-    method.init();
-    await method.run();
-
-    expect(device.features?.sessionId).toBeNull();
-    expect(device.features?.session_id).toBeNull();
-    expect(device.state?.raw?.protocolV1Features).toMatchObject({
-      sessionId: 'session-a',
-      session_id: 'session-a',
-    });
-  });
-
-  test('clears one wallet without using a device', async () => {
-    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
-    deviceWalletSessionStore.set('device-1', 'hidden-b', 'session-b');
-    const method = new ClearSessionCache({
-      payload: {
-        method: 'clearSessionCache',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-a',
-      },
-    });
-
-    method.init();
-
-    expect(method.useDevice).toBe(false);
-    await expect(method.run()).resolves.toEqual({ cleared: true });
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-b')).toBe('session-b');
-  });
-
-  test('clears one device or the full runtime store', async () => {
-    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
-    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
-
-    const clearDevice = new ClearSessionCache({
-      payload: { method: 'clearSessionCache', deviceId: 'device-1' },
-    });
-    clearDevice.init();
-    await clearDevice.run();
-
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
-    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
-
-    const clearAll = new ClearSessionCache({
-      payload: { method: 'clearSessionCache' },
-    });
-    clearAll.init();
-    await clearAll.run();
-
-    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBeUndefined();
-  });
-
-  test('routes cache clearing through the active CoreApi call channel', async () => {
-    const call = jest.fn().mockResolvedValue({ success: true, payload: { cleared: true } });
-    const api = createCoreApi(call as any);
-
-    await api.clearSessionCache({ deviceId: 'device-1', passphraseState: 'hidden-a' });
-
-    expect(call).toHaveBeenCalledWith({
-      method: 'clearSessionCache',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-a',
-    });
-  });
-});

package/__tests__/filesystemValidation.test.ts

@@ -1,53 +0,0 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import { validateProtocolV2FilesystemPath } from '../src/api/helpers/filesystemValidation';
-
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-describe('validateProtocolV2FilesystemPath', () => {
-  test('兼容并保留设备现有的卷内相对路径格式', () => {
-    expect(validateProtocolV2FilesystemPath('vol1:test.bin', 'path')).toBe('vol1:test.bin');
-  });
-
-  test('目录查询可以使用卷根目录', () => {
-    expect(
-      validateProtocolV2FilesystemPath('VOL1:', 'path', {
-        allowVolumeRoot: true,
-      })
-    ).toBe('vol1:');
-  });
-
-  test.each([
-    'vol1:/../firmware.bin',
-    'vol1:/wallets/./test.bin',
-    'vol1:/wallets//test.bin',
-    'vol1:\\wallets\\test.bin',
-    'vol2:/test.bin',
-    '/test.bin',
-  ])('拒绝不安全或未知范围的路径：%s', path => {
-    expect(() => validateProtocolV2FilesystemPath(path, 'path')).toThrow(
-      expect.objectContaining({
-        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
-      })
-    );
-  });
-
-  test('文件操作不允许使用卷根目录', () => {
-    expect(() => validateProtocolV2FilesystemPath('vol1:', 'path')).toThrow(
-      expect.objectContaining({
-        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
-      })
-    );
-  });
-
-  test('按 UTF-8 字节数拒绝超出设备最小路径缓冲区的路径', () => {
-    expect(() => validateProtocolV2FilesystemPath(`vol1:/${'测'.repeat(41)}`, 'path')).toThrow(
-      expect.objectContaining({
-        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
-      })
-    );
-  });
-});

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-checkpoint.test.ts

@@ -1,105 +0,0 @@
-import { FirmwareCheckpointWriter } from '../../src/api/firmware/FirmwareCheckpoint';
-
-describe('FirmwareCheckpointWriter', () => {
-  it('requires an awaitable sink for prepared firmware execution', () => {
-    expect(() => new FirmwareCheckpointWriter({}, { required: true })).toThrow(
-      'Prepared firmware update requires a checkpoint sink'
-    );
-  });
-
-  it('serializes checkpoints and continues the sequence across SDK calls', async () => {
-    const checkpoints: Array<{ sequence: number; stage: string }> = [];
-    const sink = {
-      commit(checkpoint: { sequence: number; stage: string }) {
-        checkpoints.push(checkpoint);
-        return Promise.resolve();
-      },
-    };
-    const first = new FirmwareCheckpointWriter({
-      checkpointSink: sink,
-      checkpointSequenceStart: 4,
-    });
-    const second = new FirmwareCheckpointWriter({
-      checkpointSink: sink,
-      checkpointSequenceStart: 4,
-    });
-
-    await first.commit({
-      stage: 'BEFORE_DEVICE_MODE_CHANGE',
-      target: 'firmware',
-    });
-    await second.commit({
-      stage: 'FILE_TRANSFER_STARTED',
-      target: 'firmware',
-    });
-
-    expect(checkpoints).toEqual([
-      expect.objectContaining({
-        schemaVersion: 1,
-        sequence: 5,
-        stage: 'BEFORE_DEVICE_MODE_CHANGE',
-        destructiveActionStarted: true,
-      }),
-      expect.objectContaining({
-        schemaVersion: 1,
-        sequence: 6,
-        stage: 'FILE_TRANSFER_STARTED',
-        destructiveActionStarted: true,
-      }),
-    ]);
-  });
-
-  it('fails closed when the sink rejects', async () => {
-    const writer = new FirmwareCheckpointWriter(
-      {
-        checkpointSink: {
-          commit: jest.fn().mockRejectedValue(new Error('disk unavailable')),
-        },
-      },
-      { required: true }
-    );
-
-    await expect(
-      writer.commit({
-        stage: 'BEFORE_DEVICE_MODE_CHANGE',
-      })
-    ).rejects.toMatchObject({
-      params: {
-        firmwareUpdateCode: 'FirmwareCheckpointRejected',
-      },
-    });
-  });
-
-  it('fails closed when a commit does not settle before the deadline', async () => {
-    const timeoutSpy = jest
-      .spyOn(global, 'setTimeout')
-      .mockImplementation((callback: (...args: any[]) => void) => {
-        Promise.resolve().then(callback);
-        return 1 as unknown as ReturnType<typeof setTimeout>;
-      });
-    const writer = new FirmwareCheckpointWriter(
-      {
-        checkpointSink: {
-          commit: () =>
-            new Promise<void>(() => {
-              // The pending promise exercises the checkpoint deadline.
-            }),
-        },
-      },
-      { required: true }
-    );
-
-    const commit = writer.commit({
-      stage: 'FILE_TRANSFER_STARTED',
-      target: 'firmware',
-    });
-    const assertion = expect(commit).rejects.toMatchObject({
-      params: {
-        firmwareUpdateCode: 'FirmwareCheckpointRejected',
-      },
-    });
-
-    await assertion;
-    timeoutSpy.mockRestore();
-  });
-});

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

@@ -1,73 +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()),
-  },
-  checkpointSink: {
-    commit: 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-update-capabilities.test.ts

@@ -1,17 +0,0 @@
-import { getFirmwareUpdateCapabilities } from '../../src/api/firmware/FirmwareUpdateCapabilities';
-
-describe('getFirmwareUpdateCapabilities', () => {
-  it('uses explicit protocol versions for the complete recovery contract', () => {
-    expect(getFirmwareUpdateCapabilities()).toEqual({
-      planSchemaVersion: 1,
-      preparedPlanSchemaVersion: 1,
-      hostBindingProtocolVersion: 1,
-      checkpointSchemaVersion: 1,
-      manifestModes: ['external-only', 'sdk-managed'],
-      supportsArtifactReader: true,
-      supportsAwaitableCheckpoint: true,
-      supportsResume: true,
-      supportsReconciliation: true,
-    });
-  });
-});