@onekeyfe/hd-core 1.2.0-alpha.147 → 1.2.0-alpha.149

package/__tests__/device-lifecycle-events.test.ts

@@ -1,7 +1,13 @@
 import { EDeviceType, ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 import { DeviceType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 
-import { initConnector, initCore, isMissingDetectedProtocolV2Error } from '../src/core';
+import {
+  initConnector,
+  initCore,
+  isMissingDetectedProtocolV2Error,
+  isRetryableBleConnectionError,
+  isRetryableBleProtocolV2ProbeError,
+} from '../src/core';
 import { DataManager } from '../src/data-manager';
 import TransportManager from '../src/data-manager/TransportManager';
 import { Device } from '../src/device/Device';
@@ -269,6 +275,38 @@ describe('public device lifecycle events', () => {
     }
   );
 
+  test.each([
+    [HardwareErrorCode.RuntimeError, true],
+    [HardwareErrorCode.BleDeviceBondError, false],
+  ] as const)(
+    'retries a Protocol V2 probe mismatch with error code %s: %s',
+    (errorCode, expected) => {
+      const method = { payload: { connectProtocol: 'V2' } } as never;
+      const error = {
+        errorCode,
+        message:
+          'Device protocol mismatch: expected V2, but device did not respond to expected protocol',
+      };
+
+      expect(isRetryableBleProtocolV2ProbeError(method, error)).toBe(expected);
+    }
+  );
+
+  test.each([
+    [HardwareErrorCode.BleConnectedError, true],
+    [HardwareErrorCode.BleTimeoutError, true],
+    [HardwareErrorCode.PollingTimeout, false],
+    [HardwareErrorCode.BleDeviceBondError, false],
+  ] as const)('retries a BLE connection error with error code %s: %s', (errorCode, expected) => {
+    const method = { payload: { connectProtocol: 'V2' } } as never;
+    const error = {
+      errorCode,
+      message: 'BLE setup wedged repeatedly',
+    };
+
+    expect(isRetryableBleConnectionError(method, error)).toBe(expected);
+  });
+
   test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();
@@ -346,7 +384,7 @@ describe('public device lifecycle events', () => {
   );
 
   test.each(['react-native', 'webusb', 'desktop-webusb'] as const)(
-    'sends a fallback Cancel for an acquired Protocol V2 %s call without a prompt callback',
+    'sends a fallback Cancel for an acquired Protocol V2 %s call with an open UI',
     async env => {
       jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
       const device = createInitializedDevice('V2');
@@ -360,6 +398,7 @@ describe('public device lifecycle events', () => {
         cancelDevice,
         cancel,
       } as never;
+      device.createProtocolV2UiPhaseMetadata('button', 'start');
 
       await device.interruptionFromUser();
 
@@ -369,6 +408,142 @@ describe('public device lifecycle events', () => {
     }
   );
 
+  test.each(['react-native', 'webusb', 'desktop-webusb'] as const)(
+    'does not send Cancel for an acquired Protocol V2 %s connect without an open UI',
+    async env => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+      const device = createInitializedDevice('V2');
+      const post = jest.fn().mockResolvedValue(undefined);
+      const cancelDevice = jest.fn(() => cancelDeviceInPrompt(device, false));
+      const cancel = jest.fn().mockResolvedValue(undefined);
+      const disconnect = jest.fn().mockResolvedValue(undefined);
+      device.originalDescriptor.session = device.mainId;
+      (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+      device.deviceConnector = { disconnect } as never;
+      device.commands = {
+        transport: { post },
+        cancelDevice,
+        cancel,
+      } as never;
+
+      await device.interruptionFromUser();
+
+      expect(cancelDevice).not.toHaveBeenCalled();
+      expect(post).not.toHaveBeenCalled();
+      expect(disconnect).not.toHaveBeenCalled();
+      expect(cancel).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  test('disconnects a BLE link without sending Cancel when the session is not acquired', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = createInitializedDevice('V2');
+    const post = jest.fn().mockResolvedValue(undefined);
+    const cancelDevice = jest.fn(() => cancelDeviceInPrompt(device, false));
+    const cancel = jest.fn().mockResolvedValue(undefined);
+    const disconnect = jest.fn().mockResolvedValue(undefined);
+    device.deviceConnector = { disconnect } as never;
+    device.commands = {
+      transport: { post },
+      cancelDevice,
+      cancel,
+    } as never;
+
+    await device.interruptionFromUser();
+
+    expect(cancelDevice).not.toHaveBeenCalled();
+    expect(post).not.toHaveBeenCalled();
+    expect(disconnect).toHaveBeenCalledWith(device.mainId);
+    expect(device.hasDeviceAcquire()).toBe(false);
+    expect(device.wasInterruptedByUser()).toBe(true);
+    expect(cancel).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not finish acquire after the user already cancelled', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = createInitializedDevice('V2');
+    const disconnect = jest.fn().mockResolvedValue(undefined);
+    let resolveAcquire: ((value: { uuid: string; protocolType: 'V2' }) => void) | undefined;
+    const acquire = jest.fn(
+      () =>
+        new Promise<{ uuid: string; protocolType: 'V2' }>(resolve => {
+          resolveAcquire = resolve;
+        })
+    );
+    device.deviceConnector = { acquire, disconnect } as never;
+
+    const acquirePromise = device.acquire('V2');
+    await device.interruptionFromUser();
+    resolveAcquire?.({ uuid: 'late-session', protocolType: 'V2' });
+
+    await expect(acquirePromise).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInterruptedFromUser,
+    });
+    expect(disconnect).toHaveBeenCalledWith('late-session');
+    expect(device.hasDeviceAcquire()).toBe(false);
+  });
+
+  test('does not retry a BLE connection error after the user cancelled', () => {
+    const device = createInitializedDevice('V2');
+    device.beginConnectionAttempt();
+    (device as unknown as { interruptedAttempt: number }).interruptedAttempt = (
+      device as unknown as { connectionAttempt: number }
+    ).connectionAttempt;
+    const method = { payload: { connectProtocol: 'V2' }, device } as never;
+    const error = {
+      errorCode: HardwareErrorCode.BleConnectedError,
+      message: 'BLE setup wedged repeatedly',
+    };
+
+    expect(isRetryableBleConnectionError(method, error)).toBe(false);
+  });
+
+  test('allows a new BLE connect after the previous attempt was cancelled', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = createInitializedDevice('V2');
+    const disconnect = jest.fn().mockResolvedValue(undefined);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'next-session', protocolType: 'V2' });
+    device.deviceConnector = { acquire, disconnect } as never;
+
+    device.beginConnectionAttempt();
+    await device.interruptionFromUser();
+    expect(device.wasInterruptedByUser()).toBe(true);
+
+    device.beginConnectionAttempt();
+    await expect(device.acquire('V2')).resolves.toBeUndefined();
+
+    expect(device.wasInterruptedByUser()).toBe(false);
+    expect(device.hasDeviceAcquire()).toBe(true);
+    expect(acquire).toHaveBeenCalledTimes(1);
+  });
+
+  test('discards a late cancelled acquire after a newer connect attempt starts', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = createInitializedDevice('V2');
+    const disconnect = jest.fn().mockResolvedValue(undefined);
+    let resolveAcquire: ((value: { uuid: string; protocolType: 'V2' }) => void) | undefined;
+    const acquire = jest.fn(
+      () =>
+        new Promise<{ uuid: string; protocolType: 'V2' }>(resolve => {
+          resolveAcquire = resolve;
+        })
+    );
+    device.deviceConnector = { acquire, disconnect } as never;
+
+    device.beginConnectionAttempt();
+    const cancelledAcquire = device.acquire('V2');
+    await device.interruptionFromUser();
+    device.beginConnectionAttempt();
+    resolveAcquire?.({ uuid: 'stale-session', protocolType: 'V2' });
+
+    await expect(cancelledAcquire).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInterruptedFromUser,
+    });
+    expect(disconnect).toHaveBeenCalledWith('stale-session');
+    expect(device.hasDeviceAcquire()).toBe(false);
+    expect(device.wasInterruptedByUser()).toBe(false);
+  });
+
   test('waits for the canceled run to finish releasing before cancellation completes', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     const device = createInitializedDevice('V2');

package/__tests__/device-utils.test.ts

@@ -123,6 +123,14 @@ describe('device feature selectors', () => {
   test('recognizes Neo discovery names before initialization', () => {
     expect(getDeviceTypeByBleName('OneKey Neo 1234')).toBe(EDeviceType.Neo);
     expect(getDeviceTypeByBleName('Neo 1234')).toBe(EDeviceType.Neo);
+    expect(getDeviceTypeByBleName('Neo22D8')).toBe(EDeviceType.Neo);
+    expect(getDeviceTypeByBleName('OneKeyNeo22D8')).toBe(EDeviceType.Neo);
+  });
+
+  test('recognizes compact Pro2 discovery names before initialization', () => {
+    expect(getDeviceTypeByBleName('Pro2 A1B2')).toBe(EDeviceType.Pro2);
+    expect(getDeviceTypeByBleName('Pro2A1B2')).toBe(EDeviceType.Pro2);
+    expect(getDeviceTypeByBleName('OneKeyPro2A1B2')).toBe(EDeviceType.Pro2);
   });
 
   test.each([EDeviceType.Pro2, EDeviceType.Neo])(

package/__tests__/deviceUploadNft.test.ts

@@ -1,4 +1,5 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 import { encode as encodeJpeg } from 'jpeg-js';
 
 import DeviceUploadNft from '../src/api/protocol-v2/DeviceUploadNft';
@@ -110,6 +111,8 @@ describe('DeviceUploadNft', () => {
 
     method.init();
 
+    expect(method.unlockPolicy).toBe('unlock-before-run');
+    expect(method.protocolV2PreUnlockPinType).toBe(DeviceSessionPinType.Any);
     expect((method as any).params).toMatchObject({
       chunkSize: 2048,
       paceMs: 0,

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

@@ -1,10 +1,9 @@
 import axios from 'axios';
-import { sha256 } from '@noble/hashes/sha256';
 import { EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { DataManager } from '../src/data-manager';
 import {
-  parseProtocolV2ResourceManifest,
+  parseProtocolV2ResourcePackage,
   parseProtocolV2Resources,
 } from '../src/protocols/protocol-v2/resources';
 
@@ -16,9 +15,6 @@ jest.mock('../src/data/config', () => ({
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
 }));
 
-const bytesToHex = (bytes: Uint8Array) =>
-  Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
-
 const resourceSource = {
   archiveUrl: 'https://example.com/resource/pro2-resource.zip',
   archiveSha256: 'a'.repeat(64),
@@ -31,65 +27,21 @@ const neoResourceSource = {
   archiveSize: 12_345_678,
 };
 
-const manifestFiles = [
-  ['bundles/firmware_logo-build.okpkg', 'firmware_logo.okpkg', 'vol0:/bundles/firmware_logo.okpkg'],
-  ['bundles/font/noto-build.okpkg', 'noto.okpkg', 'vol0:/bundles/font/noto.okpkg'],
-  ['bundles/font/roobert-build.okpkg', 'roobert.okpkg', 'vol0:/bundles/font/roobert.okpkg'],
-  [
-    'bundles/images/animation-build.okpkg',
-    'animation.okpkg',
-    'vol0:/bundles/images/animation.okpkg',
-  ],
-  ['bundles/images/images-build.okpkg', 'images.okpkg', 'vol0:/bundles/images/images.okpkg'],
-  [
-    'bundles/images/wallpaper-build.okpkg',
-    'wallpaper.okpkg',
-    'vol0:/bundles/images/wallpaper.okpkg',
-  ],
-  [
-    'bundles/translations/translations-build.okpkg',
-    'translations.okpkg',
-    'vol0:/bundles/translations/translations.okpkg',
-  ],
-  [
-    'loaders/bootloader/boot_resource-build.okpkg',
-    'boot_resource.okpkg',
-    'vol0:/loaders/bootloader/boot_resource.okpkg',
-  ],
-  ['loaders/rom/params-build.okpkg', 'params.okpkg', 'vol0:/loaders/rom/params.okpkg'],
-].map(([archive_path, original_name, device_path], index) => {
-  const binary = new Uint8Array([index + 1]).buffer;
-  return {
-    archive_path,
-    original_name,
-    device_path,
-    size: 1,
-    sha256: bytesToHex(sha256(new Uint8Array(binary))),
-    signed: true,
-    sig_algo: device_path.startsWith('vol0:/bundles/') ? 'ed25519' : 'mldsa65',
-    payload_version: '1.0.0',
-    binary,
-  };
-});
-
-const resourceManifest = {
-  schema: 1,
-  artifact_name: 'pro2-resource-build',
-  release_name: 'resource-build',
-  variant: 'resource',
-  commit: 'a'.repeat(40),
-  short_sha: 'aaaaaaa',
-  timestamp_utc: '20260807_091424',
-  core_version: '1.0.0',
-  key_set: 'dev',
-  device_root: 'vol0:',
-  restore_mode: 'bootloader_update',
-  trees: [
-    { path: 'bundles', device: 'vol0:/bundles' },
-    { path: 'loaders/bootloader', device: 'vol0:/loaders/bootloader' },
-    { path: 'loaders/rom', device: 'vol0:/loaders/rom' },
-  ],
-  files: manifestFiles.map(({ binary: _binary, ...file }) => file),
+const createResourcePackage = (devicePath: string) => {
+  const headerSize = 0x5f90;
+  const bytes = new Uint8Array(headerSize + 1);
+  bytes.set(new TextEncoder().encode('OKPP'), 0);
+  bytes.set(new TextEncoder().encode('RESC'), 0x08);
+  bytes.set(new TextEncoder().encode(devicePath), 0x6c);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0x04, 1, true);
+  view.setUint32(0x0c, headerSize, true);
+  view.setUint32(0x10, 0x010203, true);
+  view.setUint32(0x14, 1, true);
+  bytes.fill(0x11, 0x200, 0x240);
+  bytes.fill(0x22, 0x240, 0x280);
+  bytes[headerSize] = 0xaa;
+  return bytes;
 };
 
 const createSettings = (configFetcher: ConnectSettings['configFetcher']): ConnectSettings =>
@@ -146,34 +98,36 @@ describe('Pro2 resource configuration', () => {
     DataManager.lastCheckTimestamp = 0;
   });
 
-  test('accepts the manifest source and the CI schema 1 file set', () => {
+  test('accepts the release archive source', () => {
     expect(parseProtocolV2Resources({ source: resourceSource })).toEqual({
       source: resourceSource,
     });
-    expect(parseProtocolV2ResourceManifest(resourceManifest).files).toHaveLength(9);
   });
 
-  test('uses only the resource file list from a manifest', () => {
+  test('reads the version, hashes, and direct device path from a RESC package', () => {
     expect(
-      parseProtocolV2ResourceManifest({
-        files: resourceManifest.files,
-      })
-    ).toEqual({ files: resourceManifest.files });
+      parseProtocolV2ResourcePackage(createResourcePackage('vol0:/bundles/images.okpkg'))
+    ).toEqual({
+      version: [1, 2, 3],
+      payloadLength: 1,
+      devicePath: 'vol0:/bundles/images.okpkg',
+      payloadHash: '11'.repeat(64),
+      headerHash: '22'.repeat(64),
+    });
   });
 
-  test('ignores release metadata and accepts a partial resource file set', () => {
+  test('accepts the boot resource staging path and rejects paths outside resource roots', () => {
     expect(
-      parseProtocolV2ResourceManifest({
-        schema: 1,
-        variant: 'dev_resource',
-        restore_mode: 'bootloader_update',
-        trees: [],
-        files: [resourceManifest.files[0]],
-      })
-    ).toEqual({ files: [resourceManifest.files[0]] });
+      parseProtocolV2ResourcePackage(
+        createResourcePackage('vol0:/loaders/bootloader/boot_resource.okpkg.staging')
+      ).devicePath
+    ).toBe('vol0:/loaders/bootloader/boot_resource.okpkg.staging');
+    expect(() =>
+      parseProtocolV2ResourcePackage(createResourcePackage('vol0:/unexpected/images.okpkg'))
+    ).toThrow('device path');
   });
 
-  test('rejects missing source and malformed manifest paths', () => {
+  test('rejects missing or malformed release sources', () => {
     expect(() => parseProtocolV2Resources({})).toThrow('source is required');
     expect(() =>
       parseProtocolV2Resources({
@@ -193,14 +147,6 @@ describe('Pro2 resource configuration', () => {
         source: { ...resourceSource, archiveSize: 0 },
       })
     ).toThrow('positive integer');
-    expect(() =>
-      parseProtocolV2ResourceManifest({
-        ...resourceManifest,
-        files: resourceManifest.files.map((file, index) =>
-          index === 0 ? { ...file, archive_path: '../outside.okpkg' } : file
-        ),
-      })
-    ).toThrow('archive_path');
   });
 
   test('applies a validated pre-release config and exposes its archive source', async () => {

package/__tests__/protocol-v2-unlock-policy.test.ts

@@ -1,11 +1,17 @@
 import TransportUtils, { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+import { encode as encodeJpeg } from 'jpeg-js';
 
 import ConfluxSignMessageCIP23 from '../src/api/conflux/ConfluxSignMessageCIP23';
 import DeviceChangePin from '../src/api/device/DeviceChangePin';
 import DeviceLock from '../src/api/device/DeviceLock';
+import DeviceRebootToBoardloader from '../src/api/device/DeviceRebootToBoardloader';
+import DeviceRebootToBootloader from '../src/api/device/DeviceRebootToBootloader';
 import DeviceSettings from '../src/api/device/DeviceSettings';
 import DeviceVerify from '../src/api/device/DeviceVerify';
 import DeviceWipe from '../src/api/device/DeviceWipe';
+import DeviceReboot from '../src/api/protocol-v2/DeviceReboot';
+import DeviceUploadNft from '../src/api/protocol-v2/DeviceUploadNft';
+import DeviceUploadWallpaper from '../src/api/protocol-v2/DeviceUploadWallpaper';
 import FirmwareUpdateV4 from '../src/api/FirmwareUpdateV4';
 import OpenWalletSession from '../src/api/OpenWalletSession';
 import DataManager from '../src/data-manager/DataManager';
@@ -16,6 +22,12 @@ jest.mock('../src/data/config', () => ({
   getSDKVersion: () => '0.0.0-test',
 }));
 
+const createJpegBase64 = (width: number, height: number) => {
+  const data = new Uint8Array(width * height * 4);
+  for (let index = 3; index < data.length; index += 4) data[index] = 0xff;
+  return encodeJpeg({ width, height, data }, 80).data.toString('base64');
+};
+
 describe('Protocol V2 unlock semantics', () => {
   test('serializes genuine-device verification with Protocol V2 certificate messages', async () => {
     const method = new DeviceVerify({
@@ -64,6 +76,40 @@ describe('Protocol V2 unlock semantics', () => {
     expect(method.getSupportedProtocols()).toContain('V2');
   });
 
+  test.each([
+    [
+      'deviceReboot',
+      () =>
+        new DeviceReboot({
+          id: 1,
+          payload: { method: 'deviceReboot', rebootType: 2 },
+        }),
+    ],
+    [
+      'deviceRebootToBootloader',
+      () =>
+        new DeviceRebootToBootloader({
+          id: 1,
+          payload: { method: 'deviceRebootToBootloader' },
+        }),
+    ],
+    [
+      'deviceRebootToBoardloader',
+      () =>
+        new DeviceRebootToBoardloader({
+          id: 1,
+          payload: { method: 'deviceRebootToBoardloader' },
+        }),
+    ],
+  ])('pre-unlocks %s before sending DeviceReboot', (_name, createMethod) => {
+    const method = createMethod();
+    method.init();
+
+    expect(method.unlockPolicy).toBe('unlock-before-run');
+    expect(method.protocolV2PreUnlockPinType).toBe(DeviceSessionPinType.Any);
+    expect(method.useDevicePassphraseState).toBe(false);
+  });
+
   test('lock-free Protocol V2 controls explicitly opt out of wallet-session handling', () => {
     const method = new DeviceLock({
       id: 1,
@@ -258,6 +304,32 @@ describe('Protocol V2 unlock semantics', () => {
           payload: { method: 'deviceVerify', dataHex: '00' },
         }),
     ],
+    [
+      'wallpaper uploads',
+      () =>
+        new DeviceUploadWallpaper({
+          id: 1,
+          payload: {
+            method: 'deviceUploadWallpaper',
+            jpegBase64: createJpegBase64(604, 1024),
+          },
+        }),
+    ],
+    [
+      'NFT uploads',
+      () =>
+        new DeviceUploadNft({
+          id: 1,
+          payload: {
+            method: 'deviceUploadNft',
+            imageJpegBase64: createJpegBase64(540, 540),
+            thumbnailJpegBase64: createJpegBase64(263, 263),
+            title: 'NFT',
+            subtitle: '',
+            timestampMs: 1,
+          },
+        }),
+    ],
   ])('allows either PIN type when pre-unlocking %s', async (_name, createMethod) => {
     const method = createMethod();
     method.init();