@onekeyfe/hd-core 1.2.0-alpha.100 → 1.2.0-alpha.102

package/__tests__/bridgeBinaryPayload.test.ts

@@ -0,0 +1,173 @@
+import { HardwareTopLevelSdk } from '../src';
+import { findMethod } from '../src/api/utils';
+import {
+  decodeBridgeBinaryPayload,
+  encodeBridgeBinaryPayload,
+} from '../src/utils/bridgeBinaryPayload';
+
+import type { LowLevelCoreApi } from '../src';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+const crossJsonOnlyBridge = (value: unknown): unknown => JSON.parse(JSON.stringify(value));
+
+describe('bridge binary payload', () => {
+  test('preserves nested ArrayBuffer and sliced Uint8Array values', async () => {
+    const arrayBuffer = new Uint8Array([1, 2, 3]).buffer;
+    const backing = new Uint8Array([90, 4, 5, 6, 91]);
+    const encoded = await encodeBridgeBinaryPayload({
+      arrayBuffer,
+      bytes: backing.subarray(1, 4),
+    });
+    const decoded = decodeBridgeBinaryPayload(crossJsonOnlyBridge(encoded)) as {
+      arrayBuffer: ArrayBuffer;
+      bytes: Uint8Array;
+    };
+
+    expect(decoded.arrayBuffer).toBeInstanceOf(ArrayBuffer);
+    expect(Array.from(new Uint8Array(decoded.arrayBuffer))).toEqual([1, 2, 3]);
+    expect(decoded.bytes).toBeInstanceOf(Uint8Array);
+    expect(Array.from(decoded.bytes)).toEqual([4, 5, 6]);
+  });
+
+  test('encodes Blob input as byte data', async () => {
+    const encoded = await encodeBridgeBinaryPayload(new Blob([new Uint8Array([7, 8])]));
+    const decoded = decodeBridgeBinaryPayload(crossJsonOnlyBridge(encoded));
+
+    expect(decoded).toBeInstanceOf(Uint8Array);
+    expect(Array.from(decoded as Uint8Array)).toEqual([7, 8]);
+  });
+
+  test('routes portfolio, wallpaper and NFT bytes through the top-level boundary', async () => {
+    const restoredPayloads: Array<Record<string, any>> = [];
+    const lowLevelApi = {
+      call: jest.fn(params => {
+        const wirePayload = crossJsonOnlyBridge(params);
+        const method = findMethod({ id: 1, payload: wirePayload } as any);
+        restoredPayloads.push(method.payload);
+        return Promise.resolve({ success: true, payload: {} });
+      }),
+      init: jest.fn(() => Promise.resolve(true)),
+    } as unknown as LowLevelCoreApi;
+    const sdk = HardwareTopLevelSdk();
+    await sdk.init({}, lowLevelApi);
+
+    const portfolioBytes = new Uint8Array([1, 2, 3]).buffer;
+    const wallpaperBacking = new Uint8Array([90, 4, 5, 6, 91]);
+    const nftBacking = new Uint8Array([80, 7, 8, 9, 10, 81]);
+    await sdk.uploadPortfolio('connect-id', { packageBytes: portfolioBytes });
+    await sdk.deviceUploadWallpaper('connect-id', {
+      width: 604,
+      height: 1024,
+      rgba: wallpaperBacking.subarray(1, 4),
+    });
+    await sdk.deviceUploadNft('connect-id', {
+      image: { width: 540, height: 540, rgba: nftBacking.subarray(1, 3) },
+      thumbnail: { width: 263, height: 263, rgba: nftBacking.subarray(3, 5) },
+      title: 'NFT',
+      subtitle: '',
+    });
+
+    expect(Array.from(new Uint8Array(restoredPayloads[0].packageBytes))).toEqual([1, 2, 3]);
+    expect(Array.from(restoredPayloads[1].rgba)).toEqual([4, 5, 6]);
+    expect(Array.from(restoredPayloads[2].image.rgba)).toEqual([7, 8]);
+    expect(Array.from(restoredPayloads[2].thumbnail.rgba)).toEqual([9, 10]);
+  });
+
+  test('routes firmware update binaries through the top-level boundary', async () => {
+    const restoredPayloads: Array<Record<string, any>> = [];
+    const lowLevelApi = {
+      call: jest.fn(params => {
+        const wirePayload = crossJsonOnlyBridge(params);
+        const method = findMethod({ id: 1, payload: wirePayload } as any);
+        restoredPayloads.push(method.payload);
+        return Promise.resolve({ success: true, payload: {} });
+      }),
+      init: jest.fn(() => Promise.resolve(true)),
+    } as unknown as LowLevelCoreApi;
+    const sdk = HardwareTopLevelSdk();
+    await sdk.init({}, lowLevelApi);
+    const binary = (...bytes: number[]) => Uint8Array.from(bytes).buffer;
+
+    await sdk.firmwareUpdate('connect-id', {
+      binary: binary(1),
+      updateType: 'firmware',
+    });
+    await sdk.firmwareUpdateV2('connect-id', {
+      binary: binary(2),
+      updateType: 'firmware',
+      platform: 'ext',
+    });
+    await sdk.firmwareUpdateV3('connect-id', {
+      platform: 'ext',
+      bleBinary: binary(3),
+      firmwareBinary: binary(4),
+      bootloaderBinary: binary(5),
+      resourceBinary: binary(6),
+    });
+    await sdk.firmwareUpdateV4('connect-id', {
+      platform: 'ext',
+      targetsToUpdate: [
+        'boot',
+        'app_v1',
+        'app_v2',
+        'coprocessor',
+        'se01',
+        'se02',
+        'se03',
+        'se04',
+        'resource',
+      ],
+      romloaderBinary: binary(7),
+      bootloaderBinary: binary(8),
+      applicationP1Binary: binary(9),
+      applicationP2Binary: binary(10),
+      coprocessorBinary: binary(11),
+      se01Binary: binary(12),
+      se02Binary: binary(13),
+      se03Binary: binary(14),
+      se04Binary: binary(15),
+      resourceArchiveBinary: binary(16),
+    });
+    await sdk.deviceUpdateBootloader('connect-id', { binary: binary(17) });
+    await sdk.deviceFullyUploadResource('connect-id', { binary: binary(18) });
+
+    expect(restoredPayloads).toHaveLength(6);
+    const restoredBinaries = [
+      restoredPayloads[0].binary,
+      restoredPayloads[1].binary,
+      restoredPayloads[2].bleBinary,
+      restoredPayloads[2].firmwareBinary,
+      restoredPayloads[2].bootloaderBinary,
+      restoredPayloads[2].resourceBinary,
+      restoredPayloads[3].romloaderBinary,
+      restoredPayloads[3].bootloaderBinary,
+      restoredPayloads[3].applicationP1Binary,
+      restoredPayloads[3].applicationP2Binary,
+      restoredPayloads[3].coprocessorBinary,
+      restoredPayloads[3].se01Binary,
+      restoredPayloads[3].se02Binary,
+      restoredPayloads[3].se03Binary,
+      restoredPayloads[3].se04Binary,
+      restoredPayloads[3].resourceArchiveBinary,
+      restoredPayloads[4].binary,
+      restoredPayloads[5].binary,
+    ];
+    expect(restoredBinaries.map(value => Array.from(new Uint8Array(value)))).toEqual(
+      Array.from({ length: 18 }, (_, index) => [index + 1])
+    );
+  });
+
+  test('rejects malformed tagged binary data', () => {
+    expect(() =>
+      decodeBridgeBinaryPayload({
+        __onekey_hd_bridge_binary_payload__: 1,
+        data: 'not-base64',
+        type: 'uint8-array',
+      })
+    ).toThrow('Invalid bridge binary payload data');
+  });
+});

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

