@onekeyfe/hd-core 1.2.0-alpha.22 → 1.2.0-alpha.24

package/__tests__/open-wallet-session.test.ts

@@ -1,4 +1,5 @@
 import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import GetPassphraseState from '../src/api/GetPassphraseState';
 import OpenWalletSession from '../src/api/OpenWalletSession';
@@ -59,15 +60,54 @@ describe('openWalletSession', () => {
     deviceWalletSessionStore.clear();
   });
 
-  test('keeps getPassphraseState unsupported on Protocol V2', async () => {
+  test.each([{ useEmptyPassphrase: true }, { initSession: true }, {}])(
+    'requires the explicit mode in the new public API: %p',
+    legacyParams => {
+      const method = new OpenWalletSession({
+        payload: {
+          method: 'openWalletSession',
+          connectId: 'connect-id',
+          ...legacyParams,
+        },
+      });
+
+      expect(() => method.init()).toThrow('Parameter [mode] is required');
+    }
+  );
+
+  test('keeps the legacy getPassphraseState App flow working on Protocol V2', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'pro2-wallet-state',
+          session_id: 'pro2-wallet-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
     const method = new GetPassphraseState({
-      payload: { method: 'getPassphraseState', connectId: 'connect-id' },
+      payload: {
+        method: 'getPassphraseState',
+        connectId: 'connect-id',
+        initSession: true,
+        useEmptyPassphrase: false,
+      },
     });
-    method.device = createDevice() as any;
+    method.device = createDevice({ typedCall, promptPassphrase }) as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
-    });
+    await expect(method.run()).resolves.toBe('pro2-wallet-state');
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      {
+        existsAttachPinUser: false,
+        source: 'wallet-session-coordinator',
+        reason: 'open-wallet',
+      },
+      { cancelDeviceOnReject: false }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {});
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('keeps Legacy Protocol V1 getPassphraseState parameterless', async () => {
@@ -122,9 +162,7 @@ describe('openWalletSession', () => {
       payload: {
         method: 'openWalletSession',
         connectId: 'connect-id',
-        useEmptyPassphrase: true,
-        initSession: true,
-        passphraseState: 'stale-hidden-state',
+        mode: 'standard',
       },
     });
     method.init();
@@ -153,19 +191,27 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('GetPassphraseState', 'PassphraseState', {
       passphrase_state: undefined,
     });
-    expect(device.clearInternalState).toHaveBeenCalled();
+    expect(device.clearInternalState).not.toHaveBeenCalled();
   });
 
-  test('uses the compatibility form to select a hidden wallet on Protocol V2', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'hidden-state',
-        session_id: 'hidden-session',
-      },
-    });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden secret' });
+  test('uses the explicit mode to select a hidden wallet on Protocol V2', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'hidden-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
     const method = new OpenWalletSession({
-      payload: { method: 'openWalletSession', connectId: 'connect-id' },
+      payload: {
+        method: 'openWalletSession',
+        connectId: 'connect-id',
+        mode: 'select-hidden',
+      },
     });
     method.init();
     method.device = createDevice({ typedCall, promptPassphrase }) as any;
@@ -175,24 +221,32 @@ describe('openWalletSession', () => {
       walletType: 'hidden',
       passphraseState: 'hidden-state',
     });
+    expect(promptPassphrase).toHaveBeenCalled();
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {});
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('classifies the selected Pro2 wallet from the post-unlock device state', async () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'hidden-state-after-unlock',
           session_id: 'hidden-session-after-unlock',
         },
       });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden secret' });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
     });
     method.init();
-    const device = createDevice({ passphraseProtection: false, typedCall, promptPassphrase });
+    const device = createDevice({
+      passphraseProtection: false,
+      typedCall,
+      promptPassphrase,
+    });
     device.features.unlocked = false;
     device.getCurrentPassphraseProtection = () => device.features.passphraseProtection;
     device.unlockDevice = jest.fn().mockImplementation(() => {
@@ -210,29 +264,30 @@ describe('openWalletSession', () => {
       sessionId: 'hidden-session-after-unlock',
       resumed: false,
     });
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
     expect(promptPassphrase).toHaveBeenCalledTimes(1);
   });
 
-  test('uses legacy initSession to replace a hidden-wallet session on Protocol V2', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'new-hidden-state',
-        session_id: 'new-hidden-session',
-      },
-    });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'new hidden secret' });
+  test('select-hidden starts a fresh hidden-wallet session on Protocol V2', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'new-hidden-state',
+          session_id: 'new-hidden-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
         connectId: 'connect-id',
-        initSession: true,
-        deviceId: 'device-1',
-        passphraseState: 'stale-hidden-state',
+        mode: 'select-hidden',
       },
     });
     method.init();
