@onekeyfe/hd-core 1.2.0-alpha.51 → 1.2.0-alpha.52

package/__tests__/firmware-update/firmware-update-plan-bootloader-identity.test.ts

@@ -0,0 +1,294 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+import {
+  assertFirmwareUpdatePreparedPlanDeviceIdentity,
+  prepareFirmwareUpdatePlan,
+} from '../../src/api/firmware/FirmwareUpdatePreparedPlan';
+
+import type { Features } from '../../src/types';
+
+const FIRMWARE_SHA256 = 'a'.repeat(64);
+
+const BLE_SHA256 = 'b'.repeat(64);
+
+const buildDesktopPlan = (
+  features: Partial<Features>,
+  options?: {
+    ble?: { status: string; release?: Record<string, unknown> };
+    firmwareStatus?: string;
+  }
+) =>
+  buildFirmwareUpdatePlan({
+    features: features as Features,
+    firmwareType: EFirmwareType.Universal,
+    platform: 'desktop',
+    firmware: {
+      status: options?.firmwareStatus ?? 'none',
+      release: {
+        url: 'https://firmware.onekey.so/classic/firmware.bin',
+        expectedSize: 4,
+        fingerprint: FIRMWARE_SHA256,
+        version: [3, 20, 0],
+      },
+    },
+    ble: options?.ble ?? {
+      status: 'valid',
+      release: undefined,
+    },
+    bootloader: {
+      status: 'valid',
+      release: undefined,
+    },
+  });
+
+const bleNoneWithRelease = {
+  status: 'none',
+  release: {
+    url: 'https://firmware.onekey.so/classic/ble.bin',
+    webUpdate: 'https://firmware.onekey.so/classic/ble.bin',
+    expectedSize: 8,
+    fingerprint: BLE_SHA256,
+    version: [1, 5, 6],
+  },
+};
+
+// A classic1s that lost its firmware reports no serial in bootloader mode; the
+// recovery flow must still be able to build (and later execute) a prepared plan.
+const bootloaderClassic1sFeatures: Partial<Features> = {
+  deviceType: EDeviceType.Classic1s,
+  bootloaderMode: true,
+  firmwareVersion: '0.0.0',
+  bootloaderVersion: '2.1.2',
+};
+
+describe('firmware update plan identity in bootloader mode', () => {
+  test('builds a degraded-identity plan for a serial-less bootloader classic1s on desktop', () => {
+    const plan = buildDesktopPlan(bootloaderClassic1sFeatures);
+    expect(plan.deviceIdentity).toBe('unavailable');
+    expect(plan.executor).not.toBe('v4');
+    expect(plan.targetsToUpdate).toContain('firmware');
+  });
+
+  test('bootloader mode with intact firmware (status unknown) still gets the firmware artifact', () => {
+    const plan = buildDesktopPlan(
+      {
+        deviceType: EDeviceType.Classic1s,
+        bootloaderMode: true,
+        firmwareVersion: '2.1.2',
+        bootloaderVersion: '2.1.2',
+      },
+      { firmwareStatus: 'unknown' }
+    );
+    expect(plan.targetsToUpdate).toContain('firmware');
+    expect(plan.deviceIdentity).toBe('unavailable');
+  });
+
+  test('normal-mode status none with a release available still adds no artifacts', () => {
+    const plan = buildDesktopPlan({
+      deviceType: EDeviceType.Classic1s,
+      serialNo: 'CLA45F0023',
+      firmwareVersion: '3.19.0',
+      bootloaderVersion: '2.1.2',
+    });
+    expect(plan.targetsToUpdate).toEqual([]);
+  });
+
+  test('recovery plan carries the BLE artifact when the BLE version is unreadable in bootloader', () => {
+    const plan = buildDesktopPlan(bootloaderClassic1sFeatures, { ble: bleNoneWithRelease });
+    expect(plan.targetsToUpdate).toEqual(expect.arrayContaining(['firmware', 'ble']));
+  });
+
+  test('a normal-mode device without BLE hardware (status none) gets no BLE artifact', () => {
+    const plan = buildFirmwareUpdatePlan({
+      features: {
+        deviceType: EDeviceType.Mini,
+        serialNo: 'mini-device-id',
+        firmwareVersion: '3.9.0',
+        bootloaderVersion: '2.0.0',
+      } as Features,
+      firmwareType: EFirmwareType.Universal,
+      platform: 'desktop',
+      firmware: {
+        status: 'outdated',
+        release: {
+          url: 'https://firmware.onekey.so/mini/firmware.bin',
+          expectedSize: 4,
+          fingerprint: FIRMWARE_SHA256,
+          version: [3, 10, 0],
+        },
+      },
+      ble: { status: 'none', release: undefined },
+      bootloader: { status: 'valid', release: undefined },
+    });
+    expect(plan.targetsToUpdate).toEqual(['firmware']);
+  });
+
+  test('still rejects a serial-less normal-mode device on desktop', () => {
+    expect(() =>
+      buildDesktopPlan(
+        {
+          deviceType: EDeviceType.Classic1s,
+          firmwareVersion: '3.19.0',
+          bootloaderVersion: '2.1.2',
+        },
+        { firmwareStatus: 'outdated' }
+      )
+    ).toThrow(/stable device identity/);
+  });
+
+  test('keeps rejecting degraded identity for serial-less Pro (v3) in bootloader', () => {
+    expect(() =>
+      buildDesktopPlan(
+        {
+          deviceType: EDeviceType.Pro,
+          bootloaderMode: true,
+          firmwareVersion: '0.0.0',
+          bootloaderVersion: '2.8.0',
+        },
+        { firmwareStatus: 'none' }
+      )
+    ).toThrow(/stable device identity/);
+  });
+
+  test('degraded plans are v2-only', () => {
+    const plan = buildDesktopPlan(bootloaderClassic1sFeatures);
+    expect(plan.executor).toBe('v2');
+  });
+
+  describe('prepared plan device identity assertion', () => {
+    const prepareDegradedPlan = () => {
+      const plan = buildDesktopPlan(bootloaderClassic1sFeatures);
+      return prepareFirmwareUpdatePlan({
+        plan,
+        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
+        artifacts: [
+          {
+            artifactId: 'firmware',
+            artifact: {
+              artifactRef: `fw:${FIRMWARE_SHA256}`,
+              size: 4,
+              sha256: FIRMWARE_SHA256,
+            },
+          },
+        ],
+      });
+    };
+
+    test('accepts a degraded plan when the live device is also identity-less in bootloader mode', () => {
+      const preparedPlan = prepareDegradedPlan();
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: undefined,
+          bootloaderMode: true,
+          deviceModel: String(EDeviceType.Classic1s),
+        })
+      ).not.toThrow();
+    });
+
+    test('rejects a degraded plan outside bootloader mode', () => {
+      const preparedPlan = prepareDegradedPlan();
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: undefined,
+          bootloaderMode: false,
+          deviceModel: String(EDeviceType.Classic1s),
+        })
+      ).toThrow();
+    });
+
+    test('rejects a degraded plan when bootloader mode is not stated', () => {
+      const preparedPlan = prepareDegradedPlan();
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: undefined,
+          deviceModel: String(EDeviceType.Classic1s),
+        })
+      ).toThrow();
+    });
+
+    test('rejects a degraded plan when the live device reports a real identity', () => {
+      const preparedPlan = prepareDegradedPlan();
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: 'CLA45F0023',
+          bootloaderMode: true,
+          deviceModel: String(EDeviceType.Classic1s),
+        })
+      ).toThrow();
+    });
+
+    test('rejects a degraded plan on a different device model', () => {
+      const preparedPlan = prepareDegradedPlan();
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: undefined,
+          bootloaderMode: true,
+          deviceModel: String(EDeviceType.Mini),
+        })
+      ).toThrow();
+    });
+
+    test('rejects a degraded plan when the live model is unstated', () => {
+      const preparedPlan = prepareDegradedPlan();
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: undefined,
+          bootloaderMode: true,
+        })
+      ).toThrow();
+    });
+
+    test('a live serial equal to the reserved sentinel never matches a degraded plan', () => {
+      const preparedPlan = prepareDegradedPlan();
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: 'unavailable',
+          bootloaderMode: false,
+          deviceModel: String(EDeviceType.Classic1s),
+        })
+      ).toThrow();
+    });
+
+    test('rejects a real-identity plan when the live device is identity-less in bootloader mode', () => {
+      const plan = buildDesktopPlan(
+        {
+          deviceType: EDeviceType.Classic1s,
+          serialNo: 'CLA45F0023',
+          firmwareVersion: '3.19.0',
+          bootloaderVersion: '2.1.2',
+        },
+        { firmwareStatus: 'outdated' }
+      );
+      const preparedPlan = prepareFirmwareUpdatePlan({
+        plan,
+        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000002',
+        artifacts: [
+          {
+            artifactId: 'firmware',
+            artifact: {
+              artifactRef: `fw:${FIRMWARE_SHA256}`,
+              size: 4,
+              sha256: FIRMWARE_SHA256,
+            },
+          },
+        ],
+      });
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: undefined,
+          bootloaderMode: true,
+          deviceModel: String(EDeviceType.Classic1s),
+        })
+      ).toThrow();
+    });
+  });
+});

