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

package/src/types/api/searchDevices.ts

@@ -1,4 +1,4 @@
 import type { SearchDevice } from '../device';
-import type { Response } from '../params';
+import type { CommonParams, Response } from '../params';
 
-export declare function searchDevices(): Response<SearchDevice[]>;
+export declare function searchDevices(params?: CommonParams): Response<SearchDevice[]>;

package/src/types/device.ts

@@ -96,7 +96,8 @@ export type IDeviceType =
   | EDeviceType.ClassicPure
   | EDeviceType.Mini
   | EDeviceType.Touch
-  | EDeviceType.Pro;
+  | EDeviceType.Pro
+  | EDeviceType.Pro2;
 
 /**
  * model_classic: 'classic' | 'classic1s' | 'classicpure'
@@ -124,6 +125,7 @@ export const DeviceTypeToModels: { [deviceType in IDeviceType]: IDeviceModel[] }
   [EDeviceType.Mini]: ['model_mini'],
   [EDeviceType.Touch]: ['model_touch'],
   [EDeviceType.Pro]: ['model_touch'],
+  [EDeviceType.Pro2]: [],
   [EDeviceType.Unknown]: [],
 };
 

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/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();
-  });
-});