@onekeyfe/hd-core 1.2.0-alpha.66 → 1.2.0-alpha.67

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -1,5 +1,4 @@
 import AllNetworkGetAddressBase from '../src/api/allnetwork/AllNetworkGetAddressBase';
-import AllNetworkGetAddress from '../src/api/allnetwork/AllNetworkGetAddress';
 import { findMethod } from '../src/api/utils';
 import { getActiveRequestsByDeviceInstance } from '../src/utils/tracing';
 
@@ -19,317 +18,6 @@ class TestAllNetworkMethod extends AllNetworkGetAddressBase {
 }
 
 describe('AllNetworkGetAddressBase tracing', () => {
-  test('resumes a Protocol V2 hidden wallet before running a nested chain method', async () => {
-    const calls: string[] = [];
-    const checkPassphraseStateSafety = jest.fn().mockImplementation(() => {
-      calls.push('resume-hidden-session');
-      return Promise.resolve(true);
-    });
-    const innerMethod = {
-      checkSafetyLevelOnTestNet: jest.fn().mockResolvedValue(false),
-      connectId: 'connect-id',
-      deviceId: 'device-id',
-      getVersionRange: jest.fn().mockReturnValue({}),
-      assertProtocolSupported: jest.fn(),
-      init: jest.fn(),
-      name: 'evmGetAddress',
-      responseID: 43,
-      unlockPolicy: 'unlock-before-run',
-      run: jest.fn().mockImplementation(() => {
-        calls.push('run-chain-method');
-        return Promise.resolve([{ address: '0xhidden' }]);
-      }),
-      setDevice: jest.fn(),
-      strictCheckDeviceSupport: false,
-    };
-    (findMethod as jest.Mock).mockReturnValue(innerMethod);
-    const method = new TestAllNetworkMethod({
-      id: 1,
-      payload: {
-        method: 'allNetworkGetAddress',
-        connectId: 'connect-id',
-        deviceId: 'device-id',
-        passphraseState: 'hidden-state',
-        bundle: [],
-      },
-    });
-    method.protocolV2UnlockContext = { preflightCompleted: true };
-    const typedCall = jest.fn();
-    method.device = {
-      checkPassphraseStateSafety,
-      commands: {
-        typedCall,
-      },
-      getCurrentFirmwareType: jest.fn(),
-      getProtocol: jest.fn().mockReturnValue('V2'),
-      getCurrentFirmwareVersionString: jest.fn().mockReturnValue('1.0.0'),
-      getCurrentMethodVersionRange: jest
-        .fn()
-        .mockImplementation((getRange: (type: string) => unknown) => getRange('pro2')),
-      instanceId: 'device-instance',
-      isProtocolV2: jest.fn().mockReturnValue(true),
-      isBootloader: jest.fn().mockReturnValue(false),
-      isRomloader: jest.fn().mockReturnValue(false),
-      off: jest.fn(),
-      on: jest.fn(),
-      state: { status: { unlocked: true } },
-      updateProtocolV2Status: jest.fn(),
-    } as any;
-
-    await method.callMethod(
-      'evmGetAddress',
-      {
-        bundle: [
-          {
-            _originRequestParams: {
-              network: 'evm',
-              path: "m/44'/60'/0'/0/0",
-            },
-          },
-        ],
-      },
-      0
-    );
-
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(
-      'hidden-state',
-      false,
-      undefined,
-      false
-    );
-    expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
-    expect(typedCall).not.toHaveBeenCalled();
-  });
-
-  test('resumes a Protocol V2 Cardano hidden wallet with the Cardano seed domain', async () => {
-    const calls: string[] = [];
-    const checkPassphraseStateSafety = jest.fn().mockImplementation(() => {
-      calls.push('resume-cardano-session');
-      return Promise.resolve(true);
-    });
-    const innerMethod = {
-      checkSafetyLevelOnTestNet: jest.fn().mockResolvedValue(false),
-      connectId: 'connect-id',
-      deviceId: 'device-id',
-      getVersionRange: jest.fn().mockReturnValue({}),
-      assertProtocolSupported: jest.fn(),
-      init: jest.fn(),
-      name: 'cardanoGetAddress',
-      responseID: 45,
-      unlockPolicy: 'unlock-before-run',
-      run: jest.fn().mockImplementation(() => {
-        calls.push('run-cardano-method');
-        return Promise.resolve([{ address: 'addr1hidden' }]);
-      }),
-      setDevice: jest.fn(),
-      strictCheckDeviceSupport: false,
-    };
-    (findMethod as jest.Mock).mockReturnValue(innerMethod);
-    const method = new TestAllNetworkMethod({
-      id: 5,
-      payload: {
-        method: 'allNetworkGetAddress',
-        connectId: 'connect-id',
-        deviceId: 'device-id',
-        passphraseState: 'hidden-state',
-        bundle: [],
-      },
-    });
-    method.protocolV2UnlockContext = { preflightCompleted: true };
-    const typedCall = jest.fn();
-    method.device = {
-      checkPassphraseStateSafety,
-      commands: {
-        typedCall,
-      },
-      getCurrentFirmwareType: jest.fn(),
-      getProtocol: jest.fn().mockReturnValue('V2'),
-      getCurrentFirmwareVersionString: jest.fn().mockReturnValue('1.0.0'),
-      getCurrentMethodVersionRange: jest
-        .fn()
-        .mockImplementation((getRange: (type: string) => unknown) => getRange('pro2')),
-      instanceId: 'device-instance',
-      isProtocolV2: jest.fn().mockReturnValue(true),
-      isBootloader: jest.fn().mockReturnValue(false),
-      isRomloader: jest.fn().mockReturnValue(false),
-      off: jest.fn(),
-      on: jest.fn(),
-      state: { status: { unlocked: true } },
-      updateProtocolV2Status: jest.fn(),
-    } as any;
-
-    await method.callMethod(
-      'cardanoGetAddress',
-      {
-        bundle: [
-          {
-            _originRequestParams: {
-              network: 'ada',
-              path: "m/1852'/1815'/0'/0/0",
-            },
-          },
-        ],
-      },
-      0
-    );
-
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith('hidden-state', false, undefined, true);
-    expect(calls).toEqual(['resume-cardano-session', 'run-cardano-method']);
-    expect(typedCall).not.toHaveBeenCalled();
-  });
-
-  test('resumes a Protocol V2 standard wallet before running a nested chain method', async () => {
-    const calls: string[] = [];
-    const checkPassphraseStateSafety = jest.fn().mockImplementation(() => {
-      calls.push('resume-standard-session');
-      return Promise.resolve(true);
-    });
-    const innerMethod = {
-      checkSafetyLevelOnTestNet: jest.fn().mockResolvedValue(false),
-      connectId: 'connect-id',
-      deviceId: 'device-id',
-      getVersionRange: jest.fn().mockReturnValue({}),
-      assertProtocolSupported: jest.fn(),
-      init: jest.fn(),
-      name: 'evmGetAddress',
-      responseID: 44,
-      unlockPolicy: 'unlock-before-run',
-      run: jest.fn().mockImplementation(() => {
-        calls.push('run-chain-method');
-        return Promise.resolve([{ address: '0xstandard' }]);
-      }),
-      setDevice: jest.fn(),
-      strictCheckDeviceSupport: false,
-    };
-    (findMethod as jest.Mock).mockReturnValue(innerMethod);
-    const method = new TestAllNetworkMethod({
-      id: 2,
-      payload: {
-        method: 'allNetworkGetAddress',
-        connectId: 'connect-id',
-        deviceId: 'device-id',
-        useEmptyPassphrase: true,
-        bundle: [],
-      },
-    });
-    method.protocolV2UnlockContext = { preflightCompleted: true };
-    const typedCall = jest.fn();
-    method.device = {
-      checkPassphraseStateSafety,
-      commands: {
-        typedCall,
-      },
-      getCurrentFirmwareType: jest.fn(),
-      getProtocol: jest.fn().mockReturnValue('V2'),
-      getCurrentFirmwareVersionString: jest.fn().mockReturnValue('1.0.0'),
-      getCurrentMethodVersionRange: jest
-        .fn()
-        .mockImplementation((getRange: (type: string) => unknown) => getRange('pro2')),
-      instanceId: 'device-instance',
-      isProtocolV2: jest.fn().mockReturnValue(true),
-      isBootloader: jest.fn().mockReturnValue(false),
-      isRomloader: jest.fn().mockReturnValue(false),
-      off: jest.fn(),
-      on: jest.fn(),
-      state: { status: { unlocked: true } },
-      updateProtocolV2Status: jest.fn(),
-    } as any;
-
-    await method.callMethod(
-      'evmGetAddress',
-      {
-        bundle: [
-          {
-            _originRequestParams: {
-              network: 'evm',
-              path: "m/44'/60'/0'/0/0",
-            },
-          },
-        ],
-      },
-      0
-    );
-
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(undefined, true, undefined, false);
-    expect(calls).toEqual(['resume-standard-session', 'run-chain-method']);
-    expect(typedCall).not.toHaveBeenCalled();
-  });
-
-  test('runs Protocol V2 addresses one at a time so each command receives a wallet session', async () => {
-    const method = new AllNetworkGetAddress({
-      id: 3,
-      payload: {
-        method: 'allNetworkGetAddress',
-        connectId: 'connect-id',
-        deviceId: 'device-id',
-        useEmptyPassphrase: true,
-        bundle: [
-          { network: 'evm', path: "m/44'/60'/0'/0/0" },
-          { network: 'evm', path: "m/44'/60'/0'/0/1" },
-        ],
-      },
-    });
-    method.device = {
-      isProtocolV2: jest.fn().mockReturnValue(true),
-    } as any;
-    method.postMessage = jest.fn();
-    const callMethod = jest
-      .fn()
-      .mockResolvedValueOnce([{ payload: { address: '0x1' }, success: true }])
-      .mockResolvedValueOnce([{ payload: { address: '0x2' }, success: true }]);
-    method.callMethod = callMethod;
-
-    await method.getAllNetworkAddress(7);
-
-    expect(callMethod).toHaveBeenCalledTimes(2);
-    expect(callMethod).toHaveBeenNthCalledWith(
-      1,
-      'evmGetAddress',
-      expect.objectContaining({ bundle: [expect.any(Object)] }),
-      7
-    );
-    expect(callMethod).toHaveBeenNthCalledWith(
-      2,
-      'evmGetAddress',
-      expect.objectContaining({ bundle: [expect.any(Object)] }),
-      7
-    );
-  });
-
-  test('keeps same-method address batching for Protocol V1', async () => {
-    const method = new AllNetworkGetAddress({
-      id: 4,
-      payload: {
-        method: 'allNetworkGetAddress',
-        connectId: 'connect-id',
-        deviceId: 'device-id',
-        useEmptyPassphrase: true,
-        bundle: [
-          { network: 'evm', path: "m/44'/60'/0'/0/0" },
-          { network: 'evm', path: "m/44'/60'/0'/0/1" },
-        ],
-      },
-    });
-    method.device = {
-      isProtocolV2: jest.fn().mockReturnValue(false),
-    } as any;
-    method.postMessage = jest.fn();
-    const callMethod = jest.fn().mockResolvedValue([
-      { payload: { address: '0x1' }, success: true },
-      { payload: { address: '0x2' }, success: true },
-    ]);
-    method.callMethod = callMethod;
-
-    await method.getAllNetworkAddress(7);
-
-    expect(callMethod).toHaveBeenCalledTimes(1);
-    expect(callMethod).toHaveBeenCalledWith(
-      'evmGetAddress',
-      expect.objectContaining({ bundle: [expect.any(Object), expect.any(Object)] }),
-      7
-    );
-  });
-
   test('releases the nested request context when an unhandled error escapes', async () => {
     const deviceInstanceId = 'device-instance';
     const innerMethod = {
@@ -363,7 +51,6 @@ describe('AllNetworkGetAddressBase tracing', () => {
       getCurrentMethodVersionRange: jest
         .fn()
         .mockImplementation((getRange: (type: string) => unknown) => getRange('classic')),
-      isProtocolV2: jest.fn().mockReturnValue(false),
       off: jest.fn(),
       on: jest.fn(),
     } as any;

package/__tests__/DeviceCommands.test.ts

@@ -125,51 +125,6 @@ describe('DeviceCommands failure mapping', () => {
     expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
   });
 
-  it('logs the sanitized DeviceFirmwareUpdateStatus response payload', async () => {
-    const commands = createCommands();
-    const log = getLogger(LoggerNames.DeviceCommands);
-    log.messages.length = 0;
-
-    await expect(
-      commands._filterCommonTypes(
-        {
-          type: 'DeviceFirmwareUpdateStatus',
-          message: {
-            records: [
-              {
-                target_id: 4,
-                status: 2,
-                payload_version: 0x010203,
-                path: 'vol0:/application_p1.bin',
-              },
-            ],
-          },
-        } as any,
-        'DeviceFirmwareUpdateStatusGet'
-      )
-    ).resolves.toMatchObject({ type: 'DeviceFirmwareUpdateStatus' });
-
-    expect(log.messages.at(-1)?.message).toEqual([
-      '_filterCommonTypes: ',
-      {
-        request: 'DeviceFirmwareUpdateStatusGet',
-        response: {
-          type: 'DeviceFirmwareUpdateStatus',
-          message: {
-            records: [
-              {
-                target_id: 4,
-                status: 2,
-                payload_version: 0x010203,
-                path: 'vol0:/application_p1.bin',
-              },
-            ],
-          },
-        },
-      },
-    ]);
-  });
-
   it('maps an invalid DeviceSessionGet resume to WalletSessionInvalid', async () => {
     const commands = createCommands();
 
@@ -363,9 +318,9 @@ describe('DeviceCommands failure mapping', () => {
     }
   );
 
-  it.each(['SignTx', 'EthereumSignTypedDataOneKey', 'SolanaSignTx', 'GetAddress'] as const)(
-    'does not treat domain-ambiguous Protocol V2 subcode 1 for %s as cancellation',
-    async callType => {
+  it.each(['Cancelled', 'User cancelled typed data signing'])(
+    'maps the Protocol V2 MP engine cancellation response "%s" to ActionCancelled',
+    async message => {
       const commands = createCommands();
 
       await expect(
@@ -375,13 +330,18 @@ describe('DeviceCommands failure mapping', () => {
             message: {
               code: 'Failure_ProcessError',
               subcode: 1,
-              message: 'Domain-specific failure',
+              message,
             },
           } as any,
-          callType
+          'SignTx'
         )
       ).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.RuntimeError,
+        errorCode: HardwareErrorCode.ActionCancelled,
+        params: {
+          failureCode: 'Failure_ProcessError',
+          subcode: 1,
+          firmwareMessage: message,
+        },
       });
     }
   );
@@ -396,7 +356,6 @@ describe('DeviceCommands failure mapping', () => {
           type: 'Failure',
           message: {
             code: 'Failure_ProcessError',
-            subcode: 1,
             message: 'Cancelled on device',
           },
         } as any,
@@ -407,7 +366,7 @@ describe('DeviceCommands failure mapping', () => {
     });
   });
 
-  it('maps the DeviceError subcode 1 exception to DeviceBusy', async () => {
+  it('keeps an unrecognized Protocol V2 process subcode generic', async () => {
     const commands = createCommands();
 
     await expect(
@@ -423,12 +382,7 @@ describe('DeviceCommands failure mapping', () => {
         'DeviceSettingsPageShow'
       )
     ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceBusy,
-      params: {
-        failureCode: 'Failure_ProcessError',
-        subcode: 1,
-        firmwareMessage: 'Another process error',
-      },
+      errorCode: HardwareErrorCode.RuntimeError,
     });
   });
 

package/__tests__/DeviceEventRegistration.test.ts

@@ -3,8 +3,6 @@ import { registerHardwareUiEventListeners } from '../src/core/deviceEventRegistr
 
 const handlers = {
   pin: jest.fn(),
-  pinOnDevice: jest.fn(),
-  pinOnDeviceComplete: jest.fn(),
   button: jest.fn(),
   passphrase: jest.fn(),
   passphraseOnDevice: jest.fn(),
@@ -23,8 +21,6 @@ describe('hardware UI event registration', () => {
     expect(registerHardwareUiEventListeners(device as any, handlers)).toBe(true);
     expect(device.on.mock.calls.map(([type]) => type)).toEqual([
       DEVICE.PIN,
-      DEVICE.PIN_ON_DEVICE,
-      DEVICE.PIN_ON_DEVICE_COMPLETE,
       DEVICE.BUTTON,
       DEVICE.PASSPHRASE,
       DEVICE.PASSPHRASE_ON_DEVICE,
@@ -38,8 +34,6 @@ describe('hardware UI event registration', () => {
     expect(registerHardwareUiEventListeners(device as any, handlers)).toBe(true);
     expect(device.on.mock.calls.map(([type]) => type)).toEqual([
       DEVICE.PIN,
-      DEVICE.PIN_ON_DEVICE,
-      DEVICE.PIN_ON_DEVICE_COMPLETE,
       DEVICE.BUTTON,
       DEVICE.PASSPHRASE,
       DEVICE.PASSPHRASE_ON_DEVICE,