@onekeyfe/hd-core 1.2.0-alpha.84 → 1.2.0-alpha.85

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

@@ -62,14 +62,6 @@ const release: IFirmwareReleaseInfo = {
       version: [2, 0, 0],
     },
   },
-  resourceBundles: [
-    {
-      name: 'images',
-      url: 'https://example.com/images.okpkg',
-      devicePath: 'vol0:/bundles/images/images.okpkg',
-      version: [1, 0, 0],
-    },
-  ],
 };
 
 const resourceSource = {
@@ -152,7 +144,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
   test('detects same-version package hotfixes by P1 and P2 payload hash', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
-      resourceBundles: undefined,
       installOrder: ['applicationP1', 'applicationP2'],
       components: {
         applicationP1: {
@@ -203,7 +194,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
       required: false,
-      resourceBundles: undefined,
       installOrder: ['applicationP1'],
       components: {
         applicationP1: {
@@ -234,7 +224,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
       required: false,
-      resourceBundles: undefined,
       installOrder: ['applicationP1'],
       components: {
         applicationP1: {
@@ -265,7 +254,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
   test('updates both application packages when normal mode only reports P1', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
-      resourceBundles: undefined,
       installOrder: ['applicationP1', 'applicationP2'],
       components: {
         applicationP1: {
@@ -339,8 +327,14 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
         artifacts: [
           { artifactId: 'component:boot', target: 'boot' },
           { artifactId: 'component:app_v1', target: 'app_v1' },
+          {
+            artifactId: 'resource:archive',
+            target: 'resource',
+            role: 'resourceBundle',
+            container: 'zip',
+          },
         ],
-        targetsToUpdate: ['boot', 'app_v1'],
+        targetsToUpdate: ['boot', 'app_v1', 'resource'],
       },
       firmware: {
         status: 'required',
@@ -391,8 +385,9 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
           { artifactId: 'component:app_v1', target: 'app_v1' },
           { artifactId: 'component:se02', target: 'se02' },
           { artifactId: 'component:se03', target: 'se03' },
+          { artifactId: 'resource:archive', target: 'resource', container: 'zip' },
         ],
-        targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03'],
+        targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03', 'resource'],
       },
     });
   });
@@ -449,8 +444,9 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
         artifacts: [
           { artifactId: 'component:app_v1', target: 'app_v1' },
           { artifactId: 'component:coprocessor', target: 'coprocessor' },
+          { artifactId: 'resource:archive', target: 'resource', container: 'zip' },
         ],
-        targetsToUpdate: ['app_v1', 'coprocessor'],
+        targetsToUpdate: ['app_v1', 'coprocessor', 'resource'],
       },
     });
   });
@@ -576,7 +572,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
         executor: 'v4',
         deviceModel: 'neo',
         platform: 'native',
-        targetsToUpdate: ['se01', 'se02'],
+        targetsToUpdate: ['se01', 'se02', 'resource'],
       },
     });
   });
@@ -611,7 +607,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
       required: false,
-      resourceBundles: undefined,
       installOrder: ['applicationP1'],
       components: {
         applicationP1: {
@@ -730,7 +725,18 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       resourceStatus: 'unknown',
       resourcePreparationRequired: true,
       targetsToUpdate: ['resource'],
-      firmwareUpdatePlan: undefined,
+      firmwareUpdatePlan: {
+        executor: 'v4',
+        artifacts: [
+          {
+            artifactId: 'resource:archive',
+            target: 'resource',
+            role: 'resourceBundle',
+            container: 'zip',
+          },
+        ],
+        targetsToUpdate: ['resource'],
+      },
     });
   });
 

package/__tests__/firmware-memory-host.test.ts