package/dist/api/FirmwareUpdateV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdateV2.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAEb,KAAK,aAAa,EAKnB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAwB1C,OAAO,KAAK,EAAE,QAAQ,EAAe,MAAM,UAAU,CAAC;AAEtD,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAE1F,KAAK,MAAM,GAAG;IACZ,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,yBAAyB,CAAC;IACrC,gBAAgB,CAAC,EAAE,yBAAyB,CAAC;IAC7C,eAAe,CAAC,EAAE,KAAK,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,yBAAyB,CAAC;KACrC,CAAC,CAAC;IACH,cAAc,CAAC,EAAE,sBAAsB,CAAC;IACxC,YAAY,CAAC,EAAE,0BAA0B,CAAC;IAC1C,QAAQ,CAAC,EAAE,0BAA0B,CAAC,UAAU,CAAC,CAAC;IAClD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,UAAU,GAAG,KAAK,CAAC;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,YAAY,CAAC,EAAE,aAAa,CAAC;CAC9B,CAAC;AAkFF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,UAAU,CAAC,MAAM,CAAC;IAC9D,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,CAAQ;IAE1C,IAAI;IA6EJ,cAAc,YAAa,MAAM,UAS/B;YAEY,qCAAqC;IAkBnD,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS;YA6FvC,4BAA4B;IAuB1C,qBAAqB;IAUrB,uBAAuB,CAAC,UAAU,EAAE,MAAM;IAc1C,gCAAgC,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAAE,YAAY,EAAE,aAAa;IAwBtF,GAAG;CAyQV"}
+{"version":3,"file":"FirmwareUpdateV2.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAEb,KAAK,aAAa,EAKnB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAyB1C,OAAO,KAAK,EAAE,QAAQ,EAAe,MAAM,UAAU,CAAC;AAEtD,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAE1F,KAAK,MAAM,GAAG;IACZ,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,yBAAyB,CAAC;IACrC,gBAAgB,CAAC,EAAE,yBAAyB,CAAC;IAC7C,eAAe,CAAC,EAAE,KAAK,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,yBAAyB,CAAC;KACrC,CAAC,CAAC;IACH,cAAc,CAAC,EAAE,sBAAsB,CAAC;IACxC,YAAY,CAAC,EAAE,0BAA0B,CAAC;IAC1C,QAAQ,CAAC,EAAE,0BAA0B,CAAC,UAAU,CAAC,CAAC;IAClD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,UAAU,GAAG,KAAK,CAAC;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,YAAY,CAAC,EAAE,aAAa,CAAC;CAC9B,CAAC;AAkFF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,UAAU,CAAC,MAAM,CAAC;IAC9D,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,CAAQ;IAE1C,IAAI;IA6EJ,cAAc,YAAa,MAAM,UAS/B;YAEY,qCAAqC;IAkBnD,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS;YA6FvC,4BAA4B;IAuB1C,qBAAqB;IAUrB,uBAAuB,CAAC,UAAU,EAAE,MAAM;IAc1C,gCAAgC,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAAE,YAAY,EAAE,aAAa;IAwBtF,GAAG;CA2QV"}

