@onekeyfe/hd-core 1.2.0-alpha.34 → 1.2.0-alpha.36

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -18,6 +18,79 @@ 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,
+      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.device = {
+      checkPassphraseStateSafety,
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: true } }),
+      },
+      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);
+    expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
+  });
+
   test('releases the nested request context when an unhandled error escapes', async () => {
     const deviceInstanceId = 'device-instance';
     const innerMethod = {
@@ -51,6 +124,7 @@ 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

@@ -19,6 +19,90 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
+  it('logs passphrase call request and response without exposing the passphrase', async () => {
+    const commands = createCommands();
+    const requestLog = getLogger(LoggerNames.DeviceCommands);
+    const responseLog = getLogger(LoggerNames.Core);
+    requestLog.messages.length = 0;
+    responseLog.messages.length = 0;
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockResolvedValue({
+        type: 'Success',
+        message: {
+          message: 'Passphrase accepted',
+        },
+      }),
+    } as any;
+
+    await expect(
+      commands.call('DeviceSessionAskPassphrase', {
+        passphrase: 'hidden-wallet-secret',
+        on_device: false,
+      })
+    ).resolves.toMatchObject({ type: 'Success' });
+
+    expect(requestLog.messages.at(-1)?.message).toEqual([
+      '[DeviceCommands] [call] Sending',
+      'DeviceSessionAskPassphrase',
+      {
+        passphrase: '[REDACTED]',
+        on_device: false,
+      },
+    ]);
+    expect(responseLog.messages.at(-1)?.message).toEqual([
+      '[DeviceCommands] [call] Received',
+      'Success',
+      {
+        message: 'Passphrase accepted',
+      },
+    ]);
+    expect(JSON.stringify([...requestLog.messages, ...responseLog.messages])).not.toContain(
+      'hidden-wallet-secret'
+    );
+  });
+
+  it('logs DeviceStatus response fields without exposing the device ID', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.Core);
+    log.messages.length = 0;
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockResolvedValue({
+        type: 'DeviceStatus',
+        message: {
+          device_id: 'sensitive-device-id',
+          unlocked: true,
+          init_states: true,
+          backup_required: false,
+          passphrase_enabled: true,
+          attach_to_pin_enabled: false,
+          unlocked_by_attach_to_pin: false,
+        },
+      }),
+    } as any;
+
+    await expect(commands.call('DeviceStatusGet', {})).resolves.toMatchObject({
+      type: 'DeviceStatus',
+    });
+
+    const receivedLog = log.messages.at(-1)?.message;
+    expect(receivedLog).toEqual([
+      '[DeviceCommands] [call] Received',
+      'DeviceStatus',
+      {
+        device_id: '[REDACTED]',
+        unlocked: true,
+        init_states: true,
+        backup_required: false,
+        passphrase_enabled: true,
+        attach_to_pin_enabled: false,
+        unlocked_by_attach_to_pin: false,
+      },
+    ]);
+    expect(JSON.stringify(receivedLog)).not.toContain('sensitive-device-id');
+  });
+
   it('does not log DeviceSessionGet response secrets', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);

package/__tests__/DeviceEventRegistration.test.ts

@@ -3,6 +3,8 @@ 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(),
@@ -21,6 +23,8 @@ 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,
@@ -34,6 +38,8 @@ 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,

package/__tests__/device-settings.test.ts