@@ -0,0 +1,105 @@
+import { prepareFirmwareUpdateV4MemoryHost } from '../src/api/firmware/FirmwareMemoryHost';
+
+import type { CoreApi } from '../src/types/api';
+import type { FirmwareUpdatePlan } from '../src/types/api/firmwareUpdatePlan';
+
+describe('prepareFirmwareUpdateV4MemoryHost', () => {
+  test('registers artifact-backed component and resource readers', async () => {
+    const componentBinary = new Uint8Array([1, 2, 3, 4]).buffer;
+    const archiveBinary = new Uint8Array([5, 6]).buffer;
+    const manifestBinary = new TextEncoder().encode('{"schema":1}').buffer;
+    let artifactReader: Parameters<
+      CoreApi['registerFirmwareUpdateHostBinding']
+    >[0]['artifactReader'];
+    const unregisterFirmwareUpdateHostBinding = jest.fn();
+    const sdk = {
+      prepareFirmwareUpdatePlan: jest.fn(({ plan, artifacts }) => ({
+        schemaVersion: 2,
+        preparedPlanDigest: 'b'.repeat(64),
+        planDigest: plan.planDigest,
+        networkPolicy: 'forbid',
+        executor: plan.executor,
+        deviceIdentity: plan.deviceIdentity,
+        deviceModel: plan.deviceModel,
+        firmwareType: plan.firmwareType,
+        platform: plan.platform,
+        leaseRef: 'test-lease',
+        targetsToUpdate: plan.targetsToUpdate,
+        artifacts: plan.artifacts.map(planArtifact => {
+          const input = artifacts.find(item => item.artifactId === planArtifact.artifactId);
+          return {
+            ...planArtifact,
+            artifact: input?.artifact,
+            materializedEntries: input?.materializedEntries,
+          };
+        }),
+      })),
+      registerFirmwareUpdateHostBinding: jest.fn(binding => {
+        artifactReader = binding.artifactReader;
+        return 7;
+      }),
+      unregisterFirmwareUpdateHostBinding,
+    } as unknown as Pick<
+      CoreApi,
+      | 'prepareFirmwareUpdatePlan'
+      | 'registerFirmwareUpdateHostBinding'
+      | 'unregisterFirmwareUpdateHostBinding'
+    >;
+    const plan = {
+      schemaVersion: 2,
+      planDigest: 'a'.repeat(64),
+      executor: 'v4',
+      deviceIdentity: 'device-id',
+      deviceModel: 'pro2',
+      firmwareType: 0,
+      platform: 'web',
+      targetsToUpdate: ['boot', 'resource'],
+      artifacts: [
+        {
+          artifactId: 'component:boot',
+          role: 'component',
+          target: 'boot',
+          url: 'https://example.com/boot.okpkg',
+          container: 'raw',
+        },
+        {
+          artifactId: 'resource:archive',
+          role: 'resourceBundle',
+          target: 'resource',
+          url: 'https://example.com/resource.zip',
+          container: 'zip',
+          logicalName: 'resource-archive',
+        },
+      ],
+    } as FirmwareUpdatePlan;
+
+    const host = prepareFirmwareUpdateV4MemoryHost({
+      sdk,
+      plan,
+      artifacts: [
+        { artifactId: 'component:boot', binary: componentBinary },
+        {
+          artifactId: 'resource:archive',
+          binary: archiveBinary,
+          materializedEntries: [{ entryName: 'manifest.json', binary: manifestBinary }],
+        },
+      ],
+    });
+
+    expect(host.hostBindingGeneration).toBe(7);
+    expect(host.componentArtifacts.boot?.size).toBe(componentBinary.byteLength);
+    const opened = await artifactReader!.open({
+      artifactRef: host.componentArtifacts.boot!.artifactRef,
+    });
+    const chunk = await artifactReader!.read({
+      readerId: opened.readerId,
+      offset: 1,
+      length: 2,
+    });
+    expect(Array.from(new Uint8Array(chunk.data))).toEqual([2, 3]);
+    await artifactReader!.close({ readerId: opened.readerId });
+
+    host.release();
+    expect(unregisterFirmwareUpdateHostBinding).toHaveBeenCalledWith(7);
+  });
+});

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