-    deviceWalletSessionStore.set('device-1', 'stale-hidden-state', 'stale-hidden-session');
     method.device = createDevice({ typedCall, promptPassphrase }) as any;
 
     await expect(method.run()).resolves.toEqual({
@@ -246,29 +301,29 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { host_passphrase: { passphrase: 'new hidden secret' } },
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).toHaveBeenCalled();
-    expect(deviceWalletSessionStore.get('device-1', 'stale-hidden-state')).toBeUndefined();
     expect(deviceWalletSessionStore.get('device-1', 'new-hidden-state')).toBe('new-hidden-session');
   });
 
-  test('does not clear another device wallet through legacy initSession', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'current-device-state',
-        session_id: 'current-device-session',
-      },
-    });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden secret' });
+  test('select-hidden does not clear another device wallet', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'current-device-state',
+          session_id: 'current-device-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
         connectId: 'connect-id',
-        initSession: true,
-        deviceId: 'other-device',
-        passphraseState: 'other-device-state',
+        mode: 'select-hidden',
       },
     });
     method.init();
@@ -285,19 +340,22 @@ describe('openWalletSession', () => {
     );
   });
 
-  test('uses a complete legacy wallet binding to resume on Protocol V2', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'hidden-state',
-        session_id: 'renewed-session',
-      },
-    });
+  test('uses an explicit wallet binding to resume on Protocol V2', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'renewed-session',
+        },
+      });
     const promptPassphrase = jest.fn();
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
         connectId: 'connect-id',
-        initSession: false,
+        mode: 'resume-hidden',
         deviceId: 'device-1',
         passphraseState: 'hidden-state',
       },
@@ -314,8 +372,8 @@ describe('openWalletSession', () => {
       sessionId: 'renewed-session',
       resumed: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      resume: { session_id: 'known-session' },
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'known-session',
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -357,7 +415,7 @@ describe('openWalletSession', () => {
   });
 
   test.each([{ initSession: 'true' }, { useEmptyPassphrase: 'false' }])(
-    'rejects a non-boolean legacy flag: %o',
+    'rejects legacy flags without an explicit mode: %o',
     params => {
       const method = new OpenWalletSession({
         payload: {
@@ -485,12 +543,15 @@ describe('openWalletSession', () => {
   });
 
   test('rejects a standard-wallet request when Protocol V2 is unlocked by Attach PIN', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'attach-wallet-state',
-        session_id: 'attach-wallet-session',
-      },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'attach-wallet-state',
+          session_id: 'attach-wallet-session',
+        },
+      });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'standard' },
     });
@@ -507,13 +568,17 @@ describe('openWalletSession', () => {
   });
 
   test('selects a hidden wallet and returns the CLI compatibility session', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'hidden-state',
-        session_id: 'hidden-session',
-      },
-    });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden secret' });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'hidden-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
     });
@@ -530,18 +595,21 @@ describe('openWalletSession', () => {
       sessionId: 'hidden-session',
       resumed: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { host_passphrase: { passphrase: 'hidden secret' } },
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
   });
 
-  test('selects on-device passphrase entry through DeviceSessionOpen', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: { btc_test_address: 'device-state', session_id: 'device-session' },
-    });
+  test('selects on-device passphrase entry before getting the prepared session', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        message: { btc_test_address: 'device-state', session_id: 'device-session' },
+      });
     const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
