@onekeyfe/hd-core 1.1.27-alpha.42 → 1.1.27-alpha.45

package/__tests__/DeviceCommands.test.ts

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,261 @@
+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();
+  });
+});

package/__tests__/preInitialize.test.ts

@@ -0,0 +1,22 @@
+import { Device } from '../src/device/Device';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('preInitialize', () => {
+  it('matches pre-initialized state by passphraseState only', () => {
+    const device = Object.create(Device.prototype) as Device;
+
+    device.markPreInitialized({
+      passphraseState: 'passphrase-state',
+    });
+
+    expect(
+      device.isPreInitializeMetaMatch({
+        passphraseState: 'passphrase-state',
+      })
+    ).toBe(true);
+  });
+});