@onekeyfe/hd-core 1.2.0-alpha.70 → 1.2.0-alpha.72

package/__tests__/check-all-firmware-release-protocol-v2.test.ts

@@ -163,6 +163,34 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     });
   });
 
+  test('marks SE03 and SE04 as unsupported in a Neo firmware plan', () => {
+    const neoRelease: IFirmwareReleaseInfo = {
+      ...release,
+      installOrder: ['se01', 'se02', 'se03', 'se04'],
+      components: {
+        se01: { target: 'SE01', url: 'https://example.com/se01.bin', version: [2, 0, 0] },
+        se02: { target: 'SE02', url: 'https://example.com/se02.bin', version: [3, 0, 0] },
+        se03: { target: 'SE03', url: 'https://example.com/se03.bin', version: [2, 0, 0] },
+        se04: { target: 'SE04', url: 'https://example.com/se04.bin', version: [2, 0, 0] },
+      },
+    };
+
+    const result = buildProtocolV2FirmwareRelease({
+      currentVersions,
+      firmwareType: EFirmwareType.Universal,
+      release: neoRelease,
+      deviceType: 'neo',
+    });
+
+    expect(result.targetsToUpdate).toEqual(['se01', 'se02']);
+    expect(result.components).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ configKey: 'se03', status: 'unsupported', updateTarget: null }),
+        expect.objectContaining({ configKey: 'se04', status: 'unsupported', updateTarget: null }),
+      ])
+    );
+  });
+
   test('returns an unavailable plan when no Pro2 release is configured', () => {
     expect(
       buildProtocolV2FirmwareRelease({

package/__tests__/protocol-v2-firmware-targets.test.ts

@@ -1,5 +1,10 @@
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import { ProtocolV2FirmwareTargetType } from '../src/protocols/protocol-v2/firmware';
-import { isProtocolV2FirmwareFingerprintValid } from '../src/api/FirmwareUpdateV4';
+import {
+  assertProtocolV2FirmwareTargetsSupported,
+  isProtocolV2FirmwareFingerprintValid,
+} from '../src/api/FirmwareUpdateV4';
 
 jest.mock('../src/data/config', () => ({
   DEFAULT_DOMAIN: 'https://example.com/',
@@ -34,4 +39,47 @@ describe('Protocol V2 firmware target contract', () => {
     ).toBe(true);
     expect(isProtocolV2FirmwareFingerprintValid(binary, '00'.repeat(32))).toBe(false);
   });
+
+  test('allows only SE01 and SE02 firmware targets on Neo', () => {
+    expect(() =>
+      assertProtocolV2FirmwareTargetsSupported(EDeviceType.Neo, {
+        platform: 'web',
+        targetsToUpdate: ['se01', 'se02'],
+      })
+    ).not.toThrow();
+
+    expect(() =>
+      assertProtocolV2FirmwareTargetsSupported(EDeviceType.Neo, {
+        platform: 'web',
+        targetsToUpdate: ['se03'],
+        se04Binary: new ArrayBuffer(1),
+      })
+    ).toThrow('Neo only supports SE01 and SE02; unsupported firmware targets: se03, se04');
+  });
+
+  test('keeps all four SE firmware targets available on Pro2', () => {
+    expect(() =>
+      assertProtocolV2FirmwareTargetsSupported(EDeviceType.Pro2, {
+        platform: 'web',
+        targetsToUpdate: ['se03'],
+        se04Binary: new ArrayBuffer(1),
+      })
+    ).not.toThrow();
+  });
+
+  test('fails closed when SE03 or SE04 is requested without a confirmed device type', () => {
+    try {
+      assertProtocolV2FirmwareTargetsSupported(undefined, {
+        platform: 'web',
+        targetsToUpdate: ['se03'],
+      });
+      throw new Error('Expected unsupported target validation to fail');
+    } catch (error) {
+      expect(error).toMatchObject({ errorCode: HardwareErrorCode.DeviceNotSupportMethod });
+      expect(error).toHaveProperty(
+        'message',
+        'Cannot safely update se03 without a confirmed Pro2 device type'
+      );
+    }
+  });
 });

package/__tests__/protocol-v2-resources.test.ts

@@ -95,7 +95,7 @@ describe('Pro2 resource configuration', () => {
     DataManager.lastCheckTimestamp = 0;
   });
 
-  test('accepts exactly six resources and normalizes their deterministic order', () => {
+  test('accepts exactly seven resources and normalizes their deterministic order', () => {
     const parsed = parseProtocolV2Resources({
       stable: [...resources].reverse(),
       boot: bootResources,
@@ -106,15 +106,18 @@ describe('Pro2 resource configuration', () => {
     expect(PROTOCOL_V2_RESOURCE_DEVICE_PATHS.translations).toBe(
       'vol0:/bundles/translations/translations.okpkg'
     );
+    expect(PROTOCOL_V2_RESOURCE_DEVICE_PATHS.firmware_logo).toBe(
+      'vol0:/bundles/firmware_logo.okpkg'
+    );
   });
 
   test('rejects incomplete, duplicate, or malformed stable sets', () => {
     expect(() => parseProtocolV2Resources({ stable: resources.slice(1) })).toThrow(
-      'six unique resource types'
+      '7 unique resource types'
     );
     expect(() =>
-      parseProtocolV2Resources({ stable: [...resources.slice(0, 5), resources[0]] })
-    ).toThrow('six unique resource types');
+      parseProtocolV2Resources({ stable: [...resources.slice(0, 6), resources[0]] })
+    ).toThrow('7 unique resource types');
     expect(() =>
       parseProtocolV2Resources({
         stable: resources.map((resource, index) =>
@@ -224,7 +227,7 @@ describe('Pro2 resource configuration', () => {
     );
     expect(typedCall.mock.calls.some(call => call[0] === 'ResourceInventoryGet')).toBe(false);
     expect(typedCall.mock.calls.filter(call => call[0] === 'FilesystemPathInfoQuery')).toHaveLength(
-      6
+      7
     );
     expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemFileRead')).toBe(true);
   });
@@ -255,7 +258,7 @@ describe('Pro2 resource configuration', () => {
     });
     expect(
       buildProtocolV2ResourceUpdatePlan({ resources, mode: 'bootloader-recovery' }).resources
-    ).toHaveLength(6);
+    ).toHaveLength(7);
   });
 
   test('uses a filesystem inventory for incremental recovery mode updates', () => {