@@ -553,15 +621,56 @@ describe('openWalletSession', () => {
       walletType: 'hidden',
       passphraseState: 'device-state',
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { passphrase_on_device: {} },
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+  });
+
+  test('forwards a host passphrase to Pro2 firmware', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        message: { btc_test_address: 'host-state', session_id: 'host-session' },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
+    const method = new OpenWalletSession({
+      payload: {
+        method: 'openWalletSession',
+        connectId: 'connect-id',
+        mode: 'select-hidden',
+      },
+    });
+    method.init();
+    method.device = createDevice({
+      typedCall,
+      promptPassphrase,
+    }) as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'host-state',
+    });
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      {
+        existsAttachPinUser: false,
+        source: 'wallet-session-coordinator',
+        reason: 'open-wallet',
+      },
+      { cancelDeviceOnReject: false }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
+      passphrase: 'host hidden wallet',
     });
   });
 
   test('selects Attach PIN only when the device reports an existing binding', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: { btc_test_address: 'attach-state', session_id: 'attach-session' },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({
+        message: { btc_test_address: 'attach-state', session_id: 'attach-session' },
+      });
     const promptPassphrase = jest.fn().mockResolvedValue({ attachPinOnDevice: true });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
@@ -576,12 +685,15 @@ describe('openWalletSession', () => {
       passphraseState: 'attach-state',
     });
     expect(promptPassphrase).toHaveBeenCalledWith(
-      expect.objectContaining({ existsAttachPinUser: true }),
+      {
+        existsAttachPinUser: true,
+        source: 'wallet-session-coordinator',
+        reason: 'open-wallet',
+      },
       { cancelDeviceOnReject: false }
     );
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { attach_pin_on_device: {} },
-    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test.each([
@@ -596,8 +708,12 @@ describe('openWalletSession', () => {
   ])(
     'rejects an incomplete Protocol V2 hidden-wallet response missing $missingField',
     async ({ message }) => {
-      const typedCall = jest.fn().mockResolvedValue({ message });
-      const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden secret' });
+      const typedCall = jest
+        .fn()
+        .mockResolvedValueOnce({ message: { version: 2 } })
+        .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+        .mockResolvedValueOnce({ message });
+      const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
       const method = new OpenWalletSession({
         payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
       });
@@ -607,7 +723,7 @@ describe('openWalletSession', () => {
 
       await expect(method.run()).rejects.toMatchObject({
         errorCode: HardwareErrorCode.RuntimeError,
-        message: 'DeviceSessionOpen returned an incomplete DeviceSession response.',
+        message: 'DeviceSessionGet returned an incomplete DeviceSession response.',
       });
       expect(device.clearInternalState).toHaveBeenCalled();
       expect(device.updateInternalState).not.toHaveBeenCalled();
@@ -615,12 +731,15 @@ describe('openWalletSession', () => {
   );
 
   test('resumes a known hidden wallet without prompting or device selection', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'hidden-state',
-        session_id: 'renewed-session',
-      },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'renewed-session',
+        },
+      });
     const promptPassphrase = jest.fn();
     const method = new OpenWalletSession({
       payload: {
@@ -643,19 +762,22 @@ describe('openWalletSession', () => {
       sessionId: 'renewed-session',
       resumed: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      resume: { session_id: 'known-session' },
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'known-session',
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
 
   test('validates a locked Protocol V2 resume binding after deviceId refresh', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'hidden-state',
-        session_id: 'renewed-session',
-      },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'renewed-session',
+        },
+      });
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
@@ -694,14 +816,14 @@ describe('openWalletSession', () => {
     });
     expect(device.unlockDevice).toHaveBeenCalledTimes(1);
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      resume: { session_id: 'known-session' },
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'known-session',
     });
-    const sessionOpenCall = typedCall.mock.calls.findIndex(
-      ([requestName]) => requestName === 'DeviceSessionOpen'
+    const sessionGetCall = typedCall.mock.calls.findIndex(
+      ([requestName]) => requestName === 'DeviceSessionGet'
     );
     expect(device.getDeviceState.mock.invocationCallOrder[1]).toBeLessThan(
-      typedCall.mock.invocationCallOrder[sessionOpenCall]
+      typedCall.mock.invocationCallOrder[sessionGetCall]
     );
   });
 

package/__tests__/protocol-v2-ping.test.ts

@@ -0,0 +1,28 @@
+import { validateProtocolV2PingMessage } from '../src/api/protocol-v2/Ping';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+describe('Protocol V2 diagnostic Ping validation', () => {
+  test('accepts messages up to the firmware UTF-8 byte limit', () => {
+    expect(validateProtocolV2PingMessage('x'.repeat(63))).toBe('x'.repeat(63));
+    expect(validateProtocolV2PingMessage('测'.repeat(21))).toBe('测'.repeat(21));
+  });
+
+  test('rejects messages larger than the firmware UTF-8 byte limit', () => {
+    expect(() => validateProtocolV2PingMessage('x'.repeat(64))).toThrow(
+      'Protocol V2 Ping message must not exceed 63 UTF-8 bytes.'
+    );
+    expect(() => validateProtocolV2PingMessage('测'.repeat(22))).toThrow(
+      'Protocol V2 Ping message must not exceed 63 UTF-8 bytes.'
+    );
+  });
+
+  test('rejects non-string messages at the runtime API boundary', () => {
+    expect(() => validateProtocolV2PingMessage(64)).toThrow(
+      'Protocol V2 Ping message must be a string.'
+    );
+  });
+});