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

package/__tests__/protocol-v2.test.ts

@@ -100,6 +100,12 @@ import {
 } from '../src/utils';
 import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
 import { openFirmwareByteSource } from '../src/api/firmware/FirmwareArtifactSource';
+import {
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from '../src/api/firmware/FirmwareHostBinding';
+import { prepareFirmwareUpdatePlan } from '../src/api/firmware/FirmwareUpdatePreparedPlan';
+import { digestFirmwareUpdateContract } from '../src/api/firmware/FirmwareUpdatePlan';
 import {
   getPassphraseState,
   getPassphraseStateWithRefreshDeviceInfo,
@@ -5579,23 +5585,31 @@ describe('Protocol V2 firmware update targets', () => {
       .mockResolvedValue(undefined);
     (method as any).isProtocolV2ResourceBundleUpToDate = jest.fn().mockResolvedValue(false);
 
-    await (method as any).executeProtocolV2Update({
-      resourceBundles: [
+    await (method as any).executeProtocolV2SourceUpdate({
+      resourceSources: [
         {
           name: 'images.okpkg',
-          binary: new Uint8Array([1, 2]).buffer,
+          source: {
+            size: 2,
+            readAt: jest.fn(),
+            close: jest.fn(),
+          },
           devicePath: 'vol0:/bundles/images/images.okpkg',
           version: [1, 2, 3],
           payloadHash: '11'.repeat(64),
           headerHash: '22'.repeat(64),
         },
       ],
-      bootloaderBinary: null,
-      fwBinaryMap: [
+      installSources: [
         {
           fileName: 'application_p1.bin',
-          binary: new Uint8Array([3]).buffer,
+          source: {
+            size: 1,
+            readAt: jest.fn(),
+            close: jest.fn(),
+          },
           targetId: 4,
+          kind: 'firmware',
         },
       ],
     });
@@ -6101,56 +6115,218 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('rejects prepared RESC bundle paths before opening an artifact source', async () => {
+  test('maps a prepared resource archive manifest to artifact-backed resource sources', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const openPreparedSource = jest.fn();
+    const imagesBinary = createProtocolV2OkppBinary();
+    const bootBinary = createProtocolV2OkppBinary({ payloadHashByte: 0x33 });
+    const imagesSha256 = '1'.repeat(64);
+    const bootSha256 = '2'.repeat(64);
+    const manifest = {
+      schema: 1,
+      artifact_name: 'pro2-resource',
+      release_name: 'test-release',
+      variant: 'resource',
+      commit: 'abc123',
+      short_sha: 'abc123',
+      timestamp_utc: '2026-08-09T00:00:00Z',
+      core_version: '1.0.0',
+      key_set: 'production',
+      device_root: 'vol0:',
+      restore_mode: 'bootloader_update',
+      trees: [{ path: 'bundles', device: 'pro2' }],
+      files: [
+        {
+          archive_path: 'bundles/images/images.okpkg',
+          original_name: 'images.okpkg',
+          device_path: 'vol0:/bundles/images/images.okpkg',
+          size: imagesBinary.byteLength,
+          sha256: imagesSha256,
+          signed: true,
+          sig_algo: 'ed25519',
+          payload_version: '1.2.3',
+        },
+        {
+          archive_path: 'loaders/bootloader/boot_resource.okpkg',
+          original_name: 'boot_resource.okpkg',
+          device_path: 'vol0:/loaders/bootloader/boot_resource.okpkg',
+          size: bootBinary.byteLength,
+          sha256: bootSha256,
+          signed: true,
+          sig_algo: 'ed25519',
+          payload_version: '1.2.3',
+        },
+      ],
+    };
+    const manifestBinary = new TextEncoder().encode(JSON.stringify(manifest)).buffer;
+    const artifacts = new Map([
+      ['manifest', manifestBinary],
+      ['images', imagesBinary],
+      ['boot', bootBinary],
+    ]);
     (method as any).params = {
       targetsToUpdate: ['resource'],
-      resourceBundleArtifacts: [
+      preparedPlan: {
+        artifacts: [
+          {
+            artifactId: 'resource:archive',
+            role: 'resourceBundle',
+            target: 'resource',
+            container: 'zip',
+            materializedEntries: [
+              {
+                entryName: 'manifest.json',
+                artifact: {
+                  artifactRef: 'manifest',
+                  size: manifestBinary.byteLength,
+                  sha256: '0'.repeat(64),
+                },
+              },
+              {
+                entryName: 'bundles/images/images.okpkg',
+                artifact: {
+                  artifactRef: 'images',
+                  size: imagesBinary.byteLength,
+                  sha256: imagesSha256,
+                },
+              },
+              {
+                entryName: 'loaders/bootloader/boot_resource.okpkg',
+                artifact: {
+                  artifactRef: 'boot',
+                  size: bootBinary.byteLength,
+                  sha256: bootSha256,
+                },
+              },
+            ],
+          },
+        ],
+      },
+    };
+    (method as any).openProtocolV2PreparedSource = jest.fn(async artifact => {
+      const binary = artifacts.get(artifact.artifactRef);
+      if (!binary) throw new Error(`Unknown artifact: ${artifact.artifactRef}`);
+      return openFirmwareByteSource({ binary });
+    });
+
+    const sources = await (method as any).prepareProtocolV2ResourceArchiveSources();
+
+    expect(sources).toHaveLength(2);
+    expect(sources).toEqual([
+      expect.objectContaining({
+        name: 'images.okpkg',
+        devicePath: 'vol0:/bundles/images/images.okpkg',
+        version: [1, 2, 3],
+      }),
+      expect.objectContaining({
+        name: 'boot_resource.okpkg',
+        devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg',
+        version: [1, 2, 3],
+      }),
+    ]);
+    await Promise.all(sources.map(source => source.source.close()));
+  });
+
+  test('binds a prepared resource archive to the selected host generation', () => {
+    const planWithoutDigest = {
+      schemaVersion: 2 as const,
+      executor: 'v4' as const,
+      deviceIdentity: 'PRO2-SERIAL',
+      deviceModel: 'pro2',
+      firmwareType: EFirmwareType.Universal,
+      platform: 'web' as const,
+      targetsToUpdate: ['resource' as const],
+      artifacts: [
+        {
+          artifactId: 'resource:archive',
+          role: 'resourceBundle' as const,
+          target: 'resource' as const,
+          url: 'https://example.com/resource.zip',
+          container: 'zip' as const,
+          logicalName: 'protocol-v2-resource-archive',
+        },
+      ],
+    };
+    const plan = {
+      ...planWithoutDigest,
+      planDigest: digestFirmwareUpdateContract(planWithoutDigest),
+    };
+    const preparedPlan = prepareFirmwareUpdatePlan({
+      plan,
+      leaseRef: 'resource-archive-test',
+      artifacts: [
         {
-          name: 'images',
+          artifactId: 'resource:archive',
           artifact: {
-            artifactRef: `fw:${'a'.repeat(64)}`,
-            size: 1,
+            artifactRef: 'resource-archive',
+            size: 3,
             sha256: 'a'.repeat(64),
           },
+          materializedEntries: [
+            {
+              entryName: 'manifest.json',
+              artifact: {
+                artifactRef: 'resource-manifest',
+                size: 2,
+                sha256: 'b'.repeat(64),
+              },
+            },
+          ],
         },
       ],
-    };
-    (method as any).openProtocolV2PreparedSource = openPreparedSource;
-    const getFirmwareLatestReleaseSpy = jest
-      .spyOn(DataManager, 'getFirmwareLatestRelease')
-      .mockReturnValue({
-        required: false,
-        version: [1, 0, 0],
-        url: '',
-        resourceBundles: [
-          {
-            name: 'images',
-            url: 'https://example.com/images.okpkg',
-            devicePath: 'vol0:/resource/../images.okpkg',
-          },
-        ],
-        fingerprint: '',
-        changelog: {
-          'zh-CN': '',
-          'en-US': '',
+    });
+    const mismatchedHostBindingGeneration = registerFirmwareUpdateHostBinding({
+      preparedPlanDigest: 'c'.repeat(64),
+      artifactReader: {
+        open: jest.fn(),
+        read: jest.fn(),
+        close: jest.fn(),
+      },
+    });
+    try {
+      const mismatchedMethod = new FirmwareUpdateV4({
+        id: 1,
+        payload: {
+          method: 'firmwareUpdateV4',
+          platform: 'web',
+          targetsToUpdate: ['resource'],
+          preparedPlan,
+          hostBindingGeneration: mismatchedHostBindingGeneration,
         },
       });
 
-    await expect(
-      (method as any).prepareProtocolV2ResourceSources('universal', {
-        deviceType: 'pro2',
-      })
-    ).rejects.toThrow('resourceBundles[].devicePath');
-    expect(openPreparedSource).not.toHaveBeenCalled();
+      expect(() => mismatchedMethod.init()).toThrow('does not match the prepared plan');
+    } finally {
+      unregisterFirmwareUpdateHostBinding(mismatchedHostBindingGeneration);
+    }
+    const hostBindingGeneration = registerFirmwareUpdateHostBinding({
+      preparedPlanDigest: preparedPlan.preparedPlanDigest,
+      artifactReader: {
+        open: jest.fn(),
+        read: jest.fn(),
+        close: jest.fn(),
+      },
+    });
+    try {
+      const method = new FirmwareUpdateV4({
+        id: 1,
+        payload: {
+          method: 'firmwareUpdateV4',
+          platform: 'web',
+          targetsToUpdate: ['resource'],
+          preparedPlan,
+          hostBindingGeneration,
+        },
+      });
 
-    getFirmwareLatestReleaseSpy.mockRestore();
+      expect(() => method.init()).not.toThrow();
+    } finally {
+      unregisterFirmwareUpdateHostBinding(hostBindingGeneration);
+    }
   });
 
   test('stops a remote update before reboot when the latest config cannot be refreshed', async () => {
@@ -6219,252 +6395,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('treats manual resource files as authoritative payload for resource', async () => {
-    const resourceBundle = createProtocolV2OkppBinary();
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-        targetsToUpdate: ['resource'],
-        resourceFiles: [
-          {
-            binary: resourceBundle,
-            devicePath: '  VOL0:/resource/images/images.okpkg  ',
-          },
-        ],
-      },
-    });
-    method.init();
-    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
-    (method as any).device = stubDevice({
-      originalDescriptor: { protocolType: 'V2' },
-      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
-    });
-    (method as any).prepareRemoteProtocolV2Binaries = jest.fn();
-    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(true);
-    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
-    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
-    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
-      bootloaderVersion: '1.0.0',
-      bleVersion: '0.0.0',
-      firmwareVersion: '1.0.0',
-    });
-    method.postTipMessage = jest.fn();
-
-    await method.run();
-
-    expect(forceReloadDataSpy).not.toHaveBeenCalled();
-    expect((method as any).prepareRemoteProtocolV2Binaries).not.toHaveBeenCalled();
-    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith(
-      expect.objectContaining({
-        resourceBundles: [
-          {
-            name: 'images.okpkg',
-            binary: resourceBundle,
-            devicePath: 'vol0:/resource/images/images.okpkg',
-            version: [1, 2, 3],
-            payloadHash: '11'.repeat(64),
-            headerHash: '22'.repeat(64),
-          },
-        ],
-      })
-    );
-  });
-
-  test('downloads every missing firmware target when manifest resources are already prepared', async () => {
-    const resourceBundle = createProtocolV2OkppBinary();
-    const applicationBinary = new Uint8Array([7]).buffer;
-    const remoteBinaries = {
-      bootloaderBinary: null,
-      fwBinaryMap: [
-        {
-          fileName: 'application_p1.bin',
-          binary: applicationBinary,
-          targetId: 4,
-        },
-      ],
-      installItems: [
-        {
-          fileName: 'application_p1.bin',
-          binary: applicationBinary,
-          targetId: 4,
-          kind: 'firmware',
-        },
-      ],
-    };
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-        targetsToUpdate: ['app_v1', 'resource'],
-        resourceFiles: [
-          {
-            binary: resourceBundle,
-            devicePath: 'vol0:/bundles/images/images.okpkg',
-          },
-        ],
-      },
-    });
-    method.init();
-    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
-    (method as any).device = stubDevice({
-      originalDescriptor: { protocolType: 'V2' },
-      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
-    });
-    (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue(remoteBinaries);
-    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
-    method.postTipMessage = jest.fn();
-
-    await method.run();
-
-    expect(forceReloadDataSpy).toHaveBeenCalledTimes(1);
-    expect((method as any).prepareRemoteProtocolV2Binaries).toHaveBeenCalledWith(
-      'universal',
-      expect.objectContaining({ deviceType: 'pro2' }),
-      []
-    );
-    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
-      bootloaderBinary: null,
-      fwBinaryMap: remoteBinaries.fwBinaryMap,
-      installItems: remoteBinaries.installItems,
-      resourceBundles: [
-        {
-          name: 'images.okpkg',
-          binary: resourceBundle,
-          devicePath: 'vol0:/bundles/images/images.okpkg',
-          version: [1, 2, 3],
-          payloadHash: '11'.repeat(64),
-          headerHash: '22'.repeat(64),
-        },
-      ],
-    });
-  });
-
-  test('rejects a mixed resource plan when the requested firmware release is unavailable', async () => {
-    const resourceBundle = createProtocolV2OkppBinary();
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-        targetsToUpdate: ['app_v1', 'resource'],
-        resourceFiles: [
-          {
-            binary: resourceBundle,
-            devicePath: 'vol0:/bundles/images/images.okpkg',
-          },
-        ],
-      },
-    });
-    method.init();
-    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
-    (method as any).device = stubDevice({
-      originalDescriptor: { protocolType: 'V2' },
-      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
-    });
-    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(undefined);
-    (method as any).executeProtocolV2Update = jest.fn();
-    method.postTipMessage = jest.fn();
-
-    await expect(method.run()).rejects.toThrow(
-      'Protocol V2 firmware release is unavailable for requested targets: app_v1'
-    );
-    expect((method as any).executeProtocolV2Update).not.toHaveBeenCalled();
-  });
-
-  test('combines prepared firmware components with explicit manifest resource files', async () => {
-    const resourceBundle = createProtocolV2OkppBinary();
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-      },
-    });
-    method.init();
-    (method as any).params = {
-      targetsToUpdate: ['app_v1', 'resource'],
-      resourceFiles: [
-        {
-          binary: resourceBundle,
-          devicePath: 'vol0:/bundles/images/images.okpkg',
-        },
-      ],
-    };
-    const firmwareSource = { size: 10 };
-    const resourceSource = { size: resourceBundle.byteLength };
-    (method as any).prepareProtocolV2InstallSources = jest.fn().mockResolvedValue([
-      {
-        fileName: 'application_p1.bin',
-        source: firmwareSource,
-        targetId: 4,
-        kind: 'firmware',
-      },
-    ]);
-    (method as any).prepareProtocolV2ResourceSources = jest.fn();
-    (method as any).openProtocolV2MemorySource = jest.fn().mockResolvedValue(resourceSource);
-    (method as any).executeProtocolV2SourceUpdate = jest.fn().mockResolvedValue(undefined);
-    (method as any).closeProtocolV2PreparedSources = jest.fn().mockResolvedValue(undefined);
-    method.postTipMessage = jest.fn();
-
-    await (method as any).runProtocolV2PreparedArtifacts({ deviceType: 'pro2' }, 'universal');
-
-    expect((method as any).prepareProtocolV2ResourceSources).not.toHaveBeenCalled();
-    expect((method as any).executeProtocolV2SourceUpdate).toHaveBeenCalledWith({
-      installSources: [
-        {
-          fileName: 'application_p1.bin',
-          source: firmwareSource,
-          targetId: 4,
-          kind: 'firmware',
-        },
-      ],
-      resourceSources: [
-        {
-          name: 'images.okpkg',
-          source: resourceSource,
-          devicePath: 'vol0:/bundles/images/images.okpkg',
-          version: [1, 2, 3],
-          payloadHash: '11'.repeat(64),
-          headerHash: '22'.repeat(64),
-        },
-      ],
-    });
-  });
-
-  test('rejects manual RESC bundle paths before bootloader entry', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-        resourceFiles: [
-          {
-            binary: new Uint8Array([1, 2, 3]).buffer,
-            devicePath: 'vol2:/resource/images/images.okpkg',
-          },
-        ],
-      },
-    });
-    method.init();
-    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
-
-    (method as any).device = stubDevice({
-      originalDescriptor: { protocolType: 'V2' },
-      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
-    });
-    (method as any).prepareRemoteProtocolV2Binaries = jest.fn();
-    (method as any).enterProtocolV2BootloaderMode = jest.fn();
-    method.postTipMessage = jest.fn();
-
-    await expect(method.run()).rejects.toThrow('resourceFiles[0].devicePath');
-    expect((method as any).prepareRemoteProtocolV2Binaries).not.toHaveBeenCalled();
-    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
-  });
-
-  test('syncs resource bundles without sending a firmware install request', async () => {
+  test('syncs prepared resource sources without sending a firmware install request', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -6481,16 +6412,19 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).protocolV2StartFirmwareUpdate = jest.fn();
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest.fn();
 
-    await (method as any).executeProtocolV2Update({
-      resourceBundles: [
+    await (method as any).executeProtocolV2SourceUpdate({
+      installSources: [],
+      resourceSources: [
         {
           name: 'images.okpkg',
-          binary: new Uint8Array([1, 2, 3]).buffer,
+          source: {
+            size: 3,
+            readAt: jest.fn(),
+            close: jest.fn(),
+          },
           devicePath: 'vol0:/resource/images/images.okpkg',
         },
       ],
-      bootloaderBinary: null,
-      fwBinaryMap: [],
     });
 
     expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenCalledTimes(1);
@@ -6520,16 +6454,19 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
 
-    await (method as any).executeProtocolV2Update({
-      resourceBundles: [
+    await (method as any).executeProtocolV2SourceUpdate({
+      installSources: [],
+      resourceSources: [
         {
           name: 'boot_resource.okpkg',
-          binary: new Uint8Array([1, 2, 3]).buffer,
+          source: {
+            size: 3,
+            readAt: jest.fn(),
+            close: jest.fn(),
+          },
           devicePath: 'vol0:/loaders/bootloader/boot_resource.okpkg',
         },
       ],
-      bootloaderBinary: null,
-      fwBinaryMap: [],
     });
 
     const stagingPath = 'vol0:/loaders/bootloader/boot_resource.okpkg.staging';
@@ -7411,27 +7348,39 @@ describe('Protocol V2 firmware reconnect identity', () => {
     expect((method as any).protocolV2SourceUpdateProcess).not.toHaveBeenCalled();
   });
 
-  test('rejects a manually supplied resource file when its manifest hash does not match', () => {
+  test('updates a resource when the installed file size differs despite matching headers', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
         platform: 'web',
-        resourceFiles: [
-          {
-            binary: new Uint8Array([1, 2, 3]).buffer,
-            devicePath: 'vol0:/assets/loaders/boot.staging/graphics/bootloader_crest.bin',
-            size: 3,
-            fileHash: '00'.repeat(32),
-          },
-        ],
       },
     });
     method.init();
+    const installedBinary = new Uint8Array(createProtocolV2OkppBinary());
+    const typedCall = jest.fn((requestType: string) => {
+      if (requestType === 'FilesystemPathInfoQuery') {
+        return Promise.resolve({
+          message: { exist: true, directory: false, size: installedBinary.byteLength + 1 },
+        });
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
 
-    expect(() => (method as any).prepareExplicitProtocolV2ResourceFiles()).toThrow(
-      'SHA-256 mismatch'
-    );
+    await expect(
+      (method as any).isProtocolV2ResourceBundleUpToDate({
+        name: 'images.okpkg',
+        source: { size: installedBinary.byteLength },
+        devicePath: 'vol0:/bundles/images/images.okpkg',
+        version: [1, 2, 3],
+        payloadHash: '11'.repeat(64),
+        headerHash: '22'.repeat(64),
+      })
+    ).resolves.toBe(false);
+    expect(typedCall).toHaveBeenCalledTimes(1);
   });
 });
 

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

@@ -1 +1 @@
-{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAiC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EACV,kBAAkB,EAElB,kCAAkC,EAClC,+BAA+B,EAChC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EAGrB,MAAM,UAAU,CAAC;AAgIlB,MAAM,MAAM,6BAA6B,GAAG;IAC1C,YAAY,EAAE,aAAa,CAAC;IAC5B,MAAM,EAAE,+BAA+B,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,mBAAmB,CAAC;IACrC,UAAU,EAAE,kCAAkC,EAAE,CAAC;IACjD,eAAe,EAAE,sBAAsB,EAAE,CAAC;IAC1C,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,EAC7C,eAAe,EACf,mBAAwB,EACxB,iBAAyB,EACzB,mBAAwB,EACxB,YAAY,EACZ,OAAO,EACP,UAAU,GACX,EAAE;IACD,eAAe,EAAE,mBAAmB,CAAC;IACrC,mBAAmB,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACpD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IAC9D,YAAY,EAAE,aAAa,CAAC;IAC5B,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC1C,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAC7B,GAAG,6BAA6B,CAiFhC;AAID,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,qBAAqB;IAIrB,IAAI;IAME,GAAG;YAuFK,aAAa;CAmI5B"}
+{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAiC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EACV,kBAAkB,EAElB,kCAAkC,EAClC,+BAA+B,EAChC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EAGrB,MAAM,UAAU,CAAC;AAgIlB,MAAM,MAAM,6BAA6B,GAAG;IAC1C,YAAY,EAAE,aAAa,CAAC;IAC5B,MAAM,EAAE,+BAA+B,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,mBAAmB,CAAC;IACrC,UAAU,EAAE,kCAAkC,EAAE,CAAC;IACjD,eAAe,EAAE,sBAAsB,EAAE,CAAC;IAC1C,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,EAC7C,eAAe,EACf,mBAAwB,EACxB,iBAAyB,EACzB,mBAAwB,EACxB,YAAY,EACZ,OAAO,EACP,UAAU,GACX,EAAE;IACD,eAAe,EAAE,mBAAmB,CAAC;IACrC,mBAAmB,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACpD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IAC9D,YAAY,EAAE,aAAa,CAAC;IAC5B,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC1C,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAC7B,GAAG,6BAA6B,CAiFhC;AAID,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,qBAAqB;IAIrB,IAAI;IAME,GAAG;YAuFK,aAAa;CA0H5B"}

package/dist/api/FirmwareUpdateV4.d.ts

@@ -26,6 +26,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     private closeProtocolV2PreparedSources;
     private prepareProtocolV2InstallSources;
     private prepareProtocolV2ResourceSources;
+    private prepareProtocolV2ResourceArchiveSources;
     private runProtocolV2PreparedArtifacts;
     private validateExpectedTargetVersions;
     private getExpectedProtocolV2TargetVersion;
@@ -39,14 +40,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     private captureProtocolV2PhysicalIdentity;
     private verifyProtocolV2ReconnectIdentity;
     private prepareBootloaderBinary;
-    private hasExplicitProtocolV2Payload;
     private getMissingProtocolV2FirmwareTargets;
     private buildProtocolV2InstallItems;
     private getRemoteComponentEntries;
     private getRemoteComponentTarget;
     private downloadRemoteProtocolV2Component;
     private prepareRemoteProtocolV2Binaries;
-    private prepareExplicitProtocolV2ResourceFiles;
     private getProtocolV2ResourceFilePath;
     private readProtocolV2DeviceFileHeader;
     private isProtocolV2ResourceBundleUpToDate;