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

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(

package/__tests__/kaspaSignTransaction.test.ts

@@ -135,6 +135,15 @@ describe('KaspaSignTransaction capability flags', () => {
       createMethod({ inputs: [buildInput()], outputs: [{ satoshis: 1 }] }).init()
     ).toThrow('outputs require either address/addressN');
   });
+
+  it('rejects outputs containing both address and addressN', () => {
+    expect(() =>
+      createMethod({
+        inputs: [buildInput()],
+        outputs: [{ satoshis: 1, address: ADDRESS, addressN: CHANGE_PATH }],
+      }).init()
+    ).toThrow('outputs must not contain both address and addressN');
+  });
 });
 
 describe('KaspaSignTransaction protocol negotiation', () => {

package/__tests__/known-device-public-types.type-test.ts

@@ -0,0 +1,3 @@
+import type { Features, KnownDevice } from '../src/types';
+
+export const requireKnownDeviceFeatures = ({ features }: KnownDevice): Features => features;

package/__tests__/logBlockEvent.test.ts

@@ -1,4 +1,10 @@
-import { UI_RESPONSE, getLogBlockLabel } from '../src/events';
+import {
+  UI_REQUEST,
+  UI_RESPONSE,
+  formatLogMethodLabel,
+  getLogBlockLabel,
+  getSafeLogPayload,
+} from '../src/events';
 
 describe('getLogBlockLabel', () => {
   it('blocks evmSignTypedData params before logging large typed data', () => {
@@ -35,6 +41,21 @@ describe('getLogBlockLabel', () => {
     expect(getLogBlockLabel({ type: UI_RESPONSE.RECEIVE_PIN })).toBe(UI_RESPONSE.RECEIVE_PIN);
   });
 
+  it.each([UI_REQUEST.REQUEST_PASSPHRASE, UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE])(
+    'blocks wallet identifiers in %s event logging',
+    type => {
+      expect(
+        getLogBlockLabel({
+          type,
+          payload: {
+            passphraseState: 'wallet-identifier',
+            expectedPassphraseState: 'expected-wallet-identifier',
+          },
+        })
+      ).toBe(type);
+    }
+  );
+
   it('blocks openWalletSession wallet identifiers in direct and iframe call logging', () => {
     const payload = {
       method: 'openWalletSession',
@@ -53,16 +74,51 @@ describe('getLogBlockLabel', () => {
     ).toBe('openWalletSession');
   });
 
+  it('keeps openWalletSession metadata while redacting wallet session identifiers', () => {
+    const safeResponse = getSafeLogPayload(
+      {
+        success: true,
+        payload: {
+          protocol: 'V2',
+          walletType: 'hidden',
+          deviceId: 'device-id',
+          passphraseState: 'wallet-identifier',
+          sessionId: 'wallet-session-id',
+          resumed: false,
+        },
+      },
+      'openWalletSession'
+    );
+
+    expect(safeResponse).toEqual({
+      method: 'openWalletSession',
+      success: true,
+      payload: {
+        protocol: 'V2',
+        walletType: 'hidden',
+        deviceId: 'device-id',
+        passphraseState: '[REDACTED]',
+        sessionId: '[REDACTED]',
+        resumed: false,
+      },
+    });
+  });
+
   it.each(['deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
-    'blocks binary payload logging for %s',
+    'keeps metadata and replaces binary payloads with their size for %s',
     method => {
-      expect(getLogBlockLabel({ method, data: new Uint8Array(1024) })).toBe(method);
-      expect(getLogBlockLabel({ payload: { method, data: new Uint8Array(1024) } })).toBe(method);
+      const request = { method, path: 'resource.bin', data: new Uint8Array(1024) };
+      expect(getLogBlockLabel(request)).toBe(method);
+      expect(getSafeLogPayload(request, method)).toEqual({
+        method,
+        path: 'resource.bin',
+        data: '[BINARY:1024]',
+      });
     }
   );
 
   it.each(['evmSignMessage', 'btcSignMessage', 'evmSignTransaction'])(
-    'blocks request and response payload logging for every API method including %s',
+    'blocks request and response payload logging for signing method %s',
     method => {
       expect(getLogBlockLabel({ method, message: 'sensitive signing payload' })).toBe(method);
       expect(
@@ -74,6 +130,34 @@ describe('getLogBlockLabel', () => {
     }
   );
 
+  it('keeps ordinary API requests and responses visible', () => {
+    const request = { method: 'getDeviceState', connectId: 'connect-id', scope: 'runtime' };
+    const response = { success: true, payload: { protocol: 'V2', initialized: true } };
+
+    expect(getLogBlockLabel(request)).toBeUndefined();
+    expect(getSafeLogPayload(request)).toEqual(request);
+    expect(getSafeLogPayload(response)).toEqual(response);
+  });
+
+  it('redacts sensitive keys even for ordinary API payloads', () => {
+    expect(
+      getSafeLogPayload({
+        method: 'ordinaryMethod',
+        payload: { session_id: 'session-secret', nested: { pin: '1234' } },
+      })
+    ).toEqual({
+      method: 'ordinaryMethod',
+      payload: { session_id: '[REDACTED]', nested: { pin: '[REDACTED]' } },
+    });
+  });
+
+  it('puts sensitive API method names in the log label', () => {
+    expect(formatLogMethodLabel('response:', 'openWalletSession')).toBe(
+      'response: [openWalletSession]'
+    );
+    expect(formatLogMethodLabel('response:')).toBe('response:');
+  });
+
   it('does not classify events without an API method as method calls', () => {
     expect(getLogBlockLabel({ event: 'DEVICE_EVENT', type: 'device-connect' })).toBeUndefined();
   });