package/dist/api/firmware/FirmwareUpdatePlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdatePlan.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/FirmwareUpdatePlan.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,aAAa,EAA6B,MAAM,qBAAqB,CAAC;AAS5F,OAAO,KAAK,EACV,kBAAkB,EAElB,6BAA6B,EAC7B,wBAAwB,EACzB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,KAAK,sBAAsB,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,WAAW,CAAC;AAyBjF,KAAK,gBAAgB,GAAG;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AA0GF,eAAO,MAAM,4BAA4B,UAAW,OAAO,KAAG,MAG3D,CAAC;AAkBJ,eAAO,MAAM,sCAAsC,UAC1C,OAAO,KACb,6BAA6B,EAa/B,CAAC;AAuBF,eAAO,MAAM,4BAA4B,+BAavC,CAAC;AAEH,eAAO,MAAM,0BAA0B,aAOrC,CAAC;AAYH,eAAO,MAAM,wBAAwB,UAAW,OAAO,KAAG,kBAoHzD,CAAC;AA4NF,eAAO,MAAM,uBAAuB;cASxB,QAAQ;kBACJ,aAAa;cACjB,sBAAsB;cACtB,gBAAgB;SACrB,gBAAgB;;;MAGnB,kBAiJH,CAAC"}
+{"version":3,"file":"FirmwareUpdatePlan.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/FirmwareUpdatePlan.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,aAAa,EAA6B,MAAM,qBAAqB,CAAC;AAU5F,OAAO,KAAK,EACV,kBAAkB,EAElB,6BAA6B,EAC7B,wBAAwB,EACzB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,KAAK,sBAAsB,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,WAAW,CAAC;AAyBjF,KAAK,gBAAgB,GAAG;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AA0GF,eAAO,MAAM,4BAA4B,UAAW,OAAO,KAAG,MAG3D,CAAC;AAkBJ,eAAO,MAAM,sCAAsC,UAC1C,OAAO,KACb,6BAA6B,EAa/B,CAAC;AAuBF,eAAO,MAAM,4BAA4B,+BAavC,CAAC;AAEH,eAAO,MAAM,0BAA0B,aAOrC,CAAC;AAYH,eAAO,MAAM,wBAAwB,UAAW,OAAO,KAAG,kBAyHzD,CAAC;AA4NF,eAAO,MAAM,uBAAuB;cASxB,QAAQ;kBACJ,aAAa;cACjB,sBAAsB;cACtB,gBAAgB;SACrB,gBAAgB;;;MAGnB,kBAsKH,CAAC"}

