@onekeyfe/hd-core 1.2.0-alpha.17 → 1.2.0-alpha.171

package/__tests__/evmSignTypedData.test.ts

@@ -497,3 +497,83 @@ describe('EVMSignTypedData — hasClassicFamilyTypedDataFormatViolations', () =>
     });
   });
 });
+
+describe('EVMSignTypedData — OneKey Pro Safe Protocol V1', () => {
+  it('收到 Pro 的 Safe 请求后按 EthereumGnosisSafeTxAck 字段回传', async () => {
+    const data = {
+      types: {
+        EIP712Domain: [
+          { name: 'chainId', type: 'uint256' },
+          { name: 'verifyingContract', type: 'address' },
+        ],
+        SafeTx: [
+          { name: 'to', type: 'address' },
+          { name: 'value', type: 'uint256' },
+          { name: 'data', type: 'bytes' },
+          { name: 'operation', type: 'uint8' },
+          { name: 'safeTxGas', type: 'uint256' },
+          { name: 'baseGas', type: 'uint256' },
+          { name: 'gasPrice', type: 'uint256' },
+          { name: 'gasToken', type: 'address' },
+          { name: 'refundReceiver', type: 'address' },
+          { name: 'nonce', type: 'uint256' },
+        ],
+      },
+      primaryType: 'SafeTx',
+      domain: {
+        chainId: '0x89',
+        verifyingContract: '0x673f21761c5400531a37554a602fe0407addd0dd',
+      },
+      message: {
+        to: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+        value: '1000',
+        data: '0x001234',
+        operation: '1',
+        safeTxGas: '256',
+        baseGas: '0',
+        gasPrice: '15',
+        gasToken: '0x0000000000000000000000000000000000000000',
+        refundReceiver: '0x0000000000000000000000000000000000000000',
+        nonce: '2',
+      },
+    } as EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>;
+    const method = createMethod(data);
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'EthereumTypedDataSignatureOneKey',
+      message: {
+        address: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+        signature: 'abcd',
+      },
+    });
+
+    const result = await method.handleSignTypedData({
+      typedCall: typedCall as any,
+      signData: data,
+      response: { type: 'EthereumGnosisSafeTxRequest', message: {} } as any,
+      supportTrezor: false,
+    });
+
+    expect(typedCall).toHaveBeenCalledWith(
+      'EthereumGnosisSafeTxAck',
+      ['EthereumTypedDataSignature', 'EthereumTypedDataSignatureOneKey'],
+      {
+        to: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+        value: '03e8',
+        data: '1234',
+        operation: 1,
+        safeTxGas: '0100',
+        baseGas: '00',
+        gasPrice: '0f',
+        gasToken: '0x0000000000000000000000000000000000000000',
+        refundReceiver: '0x0000000000000000000000000000000000000000',
+        nonce: '02',
+        chain_id: 137,
+        verifyingContract: '0x673f21761c5400531a37554a602fe0407addd0dd',
+      }
+    );
+    expect(result).toEqual({
+      address: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+      signature: 'abcd',
+    });
+  });
+});

package/__tests__/filesystemValidation.test.ts