@@ -40,6 +40,9 @@ describe('DeviceSettings protocol routing', () => {
     ['language', { language: 'ja-JP' }],
     ['brightness', { brightness: 80 }],
     ['haptic feedback', { hapticFeedback: true }],
+    ['animation', { animationEnabled: true }],
+    ['tap to wake', { tapToWake: true }],
+    ['device name display', { deviceNameDisplayEnabled: true }],
   ])('does not unlock Protocol V2 before changing %s', (_name, settings) => {
     const method = new DeviceSettings({
       id: 1,

package/__tests__/device-wallet-session-store.test.ts

@@ -1,6 +1,7 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import ClearSessionCache from '../src/api/ClearSessionCache';
+import GetPassphraseState from '../src/api/GetPassphraseState';
 import DeviceWipe from '../src/api/device/DeviceWipe';
 import {
   DeviceWalletSessionStore,
@@ -35,15 +36,18 @@ describe('DeviceWalletSessionStore', () => {
     expect(store.get('device-2', 'hidden-a')).toBe('session-c');
   });
 
-  test('evicts the oldest wallet session when a device exceeds the SE capacity of three', () => {
+  test('keeps SDK session handles without mirroring hardware eviction policy', () => {
     const store = new DeviceWalletSessionStore();
     store.setStandard('device-1', 'wallet-a', 'session-a');
     store.set('device-1', 'wallet-b', 'session-b');
     store.set('device-1', 'wallet-c', 'session-c');
     store.set('device-1', 'wallet-d', 'session-d');
 
-    expect(store.get('device-1', 'wallet-a')).toBeUndefined();
-    expect(store.getStandard('device-1')).toBeUndefined();
+    expect(store.get('device-1', 'wallet-a')).toBe('session-a');
+    expect(store.getStandard('device-1')).toEqual({
+      passphraseState: 'wallet-a',
+      sessionId: 'session-a',
+    });
     expect(store.get('device-1', 'wallet-b')).toBe('session-b');
     expect(store.get('device-1', 'wallet-c')).toBe('session-c');
     expect(store.get('device-1', 'wallet-d')).toBe('session-d');
@@ -94,7 +98,7 @@ describe('DeviceWalletSessionStore', () => {
     expect(store.getPending('stable-device-id')).toBe('pending-session');
   });
 
-  test('keeps the three-session limit when descriptor sessions merge into a stable device id', () => {
+  test('keeps every known handle when descriptor sessions merge into a stable device id', () => {
     const store = new DeviceWalletSessionStore();
     store.setStandard('stable-device-id', 'wallet-a', 'session-a');
     store.set('stable-device-id', 'wallet-b', 'session-b');
@@ -106,8 +110,11 @@ describe('DeviceWalletSessionStore', () => {
       nextDeviceId: 'stable-device-id',
     });
 
-    expect(store.get('stable-device-id', 'wallet-a')).toBeUndefined();
-    expect(store.getStandard('stable-device-id')).toBeUndefined();
+    expect(store.get('stable-device-id', 'wallet-a')).toBe('session-a');
+    expect(store.getStandard('stable-device-id')).toEqual({
+      passphraseState: 'wallet-a',
+      sessionId: 'session-a',
+    });
     expect(store.get('stable-device-id', 'wallet-b')).toBe('session-b');
     expect(store.get('stable-device-id', 'wallet-c')).toBe('session-c');
     expect(store.get('stable-device-id', 'wallet-d')).toBe('session-d');
@@ -402,4 +409,70 @@ describe('Protocol V1 wallet identity initialization', () => {
       expect.any(Object)
     );
   });
+
+  test('selects the standard V1 wallet after a non-destructive live identity read', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-a',
+      unlocked: true,
+      passphraseProtection: false,
+    } as never;
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a' });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'Initialize',
+      'Features',
+      {
+        passphrase_state: undefined,
+        is_contains_attach: true,
+      },
+      expect.any(Object)
+    );
+  });
+});
+
+describe('Protocol V1 passphrase state classification', () => {
+  test('does not expose a standard-wallet address as passphrase state', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Address',
+      message: { address: 'standard-wallet-address' },
+    });
+    const method = new GetPassphraseState({
+      payload: {
+        method: 'getPassphraseState',
+        connectId: 'connect-a',
+      },
+    });
+    method.device = {
+      features: {},
+      commands: { typedCall },
+      isProtocolV2: () => false,
+      getCurrentDeviceType: () => EDeviceType.Classic,
+      getCurrentFirmwareVersionString: () => '1.0.0',
+      getCurrentPassphraseProtection: () => false,
+      getCurrentDeviceId: () => 'device-a',
+      getFeatures: jest.fn(),
+      getInternalState: () => undefined,
+      updateInternalState: jest.fn(),
+    } as never;
+
+    await expect(method.run()).resolves.toBeUndefined();
+    expect(typedCall).toHaveBeenCalledWith('GetAddress', 'Address', {
+      address_n: expect.any(Array),
+      coin_name: 'Testnet',
+      script_type: 'SPENDADDRESS',
+      show_display: false,
+    });
+  });
 });

package/__tests__/evmSignTransaction.test.ts

@@ -1,4 +1,5 @@
 import EVMSignTransaction from '../src/api/evm/EVMSignTransaction';
+import TransportManager from '../src/data-manager/TransportManager';
 
 import type { EVMTransactionEIP7702 } from '../src/types';
 
@@ -17,13 +18,17 @@ jest.mock('../src/device/Device', () => ({
   Device: jest.fn(),
 }));
 
+const mockTransportManager = jest.mocked(TransportManager);
+
 describe('EVMSignTransaction EIP-7702', () => {
   let mockDevice: any;
   let mockTypedCall: jest.Mock;
 
   beforeEach(() => {
+    mockTransportManager.getProtocolV1MessageSchema.mockReturnValue('v1CurrentSchema');
     mockTypedCall = jest.fn();
     mockDevice = {
+      isProtocolV2: jest.fn(() => false),
       commands: {
         typedCall: {
           bind: jest.fn(() => mockTypedCall),
@@ -32,6 +37,70 @@ describe('EVMSignTransaction EIP-7702', () => {
     };
   });
 
+  describe('Protocol-specific schema routing', () => {
+    const transaction: EVMTransactionEIP7702 = {
+      to: '0x4Cd241E8d1510e30b2076397afc7508Ae59C66c9',
+      value: '0x0',
+      gasLimit: '0x5208',
+      nonce: '0x0',
+      chainId: 1,
+      maxFeePerGas: '0xbebc200',
+      maxPriorityFeePerGas: '0x9502f900',
+      authorizationList: [
+        {
+          chainId: 1,
+          address: '0x4Cd241E8d1510e30b2076397afc7508Ae59C66c9',
+          nonce: '0x1',
+        },
+      ],
+    };
+
+    const createTransactionMethod = () => {
+      const method = new EVMSignTransaction({
+        id: 1,
+        payload: {
+          method: 'evmSignTransaction',
+          path: "m/44'/60'/0'/0/0",
+          transaction,
+        },
+      });
+      method.device = mockDevice;
+      method.init();
+      return method;
+    };
+
+    it('keeps Protocol V2 on current OneKey messages after a legacy V1 device', async () => {
+      mockTransportManager.getProtocolV1MessageSchema.mockReturnValue('v1LegacySchema');
+      mockDevice.isProtocolV2.mockReturnValue(true);
+      mockTypedCall.mockResolvedValue({
+        message: {
+          signature_v: 27,
+          signature_r: '01',
+          signature_s: '02',
+          authorization_signatures: [],
+        },
+      });
+
+      await expect(createTransactionMethod().run()).resolves.toMatchObject({
+        v: '0x1b',
+      });
+      expect(mockTypedCall).toHaveBeenCalledWith(
+        'EthereumSignTxEIP7702OneKey',
+        'EthereumTxRequestOneKey',
+        expect.any(Object)
+      );
+    });
+
+    it('continues to use legacy messages for a Protocol V1 legacy device', async () => {
+      mockTransportManager.getProtocolV1MessageSchema.mockReturnValue('v1LegacySchema');
+
+      await expect(createTransactionMethod().run()).rejects.toThrow(
+        'EIP7702 not supported by Trezor'
+      );
+      expect(mockTypedCall).not.toHaveBeenCalled();
+    });
+  });
+
   describe('EIP-7702 Transaction Detection', () => {
     it('should detect EIP-7702 transaction with authorization list', () => {
       const transaction: EVMTransactionEIP7702 = {