@onekeyfe/hd-core 1.2.0-alpha.68 → 1.2.0-alpha.69

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__/connectSettings.test.ts

@@ -1,61 +1,19 @@
-import DataManager from '../src/data-manager/DataManager';
 import { parseConnectSettings } from '../src/data-manager/connectSettings';
 
-import type { RemoteConfigResponse } from '../src/types';
-
-jest.mock('axios', () => ({
-  get: jest.fn(),
-}));
-
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
-const mockAxiosGet: jest.Mock = jest.requireMock('axios').get;
-
 describe('parseConnectSettings', () => {
-  const preloadedConfig = {
-    bridge: {},
-    classic: { firmware: [], ble: [] },
-    classic1s: { firmware: [], ble: [] },
-    classicpure: { firmware: [], ble: [] },
-    mini: { firmware: [], ble: [] },
-    touch: { firmware: [], ble: [] },
-    pro: { firmware: [], ble: [] },
-    pro2: { firmware: [], ble: [] },
-  } as unknown as RemoteConfigResponse;
-
-  it('keeps a serializable preloaded config in parsed settings', () => {
-    const settings = parseConnectSettings({
-      firmwareManifestMode: 'sdk-managed',
-      preloadedConfig,
-    });
-
-    expect(settings.firmwareManifestMode).toBe('sdk-managed');
-    expect(settings.preloadedConfig).toBe(preloadedConfig);
-  });
-
-  it('uses the preloaded config before the SDK network client', async () => {
-    const settings = parseConnectSettings({
-      firmwareManifestMode: 'sdk-managed',
-      preloadedConfig,
-    });
-
-    await DataManager.load(settings);
-
-    expect(mockAxiosGet).not.toHaveBeenCalled();
-    expect(DataManager.deviceMap.classic).toEqual({ firmware: [], ble: [] });
-  });
+  it('keeps custom configFetcher in parsed settings', () => {
+    const configFetcher = jest.fn();
 
-  it('fails closed without a preloaded config in external-only mode', async () => {
     const settings = parseConnectSettings({
-      firmwareManifestMode: 'external-only',
+      fetchConfig: true,
+      configFetcher,
     });
 
-    await expect(DataManager.load(settings)).rejects.toThrow(
-      'External firmware config snapshot is required'
-    );
-    expect(mockAxiosGet).not.toHaveBeenCalled();
+    expect(settings.configFetcher).toBe(configFetcher);
   });
 });

package/__tests__/firmware-update/firmware-update-v2-download-before-boot.test.ts

@@ -1,8 +1,8 @@
-import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
 import { getBinary } from '../../src/api/firmware/getBinary';
-import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
+import { uploadFirmware } from '../../src/api/firmware/uploadFirmware';
 import * as utils from '../../src/utils';
 
 jest.mock('../../src/data/config', () => ({
@@ -18,8 +18,7 @@ jest.mock('../../src/api/firmware/getBinary', () => ({
 
 jest.mock('../../src/api/firmware/uploadFirmware', () => ({
   updateResources: jest.fn(),
-  updateResourcesFromSources: jest.fn(),
-  uploadFirmwareFromSource: jest.fn(),
+  uploadFirmware: jest.fn(),
 }));
 
 jest.mock('../../src/device/DevicePool', () => ({
@@ -30,9 +29,7 @@ jest.mock('../../src/device/DevicePool', () => ({
 }));
 
 const mockGetBinary = getBinary as jest.MockedFunction<typeof getBinary>;
-const mockUploadFirmwareFromSource = uploadFirmwareFromSource as jest.MockedFunction<
-  typeof uploadFirmwareFromSource
->;
+const mockUploadFirmware = uploadFirmware as jest.MockedFunction<typeof uploadFirmware>;
 
 type DeviceType = 'CLASSIC1S' | 'PURE';
 
@@ -178,26 +175,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).toHaveBeenCalledTimes(1);
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
-  });
-
-  it('preserves structured preparation errors before any firmware mutation', async () => {
-    const preparationError = ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      'Firmware must be prepared by the external firmware host',
-      {
-        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-        artifactName: 'firmware',
-      }
-    );
-    mockGetBinary.mockRejectedValue(preparationError);
-    const { method, typedCall, acquire } = createMethod();
-
-    await expect(method.run()).rejects.toBe(preparationError);
-
-    expectNoFirmwareMutationCalls(typedCall);
-    expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -238,11 +216,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           binary: firmwareBinary,
         } as Awaited<ReturnType<typeof getBinary>>);
       });
-      mockUploadFirmwareFromSource.mockImplementation(() => {
+      mockUploadFirmware.mockImplementation(() => {
         callOrder.push('upload');
-        return Promise.resolve(
-          expectedResponse as Awaited<ReturnType<typeof uploadFirmwareFromSource>>
-        );
+        return Promise.resolve(expectedResponse as Awaited<ReturnType<typeof uploadFirmware>>);
       });
       const { method, typedCall } = createMethod({
         updateType,
@@ -272,15 +248,15 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           },
         })
       );
-      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
         updateType,
         expect.any(Function),
         expect.any(Function),
         method.device,
-        expect.objectContaining({
-          size: firmwareBinary.byteLength,
-        }),
-        true,
+        {
+          payload: firmwareBinary,
+          rebootOnSuccess: true,
+        },
         isUpdateBootloader
       );
     }
@@ -295,11 +271,11 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
         binary: firmwareBinary,
       } as Awaited<ReturnType<typeof getBinary>>);
     });
