@onekeyfe/hd-core 1.2.2-alpha.100 → 1.2.2-alpha.101

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -95,7 +95,8 @@ describe('AllNetworkGetAddressBase tracing', () => {
       'hidden-state',
       false,
       undefined,
-      false
+      undefined,
+      undefined
     );
     expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
@@ -173,7 +174,13 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith('hidden-state', false, undefined, true);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(
+      'hidden-state',
+      false,
+      undefined,
+      true,
+      undefined
+    );
     expect(calls).toEqual(['resume-cardano-session', 'run-cardano-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });
@@ -212,7 +219,10 @@ describe('AllNetworkGetAddressBase tracing', () => {
         bundle: [],
       },
     });
-    method.protocolV2UnlockContext = { preflightCompleted: true };
+    method.protocolV2UnlockContext = {
+      preflightCompleted: true,
+      preflightMainPinSelected: true,
+    };
     const typedCall = jest.fn();
     method.device = {
       checkPassphraseStateSafety,
@@ -250,7 +260,13 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(undefined, true, undefined, false);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(
+      undefined,
+      true,
+      undefined,
+      undefined,
+      true
+    );
     expect(calls).toEqual(['resume-standard-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });

package/__tests__/DeviceCommands.test.ts

@@ -126,6 +126,19 @@ describe('DeviceCommands failure mapping', () => {
     );
   });
 
+  it('preserves the Protocol V2 peer-removed pairing error code', async () => {
+    const commands = createCommands();
+    const transportError = Object.assign(new Error('Peer removed pairing information'), {
+      errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
+    });
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockRejectedValue(transportError),
+    } as any;
+
+    await expect(commands._commonCall('DeviceInfoGet', {})).rejects.toBe(transportError);
+  });
+
   it('logs canonical DeviceStatus response fields without exposing the device ID', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);

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

@@ -33,8 +33,6 @@ const validComponentIntegrity = {
 const release: IFirmwareReleaseInfo = {
   required: true,
   version: [2, 0, 0],
-  url: 'https://example.com/application-p1.bin',
-  fingerprint: 'release-fingerprint',
   changelog: {
     'zh-CN': '更新',
     'en-US': 'Update',

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

@@ -16,8 +16,6 @@ jest.mock('../src/data/config', () => ({
 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',

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

@@ -2,11 +2,15 @@ import { EDeviceType, ERRORS, HardwareErrorCode, createDeferred } from '@onekeyf
 import { DeviceType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 
 import {
+  cancel,
   initConnector,
   initCore,
+  isDeviceIdentityMismatchError,
   isMissingDetectedProtocolV2Error,
   isRetryableBleConnectionError,
   isRetryableBleProtocolV2ProbeError,
+  isTerminalBleStaleBondError,
+  resolveBleConnectProtocol,
 } from '../src/core';
 import { DataManager } from '../src/data-manager';
 import TransportManager from '../src/data-manager/TransportManager';
@@ -70,6 +74,19 @@ describe('public device lifecycle events', () => {
     jest.restoreAllMocks();
   });
 
+  test('prefers Protocol V2 only when the method contract is explicitly V2-only', () => {
+    const createMethod = (protocols: readonly ('V1' | 'V2')[], connectProtocol?: 'V1' | 'V2') =>
+      ({
+        payload: { connectProtocol },
+        getSupportedProtocols: () => protocols,
+      } as never);
+
+    expect(resolveBleConnectProtocol(createMethod(['V2']))).toBe('V2');
+    expect(resolveBleConnectProtocol(createMethod(['V1']))).toBeUndefined();
+    expect(resolveBleConnectProtocol(createMethod(['V1', 'V2']))).toBeUndefined();
+    expect(resolveBleConnectProtocol(createMethod(['V2'], 'V1'))).toBe('V1');
+  });
+
   test('registers the shared device lifecycle listeners exactly once', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();
@@ -105,6 +122,58 @@ describe('public device lifecycle events', () => {
     expect(context.getPrePendingCallPromise('device-a')).toBe(replacementCleanup.promise);
   });
 
+  test('cancels only requests associated with the requested connect id', () => {
+    core = initCore();
+    const context = (core as any).getCoreContext();
+    const deviceA = {
+      mainId: 'transport-session-a',
+      getConnectId: jest.fn(() => 'serial-a'),
+      interruptionFromUser: jest.fn().mockResolvedValue(undefined),
+    };
+    const deviceB = {
+      mainId: 'device-b',
+      getConnectId: jest.fn(() => 'serial-b'),
+      interruptionFromUser: jest.fn().mockResolvedValue(undefined),
+    };
+    const taskA = context.requestQueue.createTask({
+      responseID: 101,
+      connectId: '',
+      device: deviceA,
+    } as never);
+    const taskB = context.requestQueue.createTask({
+      responseID: 102,
+      connectId: 'device-b',
+      device: deviceB,
+    } as never);
+    const signalA = taskA.abortController?.signal;
+    const signalB = taskB.abortController?.signal;
+
+    cancel(context, 'serial-a');
+
+    expect(signalA?.aborted).toBe(true);
+    expect(context.requestQueue.getTask(taskA.id)).toBeUndefined();
+    expect(signalB?.aborted).toBe(false);
+    expect(context.requestQueue.getTask(taskB.id)).toBe(taskB);
+    expect(deviceA.interruptionFromUser).toHaveBeenCalledTimes(1);
+    expect(deviceB.interruptionFromUser).not.toHaveBeenCalled();
+  });
+
+  test('aborts every request before cancel-all rejects WebUSB tasks', () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    core = initCore();
+    const context = (core as any).getCoreContext();
+    const task = context.requestQueue.createTask({
+      responseID: 103,
+      connectId: 'webusb-device',
+    } as never);
+    const signal = task.abortController?.signal;
+
+    cancel(context);
+
+    expect(signal?.aborted).toBe(true);
+    expect(context.requestQueue.getTask(task.id)).toBeUndefined();
+  });
+
   test('keeps shared device lifecycle listeners across a device cache reset', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();
@@ -278,6 +347,7 @@ describe('public device lifecycle events', () => {
   test.each([
     [HardwareErrorCode.RuntimeError, true],
     [HardwareErrorCode.BleDeviceBondError, false],
+    [HardwareErrorCode.BlePeerRemovedPairingInformation, false],
   ] as const)(
     'retries a Protocol V2 probe mismatch with error code %s: %s',
     (errorCode, expected) => {
@@ -297,6 +367,8 @@ describe('public device lifecycle events', () => {
     [HardwareErrorCode.BleTimeoutError, true],
     [HardwareErrorCode.PollingTimeout, false],
     [HardwareErrorCode.BleDeviceBondError, false],
+    [HardwareErrorCode.BlePeerRemovedPairingInformation, false],
+    [HardwareErrorCode.BleBondInvalid, false],
   ] as const)('retries a BLE connection error with error code %s: %s', (errorCode, expected) => {
     const method = { payload: { connectProtocol: 'V2' } } as never;
     const error = {
@@ -307,6 +379,36 @@ describe('public device lifecycle events', () => {
     expect(isRetryableBleConnectionError(method, error)).toBe(expected);
   });
 
+  test('does not retry the desktop acquire deadline fallback', () => {
+    const method = { payload: { connectProtocol: 'V2' } } as never;
+    const error = {
+      errorCode: HardwareErrorCode.BleTimeoutError,
+      params: { acquireDeadlineExceeded: true },
+    };
+
+    expect(isRetryableBleConnectionError(method, error)).toBe(false);
+  });
+
+  test.each([
+    [HardwareErrorCode.BleDeviceBondError, true],
+    [HardwareErrorCode.BlePeerRemovedPairingInformation, true],
+    [HardwareErrorCode.BleBondInvalid, true],
+    [HardwareErrorCode.DeviceNotFound, false],
+  ] as const)('treats BLE stale-bond error code %s as terminal: %s', (errorCode, expected) => {
+    const error = {
+      errorCode,
+    };
+
+    expect(isTerminalBleStaleBondError(error)).toBe(expected);
+  });
+
+  test.each([
+    [HardwareErrorCode.DeviceCheckDeviceIdError, true],
+    [HardwareErrorCode.DeviceNotFound, false],
+  ] as const)('treats device identity error code %s as a mismatch: %s', (errorCode, expected) => {
+    expect(isDeviceIdentityMismatchError({ errorCode })).toBe(expected);
+  });
+
   test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();

package/__tests__/deviceUploadNft.test.ts

@@ -32,10 +32,12 @@ const createMethod = ({
   typedCall,
   supportedMessages = [60802, 60805, 60808, 61500],
   useFullBundle = false,
+  firmwareVersion = '1.0.0',
 }: {
   typedCall: jest.Mock;
   supportedMessages?: number[];
   useFullBundle?: boolean;
+  firmwareVersion?: string;
 }) => {
   const method = new DeviceUploadNft({
     id: 1,
@@ -52,6 +54,7 @@ const createMethod = ({
   });
   (method as any).device = {
     commands: { typedCall },
+    state: { versions: { firmware: firmwareVersion } },
     ensureProtocolV2RuntimeContext: jest.fn(() =>
       Promise.resolve({
         version: 2,
@@ -60,6 +63,7 @@ const createMethod = ({
       })
     ),
     getCurrentFirmwareType: jest.fn(),
+    getCurrentFirmwareVersionString: jest.fn(() => firmwareVersion),
   };
   method.postMessage = jest.fn();
 
@@ -202,6 +206,70 @@ describe('DeviceUploadNft', () => {
     });
   });
 
+  test('uploads one host asset package on firmware 1.0.1', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: { message: 'NFT updated' } };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({
+      typedCall,
+      supportedMessages: [60805, 61500],
+      firmwareVersion: '1.0.1',
+    });
+
+    const result = await method.run();
+
+    const requests = typedCall.mock.calls.map(call => call[0]);
+    expect(requests).not.toContain('FilesystemPathInfoQuery');
+    expect(requests).not.toContain('FilesystemDirList');
+    const fileWrites = typedCall.mock.calls.filter(call => call[0] === 'FilesystemFileWrite');
+    expect(new Set(fileWrites.map(call => call[2].file.path))).toEqual(
+      new Set(['vol1:/nft/nft-deadbeef-1760000000000.okpkg'])
+    );
+    expect(fileWrites[0][2].file.data.subarray(0, 4)).toEqual(
+      new Uint8Array([0x4f, 0x4b, 0x50, 0x50])
+    );
+    expect(typedCall).toHaveBeenLastCalledWith(
+      'NftUpdate',
+      'Success',
+      { file_name_no_ext: result.basename },
+      { timeoutMs: 15_000 }
+    );
+    expect(result).toMatchObject({
+      imagePath: 'vol1:/nft/nft-deadbeef-1760000000000.bin',
+      thumbnailPath: 'vol1:/nft/nft-deadbeef-1760000000000_m.bin',
+      metadataPath: 'vol1:/nft/nft-deadbeef-1760000000000.json',
+      nftUpdated: true,
+    });
+  });
+
+  test('keeps the legacy upload flow on a 1.0.1 prerelease', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemPathInfoQuery') {
+        return { message: { exist: true, directory: true } };
+      }
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: {} };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall, firmwareVersion: '1.0.1-beta.1' });
+
+    await method.run();
+
+    const requests = typedCall.mock.calls.map(call => call[0]);
+    expect(requests).toContain('FilesystemPathInfoQuery');
+    expect(requests).toContain('FilesystemDirList');
+    const paths = typedCall.mock.calls
+      .filter(call => call[0] === 'FilesystemFileWrite')
+      .map(call => call[2].file.path as string);
+    expect(paths.some(path => path.endsWith('.okpkg'))).toBe(false);
+    expect(paths).toContain('vol1:/nft/nft-deadbeef-1760000000000.bin');
+  });
+
   test('treats a missing NFT directory as empty before the first upload', async () => {
     const typedCall = jest.fn((request: string, _response: string, params: any) => {
       if (request === 'FilesystemPathInfoQuery') {

package/__tests__/evmSignTypedData.test.ts

@@ -1,3 +1,5 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
 import EVMSignTypedData from '../src/api/evm/EVMSignTypedData';
 
 import type { EthereumSignTypedDataMessage, EthereumSignTypedDataTypes } from '../src/types';
@@ -577,3 +579,43 @@ describe('EVMSignTypedData — OneKey Pro Safe Protocol V1', () => {
     });
   });
 });
+
+describe('EVMSignTypedData — Protocol V2 data size routing', () => {
+  const buildSafeTxData = (
+    dataSize: number
+  ): EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> =>
+    ({
+      types: {
+        EIP712Domain: [],
+        SafeTx: [{ name: 'data', type: 'bytes' }],
+      },
+      primaryType: 'SafeTx',
+      domain: {},
+      message: { data: `0x${'ab'.repeat(dataSize)}` },
+    } as EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>);
+
+  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
+    'keeps SafeTx data up to 1536 bytes on the structured route for %s',
+    deviceType => {
+      const data = buildSafeTxData(1316);
+      const method = createMethod(data);
+      method.device.getCurrentDeviceType = jest.fn(() => deviceType);
+      method.device.getCurrentFirmwareVersionString = jest.fn(() => '1.0.0');
+
+      expect(method.hasBiggerData(data)).toBe(false);
+      expect(method.hasBiggerData(buildSafeTxData(1536))).toBe(false);
+    }
+  );
+
+  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
+    'falls back to the hash route above 1536 bytes for %s',
+    deviceType => {
+      const data = buildSafeTxData(1537);
+      const method = createMethod(data);
+      method.device.getCurrentDeviceType = jest.fn(() => deviceType);
+      method.device.getCurrentFirmwareVersionString = jest.fn(() => '1.0.0');
+
+      expect(method.hasBiggerData(data)).toBe(true);
+    }
+  );
+});