@onekeyfe/hd-core 1.2.2-alpha.8 → 1.2.2

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

@@ -26,12 +26,16 @@ jest.mock('../src/data/config', () => ({
 const createDevice = ({
   passphraseProtection = true,
   unlockedAttachPin = false,
+  refreshedUnlocked = true,
+  refreshedPassphraseProtection = passphraseProtection,
   refreshedUnlockedAttachPin = unlockedAttachPin,
   typedCall = jest.fn(),
   promptPassphrase = jest.fn(),
 }: {
   passphraseProtection?: boolean;
   unlockedAttachPin?: boolean;
+  refreshedUnlocked?: boolean;
+  refreshedPassphraseProtection?: boolean;
   refreshedUnlockedAttachPin?: boolean;
   typedCall?: jest.Mock;
   promptPassphrase?: jest.Mock;
@@ -50,11 +54,11 @@ const createDevice = ({
           return {
             message: {
               device_id: 'device-1',
-              unlocked: true,
+              unlocked: refreshedUnlocked,
               attach_to_pin_enabled: unlockedAttachPin,
               unlocked_attach_pin: refreshedUnlockedAttachPin,
               unlocked_by_attach_to_pin: refreshedUnlockedAttachPin,
-              passphrase_enabled: passphraseProtection,
+              passphrase_enabled: refreshedPassphraseProtection,
             },
           };
         }
@@ -95,6 +99,8 @@ const createDevice = ({
     unlockDevice: jest.fn(),
     updateProtocolV2Status: jest.fn((status: Record<string, unknown>) => {
       device.features.unlocked = status.unlocked ?? device.features.unlocked;
+      device.features.passphraseProtection =
+        status.passphrase_enabled ?? device.features.passphraseProtection;
       device.features.attachToPinEnabled =
         status.attach_to_pin_enabled ?? device.features.attachToPinEnabled;
       device.features.unlockedAttachPin =
@@ -182,6 +188,65 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
+  test('refreshes stale wallet status before accepting an only-Main-PIN session', async () => {
+    let attachPinSelected = true;
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'standard-session',
+          },
+        };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({
+      passphraseProtection: false,
+      unlockedAttachPin: false,
+      typedCall,
+    });
+    device.commands.typedCall.mockImplementation((request: string, ...args: unknown[]) => {
+      if (request === 'DeviceStatusGet') {
+        return {
+          message: {
+            device_id: 'device-1',
+            unlocked: true,
+            attach_to_pin_enabled: true,
+            unlocked_attach_pin: attachPinSelected,
+            unlocked_by_attach_to_pin: attachPinSelected,
+            passphrase_enabled: true,
+          },
+        };
+      }
+      return typedCall(request, ...args);
+    });
+    device.unlockDevice.mockImplementation(() => {
+      attachPinSelected = false;
+      device.features.unlockedAttachPin = false;
+      return Promise.resolve(device.features);
+    });
+
+    await expect(
+      getProtocolV2WalletSession(device as any, { onlyMainPin: true })
+    ).resolves.toMatchObject({
+      unlockedAttachPin: false,
+    });
+
+    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'wallet-session-coordinator',
+      reason: 'open-wallet',
+      deviceOnly: true,
+    });
+  });
+
   test('still requires Main PIN when a cached standard session resolves to another wallet', async () => {
     let sessionGetCount = 0;
     const typedCall = jest.fn((request: string) => {
@@ -267,8 +332,7 @@ describe('openWalletSession', () => {
       }
       throw new Error(`Unexpected request: ${request}`);
     });
-    const device = createDevice({ typedCall });
-    device.features.unlockedAttachPin = true;
+    const device = createDevice({ refreshedUnlockedAttachPin: true, typedCall });
 
     await getProtocolV2WalletSession(device as any, { onlyMainPin: true });
 
@@ -918,45 +982,6 @@ describe('openWalletSession', () => {
     );
   });
 
-  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',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: true,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'known-session',
-      btc_test_address: 'hidden-state',
-      ...standardSessionGet,
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
-  });
-
   test.each([
     {
       mode: 'standard',
@@ -971,12 +996,6 @@ describe('openWalletSession', () => {
       deviceId: 'device-1',
       passphraseState: 'hidden-state',
     },
-    {
-      mode: 'resume-hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      initSession: false,
-    },
   ])('rejects legacy parameters combined with explicit mode: %o', params => {
     const method = new OpenWalletSession({
       payload: {
@@ -1012,63 +1031,7 @@ describe('openWalletSession', () => {
     }
   );
 
-  test('reuses the SDK-managed Protocol V1 hidden-wallet session before validation', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
-      message: {
-        passphrase_state: 'hidden-state',
-        session_id: 'known-session',
-        unlocked_attach_pin: false,
-      },
-    });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    const device = createDevice({ typedCall });
-    device.isProtocolV2 = () => false;
-    device.features = {
-      ...device.features,
-      deviceId: 'device-1',
-      unlocked: true,
-      sessionId: null,
-    };
-    device.getCurrentFirmwareVersionString = () => '4.15.0';
-    device.getCurrentDeviceType = () => EDeviceType.Pro;
-    device.getFeatures = jest.fn();
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toMatchObject({
-      protocol: 'V1',
-      walletType: 'hidden',
-      passphraseState: 'hidden-state',
-      resumed: true,
-    });
-    expect(device.initialize).toHaveBeenCalledWith({
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-    });
-    expect(typedCall).toHaveBeenCalledWith('GetPassphraseState', 'PassphraseState', {
-      passphrase_state: 'hidden-state',
-    });
-  });
-
-  test('rejects a Protocol V1 resume when the device returns another hidden wallet', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
-      message: {
-        passphrase_state: 'other-hidden-state',
-        session_id: 'other-session',
-        unlocked_attach_pin: false,
-      },
-    });
+  test('rejects the removed resume-hidden mode', () => {
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
@@ -1076,28 +1039,15 @@ describe('openWalletSession', () => {
         mode: 'resume-hidden',
         deviceId: 'device-1',
         passphraseState: 'hidden-state',
-      },
+      } as any,
     });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    const device = createDevice({ typedCall });
-    device.isProtocolV2 = () => false;
-    device.features = {
-      ...device.features,
-      deviceId: 'device-1',
-      unlocked: true,
-      sessionId: null,
-    };
-    device.getCurrentFirmwareVersionString = () => '4.15.0';
-    device.getCurrentDeviceType = () => EDeviceType.Pro;
-    device.getFeatures = jest.fn();
-    method.device = device as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
-    });
-    expect(device.clearInternalState).toHaveBeenCalledTimes(1);
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBeUndefined();
+    expect(() => method.init()).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+        message: 'Parameter [mode] must be one of standard or select-hidden.',
+      })
+    );
   });
 
   test('opens the standard wallet without selecting a hidden wallet', async () => {
@@ -1157,7 +1107,7 @@ describe('openWalletSession', () => {
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'standard' },
     });
     method.init();
-    const device = createDevice({ typedCall });
+    const device = createDevice({ refreshedUnlocked: false, typedCall });
     device.features.unlocked = false;
     device.getDeviceState = jest
       .fn()
@@ -1257,6 +1207,7 @@ describe('openWalletSession', () => {
   });
 
   test('switches from Attach PIN to Main PIN before opening the standard wallet', async () => {
+    let attachPinSelected = true;
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
@@ -1273,6 +1224,21 @@ describe('openWalletSession', () => {
     method.init();
     const device = createDevice({ typedCall });
     device.features.unlockedAttachPin = true;
+    device.commands.typedCall.mockImplementation((request: string, ...args: unknown[]) => {
+      if (request === 'DeviceStatusGet') {
+        return {
+          message: {
+            device_id: 'device-1',
+            unlocked: true,
+            attach_to_pin_enabled: true,
+            unlocked_attach_pin: attachPinSelected,
+            unlocked_by_attach_to_pin: attachPinSelected,
+            passphrase_enabled: true,
+          },
+        };
+      }
+      return typedCall(request, ...args);
+    });
     device.getDeviceState = jest
       .fn()
       .mockResolvedValueOnce({
@@ -1292,6 +1258,7 @@ describe('openWalletSession', () => {
         },
       });
     device.unlockDevice = jest.fn().mockImplementation(() => {
+      attachPinSelected = false;
       device.features.unlockedAttachPin = false;
       return Promise.resolve(device.features);
     });
@@ -1801,242 +1768,6 @@ describe('openWalletSession', () => {
     }
   );
 
-  test('resumes a known hidden wallet without prompting or device selection', 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',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: true,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'known-session',
-      btc_test_address: 'hidden-state',
-      ...standardSessionGet,
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
-  });
-
-  test('validates a locked Protocol V2 resume binding after deviceId refresh', async () => {
-    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',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    const device = createDevice({ typedCall });
-    device.features.unlocked = false;
-    device.getDeviceState = jest
-      .fn()
-      .mockResolvedValueOnce({
-        identity: { deviceId: undefined },
-        status: { unlocked: false, passphraseProtection: true },
-      })
-      .mockResolvedValueOnce({
-        identity: { deviceId: 'device-1' },
-        status: {
-          unlocked: true,
-          passphraseProtection: true,
-          unlockedAttachPin: false,
-        },
-      });
-    device.unlockDevice = jest.fn().mockImplementation(() => {
-      device.features.unlocked = true;
-      return Promise.resolve(device.features);
-    });
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toMatchObject({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: true,
-    });
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
-    expect(device.getDeviceState).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'known-session',
-      btc_test_address: 'hidden-state',
-      ...standardSessionGet,
-    });
-    const sessionGetCall = typedCall.mock.calls.findIndex(
-      ([requestName]) => requestName === 'DeviceSessionGet'
-    );
-    expect(device.getDeviceState.mock.invocationCallOrder[1]).toBeLessThan(
-      typedCall.mock.invocationCallOrder[sessionGetCall]
-    );
-  });
-
-  test('rejects a Protocol V2 resume when the refreshed deviceId does not match', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'hidden-state',
-        session_id: 'renewed-session',
-      },
-    });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    const device = createDevice({ typedCall });
-    device.features.unlocked = false;
-    device.getDeviceState = jest
-      .fn()
-      .mockResolvedValueOnce({
-        identity: { deviceId: undefined },
-        status: { passphraseProtection: true },
-      })
-      .mockResolvedValueOnce({
-        identity: { deviceId: 'other-device' },
-        status: {
-          unlocked: true,
-          passphraseProtection: true,
-          unlockedAttachPin: false,
-        },
-      });
-    device.unlockDevice = jest.fn().mockImplementation(() => {
-      device.features.unlocked = true;
-      return Promise.resolve(device.features);
-    });
-    method.device = device as any;
-
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceCheckDeviceIdError,
-    });
-    expect(typedCall).not.toHaveBeenCalled();
-    expect(device.clearInternalState).not.toHaveBeenCalled();
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBeUndefined();
-  });
-
-  test('reselects the expected hidden wallet when a cached Protocol V2 session is invalid', async () => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockRejectedValueOnce(
-        Object.assign(new Error('Invalid session'), {
-          errorCode: HardwareErrorCode.WalletSessionInvalid,
-        })
-      )
-      .mockResolvedValueOnce({ message: {} })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state',
-          session_id: 'renewed-session',
-        },
-      });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'expired-session');
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'expired-session',
-      btc_test_address: 'hidden-state',
-      ...standardSessionGet,
-    });
-    expect(promptPassphrase).toHaveBeenCalledTimes(1);
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
-  });
-
-  test('selects the expected hidden wallet when Protocol V2 has no cached session', async () => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state',
-          session_id: 'new-session',
-        },
-      });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      btc_test_address: 'hidden-state',
-      ...standardSessionGet,
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('new-session');
-  });
-
   test.each([false, true])(
     'openWalletSession does not thread CommonParams.deriveCardano: %s',
     async deriveCardano => {