@@ -346,6 +346,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     expect(typedCall).not.toHaveBeenCalled();
     expect(getDeviceState).toHaveBeenCalledWith({
       refreshSections: ['identity', 'versions'],
+      allowLegacyProtocolV2ProtocolInfo: true,
     });
     expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
   });
@@ -725,6 +726,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     });
     expect(getDeviceState).toHaveBeenCalledWith({
       refreshSections: ['identity', 'versions', 'verification'],
+      allowLegacyProtocolV2ProtocolInfo: true,
     });
   });
 

package/__tests__/device-pool-state.test.ts

@@ -38,6 +38,35 @@ describe('DevicePool state lifecycle', () => {
     expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['settings'] });
   });
 
+  test('keeps legacy ProtocolInfo compatibility scoped to a discovery refresh', async () => {
+    const getDeviceState = jest.fn().mockResolvedValue({ status: { mode: 'bootloader' } });
+    const run = jest.fn(async (callback: () => Promise<void>) => callback());
+    const device = {
+      isProtocolV2: () => true,
+      getDeviceState,
+      run,
+    } as any;
+
+    await (DevicePool as any)._refreshRuntimeState(device, {
+      refreshRuntimeState: true,
+      allowLegacyProtocolV2ProtocolInfo: true,
+    });
+
+    expect(run).toHaveBeenCalledWith(expect.any(Function), {
+      connectProtocol: undefined,
+      forceProtocolDetection: undefined,
+      allowLegacyProtocolV2ProtocolInfo: true,
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(1, {
+      refreshSections: ['status'],
+      allowLegacyProtocolV2ProtocolInfo: true,
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
+      refreshSections: ['settings'],
+      allowLegacyProtocolV2ProtocolInfo: true,
+    });
+  });
+
   test('actively re-detects a cached device when protocol detection is forced', async () => {
     const descriptor = { path: 'cached-path', protocolType: 'V1' } as any;
     const device = Device.fromDescriptor(descriptor);

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

@@ -376,62 +376,66 @@ describe('buildFirmwareUpdatePlan', () => {
     }
   );
 
-  test('rejects a legacy resource archive without complete integrity metadata', () => {
-    expectFirmwarePlanInvalid(
-      () =>
-        buildFirmwareUpdatePlan(
-          createLegacyForceInput(['resource'], {
-            url: 'https://firmware.onekey.so/pro/firmware.bin',
-            resource: 'https://firmware.onekey.so/pro/resource.zip',
-            resourceExpectedSize: 4096,
-          })
-        ),
-      'integrity metadata is invalid'
-    );
-  });
+  test.each([
+    {
+      executor: 'v2',
+      deviceType: EDeviceType.Classic1s,
+      bootloaderVersion: '2.1.2',
+    },
+    {
+      executor: 'v3',
+      deviceType: EDeviceType.Pro,
+      bootloaderVersion: '2.8.4',
+    },
+  ])(
+    'allows $executor config releases without optional integrity metadata',
+    ({ executor, deviceType, bootloaderVersion }) => {
+      const plan = buildFirmwareUpdatePlan({
+        features: createFeatures({
+          deviceType,
+          firmwareVersion: '4.21.0',
+          bootloaderVersion,
+        }),
+        firmwareType: EFirmwareType.Universal,
+        platform: 'desktop',
+        firmware: {
+          status: 'valid',
+          release: {
+            url: 'https://firmware.onekey.so/legacy/firmware.bin',
+            version: [4, 21, 0],
+            fingerprint: '',
+            resource: 'https://firmware.onekey.so/legacy/resource.zip',
+            resourceFingerprint: '',
+          },
+        },
+        ble: {
+          status: 'valid',
+          release: {
+            webUpdate: 'https://firmware.onekey.so/legacy/ble.bin',
+            version: [2, 3, 7],
+            fingerprintWeb: '',
+          },
+        },
+        bootloader: {
+          status: 'valid',
+          release: {
+            bootloaderResource: 'https://firmware.onekey.so/legacy/bootloader.bin',
+            bootloaderVersion: [2, 8, 4],
+            bootloaderFingerprint: '',
+          },
+        },
+        forceUpdateTargets: ['firmware', 'resource', 'ble', 'bootloader'],
+      });
 
-  test.each(['firmware', 'ble', 'bootloader'] as const)(
-    'rejects a remote legacy %s artifact without complete integrity metadata',
-    target => {
-      expectFirmwarePlanInvalid(
-        () =>
-          buildFirmwareUpdatePlan({
-            features: createFeatures({ deviceType: EDeviceType.Classic1s }),
-            firmwareType: EFirmwareType.Universal,
-            platform: 'desktop',
-            firmware:
-              target === 'firmware'
-                ? {
-                    status: 'outdated',
-                    release: {
-                      url: 'https://firmware.onekey.so/classic/firmware.bin',
-                      expectedSize: 1024,
-                    },
-                  }
-                : noUpdate,
-            ble:
-              target === 'ble'
-                ? {
-                    status: 'outdated',
-                    release: {
-                      webUpdate: 'https://firmware.onekey.so/classic/ble.bin',
-                      expectedSize: 512,
-                    },
-                  }
-                : noUpdate,
-            bootloader:
-              target === 'bootloader'
-                ? {
-                    status: 'outdated',
-                    release: {
-                      bootloaderResource: 'https://firmware.onekey.so/classic/bootloader.bin',
-                      bootloaderExpectedSize: 768,
-                    },
-                  }
-                : noUpdate,
-          }),
-        'integrity metadata is invalid'
-      );
+      expect(plan.executor).toBe(executor);
+      expect(plan.artifacts.map(artifact => artifact.artifactId)).toEqual([
+        'bootloader',
+        'firmware',
+        'resource',
+        'ble',
+      ]);
+      expect(plan.artifacts.every(artifact => artifact.expectedSize === undefined)).toBe(true);
+      expect(plan.artifacts.every(artifact => artifact.expectedSha256 === undefined)).toBe(true);
     }
   );
 

package/__tests__/get-device-state.test.ts

@@ -202,25 +202,111 @@ describe('getDeviceState', () => {
     expect(state.versions.se01).toBe('1.0.0');
   });
 
-  test.each(['bootloader', 'romloader'] as const)(
-    'uses ProtocolInfo to preserve %s mode without DeviceStatusGet',
-    async mode => {
+  test.each([
+    ['bootloader', EDeviceType.Pro2, DeviceType.PRO2],
+    ['romloader', EDeviceType.Pro2, DeviceType.PRO2],
+    ['bootloader', EDeviceType.Neo, DeviceType.NEO],
+    ['romloader', EDeviceType.Neo, DeviceType.NEO],
+  ] as const)(
+    'refreshes cached %s state after %s reboots into the application',
+    async (mode, deviceType, protocolV2DeviceType) => {
       const typedCall = jest.fn().mockImplementation((requestType: string) => {
-        if (requestType === 'DeviceInfoGet') {
+        if (requestType === 'ProtocolInfoRequest') {
+          return { message: protocolV2ApplicationInfo };
+        }
+        if (requestType === 'DeviceStatusGet') {
           return {
-            message: {
-              hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
+            message: { init_states: true, unlocked: true, device_id: 'wallet-1' },
+          };
+        }
+        throw new Error(`Unexpected request: ${requestType}`);
+      });
+      const device = createV2Device(typedCall);
+      device.updateState(
+        {
+          protocol: 'V2',
+          identity: { deviceType },
+          status: { mode },
+          raw: {
+            protocolV2DeviceInfo: {
+              hw: { Device_type: protocolV2DeviceType, serial_no: 'SERIAL-1' },
               fw:
                 mode === 'romloader'
                   ? { romloader: { version: '1.0.0' } }
                   : { bootloader: { version: '1.0.0' } },
             },
-          };
-        }
-        if (requestType === 'ProtocolInfoRequest') {
-          return { message: getProtocolV2LoaderInfo(mode) };
-        }
-        throw new Error(`Unexpected request: ${requestType}`);
+            protocolV2ProtocolInfo: getProtocolV2LoaderInfo(mode),
+          },
+        },
+        'initialize'
+      );
+
+      const state = await device.getDeviceState({ refreshSections: ['status'] });
+
+      expect(state.status.mode).toBe('normal');
+      expect(state.identity.deviceId).toBe('wallet-1');
+      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+        'ProtocolInfoRequest',
+        'DeviceStatusGet',
+      ]);
+    }
+  );
+
+  test.each([
+    [EDeviceType.Pro2, DeviceType.PRO2],
+    [EDeviceType.Neo, DeviceType.NEO],
+  ] as const)('invalidates cached loader state when %s is cancelled', async (deviceType, type) => {
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            protocol_version: 2,
+            hw: { Device_type: type, serial_no: 'SERIAL-1' },
+            fw: { application: { version: '5.0.0' } },
+          },
+        };
+      }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
+      if (requestType === 'DeviceStatusGet') {
+        return {
+          message: { init_states: true, unlocked: true, device_id: 'wallet-1' },
+        };
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const cancel = jest.fn().mockResolvedValue(undefined);
+    const device = createV2Device(typedCall);
+    (device as any).commands = { cancel, typedCall };
+    device.updateState(
+      {
+        protocol: 'V2',
+        identity: { deviceType },
+        status: { mode: 'bootloader' },
+        raw: { protocolV2ProtocolInfo: getProtocolV2LoaderInfo('bootloader') },
+      },
+      'initialize'
+    );
+
+    await device.interruptionFromUser();
+    await device.initialize();
+
+    expect(cancel).toHaveBeenCalledTimes(1);
+    expect(device.state?.status.mode).toBe('normal');
+    expect(device.state?.identity.deviceId).toBe('wallet-1');
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceInfoGet',
+      'ProtocolInfoRequest',
+      'DeviceStatusGet',
+    ]);
+  });
+
+  test.each(['bootloader', 'romloader'] as const)(
+    'keeps live %s mode after refreshing cached loader state',
+    async mode => {
+      const typedCall = jest.fn().mockResolvedValue({
+        message: getProtocolV2LoaderInfo(mode),
       });
       const device = createV2Device(typedCall);
       device.updateState(
@@ -236,7 +322,10 @@ describe('getDeviceState', () => {
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
       expect(state.status.mode).toBe(mode);
-      expect(typedCall).not.toHaveBeenCalled();
+      expect(typedCall).toHaveBeenCalledTimes(1);
+      expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+        eventless_wallet_session: true,
+      });
     }
   );
 

package/__tests__/protocol-v2-legacy-recovery.test.ts

@@ -0,0 +1,29 @@
+import { isLegacyProtocolV2FirmwareRecoveryMethod } from '../src/core/protocolV2LegacyRecovery';
+
+import type { BaseMethod } from '../src/api/BaseMethod';
+
+const createMethod = (
+  name: string,
+  payload: Record<string, unknown>
+): Pick<BaseMethod, 'name' | 'payload'> => ({
+  name,
+  payload: { method: name, ...payload },
+});
+
+describe('Protocol V2 legacy firmware recovery policy', () => {
+  test.each([
+    ['firmware state read', 'getDeviceState', { scope: 'firmware' }],
+    ['firmware release check', 'checkAllFirmwareRelease', {}],
+    ['firmware update', 'firmwareUpdateV4', {}],
+  ])('allows legacy ProtocolInfo for %s', (_label, name, payload) => {
+    expect(isLegacyProtocolV2FirmwareRecoveryMethod(createMethod(name, payload))).toBe(true);
+  });
+
+  test.each([
+    ['runtime state read', 'getDeviceState', { scope: 'runtime' }],
+    ['settings state read', 'getDeviceState', { scope: 'settings' }],
+    ['ordinary API', 'getFeatures', {}],
+  ])('rejects legacy ProtocolInfo for %s', (_label, name, payload) => {
+    expect(isLegacyProtocolV2FirmwareRecoveryMethod(createMethod(name, payload))).toBe(false);
+  });
+});