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

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

@@ -73,7 +73,9 @@ const release: IFirmwareReleaseInfo = {
 };
 
 const resourceSource = {
-  manifestUrl: 'https://example.com/pro2-resource/manifest.json',
+  archiveUrl: 'https://example.com/pro2-resource/pro2-resource.zip',
+  archiveSha256: 'a'.repeat(64),
+  archiveSize: 16_815_479,
 };
 
 describe('checkAllFirmwareRelease Protocol V2 support', () => {
@@ -328,8 +330,9 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       deviceType: 'pro2',
       status: 'required',
       resourceStatus: 'unknown',
-      resourceManifestUrl: resourceSource.manifestUrl,
-      targetsToUpdate: ['boot', 'app_v1'],
+      resourceArchive: resourceSource,
+      resourcePreparationRequired: true,
+      targetsToUpdate: ['boot', 'app_v1', 'resource'],
       firmware: {
         status: 'required',
       },
@@ -417,13 +420,56 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       await expect(method.run()).resolves.toMatchObject({
         protocol: 'V2',
         resourceStatus: 'unknown',
-        resourceManifestUrl: resourceSource.manifestUrl,
-        targetsToUpdate: ['boot', 'app_v1'],
+        resourceArchive: resourceSource,
+        resourcePreparationRequired: true,
+        targetsToUpdate: ['boot', 'app_v1', 'resource'],
       });
       expect(typedCall).not.toHaveBeenCalled();
     }
   );
 