@@ -297,12 +297,6 @@ describe('buildFirmwareUpdatePlan', () => {
       forceTarget: 'firmware' as const,
       release: {
         components: {},
-        resourceBundles: [
-          {
-            name: 'images',
-            url: 'https://firmware.onekey.so/pro2/images.okpkg',
-          },
-        ],
       },
     },
     {
@@ -325,41 +319,21 @@ describe('buildFirmwareUpdatePlan', () => {
     }
   );
 
-  test.each([
-    {
-      forceTarget: 'firmware' as const,
-      expectedArtifactIds: ['component:app_v1'],
-      expectedTargets: ['app_v1'],
-    },
-    {
-      forceTarget: 'resource' as const,
-      expectedArtifactIds: ['resourceBundle:images'],
-      expectedTargets: ['resource'],
-    },
-  ])(
-    'limits a Pro2 $forceTarget force to the selected artifact role',
-    ({ forceTarget, expectedArtifactIds, expectedTargets }) => {
-      const plan = buildFirmwareUpdatePlan(
-        createProtocolV2ForceInput([forceTarget], {
-          components: {
-            applicationP1: {
-              target: 'APPLICATION_P1',
-              url: 'https://firmware.onekey.so/pro2/application-p1.bin',
-            },
+  test('limits a Pro2 firmware force to component artifacts', () => {
+    const plan = buildFirmwareUpdatePlan(
+      createProtocolV2ForceInput(['firmware'], {
+        components: {
+          applicationP1: {
+            target: 'APPLICATION_P1',
+            url: 'https://firmware.onekey.so/pro2/application-p1.bin',
           },
-          resourceBundles: [
-            {
-              name: 'images',
-              url: 'https://firmware.onekey.so/pro2/images.okpkg',
-            },
-          ],
-        })
-      );
+        },
+      })
+    );
 
-      expect(plan.artifacts.map(artifact => artifact.artifactId)).toEqual(expectedArtifactIds);
-      expect(plan.targetsToUpdate).toEqual(expectedTargets);
-    }
-  );
+    expect(plan.artifacts.map(artifact => artifact.artifactId)).toEqual(['component:app_v1']);
+    expect(plan.targetsToUpdate).toEqual(['app_v1']);
+  });
 
   test('rejects a prepared native plan without a stable device identity', () => {
     const features = createFeatures({
@@ -384,7 +358,7 @@ describe('buildFirmwareUpdatePlan', () => {
     ).toThrow('requires a stable device identity');
   });
 
-  test('maps the Pro2 component order and resource bundles without downloading them', () => {
+  test('maps the Pro2 component order without downloading artifacts', () => {
     const plan = buildFirmwareUpdatePlan({
       features: createFeatures({ deviceType: EDeviceType.Pro2 }),
       firmwareType: EFirmwareType.Universal,
@@ -409,12 +383,6 @@ describe('buildFirmwareUpdatePlan', () => {
               url: 'https://firmware.onekey.so/pro2/se01.bin',
             },
           },
-          resourceBundles: [
-            {
-              name: 'images',
-              url: 'https://firmware.onekey.so/pro2/images.okpkg',
-            },
-          ],
         },
       },
       ble: noUpdate,
@@ -426,9 +394,8 @@ describe('buildFirmwareUpdatePlan', () => {
       'component:boot',
       'component:app_v1',
       'component:se01',
-      'resourceBundle:images',
     ]);
-    expect(plan.targetsToUpdate).toEqual(['boot', 'app_v1', 'se01', 'resource']);
+    expect(plan.targetsToUpdate).toEqual(['boot', 'app_v1', 'se01']);
     expect(plan.artifacts[1]).toEqual(
       expect.objectContaining({
         expectedSize: 1024,
@@ -477,28 +444,6 @@ describe('buildFirmwareUpdatePlan', () => {
       },
       expectedError: 'duplicates target app_v1',
     },
-    {
-      label: 'resource bundle name',
-      release: {
-        components: {
-          application: {
-            target: 'APPLICATION_P1',
-            url: 'https://firmware.onekey.so/pro2/application.bin',
-          },
-        },
-        resourceBundles: [
-          {
-            name: 'images',
-            url: 'https://firmware.onekey.so/pro2/images.okpkg',
-          },
-          {
-            name: 'images',
-            url: 'https://firmware.onekey.so/pro2/images-duplicate.okpkg',
-          },
-        ],
-      },
-      expectedError: 'duplicates name images',
-    },
   ])('rejects a duplicate Pro2 $label', ({ release, expectedError }) => {
     expect(() =>
       buildFirmwareUpdatePlan({

package/__tests__/firmware-update/firmware-update-prepared-plan.test.ts

@@ -1,6 +1,9 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
-import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+import {
+  buildFirmwareUpdatePlan,
+  digestFirmwareUpdateContract,
+} from '../../src/api/firmware/FirmwareUpdatePlan';
 import {
   assertFirmwareUpdatePreparedPlanBinding,
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
@@ -209,6 +212,55 @@ describe('FirmwareUpdatePreparedPlan', () => {
     ).toThrow('entry name is invalid');
   });
 
+  test('rejects duplicate materialized entry names during standalone validation', () => {
+    const plan = buildPlan();
+    const prepared = prepareFirmwareUpdatePlan({
+      plan,
+      leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
+      artifacts: [
+        {
+          artifactId: 'firmware',
+          artifact: artifact('a'.repeat(64), 4),
+        },
+        {
+          artifactId: 'resource',
+          artifact: artifact('b'.repeat(64), 8),
+          materializedEntries: [
+            {
+              entryName: 'resource/index.bin',
+              artifact: artifact('c'.repeat(64), 2),
+            },
+          ],
+        },
+      ],
+    });
+    const resourceArtifact = prepared.artifacts.find(item => item.target === 'resource')!;
+    const tamperedWithoutDigest = {
+      ...prepared,
+      artifacts: prepared.artifacts.map(item =>
+        item === resourceArtifact
+          ? {
+              ...item,
+              materializedEntries: [
+                ...resourceArtifact.materializedEntries!,
+                {
+                  entryName: 'other/index.bin',
+                  artifact: artifact('d'.repeat(64), 2),
+                },
+              ],
+            }
+          : item
+      ),
+    };
+    const { preparedPlanDigest: _preparedPlanDigest, ...digestInput } = tamperedWithoutDigest;
+    const tampered = {
+      ...tamperedWithoutDigest,
+      preparedPlanDigest: digestFirmwareUpdateContract(digestInput),
+    };
+
+    expect(() => validateFirmwareUpdatePreparedPlan(tampered)).toThrow('duplicate entry names');
+  });
+
   test('rejects unknown fields even when a caller presents a plan-shaped object', () => {
     const plan = buildPlan();
     expect(() =>

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

@@ -4,10 +4,8 @@ import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { DataManager } from '../src/data-manager';
 import {
-  isProtocolV2ResourceFileValid,
   parseProtocolV2ResourceManifest,
   parseProtocolV2Resources,
-  prepareProtocolV2ResourceFiles,
 } from '../src/protocols/protocol-v2/resources';
 
 import type { ConnectSettings, RemoteConfigResponse } from '../src/types';
@@ -151,42 +149,6 @@ describe('Pro2 resource configuration', () => {
     ).toThrow('archive_path');
   });
 
-  test('verifies selected manifest files and preserves manifest device paths', () => {
-    const prepared = prepareProtocolV2ResourceFiles({
-      manifest: resourceManifest,
-      files: manifestFiles.map(file => ({
-        archivePath: file.archive_path,
-        binary: file.binary,
-      })),
-      targetsToUpdate: ['resource'],
-    });
-    expect(prepared.map(file => file.devicePath)).toEqual(
-      manifestFiles.map(file => file.device_path)
-    );
-    expect(() =>
-      prepareProtocolV2ResourceFiles({
-        manifest: resourceManifest,
-        files: manifestFiles.map((file, index) => ({
-          archivePath: file.archive_path,
-          binary: index === 0 ? new Uint8Array([0]).buffer : file.binary,
-        })),
-        targetsToUpdate: ['resource'],
-      })
-    ).toThrow('verification failed');
-  });
-
-  test('verifies both full file size and SHA-256 before transfer', () => {
-    const bytes = new Uint8Array([1, 2, 3]);
-    const binary = bytes.buffer;
-    const identity = { size: bytes.byteLength, fileHash: bytesToHex(sha256(bytes)) };
-
-    expect(isProtocolV2ResourceFileValid(binary, identity)).toBe(true);
-    expect(isProtocolV2ResourceFileValid(binary, { ...identity, size: 4 })).toBe(false);
-    expect(isProtocolV2ResourceFileValid(binary, { ...identity, fileHash: '0'.repeat(64) })).toBe(
-      false
-    );
-  });
-
   test('applies a validated pre-release config and exposes its archive source', async () => {
     const configFetcher = jest.fn().mockResolvedValue(createRemoteConfig());