@onekeyfe/hd-core 1.1.26 → 1.1.27-alpha.31

package/src/types/params.ts

@@ -1,3 +1,5 @@
+import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
+
 export interface CommonParams {
   keepSession?: boolean;
   /**
@@ -47,6 +49,11 @@ export interface CommonParams {
    * Only connect device, not initialize device, only ble connect
    */
   onlyConnectBleDevice?: boolean;
+
+  /**
+   * Expected transport protocol. If omitted, SDK probes Protocol V1 then Protocol V2.
+   */
+  connectProtocol?: HardwareConnectProtocol;
 }
 
 export type Params<T> = CommonParams & T & { bundle?: undefined };

package/src/types/settings.ts

@@ -83,7 +83,7 @@ export type IBLEFirmwareReleaseInfo = {
   };
 };
 
-type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
+type IKnownDevice = Exclude<IDeviceType, 'unknown' | 'pro2'>;
 
 /**
  * Device firmware configuration map

package/src/utils/deviceFeaturesUtils.ts

@@ -5,7 +5,10 @@ import { Enum_Capability } from '@onekeyfe/hd-transport';
 
 import { toHardened } from '../api/helpers/pathUtils';
 import { DeviceModelToTypes, DeviceTypeToModels } from '../types';
-import DataManager, { type IFirmwareField, type MessageVersion } from '../data-manager/DataManager';
+import DataManager, {
+  type IFirmwareField,
+  type ProtocolV1MessageSchema,
+} from '../data-manager/DataManager';
 import { PROTOBUF_MESSAGE_CONFIG } from '../data-manager/MessagesConfig';
 import { getDeviceType } from './deviceInfoUtils';
 import { getDeviceFirmwareVersion } from './deviceVersionUtils';
@@ -15,13 +18,13 @@ import type { Device } from '../device/Device';
 import type { DeviceCommands } from '../device/DeviceCommands';
 import type { Features, SupportFeatureType } from '../types';
 
-export const getSupportMessageVersion = (
+export const getSupportProtocolV1MessageSchema = (
   features: Features | undefined
-): { messages: JSON; messageVersion: MessageVersion } => {
+): { messages: JSON; protocolV1MessageSchema: ProtocolV1MessageSchema } => {
   if (!features)
     return {
-      messages: DataManager.messages.latest,
-      messageVersion: 'latest',
+      messages: DataManager.messages.protocolV1Current,
+      protocolV1MessageSchema: 'protocolV1Current',
     };
 
   const currentDeviceVersion = getDeviceFirmwareVersion(features).join('.');
@@ -37,18 +40,18 @@ export const getSupportMessageVersion = (
   const sortedDeviceVersionConfigs =
     deviceVersionConfigs?.sort((a, b) => semver.compare(b.minVersion, a.minVersion)) ?? [];
 
-  for (const { minVersion, messageVersion } of sortedDeviceVersionConfigs) {
+  for (const { minVersion, protocolV1MessageSchema } of sortedDeviceVersionConfigs) {
     if (semver.gte(currentDeviceVersion, minVersion)) {
       return {
-        messages: DataManager.messages[messageVersion],
-        messageVersion,
+        messages: DataManager.messages[protocolV1MessageSchema],
+        protocolV1MessageSchema,
       };
     }
   }
 
   return {
-    messages: DataManager.messages.latest,
-    messageVersion: 'latest',
+    messages: DataManager.messages.protocolV1Current,
+    protocolV1MessageSchema: 'protocolV1Current',
   };
 };
 
@@ -68,7 +71,11 @@ export const supportNewPassphrase = (features?: Features): SupportFeatureType =>
   if (!features) return { support: false };
 
   const deviceType = getDeviceType(features);
-  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
+  if (
+    deviceType === EDeviceType.Touch ||
+    deviceType === EDeviceType.Pro ||
+    deviceType === EDeviceType.Pro2
+  ) {
     return { support: true };
   }
 
@@ -86,6 +93,8 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
 ) => {
   const { features, commands } = device;
   const locked = features?.unlocked === false;
+  const deviceType = getDeviceType(features);
+  const isPro2 = deviceType === EDeviceType.Pro2;
 
   const { passphraseState, newSession, unlockedAttachPin } = await getPassphraseState(
     features,
@@ -95,12 +104,12 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
     }
   );
 
-  const isModeT =
-    getDeviceType(features) === EDeviceType.Touch || getDeviceType(features) === EDeviceType.Pro;
+  const isModeT = deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro;
 
   // 如果可以获取到 passphraseState，但是设备 features 显示设备未开启 passphrase，需要刷新设备状态
   // if passphraseState can be obtained, but the device features show that the device has not enabled passphrase, the device status needs to be refreshed
-  const needRefreshWithPassphrase = passphraseState && features?.passphrase_protection !== true;
+  const needRefreshWithPassphrase =
+    !isPro2 && passphraseState && features?.passphrase_protection !== true;
   // 如果 Touch/Pro 在之前是锁定状态，刷新设备状态
   // if Touch/Pro was locked before, refresh the device state
   const needRefreshWithLocked = isModeT && locked;
@@ -110,10 +119,17 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
     await device.getFeatures();
   }
 
+  if (isPro2 && device.features && (passphraseState || newSession)) {
+    device.features.passphrase_protection = true;
+    if (newSession) {
+      device.features.session_id = newSession;
+    }
+  }
+
   // Attach to pin try to fix internal state
   if (features?.device_id) {
     device.updateInternalState(
-      device.features?.passphrase_protection ?? false,
+      (device.features?.passphrase_protection ?? false) || isPro2,
       passphraseState,
       device.features?.device_id ?? '',
       newSession,
@@ -148,6 +164,8 @@ export const getPassphraseState = async (
   );
   const supportGetPassphraseState =
     supportAttachPinCapability ||
+    // Pro2 V2 暂未从 features 暴露 capabilities，先直连该方法用于固件联调。
+    deviceType === EDeviceType.Pro2 ||
     (deviceType === EDeviceType.Pro && semver.gte(firmwareVersion.join('.'), '4.15.0'));
 
   if (supportGetPassphraseState) {

package/src/utils/deviceInfoUtils.ts

@@ -27,6 +27,9 @@ export const getDeviceType = (features?: Features): IDeviceType => {
       return EDeviceType.Touch;
     case 'PRO':
       return EDeviceType.Pro;
+    case 'PRO2':
+    case 'pro2':
+      return EDeviceType.Pro2;
     case 'PURE':
       return EDeviceType.ClassicPure;
     default:
@@ -68,13 +71,14 @@ export const getDeviceType = (features?: Features): IDeviceType => {
 export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
   if (!name) return EDeviceType.Unknown;
 
-  if (name.startsWith('BixinKey')) return EDeviceType.Classic;
-  if (name.startsWith('K')) return EDeviceType.Classic;
+  if (/^BixinKey/i.test(name)) return EDeviceType.Classic;
+  if (/^K/i.test(name)) return EDeviceType.Classic;
 
-  if (name.startsWith('T')) return EDeviceType.Touch;
-  if (name.startsWith('Touch')) return EDeviceType.Touch;
+  if (/^T/i.test(name)) return EDeviceType.Touch;
+  if (/^Touch/i.test(name)) return EDeviceType.Touch;
 
-  if (name.startsWith('Pro')) return EDeviceType.Pro;
+  if (/\bPro\s*2\b/i.test(name) || /^Pro2/i.test(name)) return EDeviceType.Pro2;
+  if (/\bPro\b/i.test(name) || /^Pro/i.test(name)) return EDeviceType.Pro;
 
   return EDeviceType.Unknown;
 };
@@ -152,6 +156,11 @@ export const getMethodVersionRange = (
   return versionRange;
 };
 
+export const shouldSkipMethodSupportCheck = (
+  features: Features | undefined,
+  protocolType?: string
+): boolean => protocolType === 'V2' || getDeviceType(features) === EDeviceType.Pro2;
+
 export const getFirmwareType = (features: Features | undefined) => {
   if (!features) {
     return EFirmwareType.Universal;

package/src/utils/index.ts

@@ -11,6 +11,7 @@ export {
   getDeviceUUID,
   getDeviceLabel,
   getMethodVersionRange,
+  shouldSkipMethodSupportCheck,
   getFirmwareType,
 } from './deviceInfoUtils';
 export {

package/__tests__/DeviceCommands.test.ts

@@ -1,99 +0,0 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import { DeviceCommands } from '../src/device/DeviceCommands';
-
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-const createCommands = () => {
-  const commands = Object.create(DeviceCommands.prototype) as DeviceCommands;
-  commands.device = {
-    clearCancelableAction: jest.fn(),
-  } as any;
-  return commands;
-};
-
-describe('DeviceCommands failure mapping', () => {
-  it.each([
-    ['ButtonAck', 'Not in Ethereum signing mode'],
-    ['PinMatrixAck', 'Not in Conflux signing mode'],
-  ])('keeps %s unexpected message "%s" as firmware runtime error', async (callType, message) => {
-    const commands = createCommands();
-
-    await expect(
-      commands._filterCommonTypes(
-        {
-          type: 'Failure',
-          message: {
-            code: 'Failure_UnexpectedMessage',
-            message,
-          },
-        } as any,
-        callType as any
-      )
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.RuntimeError,
-      message: `Failure_UnexpectedMessage,${message}`,
-    });
-  });
-
-  it('keeps the existing NotInSigningMode mapping', async () => {
-    const commands = createCommands();
-
-    await expect(
-      commands._filterCommonTypes(
-        {
-          type: 'Failure',
-          message: {
-            code: 'Failure_UnexpectedMessage',
-            message: 'Not in Signing mode',
-          },
-        } as any,
-        'ButtonAck'
-      )
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.NotInSigningMode,
-    });
-  });
-
-  it('keeps the existing unexpected passphrase mapping', async () => {
-    const commands = createCommands();
-
-    await expect(
-      commands._filterCommonTypes(
-        {
-          type: 'Failure',
-          message: {
-            code: 'Failure_UnexpectedMessage',
-            message: 'Unexpected message',
-          },
-        } as any,
-        'PassphraseAck'
-      )
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.UnexpectPassphrase,
-    });
-  });
-
-  it('keeps non signing unexpected messages as runtime errors', async () => {
-    const commands = createCommands();
-
-    await expect(
-      commands._filterCommonTypes(
-        {
-          type: 'Failure',
-          message: {
-            code: 'Failure_UnexpectedMessage',
-            message: 'Not in Reset mode',
-          },
-        } as any,
-        'ButtonAck'
-      )
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.RuntimeError,
-      message: 'Failure_UnexpectedMessage,Not in Reset mode',
-    });
-  });
-});

package/__tests__/evmLedgerLegacySafety.test.ts

@@ -1,261 +0,0 @@
-import AllNetworkGetAddressBase from '../src/api/allnetwork/AllNetworkGetAddressBase';
-import EvmGetAddress from '../src/api/evm/EVMGetAddress';
-import EVMGetPublicKey from '../src/api/evm/EVMGetPublicKey';
-import { findMethod } from '../src/api/utils';
-
-jest.mock('../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-jest.mock('../src/api/utils', () => ({
-  findMethod: jest.fn(),
-}));
-
-const createDevice = (onekeyDeviceType: string) => {
-  const typedCall = jest.fn();
-  return {
-    typedCall,
-    device: {
-      features: {
-        onekey_device_type: onekeyDeviceType,
-        safety_checks: 'Strict',
-      },
-      commands: {
-        typedCall,
-      },
-    },
-  };
-};
-
-class TestAllNetworkMethod extends AllNetworkGetAddressBase {
-  async getAllNetworkAddress() {
-    return Promise.resolve([]);
-  }
-}
-
-describe('EVM Ledger legacy path safety checks', () => {
-  it.each([
-    ['evmGetAddress', EvmGetAddress],
-    ['evmGetPublicKey', EVMGetPublicKey],
-  ])(
-    'temporarily relaxes safety checks for Pro %s on ledger legacy path index greater than 1',
-    async (methodName, Method) => {
-      const { device, typedCall } = createDevice('PRO');
-      const method = new Method({
-        id: 1,
-        payload: {
-          method: methodName,
-          path: "m/44'/60'/0'/2",
-        },
-      });
-      method.device = device as any;
-
-      await method.checkSafetyLevelOnTestNet();
-
-      expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-        safety_checks: 'PromptTemporarily',
-      });
-    }
-  );
-
-  it('temporarily relaxes safety checks for Touch get public key on ledger legacy path index greater than 1', async () => {
-    const { device, typedCall } = createDevice('TOUCH');
-    const method = new EVMGetPublicKey({
-      id: 1,
-      payload: {
-        method: 'evmGetPublicKey',
-        path: "m/44'/60'/0'/2",
-      },
-    });
-    method.device = device as any;
-
-    await method.checkSafetyLevelOnTestNet();
-
-    expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-      safety_checks: 'PromptTemporarily',
-    });
-  });
-
-  it('runs EVM safety checks when allNetwork dispatches to the inner get address method', async () => {
-    const { device, typedCall } = createDevice('PRO');
-    (findMethod as jest.Mock).mockImplementation(message => new EvmGetAddress(message));
-    const runSpy = jest.spyOn(EvmGetAddress.prototype, 'run').mockResolvedValue([
-      {
-        path: "m/44'/60'/0'/2",
-        address: '0x0000000000000000000000000000000000000000',
-      },
-    ]);
-    const method = new TestAllNetworkMethod({
-      id: 1,
-      payload: {
-        method: 'allNetworkGetAddress',
-        connectId: 'connect-id',
-        deviceId: 'device-id',
-        bundle: [],
-      },
-    });
-    method.device = {
-      ...device,
-      on: jest.fn(),
-      off: jest.fn(),
-    } as any;
-
-    await method.callMethod(
-      'evmGetAddress',
-      {
-        bundle: [
-          {
-            path: "m/44'/60'/0'/2",
-            showOnOneKey: false,
-            chainId: 1,
-            _originRequestParams: {
-              network: 'evm',
-              path: "m/44'/60'/0'/2",
-              showOnOneKey: false,
-              chainName: '1',
-            },
-          },
-        ],
-      },
-      0
-    );
-
-    expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-      safety_checks: 'PromptTemporarily',
-    });
-
-    runSpy.mockRestore();
-  });
-
-  it('only applies temporary safety checks once during one allNetwork request even when features stay strict', async () => {
-    const { device, typedCall } = createDevice('PRO');
-    (findMethod as jest.Mock).mockImplementation(message => new EvmGetAddress(message));
-    const runSpy = jest
-      .spyOn(EvmGetAddress.prototype, 'run')
-      .mockResolvedValueOnce([
-        {
-          path: "m/44'/60'/0'/2",
-          address: '0x0000000000000000000000000000000000000002',
-        },
-      ])
-      .mockResolvedValueOnce([
-        {
-          path: "m/44'/60'/0'/3",
-          address: '0x0000000000000000000000000000000000000003',
-        },
-      ]);
-    const method = new TestAllNetworkMethod({
-      id: 1,
-      payload: {
-        method: 'allNetworkGetAddressByLoop',
-        connectId: 'connect-id',
-        deviceId: 'device-id',
-        bundle: [],
-      },
-    });
-    method.device = {
-      ...device,
-      on: jest.fn(),
-      off: jest.fn(),
-    } as any;
-
-    await method.callMethod(
-      'evmGetAddress',
-      {
-        bundle: [
-          {
-            path: "m/44'/60'/0'/2",
-            showOnOneKey: false,
-            chainId: 1,
-            _originRequestParams: {
-              network: 'evm',
-              path: "m/44'/60'/0'/2",
-              showOnOneKey: false,
-              chainName: '1',
-            },
-          },
-        ],
-      },
-      0
-    );
-
-    await method.callMethod(
-      'evmGetAddress',
-      {
-        bundle: [
-          {
-            path: "m/44'/60'/0'/3",
-            showOnOneKey: false,
-            chainId: 1,
-            _originRequestParams: {
-              network: 'evm',
-              path: "m/44'/60'/0'/3",
-              showOnOneKey: false,
-              chainName: '1',
-            },
-          },
-        ],
-      },
-      0
-    );
-
-    expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-      safety_checks: 'PromptTemporarily',
-    });
-
-    runSpy.mockRestore();
-  });
-
-  it.each(["m/44'/60'/0'/0", "m/44'/60'/0'/1"])(
-    'keeps safety checks unchanged for legal ledger legacy path %s',
-    async path => {
-      const { device, typedCall } = createDevice('PRO');
-      const method = new EvmGetAddress({
-        id: 1,
-        payload: {
-          method: 'evmGetAddress',
-          path,
-        },
-      });
-      method.device = device as any;
-
-      await method.checkSafetyLevelOnTestNet();
-
-      expect(typedCall).not.toHaveBeenCalled();
-    }
-  );
-
-  it('keeps safety checks unchanged for standard 5-segment BIP44 paths', async () => {
-    const { device, typedCall } = createDevice('PRO');
-    const method = new EvmGetAddress({
-      id: 1,
-      payload: {
-        method: 'evmGetAddress',
-        path: "m/44'/60'/0'/0/2",
-      },
-    });
-    method.device = device as any;
-
-    await method.checkSafetyLevelOnTestNet();
-
-    expect(typedCall).not.toHaveBeenCalled();
-  });
-
-  it('keeps safety checks unchanged on non Pro/Touch devices', async () => {
-    const { device, typedCall } = createDevice('MINI');
-    const method = new EvmGetAddress({
-      id: 1,
-      payload: {
-        method: 'evmGetAddress',
-        path: "m/44'/60'/0'/2",
-      },
-    });
-    method.device = device as any;
-
-    await method.checkSafetyLevelOnTestNet();
-
-    expect(typedCall).not.toHaveBeenCalled();
-  });
-});