+  test('requires manifest preparation when only Protocol V2 resources may have changed', async () => {
+    const currentRelease: IFirmwareReleaseInfo = {
+      ...release,
+      required: false,
+      installOrder: ['applicationP1'],
+      components: {
+        applicationP1: {
+          target: 'APPLICATION_P1',
+          url: 'https://example.com/application-p1.okpkg',
+          version: [1, 0, 0],
+        },
+      },
+    };
+    const method = new CheckAllFirmwareRelease({
+      id: 1,
+      payload: {
+        method: 'checkAllFirmwareRelease',
+        firmwareType: EFirmwareType.Universal,
+      },
+    });
+    method.init();
+    method.device = {
+      isProtocolV2: () => true,
+      features: { deviceType: 'pro2', firmwareVersion: '1.0.0' },
+      getDeviceState: jest.fn().mockResolvedValue({
+        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
+        status: { mode: 'normal' },
+        versions: { ...currentVersions, applicationP1: '1.0.0' },
+      }),
+    } as unknown as CheckAllFirmwareRelease['device'];
+    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(currentRelease);
+    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
+
+    await expect(method.run()).resolves.toMatchObject({
+      status: 'unknown',
+      hasUpgrade: true,
+      resourceStatus: 'unknown',
+      resourcePreparationRequired: true,
+      targetsToUpdate: ['resource'],
+    });
+  });
+
   test('continues forwarding the existing public method', async () => {
     const call = jest.fn().mockResolvedValue({ success: true, payload: {} });
     const api = createCoreApi(call as CoreApi['call']) as CoreApi;

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

@@ -0,0 +1,164 @@
+import { EFirmwareType } from '@onekeyfe/hd-shared';
+
+import CheckAllFirmwareRelease from '../src/api/CheckAllFirmwareRelease';
+import CheckBLEFirmwareRelease from '../src/api/CheckBLEFirmwareRelease';
+import CheckBootloaderRelease from '../src/api/CheckBootloaderRelease';
+import CheckFirmwareRelease from '../src/api/CheckFirmwareRelease';
+import { DataManager } from '../src/data-manager';
+
+import type { IFirmwareReleaseInfo } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+const release: IFirmwareReleaseInfo = {
+  required: false,
+  version: [2, 0, 0],
+  url: 'https://example.com/application-p1.okpkg',
+  fingerprint: 'release-fingerprint',
+  changelog: {
+    'zh-CN': '更新',
+    'en-US': 'Update',
+  },
+  installOrder: ['bootloader', 'applicationP1', 'coprocessor'],
+  components: {
+    bootloader: {
+      target: 'BOOTLOADER',
+      url: 'https://example.com/bootloader.okpkg',
+      version: [2, 0, 0],
+    },
+    applicationP1: {
+      target: 'APPLICATION_P1',
+      url: 'https://example.com/application-p1.okpkg',
+      version: [2, 0, 0],
+    },
+    coprocessor: {
+      target: 'COPROCESSOR',
+      url: 'https://example.com/coprocessor.okpkg',
+      version: [2, 0, 0],
+    },
+  },
+};
+
+const createDevice = (deviceType: 'pro2' | 'neo') => ({
+  isProtocolV2: () => true,
+  features: {
+    deviceType,
+    firmwareVersion: '1.0.0',
+  },
+  getDeviceState: jest.fn().mockResolvedValue({
+    identity: {
+      deviceType,
+      firmwareType: EFirmwareType.Universal,
+    },
+    status: { mode: 'normal' },
+    versions: {
+      firmware: '1.0.0',
+      applicationP1: '1.0.0',
+      bootloader: '1.0.0',
+      board: '1.0.0',
+      ble: '1.0.0',
+    },
+  }),
+});
+
+describe.each(['pro2', 'neo'] as const)('Protocol V2 release checks for %s', deviceType => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('supports firmware, BLE, bootloader, and aggregate release checks', async () => {
+    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
+    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue({
+      archiveUrl: `https://example.com/${deviceType}/pro2-resource.zip`,
+      archiveSha256: 'a'.repeat(64),
+      archiveSize: 16_815_479,
+    });
+
+    const firmwareMethod = new CheckFirmwareRelease({
+      id: 1,
+      payload: { method: 'checkFirmwareRelease' },
+    });
+    firmwareMethod.init();
+    firmwareMethod.device = createDevice(deviceType) as unknown as CheckFirmwareRelease['device'];
+
+    const bleMethod = new CheckBLEFirmwareRelease({
+      id: 2,
+      payload: { method: 'checkBLEFirmwareRelease' },
+    });
+    bleMethod.init();
+    bleMethod.device = createDevice(deviceType) as unknown as CheckBLEFirmwareRelease['device'];
+
+    const bootloaderMethod = new CheckBootloaderRelease({
+      id: 3,
+      payload: { method: 'checkBootloaderRelease' },
+    });
+    bootloaderMethod.init();
+    bootloaderMethod.device = createDevice(
+      deviceType
+    ) as unknown as CheckBootloaderRelease['device'];
+
+    const allMethod = new CheckAllFirmwareRelease({
+      id: 4,
+      payload: { method: 'checkAllFirmwareRelease' },
+    });
+    allMethod.init();
+    allMethod.device = createDevice(deviceType) as unknown as CheckAllFirmwareRelease['device'];
+
+    await expect(firmwareMethod.run()).resolves.toMatchObject({
+      status: 'outdated',
+      shouldUpdate: true,
+      release,
+    });
+    await expect(bleMethod.run()).resolves.toMatchObject({
+      status: 'outdated',
+      shouldUpdate: true,
+      release: {
+        protocol: 'V2',
+        configKey: 'coprocessor',
+        componentTarget: 'COPROCESSOR',
+        target: 'COPROCESSOR',
+        url: 'https://example.com/coprocessor.okpkg',
+        version: [2, 0, 0],
+      },
+    });
+    await expect(bootloaderMethod.run()).resolves.toMatchObject({
+      status: 'outdated',
+      shouldUpdate: true,
+      release: {
+        protocol: 'V2',
+        configKey: 'bootloader',
+        componentTarget: 'BOOTLOADER',
+        target: 'BOOTLOADER',
+        url: 'https://example.com/bootloader.okpkg',
+        version: [2, 0, 0],
+      },
+    });
+    await expect(allMethod.run()).resolves.toMatchObject({
+      protocol: 'V2',
+      deviceType,
+      status: 'outdated',
+      hasUpgrade: true,
+      resourcePreparationRequired: true,
+      targetsToUpdate: ['boot', 'app_v1', 'coprocessor', 'resource'],
+      firmware: { status: 'outdated', shouldUpdate: true },
+      ble: {
+        status: 'outdated',
+        shouldUpdate: true,
+        release: { componentTarget: 'COPROCESSOR' },
+      },
+      bootloader: {
+        status: 'outdated',
+        shouldUpdate: true,
+        release: { componentTarget: 'BOOTLOADER' },
+      },
+    });
+
+    expect(firmwareMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    expect(bleMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    expect(bootloaderMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    expect(allMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+  });
+});

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

@@ -22,7 +22,9 @@ const bytesToHex = (bytes: Uint8Array) =>
   Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
 
 const resourceSource = {
-  manifestUrl: 'https://example.com/resource/manifest.json',
+  archiveUrl: 'https://example.com/resource/pro2-resource.zip',
+  archiveSha256: 'a'.repeat(64),
+  archiveSize: 16_815_479,
 };
 
 const manifestFiles = [
@@ -122,8 +124,23 @@ describe('Pro2 resource configuration', () => {
   test('rejects missing source and malformed manifest paths', () => {
     expect(() => parseProtocolV2Resources({})).toThrow('source is required');
     expect(() =>
-      parseProtocolV2Resources({ source: { manifestUrl: 'http://example.com/manifest.json' } })
+      parseProtocolV2Resources({
+        source: {
+          ...resourceSource,
+          archiveUrl: 'http://example.com/pro2-resource.zip',
+        },
+      })
     ).toThrow('must use HTTPS');
+    expect(() =>
+      parseProtocolV2Resources({
+        source: { ...resourceSource, archiveSha256: 'invalid' },
+      })
+    ).toThrow('SHA-256');
+    expect(() =>
+      parseProtocolV2Resources({
+        source: { ...resourceSource, archiveSize: 0 },
+      })
+    ).toThrow('positive integer');
     expect(() =>
       parseProtocolV2ResourceManifest({
         ...resourceManifest,
@@ -141,12 +158,11 @@ describe('Pro2 resource configuration', () => {
         archivePath: file.archive_path,
         binary: file.binary,
       })),
-      targetsToUpdate: ['boot_resources'],
+      targetsToUpdate: ['resource'],
     });
-    expect(prepared.map(file => file.devicePath)).toEqual([
-      'vol0:/loaders/bootloader/boot_resource.okpkg',
-      'vol0:/loaders/rom/params.okpkg',
-    ]);
+    expect(prepared.map(file => file.devicePath)).toEqual(
+      manifestFiles.map(file => file.device_path)
+    );
     expect(() =>
       prepareProtocolV2ResourceFiles({
         manifest: resourceManifest,
@@ -171,7 +187,7 @@ describe('Pro2 resource configuration', () => {
     );
   });
 
-  test('applies a validated pre-release config and exposes its manifest source', async () => {
+  test('applies a validated pre-release config and exposes its archive source', async () => {
     const configFetcher = jest.fn().mockResolvedValue(createRemoteConfig());
 
     await expect(DataManager.load(createSettings(configFetcher))).resolves.toBe(true);

package/__tests__/protocol-v2.test.ts

@@ -114,6 +114,26 @@ jest.mock('../src/data/config', () => ({
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
+const createProtocolV2OkppBinary = ({
+  version = [1, 2, 3],
+  payloadHashByte = 0x11,
+  headerHashByte = 0x22,
+}: {
+  version?: [number, number, number];
+  payloadHashByte?: number;
+  headerHashByte?: number;
+} = {}) => {
+  const bytes = new Uint8Array(0x52a0);
+  bytes.set([0x4f, 0x4b, 0x50, 0x50], 0);
+  bytes.set([0x52, 0x45, 0x53, 0x43], 0x08);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0x0c, 0x52a0, true);
+  view.setUint32(0x10, version[0] * 0x10000 + version[1] * 0x100 + version[2], true);
+  bytes.fill(payloadHashByte, 0x200, 0x240);
+  bytes.fill(headerHashByte, 0x240, 0x280);
+  return bytes.buffer;
+};
+
 const createWalletSessionTypedCall = (
   implementation = jest.fn(),
   status: Partial<DeviceStatus> = { passphrase_enabled: true }
@@ -5554,6 +5574,7 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
       .fn()
       .mockResolvedValue(undefined);
+    (method as any).isProtocolV2ResourceBundleUpToDate = jest.fn().mockResolvedValue(false);
 
     await (method as any).executeProtocolV2Update({
       resourceBundles: [
@@ -5561,6 +5582,9 @@ describe('Protocol V2 firmware update targets', () => {
           name: 'images.okpkg',
           binary: new Uint8Array([1, 2]).buffer,
           devicePath: 'vol0:/bundles/images/images.okpkg',
+          version: [1, 2, 3],
+          payloadHash: '11'.repeat(64),
+          headerHash: '22'.repeat(64),
         },
       ],
       bootloaderBinary: null,
@@ -5585,6 +5609,13 @@ describe('Protocol V2 firmware update targets', () => {
       2,
       expect.objectContaining({ processedSize: 0, totalSize: 1 })
     );
+    expect((method as any).isProtocolV2ResourceBundleUpToDate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        version: [1, 2, 3],
+        payloadHash: '11'.repeat(64),
+        headerHash: '22'.repeat(64),
+      })
+    );
   });
 
   test('installs and verifies bootloader before syncing manifest resources', () => {
@@ -6111,58 +6142,118 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test.each(['resource', 'boot_resources'] as const)(
-    'treats manual resource files as authoritative payload for %s',
-    async target => {
-      const resourceBundle = new Uint8Array([1, 2, 3]).buffer;
-      const method = new FirmwareUpdateV4({
-        id: 1,
-        payload: {
-          method: 'firmwareUpdateV4',
-          platform: 'web',
-          targetsToUpdate: [target],
-          resourceFiles: [
-            {
-              binary: resourceBundle,
-              devicePath: '  VOL0:/resource/images/images.okpkg  ',
-            },
-          ],
+  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('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',
         },
-      });
-      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();
+      ],
+    };
+    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.run();
+    await (method as any).runProtocolV2PreparedArtifacts({ deviceType: 'pro2' }, 'universal');
 
-      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',
-            },
-          ],
-        })
-      );
-    }
-  );
+    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({
@@ -7086,6 +7177,61 @@ describe('Protocol V2 firmware reconnect identity', () => {
     expect(Math.max(...readChunkLengths)).toBe(900);
   });
 
+  test('skips resource transfer when installed okpkg hashes match the downloaded package', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+      },
+    });
+    method.init();
+    const installedBinary = new Uint8Array(createProtocolV2OkppBinary());
+    const typedCall = jest.fn((requestType: string, _responseType: string, request: any) => {
+      if (requestType === 'FilesystemPathInfoQuery') {
+        return Promise.resolve({
+          message: { exist: true, directory: false, size: installedBinary.byteLength },
+        });
+      }
+      if (requestType === 'FilesystemFileRead') {
+        return Promise.resolve({
+          message: {
+            data: installedBinary.slice(
+              Number(request.file.offset),
+              Number(request.file.offset) + Number(request.chunk_len)
+            ),
+          },
+        });
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+    (method as any).protocolV2SourceUpdateProcess = jest.fn();
+
+    await (method as any).executeProtocolV2TransferPhase({
+      installSources: [],
+      resourceSources: [
+        {
+          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),
+        },
+      ],
+    });
+
+    expect(typedCall).toHaveBeenCalledWith('FilesystemPathInfoQuery', 'FilesystemPathInfo', {
+      path: 'vol0:/bundles/images/images.okpkg',
+    });
+    expect((method as any).protocolV2SourceUpdateProcess).not.toHaveBeenCalled();
+  });
+
   test('rejects a manually supplied resource file when its manifest hash does not match', () => {
     const method = new FirmwareUpdateV4({
       id: 1,

package/dist/api/CheckAllFirmwareRelease.d.ts

@@ -1,9 +1,9 @@
-import { EFirmwareType } from '@onekeyfe/hd-shared';
 import { BaseMethod } from './BaseMethod';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { AllFirmwareRelease, ProtocolV2FirmwareComponentRelease, ProtocolV2FirmwareReleaseStatus } from '../types/api/checkAllFirmwareRelease';
 import type { FirmwareUpdateV4Target } from '../types/api/firmwareUpdate';
 import type { DeviceFeaturesVerify, DeviceStateVersions, IFirmwareReleaseInfo } from '../types';
-type ProtocolV2FirmwareReleasePlan = {
+export type ProtocolV2FirmwareReleasePlan = {
     firmwareType: EFirmwareType;
     status: ProtocolV2FirmwareReleaseStatus;
     hasUpgrade: boolean;
@@ -28,5 +28,4 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
     run(): Promise<AllFirmwareRelease | null>;
     private runProtocolV2;
 }
-export {};
 //# sourceMappingURL=CheckAllFirmwareRelease.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EAId,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAqB1C,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,KAAK,6BAA6B,GAAG;IACnC,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;CAmE5B"}
+{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AA8B1C,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;CA+D5B"}

package/dist/api/CheckBLEFirmwareRelease.d.ts

@@ -1,7 +1,8 @@
 import { BaseMethod } from './BaseMethod';
 export default class CheckBLEFirmwareRelease extends BaseMethod {
+    getSupportedProtocols(): readonly ["V1", "V2"];
     init(): void;
-    run(): Promise<null> | Promise<{
+    run(): Promise<import("..").FirmwareReleaseCheckResult | {
         status: import("..").IDeviceBLEFirmwareStatus;
         changelog: {
             "zh-CN": string;

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

@@ -1 +1 @@
-{"version":3,"file":"CheckBLEFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckBLEFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAI1C,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,IAAI;IAUJ,GAAG;;;;;;;;;CAOJ"}
+{"version":3,"file":"CheckBLEFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckBLEFirmwareRelease.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAY1C,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,qBAAqB;IAIrB,IAAI;IAUE,GAAG;;;;;;;;;CA+BV"}

package/dist/api/CheckBootloaderRelease.d.ts

@@ -1,7 +1,8 @@
 import { BaseMethod } from './BaseMethod';
 export default class CheckBootloaderRelease extends BaseMethod {
+    getSupportedProtocols(): readonly ["V1", "V2"];
     init(): void;
-    run(): Promise<{
+    run(): Promise<import("..").FirmwareReleaseCheckResult | {
         status: string;
         changelog: ({
             "zh-CN": string;
@@ -10,6 +11,6 @@ export default class CheckBootloaderRelease extends BaseMethod {
         release: import("..").IFirmwareReleaseInfo | undefined;
         bootloaderMode: boolean;
         shouldUpdate: boolean;
-    } | null>;
+    }>;
 }
 //# sourceMappingURL=CheckBootloaderRelease.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"CheckBootloaderRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckBootloaderRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAM1C,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,UAAU;IAC5D,IAAI;IAME,GAAG;;;;;;;;;;CAiBV"}
+{"version":3,"file":"CheckBootloaderRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckBootloaderRelease.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAc1C,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,UAAU;IAC5D,qBAAqB;IAIrB,IAAI;IAME,GAAG;;;;;;;;;;CA0CV"}

package/dist/api/CheckFirmwareRelease.d.ts

@@ -1,7 +1,8 @@
 import { BaseMethod } from './BaseMethod';
 export default class CheckFirmwareRelease extends BaseMethod {
+    getSupportedProtocols(): readonly ["V1", "V2"];
     init(): void;
-    run(): Promise<null> | Promise<{
+    run(): Promise<import("..").FirmwareReleaseCheckResult | {
         status: import("..").IDeviceFirmwareStatus;
         changelog: {
             "zh-CN": string;