@@ -0,0 +1,53 @@
+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/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,109 @@
+import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+
+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(),
+  clearFirmwareUpdatePreparedPlanDeviceIdentityPin: jest.fn(),
+  getFirmwareUpdatePreparedRawArtifact: jest.fn(
+    ({ preparedPlan }: { preparedPlan: { artifacts: unknown[] } }) => preparedPlan.artifacts[0]
+  ),
+  validateFirmwareUpdatePreparedPlan: jest.fn((preparedPlan: unknown) => preparedPlan),
+}));
+
+jest.mock('../../src/data-manager', () => ({
+  DataManager: {
+    getSettings: jest.fn(),
+    isBleConnect: jest.fn(),
+  },
+}));
+
+jest.mock('../../src/device/DevicePool', () => ({
+  DevicePool: {},
+}));
+
+const artifactBytes = Uint8Array.from([1, 2, 3, 4]);
+const artifact = {
+  artifactRef: `fw:${'a'.repeat(64)}`,
+  size: artifactBytes.byteLength,
+  sha256: bytesToHex(sha256(artifactBytes)),
+};
+
+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(({ offset, length }: { offset: number; length: number }) => {
+      const data = artifactBytes.slice(offset, offset + length).buffer;
+      return Promise.resolve({
+        data,
+        bytesRead: data.byteLength,
+        eof: offset + length === artifactBytes.byteLength,
+      });
+    }),
+    close,
+  };
+  const hostBindingGeneration = registerFirmwareUpdateHostBinding({
+    artifactReader,
+    preparedPlanDigest: 'a'.repeat(64),
+  });
+  const method = new DeviceUpdateBootloader({
+    id: 1,
+    payload: {
+      method: 'deviceUpdateBootloader',
+      artifact,
+      hostBindingGeneration,
+      preparedPlan: {
+        preparedPlanDigest: 'a'.repeat(64),
+        firmwareType: EFirmwareType.Universal,
+        artifacts: [{ artifact }],
+      },
+    },
+  });
+  (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,171 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+
+import {
+  MAX_FIRMWARE_ARTIFACT_READ_BYTES,
+  openFirmwareByteSource,
+  writeFirmwareByteSource,
+} from '../../src/api/firmware/FirmwareArtifactSource';
+
+import type { FirmwareArtifactReader } from '../../src/types/api/firmwareUpdate';
+
+const artifactBytes = Uint8Array.from([1, 2, 3, 4, 5, 6]);
+const artifact = {
+  artifactRef: `fw:${'a'.repeat(64)}`,
+  size: artifactBytes.byteLength,
+  sha256: bytesToHex(sha256(artifactBytes)),
+};
+
+const createReader = (bytes = artifactBytes) => {
+  const open = jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: bytes.byteLength }));
+  const read = jest.fn(({ offset, length }: { readerId: string; offset: number; length: number }) =>
+    Promise.resolve({
+      data: bytes.slice(offset, offset + length).buffer,
+      bytesRead: length,
+      eof: offset + length === bytes.byteLength,
+    })
+  );
+  const close = jest.fn(() => Promise.resolve());
+  const reader: FirmwareArtifactReader = { open, read, close };
+  return { reader, open, read, close };
+};
+
+describe('FirmwareArtifactSource', () => {
+  it('materializes verified bytes before exposing the source', async () => {
+    const backingBytes = Uint8Array.from(artifactBytes);
+    const { reader, read, close } = createReader(backingBytes);
+    const source = await openFirmwareByteSource({ artifact, reader });
+    if (!source) {
+      throw new Error('Expected a firmware byte source');
+    }
+    expect(read).toHaveBeenCalledWith({ readerId: 'reader-1', offset: 0, length: artifact.size });
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+
+    backingBytes.fill(9);
+    read.mockClear();
+
+    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(read).not.toHaveBeenCalled();
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  it('rejects same-sized bytes that do not match the receipt digest', async () => {
+    const { reader, close } = createReader(Uint8Array.from([6, 5, 4, 3, 2, 1]));
+
+    await expect(openFirmwareByteSource({ artifact, reader })).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+      },
+    });
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+  });
+
+  it('verifies large artifacts through bounded sequential reads', async () => {
+    const bytes = new Uint8Array(MAX_FIRMWARE_ARTIFACT_READ_BYTES + 3);
+    bytes.fill(7);
+    const largeArtifact = {
+      ...artifact,
+      size: bytes.byteLength,
+      sha256: bytesToHex(sha256(bytes)),
+    };
+    const { reader, read } = createReader(bytes);
+
+    const source = await openFirmwareByteSource({ artifact: largeArtifact, reader });
+    if (!source) {
+      throw new Error('Expected a firmware byte source');
+    }
+    expect(read.mock.calls.map(([request]) => request)).toEqual([
+      {
+        readerId: 'reader-1',
+        offset: 0,
+        length: MAX_FIRMWARE_ARTIFACT_READ_BYTES,
+      },
+      {
+        readerId: 'reader-1',
+        offset: MAX_FIRMWARE_ARTIFACT_READ_BYTES,
+        length: 3,
+      },
+    ]);
+    await source.close();
+  });
+
+  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 writes before invoking the host again', 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');
+    }
+    read.mockClear();
+    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,79 @@
+import {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  resolveFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from '../../src/api/firmware/FirmwareHostBinding';
+
+const createBinding = () => ({
+  preparedPlanDigest: 'a'.repeat(64),
+  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',
+    });
+  });
+
+  test('rejects a prepared plan from another host generation before opening artifacts', () => {
+    const generation = registerFirmwareUpdateHostBinding(createBinding());
+
+    expect(() => resolveFirmwareUpdateHostBinding(generation, 'b'.repeat(64))).toThrow(
+      'does not match the prepared plan'
+    );
+  });
+});

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