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

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__/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 = {

package/__tests__/get-device-state.test.ts

@@ -1,7 +1,9 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceType } from '@onekeyfe/hd-transport';
 
 import { Device } from '../src/device/Device';
 import { DEVICE } from '../src/events';
+import { PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE } from '../src/protocols/protocol-v2';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -28,6 +30,18 @@ const createV1Device = (typedCall: jest.Mock) => {
   return device;
 };
 
+const protocolV2ApplicationInfo = {
+  version: 1,
+  build_fingerprint: 'application__5.0.0__abcdef0__PROD__RELEASE',
+  supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
+};
+
+const getProtocolV2LoaderInfo = (mode: 'bootloader' | 'romloader') => ({
+  version: 1,
+  build_fingerprint: `${mode}__1.0.0__abcdef0__PROD__RELEASE`,
+  supported_messages: [],
+});
+
 describe('getDeviceState', () => {
   test('does not expose the internal wallet session', async () => {
     const device = createV2Device(jest.fn());
@@ -39,45 +53,55 @@ describe('getDeviceState', () => {
   });
 
   test('hydrates Protocol V2 with separate DeviceInfoGet and DeviceStatusGet', async () => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => ({
-      message:
-        requestType === 'DeviceInfoGet'
-          ? {
-              protocol_version: 2,
-              hw: { serial_no: 'SERIAL-1' },
-              fw: { application: { version: '5.0.0' } },
-            }
-          : { init_states: true, unlocked: true },
-    }));
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            protocol_version: 2,
+            hw: { serial_no: 'SERIAL-1' },
+            fw: { application: { version: '5.0.0' } },
+          },
+        };
+      }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
+      return { message: { init_states: true, unlocked: true } };
+    });
     const device = createV2Device(typedCall);
 
     const state = await device.getDeviceState();
 
     expect(state.identity.serialNo).toBe('SERIAL-1');
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(3);
     expect(typedCall.mock.calls[0][0]).toBe('DeviceInfoGet');
     expect(typedCall.mock.calls[0][2]?.targets?.status).not.toBe(true);
     expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
   });
 
   test('uses one full DeviceInfoGet plus DeviceStatusGet when firmware refresh initializes state', async () => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => ({
-      message:
-        requestType === 'DeviceInfoGet'
-          ? {
-              protocol_version: 2,
-              hw: { serial_no: 'SERIAL-1' },
-              fw: { application: { version: '5.0.0', hash: 'HASH-1' } },
-            }
-          : { init_states: true, unlocked: true },
-    }));
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            protocol_version: 2,
+            hw: { serial_no: 'SERIAL-1' },
+            fw: { application: { version: '5.0.0', hash: 'HASH-1' } },
+          },
+        };
+      }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
+      return { message: { init_states: true, unlocked: true } };
+    });
     const device = createV2Device(typedCall);
 
     await device.getDeviceState({
       refreshSections: ['identity', 'versions', 'verification'],
     });
 
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(3);
     expect(typedCall).toHaveBeenNthCalledWith(
       1,
       'DeviceInfoGet',
@@ -115,13 +139,13 @@ describe('getDeviceState', () => {
   });
 
   test.each(['bootloader', 'romloader'] as const)(
-    'temporarily treats failed DeviceStatusGet with %s metadata as bootloader',
+    'uses ProtocolInfo to preserve %s mode without DeviceStatusGet',
     async mode => {
       const typedCall = jest.fn().mockImplementation((requestType: string) => {
         if (requestType === 'DeviceInfoGet') {
           return {
             message: {
-              hw: { serial_no: 'SERIAL-1' },
+              hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
               fw:
                 mode === 'romloader'
                   ? { romloader: { version: '1.0.0' } }
@@ -129,24 +153,38 @@ describe('getDeviceState', () => {
             },
           };
         }
-        throw new Error('DeviceStatusGet unavailable');
+        if (requestType === 'ProtocolInfoRequest') {
+          return { message: getProtocolV2LoaderInfo(mode) };
+        }
+        throw new Error(`Unexpected request: ${requestType}`);
       });
       const device = createV2Device(typedCall);
       device.updateState({ protocol: 'V2', status: { mode } }, 'initialize');
 
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
-      expect(state.status.mode).toBe('bootloader');
+      expect(state.status.mode).toBe(mode);
       expect(typedCall.mock.calls.map(call => call[0])).toEqual([
         'DeviceInfoGet',
-        'DeviceStatusGet',
+        'ProtocolInfoRequest',
       ]);
     }
   );
 
   test('refreshes Protocol V2 status only when explicitly requested in normal mode', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: { init_states: true, unlocked: true, device_id: 'device-1' },
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            hw: { serial_no: 'SERIAL-1' },
+            fw: { application: { version: '5.0.0' } },
+          },
+        };
+      }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
+      return { message: { init_states: true, unlocked: true, device_id: 'device-1' } };
     });
     const device = createV2Device(typedCall);
     device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
@@ -203,6 +241,9 @@ describe('getDeviceState', () => {
           message: { init_states: true, unlocked: false, device_id: 'device-1' },
         };
       }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
       if (requestType === 'DeviceSettingsGet') {
         return { message: { label: 'Renamed Pro 2' } };
       }
@@ -215,6 +256,7 @@ describe('getDeviceState', () => {
 
     expect(typedCall.mock.calls.map(call => call[0])).toEqual([
       'DeviceInfoGet',
+      'ProtocolInfoRequest',
       'DeviceStatusGet',
       'DeviceSettingsGet',
     ]);
@@ -237,6 +279,9 @@ describe('getDeviceState', () => {
           message: { init_states: true, unlocked: false, device_id: 'device-1' },
         };
       }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
       throw Object.assign(new Error('Device locked'), {
         errorCode: HardwareErrorCode.DeviceLocked,
       });
@@ -383,7 +428,10 @@ describe('getDeviceState', () => {
           },
         };
       }
-      throw new Error('DeviceStatusGet unavailable in bootloader');
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: getProtocolV2LoaderInfo('bootloader') };
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
     });
     const device = createV2Device(typedCall);
     device.updateState(