@onekeyfe/hd-core 1.2.0-alpha.8 → 1.2.0-alpha.80

package/__tests__/firmware-update/firmware-update-bootloader-poll.test.ts

@@ -0,0 +1,200 @@
+import FirmwareUpdate from '../../src/api/FirmwareUpdate';
+import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
+import FirmwareUpdateV3 from '../../src/api/FirmwareUpdateV3';
+import { BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS } from '../../src/api/firmware/FirmwareUpdateBaseMethod';
+import { DataManager } from '../../src/data-manager';
+
+import type { Device } from '../../src/device/Device';
+
+jest.mock('../../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+const BLE_ID = 'ble-device';
+
+const flush = () =>
+  new Promise(resolve => {
+    setImmediate(resolve);
+  });
+
+describe.each([
+  [
+    'FirmwareUpdateV2',
+    () =>
+      new FirmwareUpdateV2({
+        id: 1,
+        payload: { method: 'firmwareUpdateV2', connectId: BLE_ID },
+      }),
+  ],
+  [
+    'FirmwareUpdateV3 (base method)',
+    () =>
+      new FirmwareUpdateV3({
+        id: 1,
+        payload: { method: 'firmwareUpdateV3', connectId: BLE_ID },
+      }),
+  ],
+  [
+    'FirmwareUpdate (legacy)',
+    () =>
+      new FirmwareUpdate({
+        id: 1,
+        payload: { method: 'firmwareUpdate', connectId: BLE_ID },
+      }),
+  ],
+])('%s BLE bootloader reboot polling', (_name, buildMethod) => {
+  beforeAll(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.restoreAllMocks();
+  });
+
+  test('probes serially with a short timeout and survives a slow reboot', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    jest.spyOn(DataManager, 'isBleConnect').mockReturnValue(true);
+
+    const method = buildMethod();
+
+    let deviceBack = false;
+    let inFlight = 0;
+    let maxInFlight = 0;
+    const probeTimeouts: Array<number | undefined> = [];
+
+    const initialize = jest.fn((options?: { timeoutMs?: number }) => {
+      inFlight += 1;
+      maxInFlight = Math.max(maxInFlight, inFlight);
+      probeTimeouts.push(options?.timeoutMs);
+      return new Promise<void>((resolve, reject) => {
+        if (deviceBack) {
+          inFlight -= 1;
+          resolve();
+          return;
+        }
+        if (options?.timeoutMs) {
+          setTimeout(() => {
+            inFlight -= 1;
+            reject(Object.assign(new Error('BLE response timeout'), { errorCode: 713 }));
+          }, options.timeoutMs);
+        }
+        // Without a per-probe timeout this promise never settles, matching a device
+        // that never received the request while rebooting.
+      });
+    });
+
+    method.device = {
+      originalDescriptor: { id: BLE_ID },
+      deviceConnector: { acquire: jest.fn(() => Promise.resolve()) },
+      initialize,
+      isBootloader: jest.fn(() => deviceBack),
+      getCurrentDeviceType: jest.fn(() => 'classic1s'),
+    } as unknown as Device;
+
+    // The device re-enumerates in bootloader mode 7 seconds after "reboot start".
+    setTimeout(() => {
+      deviceBack = true;
+    }, 7000);
+
+    method.checkDeviceToBootloader(BLE_ID);
+    const resolved = jest.fn();
+    method.checkPromise?.promise.then(resolved);
+
+    for (let elapsed = 0; elapsed < 15000; elapsed += 500) {
+      jest.advanceTimersByTime(500);
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      if (resolved.mock.calls.length) break;
+    }
+
+    // Must detect bootloader mode well inside the 30s reboot budget.
+    expect(resolved).toHaveBeenCalledWith(true);
+    expect(initialize).toHaveBeenCalled();
+    // Probes must never overlap: an unanswered Initialize left in flight is what
+    // the transport later times out and used to tear the connection down with.
+    expect(maxInFlight).toBe(1);
+    // Every probe must carry the bounded poll timeout so a silent device frees the
+    // slot promptly; the 30s reboot budget must fit several attempts.
+    expect(BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS).toBeLessThanOrEqual(10000);
+    for (const timeoutMs of probeTimeouts) {
+      expect(timeoutMs).toBe(BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS);
+    }
+  });
+
+  test('skips ticks while a probe hangs in acquire', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    jest.spyOn(DataManager, 'isBleConnect').mockReturnValue(true);
+
+    const method = buildMethod();
+
+    let deviceBack = false;
+    let activeProbes = 0;
+    let maxActiveProbes = 0;
+
+    // The first acquire hangs for 7s (BLE reconnect while the device reboots);
+    // later acquires resolve immediately.
+    let acquireCalls = 0;
+    const acquire = jest.fn(() => {
+      activeProbes += 1;
+      maxActiveProbes = Math.max(maxActiveProbes, activeProbes);
+      acquireCalls += 1;
+      if (acquireCalls === 1) {
+        return new Promise<void>(resolve => {
+          setTimeout(resolve, 7000);
+        });
+      }
+      return Promise.resolve();
+    });
+
+    const initialize = jest.fn(
+      (options?: { timeoutMs?: number }) =>
+        new Promise<void>((resolve, reject) => {
+          if (deviceBack) {
+            activeProbes -= 1;
+            resolve();
+            return;
+          }
+          if (options?.timeoutMs) {
+            setTimeout(() => {
+              activeProbes -= 1;
+              reject(Object.assign(new Error('BLE response timeout'), { errorCode: 713 }));
+            }, options.timeoutMs);
+          }
+        })
+    );
+
+    method.device = {
+      originalDescriptor: { id: BLE_ID },
+      deviceConnector: { acquire },
+      initialize,
+      isBootloader: jest.fn(() => deviceBack),
+      getCurrentDeviceType: jest.fn(() => 'classic1s'),
+    } as unknown as Device;
+
+    setTimeout(() => {
+      deviceBack = true;
+    }, 7000);
+
+    method.checkDeviceToBootloader(BLE_ID);
+    const resolved = jest.fn();
+    method.checkPromise?.promise.then(resolved);
+
+    for (let elapsed = 0; elapsed < 15000; elapsed += 500) {
+      jest.advanceTimersByTime(500);
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      if (resolved.mock.calls.length) break;
+    }
+
+    expect(resolved).toHaveBeenCalledWith(true);
+    // While the first probe hangs inside acquire, interval ticks must be skipped —
+    // overlapping probes are the exact mechanism from the incident.
+    expect(maxActiveProbes).toBe(1);
+  });
+});