-    mockUploadFirmwareFromSource.mockImplementation(() => {
+    mockUploadFirmware.mockImplementation(() => {
       callOrder.push('upload');
       return Promise.resolve({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
     });
     const { method, typedCall, acquire } = createMethod({
       bootloaderMode: true,
@@ -324,9 +300,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           resolveDownload = resolve;
         })
     );
-    mockUploadFirmwareFromSource.mockResolvedValue({
+    mockUploadFirmware.mockResolvedValue({
       success: true,
-    } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
     const { method, typedCall } = createMethod();
 
     const runPromise = method.run();
@@ -357,7 +333,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
 
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -366,23 +342,23 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
   ])(
     'keeps the non-empty %s binary overload and never downloads it again',
     async (_kind, binary) => {
-      mockUploadFirmwareFromSource.mockResolvedValue({
+      mockUploadFirmware.mockResolvedValue({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
       const { method } = createMethod({ binary });
 
       await method.run();
 
       expect(mockGetBinary).not.toHaveBeenCalled();
-      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
         'firmware',
         expect.any(Function),
         expect.any(Function),
         method.device,
-        expect.objectContaining({
-          size: binary.byteLength,
-        }),
-        true,
+        {
+          payload: binary,
+          rebootOnSuccess: true,
+        },
         undefined
       );
     }
@@ -393,21 +369,17 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     ['DataView', new DataView(new Uint8Array([9, 3, 4, 9]).buffer, 1, 2), [3, 4]],
     ['custom Buffer', createCustomBuffer(4), [1, 2, 3, 4]],
   ])('normalizes a non-empty %s before rebooting', async (_kind, binary, expectedBytes) => {
-    let uploadedBytes: number[] = [];
-    mockUploadFirmwareFromSource.mockImplementation(
-      async (_updateType, _typedCall, _postMessage, _device, source) => {
-        uploadedBytes = Array.from(new Uint8Array(await source.readAt(0, source.size)));
-        return {
-          success: true,
-        } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>;
-      }
-    );
+    mockUploadFirmware.mockResolvedValue({
+      success: true,
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
     const { method } = createMethod({ binary });
 
     await method.run();
 
     expect(mockGetBinary).not.toHaveBeenCalled();
-    expect(uploadedBytes).toEqual(expectedBytes);
+    const normalizedBinary = mockUploadFirmware.mock.calls[0][4].payload;
+    expect(normalizedBinary).toBeInstanceOf(ArrayBuffer);
+    expect(Array.from(new Uint8Array(normalizedBinary))).toEqual(expectedBytes);
   });
 
   it.each([
@@ -425,6 +397,6 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).not.toHaveBeenCalled();
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 });

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

@@ -1,5 +1,10 @@
+import { EDeviceType } 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,31 @@ 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();
+  });
 });

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', () => {