package/dist/api/firmware/FirmwareUpdatePreparedPlan.d.ts

@@ -8,9 +8,11 @@ export declare const prepareFirmwareUpdatePlan: ({ plan: value, leaseRef, artifa
     artifacts: FirmwareUpdatePreparedArtifactInput[];
 }) => FirmwareUpdatePreparedPlan;
 export declare const validateFirmwareUpdatePreparedPlan: (value: unknown) => FirmwareUpdatePreparedPlan;
-export declare const assertFirmwareUpdatePreparedPlanDeviceIdentity: ({ preparedPlan: value, deviceIdentity, }: {
+export declare const assertFirmwareUpdatePreparedPlanDeviceIdentity: ({ preparedPlan: value, deviceIdentity: reportedIdentity, bootloaderMode, deviceModel, }: {
     preparedPlan: unknown;
     deviceIdentity: string | undefined;
+    bootloaderMode?: boolean | undefined;
+    deviceModel?: string | undefined;
 }) => FirmwareUpdatePreparedPlan;
 type FirmwareUpdatePreparedBinding = {
     target: FirmwareUpdatePlan['targetsToUpdate'][number];

package/dist/api/firmware/FirmwareUpdatePreparedPlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdatePreparedPlan.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/FirmwareUpdatePreparedPlan.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAEV,mCAAmC,EAEnC,0BAA0B,EAC3B,MAAM,4CAA4C,CAAC;AACpD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAwB7E,eAAO,MAAM,6BAA6B,UAAW,OAAO,KAAG,MA8B9D,CAAC;AAgGF,eAAO,MAAM,yBAAyB;UAK9B,kBAAkB;cACd,MAAM;eACL,mCAAmC,EAAE;MAC9C,0BAmBH,CAAC;AAEF,eAAO,MAAM,kCAAkC,UAAW,OAAO,KAAG,0BAmGnE,CAAC;AAEF,eAAO,MAAM,8CAA8C;kBAI3C,OAAO;oBACL,MAAM,GAAG,SAAS;MAChC,0BAMH,CAAC;AAEF,KAAK,6BAA6B,GAAG;IACnC,MAAM,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,EAAE,yBAAyB,CAAC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAUF,eAAO,MAAM,uCAAuC;kBAQpC,OAAO;cACX,0BAA0B,CAAC,UAAU,CAAC;;;kBAGlC,0BAA0B,CAAC,iBAAiB,CAAC;cACjD,6BAA6B,EAAE;MACvC,0BAmDH,CAAC"}
+{"version":3,"file":"FirmwareUpdatePreparedPlan.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/FirmwareUpdatePreparedPlan.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAEV,mCAAmC,EAEnC,0BAA0B,EAC3B,MAAM,4CAA4C,CAAC;AACpD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAwB7E,eAAO,MAAM,6BAA6B,UAAW,OAAO,KAAG,MA8B9D,CAAC;AAgGF,eAAO,MAAM,yBAAyB;UAK9B,kBAAkB;cACd,MAAM;eACL,mCAAmC,EAAE;MAC9C,0BAmBH,CAAC;AAEF,eAAO,MAAM,kCAAkC,UAAW,OAAO,KAAG,0BAmGnE,CAAC;AAEF,eAAO,MAAM,8CAA8C;kBAM3C,OAAO;oBACL,MAAM,GAAG,SAAS;;;MAKhC,0BAuBH,CAAC;AAEF,KAAK,6BAA6B,GAAG;IACnC,MAAM,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,EAAE,yBAAyB,CAAC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAUF,eAAO,MAAM,uCAAuC;kBAQpC,OAAO;cACX,0BAA0B,CAAC,UAAU,CAAC;;;kBAGlC,0BAA0B,CAAC,iBAAiB,CAAC;cACjD,6BAA6B,EAAE;MACvC,0BAmDH,CAAC"}

package/dist/index.js

@@ -317,6 +317,13 @@ const resolveDeviceSerialNo = (features) => {
     const compatible = asCompatibleFeatures(features);
     return ((_a = firstNonEmptyString(compatible.serialNo, compatible.onekey_serial_no, compatible.onekey_serial, compatible.serial_no)) !== null && _a !== void 0 ? _a : '');
 };
+const resolveDeviceBootloaderMode = (features) => {
+    var _a;
+    if (!features)
+        return false;
+    const compatible = asCompatibleFeatures(features);
+    return ((_a = compatible.bootloaderMode) !== null && _a !== void 0 ? _a : compatible.bootloader_mode) === true;
+};
 const resolveDeviceType = (features) => {
     var _a, _b, _c, _d;
     if (!features || typeof features !== 'object') {
@@ -721,6 +728,7 @@ const assertFirmwareUpdatePlan = (value) => {
             plan.targetsToUpdate.some(target => legacyOnlyTargets.has(target))) ||
         (plan.artifacts.length > 0 &&
             (plan.platform === 'native' || plan.platform === 'desktop') &&
+            plan.executor !== 'v2' &&
             plan.deviceIdentity === 'unavailable')) {
         return planError('Firmware update plan executor contract is invalid');
     }
@@ -855,7 +863,11 @@ const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, b
     const firmwareRelease = asRelease(firmware);
     const validatedForceTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
     const forcedTargets = new Set(validatedForceTargets);
-    const shouldUpdateFirmware = isUpgrade(firmware) || forcedTargets.has('firmware');
+    const bootloaderMode = resolveDeviceBootloaderMode(features);
+    const isRecoveryInstall = (release) => bootloaderMode &&
+        ((release === null || release === void 0 ? void 0 : release.status) === 'none' || (release === null || release === void 0 ? void 0 : release.status) === 'unknown') &&
+        !!asRelease(release);
+    const shouldUpdateFirmware = isUpgrade(firmware) || isRecoveryInstall(firmware) || forcedTargets.has('firmware');
     const shouldUpdateResource = isUpgrade(firmware) || forcedTargets.has('resource');
     if (executor === 'v4' &&
         validatedForceTargets.some(target => target === 'ble' || target === 'bootloader')) {
@@ -912,7 +924,7 @@ const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, b
                 }
             }
         }
-        if (isUpgrade(ble) || forcedTargets.has('ble')) {
+        if (isUpgrade(ble) || isRecoveryInstall(ble) || forcedTargets.has('ble')) {
             const bleRelease = asRelease(ble);
             artifacts.push(Object.assign(Object.assign({ artifactId: 'ble', role: 'ble', target: 'ble', url: assertArtifactUrl((_f = bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.webUpdate) !== null && _f !== void 0 ? _f : bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.url, 'BLE release'), container: 'raw' }, asIntegrity({
                 size: bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.expectedSize,
@@ -929,10 +941,12 @@ const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, b
         artifacts,
         targetsToUpdate,
     });
-    const deviceIdentity = getDeviceUUID(features);
+    const reportedIdentity = getDeviceUUID(features);
+    const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
     if (artifacts.length > 0 &&
         (platform === 'native' || platform === 'desktop') &&
-        !deviceIdentity) {
+        !deviceIdentity &&
+        !(bootloaderMode && executor === 'v2')) {
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Prepared firmware update requires a stable device identity', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
     }
     const planWithoutDigest = {
@@ -1160,8 +1174,16 @@ const validateFirmwareUpdatePreparedPlan = (value) => {
     }
     return preparedPlan;
 };
-const assertFirmwareUpdatePreparedPlanDeviceIdentity = ({ preparedPlan: value, deviceIdentity, }) => {
+const assertFirmwareUpdatePreparedPlanDeviceIdentity = ({ preparedPlan: value, deviceIdentity: reportedIdentity, bootloaderMode, deviceModel, }) => {
     const preparedPlan = validateFirmwareUpdatePreparedPlan(value);
+    const deviceIdentity = reportedIdentity === 'unavailable' ? undefined : reportedIdentity;
+    if (preparedPlan.deviceIdentity === 'unavailable' &&
+        !deviceIdentity &&
+        bootloaderMode === true &&
+        deviceModel !== undefined &&
+        preparedPlan.deviceModel === deviceModel) {
+        return preparedPlan;
+    }
     if (!deviceIdentity || preparedPlan.deviceIdentity !== deviceIdentity) {
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError);
     }
@@ -49193,6 +49215,8 @@ class FirmwareUpdateV2 extends BaseMethod {
                 assertFirmwareUpdatePreparedPlanDeviceIdentity({
                     preparedPlan: params.preparedPlan,
                     deviceIdentity: getDeviceUUID(features) || undefined,
+                    bootloaderMode: resolveDeviceBootloaderMode(features),
+                    deviceModel: String(getDeviceType(features)),
                 });
             }
             const deviceFirmwareType = device.getCurrentFirmwareType();

package/dist/utils/deviceFeaturesCompat.d.ts

@@ -3,6 +3,7 @@ import type { PROTO } from '../constants';
 import type { Features, IDeviceType } from '../types';
 export type DeviceFeaturesInput = Features | PROTO.Features;
 export declare const resolveDeviceSerialNo: (features?: DeviceFeaturesInput) => string;
+export declare const resolveDeviceBootloaderMode: (features?: DeviceFeaturesInput) => boolean;
 export declare const resolveDeviceType: (features?: DeviceFeaturesInput) => IDeviceType;
 export declare const resolveDeviceFirmwareType: (features?: DeviceFeaturesInput) => EFirmwareType;
 export declare const resolveDeviceBleName: (features?: DeviceFeaturesInput) => string | null;

package/dist/utils/deviceFeaturesCompat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deviceFeaturesCompat.d.ts","sourceRoot":"","sources":["../../src/utils/deviceFeaturesCompat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEtD,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;AAoB5D,eAAO,MAAM,qBAAqB,cAAe,mBAAmB,KAAG,MAWtE,CAAC;AAEF,eAAO,MAAM,iBAAiB,cAAe,mBAAmB,KAAG,WAgDlE,CAAC;AAEF,eAAO,MAAM,yBAAyB,cAAe,mBAAmB,KAAG,aAsB1E,CAAC;AAEF,eAAO,MAAM,oBAAoB,cAAe,mBAAmB,KAAG,MAAM,GAAG,IAM9E,CAAC;AAEF,eAAO,MAAM,4BAA4B,cAAe,mBAAmB,KAAG,MAAM,GAAG,IAgBtF,CAAC;AAEF,eAAO,MAAM,8BAA8B,cAAe,mBAAmB,KAAG,MAAM,GAAG,IAiBxF,CAAC;AAEF,eAAO,MAAM,yBAAyB,cAAe,mBAAmB,KAAG,MAAM,GAAG,IAUnF,CAAC;AAEF,eAAO,MAAM,+BAA+B,cAAe,mBAAmB,KAAG,MAAM,GAAG,IASzF,CAAC"}
+{"version":3,"file":"deviceFeaturesCompat.d.ts","sourceRoot":"","sources":["../../src/utils/deviceFeaturesCompat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEtD,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;AAoB5D,eAAO,MAAM,qBAAqB,cAAe,mBAAmB,KAAG,MAWtE,CAAC;AAEF,eAAO,MAAM,2BAA2B,cAAe,mBAAmB,KAAG,OAI5E,CAAC;AAEF,eAAO,MAAM,iBAAiB,cAAe,mBAAmB,KAAG,WAgDlE,CAAC;AAEF,eAAO,MAAM,yBAAyB,cAAe,mBAAmB,KAAG,aAsB1E,CAAC;AAEF,eAAO,MAAM,oBAAoB,cAAe,mBAAmB,KAAG,MAAM,GAAG,IAM9E,CAAC;AAEF,eAAO,MAAM,4BAA4B,cAAe,mBAAmB,KAAG,MAAM,GAAG,IAgBtF,CAAC;AAEF,eAAO,MAAM,8BAA8B,cAAe,mBAAmB,KAAG,MAAM,GAAG,IAiBxF,CAAC;AAEF,eAAO,MAAM,yBAAyB,cAAe,mBAAmB,KAAG,MAAM,GAAG,IAUnF,CAAC;AAEF,eAAO,MAAM,+BAA+B,cAAe,mBAAmB,KAAG,MAAM,GAAG,IASzF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.0-alpha.51",
+  "version": "1.2.0-alpha.52",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.0-alpha.51",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.51",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.52",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.52",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "bytebuffer": "^5.0.1",
@@ -44,5 +44,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "c947101d26542c9fd27264b9ddff7f7bba0ad24d"
+  "gitHead": "d8fd8f3d30c4ff3653d0379d5c3e1c100414b61e"
 }

package/src/api/FirmwareUpdateV2.ts

@@ -21,7 +21,8 @@ import {
   uploadFirmwareFromSource,
 } from './firmware/uploadFirmware';
 import { BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS } from './firmware/FirmwareUpdateBaseMethod';
-import { LoggerNames, getDeviceUUID, getLogger, wait } from '../utils';
+import { LoggerNames, getDeviceType, getDeviceUUID, getLogger, wait } from '../utils';
+import { resolveDeviceBootloaderMode } from '../utils/deviceFeaturesCompat';
 import { FirmwareUpdateTipMessage, createUiMessage } from '../events/ui-request';
 import { DeviceModelToTypes } from '../types';
 import { DataManager } from '../data-manager';
@@ -429,6 +430,8 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
       assertFirmwareUpdatePreparedPlanDeviceIdentity({
         preparedPlan: params.preparedPlan,
         deviceIdentity: getDeviceUUID(features) || undefined,
+        bootloaderMode: resolveDeviceBootloaderMode(features),
+        deviceModel: String(getDeviceType(features)),
       });
     }
 

package/src/api/firmware/FirmwareUpdatePlan.ts

@@ -4,6 +4,7 @@ import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe
 import semver from 'semver';
 
 import { getDeviceType, getDeviceUUID } from '../../utils/deviceInfoUtils';
+import { resolveDeviceBootloaderMode } from '../../utils/deviceFeaturesCompat';
 import {
   getDeviceBootloaderVersion,
   getDeviceFirmwareVersion,
@@ -350,8 +351,13 @@ export const assertFirmwareUpdatePlan = (value: unknown): FirmwareUpdatePlan =>
       plan.targetsToUpdate.some(target =>
         legacyOnlyTargets.has(target as FirmwareUpdatePlanTarget)
       )) ||
+    // Only executor v2 services identity-less bootloader recovery (classic family);
+    // Pro (v3) and Pro2 (v4) report a serial even in bootloader mode, so their plans
+    // must always carry a real identity. Degraded v2 plans are bound to the live
+    // device at install time instead.
     (plan.artifacts.length > 0 &&
       (plan.platform === 'native' || plan.platform === 'desktop') &&
+      plan.executor !== 'v2' &&
       plan.deviceIdentity === 'unavailable')
   ) {
     return planError('Firmware update plan executor contract is invalid');
@@ -604,7 +610,19 @@ export const buildFirmwareUpdatePlan = ({
   const firmwareRelease = asRelease(firmware);
   const validatedForceTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
   const forcedTargets = new Set(validatedForceTargets);
-  const shouldUpdateFirmware = isUpgrade(firmware) || forcedTargets.has('firmware');
+  const bootloaderMode = resolveDeviceBootloaderMode(features);
+  // Bootloader recovery: an erased device reports firmware status 'none', a device
+  // with intact firmware in bootloader mode reports 'unknown' (version fields carry
+  // the bootloader version), and neither can report its BLE version — yet the app
+  // treats bootloader mode as a mandatory reinstall. Only bootloader mode may treat
+  // these statuses as install targets: in normal mode 'none' also describes devices
+  // without the component at all (e.g. Mini has no BLE) and must stay excluded.
+  const isRecoveryInstall = (release: ReleaseSelection | undefined): boolean =>
+    bootloaderMode &&
+    (release?.status === 'none' || release?.status === 'unknown') &&
+    !!asRelease(release);
+  const shouldUpdateFirmware =
+    isUpgrade(firmware) || isRecoveryInstall(firmware) || forcedTargets.has('firmware');
   const shouldUpdateResource = isUpgrade(firmware) || forcedTargets.has('resource');
 
   if (
@@ -689,7 +707,7 @@ export const buildFirmwareUpdatePlan = ({
         }
       }
     }
-    if (isUpgrade(ble) || forcedTargets.has('ble')) {
+    if (isUpgrade(ble) || isRecoveryInstall(ble) || forcedTargets.has('ble')) {
       const bleRelease = asRelease(ble);
       artifacts.push({
         artifactId: 'ble',
@@ -716,11 +734,20 @@ export const buildFirmwareUpdatePlan = ({
     targetsToUpdate,
   });
 
-  const deviceIdentity = getDeviceUUID(features);
+  // 'unavailable' is the reserved degraded-identity sentinel; a device-reported
+  // serial must never be able to collide with it.
+  const reportedIdentity = getDeviceUUID(features);
+  const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
+  // Bootloader-mode classic-family devices (executor v2, e.g. classic1s) cannot report
+  // a serial number, so their recovery plans fall back to the degraded 'unavailable'
+  // identity. Binding is then enforced against the live device at install time instead
+  // (assertFirmwareUpdatePreparedPlanDeviceIdentity), and plan integrity by the digest.
+  // Pro (v3) and Pro2 (v4) report a serial even in bootloader mode and stay strict.
   if (
     artifacts.length > 0 &&
     (platform === 'native' || platform === 'desktop') &&
-    !deviceIdentity
+    !deviceIdentity &&
+    !(bootloaderMode && executor === 'v2')
   ) {
     throw ERRORS.TypedError(
       HardwareErrorCode.RuntimeError,

package/src/api/firmware/FirmwareUpdatePreparedPlan.ts

@@ -297,12 +297,35 @@ export const validateFirmwareUpdatePreparedPlan = (value: unknown): FirmwareUpda
 
 export const assertFirmwareUpdatePreparedPlanDeviceIdentity = ({
   preparedPlan: value,
-  deviceIdentity,
+  deviceIdentity: reportedIdentity,
+  bootloaderMode,
+  deviceModel,
 }: {
   preparedPlan: unknown;
   deviceIdentity: string | undefined;
+  /** Live device mode; only bootloader mode may accept a degraded-identity plan. */
+  bootloaderMode?: boolean;
+  /** Live device model; a degraded plan must target the same model. */
+  deviceModel?: string;
 }): FirmwareUpdatePreparedPlan => {
   const preparedPlan = validateFirmwareUpdatePreparedPlan(value);
+  // 'unavailable' is the reserved degraded sentinel — a device-reported serial equal
+  // to it must never satisfy the exact-match branch below.
+  const deviceIdentity = reportedIdentity === 'unavailable' ? undefined : reportedIdentity;
+  // Bootloader recovery: classic-family devices report no serial in bootloader mode,
+  // so a degraded plan is only acceptable when the live device is equally
+  // identity-less AND targets the same device model (identity equality implies the
+  // model match in the strict branch; the degraded branch must substitute it).
+  // A device that DOES report an identity must match the plan exactly.
+  if (
+    preparedPlan.deviceIdentity === 'unavailable' &&
+    !deviceIdentity &&
+    bootloaderMode === true &&
+    deviceModel !== undefined &&
+    preparedPlan.deviceModel === deviceModel
+  ) {
+    return preparedPlan;
+  }
   if (!deviceIdentity || preparedPlan.deviceIdentity !== deviceIdentity) {
     throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
   }

package/src/utils/deviceFeaturesCompat.ts

@@ -37,6 +37,12 @@ export const resolveDeviceSerialNo = (features?: DeviceFeaturesInput): string =>
   );
 };
 
+export const resolveDeviceBootloaderMode = (features?: DeviceFeaturesInput): boolean => {
+  if (!features) return false;
+  const compatible = asCompatibleFeatures(features);
+  return (compatible.bootloaderMode ?? compatible.bootloader_mode) === true;
+};
+
 export const resolveDeviceType = (features?: DeviceFeaturesInput): IDeviceType => {
   if (!features || typeof features !== 'object') {
     return EDeviceType.Unknown;