package/__tests__/firmware-update/firmware-update-capabilities.test.ts

@@ -0,0 +1,13 @@
+import { getFirmwareUpdateCapabilities } from '../../src/api/firmware/FirmwareUpdateCapabilities';
+
+describe('getFirmwareUpdateCapabilities', () => {
+  it('advertises only the prepared artifact contract', () => {
+    expect(getFirmwareUpdateCapabilities()).toEqual({
+      planSchemaVersion: 2,
+      preparedPlanSchemaVersion: 2,
+      hostBindingProtocolVersion: 2,
+      manifestModes: ['external-only', 'sdk-managed'],
+      supportsArtifactReader: true,
+    });
+  });
+});

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

@@ -0,0 +1,394 @@
+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('degraded plan identity transition within one recovery workflow', () => {
+    // Bootloader recovery installs the main firmware while the device has no serial;
+    // it then reboots into normal mode and reports one, and the remaining phases of
+    // the SAME workflow reuse the same prepared plan.
+    let lease = 0;
+    const prepareRecoveryPlan = () => {
+      lease += 1;
+      const plan = buildDesktopPlan(bootloaderClassic1sFeatures);
+      return prepareFirmwareUpdatePlan({
+        plan,
+        leaseRef: `fwlease:00000000-0000-4000-8000-00000000000${lease}`,
+        artifacts: [
+          {
+            artifactId: 'firmware',
+            artifact: {
+              artifactRef: `fw:${FIRMWARE_SHA256}`,
+              size: 4,
+              sha256: FIRMWARE_SHA256,
+            },
+          },
+        ],
+      });
+    };
+
+    test('accepts the phase that runs after the device reboots and reports a serial', () => {
+      const preparedPlan = prepareRecoveryPlan();
+      // Phase 1: still in bootloader, no serial.
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: undefined,
+          bootloaderMode: true,
+          deviceModel: String(EDeviceType.Classic1s),
+        })
+      ).not.toThrow();
+      // Phase 2: firmware installed, device rebooted and now has an identity.
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: 'CLA45F0023',
+          bootloaderMode: false,
+          deviceModel: String(EDeviceType.Classic1s),
+        })
+      ).not.toThrow();
+    });
+
+    test('pins the first identity it sees, so a different device cannot take over', () => {
+      const preparedPlan = prepareRecoveryPlan();
+      assertFirmwareUpdatePreparedPlanDeviceIdentity({
+        preparedPlan,
+        deviceIdentity: 'CLA45F0023',
+        bootloaderMode: false,
+        deviceModel: String(EDeviceType.Classic1s),
+      });
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: 'CLA99Z9999',
+          bootloaderMode: false,
+          deviceModel: String(EDeviceType.Classic1s),
+        })
+      ).toThrow();
+    });
+
+    test('still refuses a different device model after the identity appears', () => {
+      const preparedPlan = prepareRecoveryPlan();
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: 'MINI0000001',
+          bootloaderMode: false,
+          deviceModel: String(EDeviceType.Mini),
+        })
+      ).toThrow();
+    });
+
+    test('a fresh workflow does not inherit the previous workflow identity pin', () => {
+      const first = prepareRecoveryPlan();
+      assertFirmwareUpdatePreparedPlanDeviceIdentity({
+        preparedPlan: first,
+        deviceIdentity: 'CLA45F0023',
+        bootloaderMode: false,
+        deviceModel: String(EDeviceType.Classic1s),
+      });
+      const second = prepareRecoveryPlan();
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan: second,
+          deviceIdentity: 'CLA99Z9999',
+          bootloaderMode: false,
+          deviceModel: String(EDeviceType.Classic1s),
+        })
+      ).not.toThrow();
+    });
+  });
+
+  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();
+    });
+
+    // Superseded: a degraded plan MUST accept the first real identity, because that is
+    // the recovering device reporting its serial after the firmware phase rebooted it.
+    // The boundary that remains — a SECOND, different identity — is covered by
+    // 'pins the first identity it sees, so a different device cannot take over'.
+    test('binds to the identity the recovered device reports', () => {
+      const preparedPlan = prepareDegradedPlan();
+      expect(() =>
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: 'CLA45F0023',
+          bootloaderMode: true,
+          deviceModel: String(EDeviceType.Classic1s),
+        })
+      ).not.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();
+    });
+  });
+});