@onekeyfe/hd-core 1.2.0-alpha.66 → 1.2.0-alpha.67

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

@@ -1,15 +1,10 @@
 import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType, DeviceSessionSeedDomain } from '@onekeyfe/hd-transport';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import GetPassphraseState from '../src/api/GetPassphraseState';
 import OpenWalletSession from '../src/api/OpenWalletSession';
 import { Device } from '../src/device/Device';
 import { deviceWalletSessionStore } from '../src/device/DeviceWalletSessionStore';
-import { DEVICE } from '../src/events';
-import {
-  ensureProtocolV2WalletSessionUnlocked,
-  getProtocolV2WalletSession,
-} from '../src/protocols/protocol-v2/walletSession';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -18,14 +13,10 @@ jest.mock('../src/data/config', () => ({
 
 const createDevice = ({
   passphraseProtection = true,
-  unlockedAttachPin = false,
-  refreshedUnlockedAttachPin = unlockedAttachPin,
   typedCall = jest.fn(),
   promptPassphrase = jest.fn(),
 }: {
   passphraseProtection?: boolean;
-  unlockedAttachPin?: boolean;
-  refreshedUnlockedAttachPin?: boolean;
   typedCall?: jest.Mock;
   promptPassphrase?: jest.Mock;
 } = {}) => {
@@ -34,8 +25,7 @@ const createDevice = ({
     features: {
       unlocked: true,
       passphraseProtection,
-      attachToPinEnabled: unlockedAttachPin,
-      unlockedAttachPin,
+      attachToPinEnabled: false,
     },
     commands: {
       typedCall: jest.fn((request: string, ...args: unknown[]) => {
@@ -44,9 +34,7 @@ const createDevice = ({
             message: {
               device_id: 'device-1',
               unlocked: true,
-              attach_to_pin_enabled: unlockedAttachPin,
-              unlocked_attach_pin: refreshedUnlockedAttachPin,
-              unlocked_by_attach_to_pin: refreshedUnlockedAttachPin,
+              unlocked_attach_pin: false,
               passphrase_enabled: passphraseProtection,
             },
           };
@@ -55,21 +43,10 @@ const createDevice = ({
       }),
       promptPassphrase,
     },
-    ensureProtocolV2RuntimeContext: jest.fn(() =>
-      device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
-        eventless_wallet_session: true,
-      })
-    ),
-    getDeviceState: jest.fn(() =>
-      Promise.resolve({
-        identity: { deviceId: 'device-1' },
-        status: {
-          unlocked: device.features.unlocked,
-          passphraseProtection: device.features.passphraseProtection,
-          unlockedAttachPin: device.features.unlockedAttachPin,
-        },
-      })
-    ),
+    getDeviceState: jest.fn().mockResolvedValue({
+      identity: { deviceId: 'device-1' },
+      status: { passphraseProtection },
+    }),
     getCurrentDeviceId: () => 'device-1',
     getCurrentPassphraseProtection: () => passphraseProtection,
     getInternalState: () =>
@@ -88,12 +65,8 @@ const createDevice = ({
     unlockDevice: jest.fn(),
     updateProtocolV2Status: jest.fn((status: Record<string, unknown>) => {
       device.features.unlocked = status.unlocked ?? device.features.unlocked;
-      device.features.attachToPinEnabled =
-        status.attach_to_pin_enabled ?? device.features.attachToPinEnabled;
       device.features.unlockedAttachPin =
-        status.unlocked_by_attach_to_pin ??
-        status.unlocked_attach_pin ??
-        device.features.unlockedAttachPin;
+        status.unlocked_attach_pin ?? device.features.unlockedAttachPin;
       return device.features;
     }),
     initialize: jest.fn(),
@@ -109,148 +82,6 @@ describe('openWalletSession', () => {
     deviceWalletSessionStore.clear();
   });
 
-  test('selects the standard wallet explicitly when passphrase is enabled', async () => {
-    const typedCall = jest.fn((request: string) => {
-      if (request === 'ProtocolInfoRequest') {
-        return { message: { version: 2 } };
-      }
-      if (request === 'DeviceSessionAskPassphrase') {
-        return { message: {} };
-      }
-      if (request === 'DeviceSessionGet') {
-        return {
-          message: {
-            btc_test_address: 'standard-state',
-            session_id: 'standard-session',
-          },
-        };
-      }
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const device = createDevice({ typedCall });
-
-    await expect(
-      getProtocolV2WalletSession(device as any, {
-        onlyMainPin: true,
-      })
-    ).resolves.toMatchObject({
-      passphraseState: 'standard-state',
-      newSession: 'standard-session',
-    });
-
-    expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
-      passphrase: '',
-      on_device: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
-  });
-
-  test('opens the standard wallet directly when passphrase is disabled', async () => {
-    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',
-          },
-        };
-      }
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const device = createDevice({ passphraseProtection: false, typedCall });
-
-    await getProtocolV2WalletSession(device as any, { onlyMainPin: true });
-
-    expect(typedCall).not.toHaveBeenCalledWith(
-      'DeviceSessionAskPassphrase',
-      'Success',
-      expect.anything()
-    );
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
-  });
-
-  test('does not treat an Attach PIN DeviceStatus as the Main wallet', async () => {
-    const typedCall = jest.fn((request: string) => {
-      if (request === 'ProtocolInfoRequest') {
-        return { message: { version: 2 } };
-      }
-      if (request === 'DeviceSessionAskPassphrase') {
-        return { message: {} };
-      }
-      if (request === 'DeviceSessionGet') {
-        return {
-          message: {
-            btc_test_address: 'standard-state',
-            session_id: 'standard-session',
-          },
-        };
-      }
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const device = createDevice({ typedCall });
-    device.features.unlockedAttachPin = true;
-
-    await getProtocolV2WalletSession(device as any, { onlyMainPin: true });
-
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
-      source: 'wallet-session-coordinator',
-      reason: 'open-wallet',
-      deviceOnly: true,
-    });
-  });
-
-  test('unlocks a locked Protocol V2 device before restoring a wallet session', async () => {
-    const device = {
-      commands: {
-        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: false } }),
-      },
-      isBootloader: jest.fn().mockReturnValue(false),
-      isProtocolV2: jest.fn().mockReturnValue(true),
-      isRomloader: jest.fn().mockReturnValue(false),
-      state: { status: { unlocked: false } },
-      unlockDevice: jest.fn().mockResolvedValue(undefined),
-      updateProtocolV2Status: jest.fn(function updateProtocolV2Status(
-        this: { state: { status: { unlocked: boolean } } },
-        status: { unlocked?: boolean }
-      ) {
-        this.state.status.unlocked = status.unlocked ?? this.state.status.unlocked;
-      }),
-    };
-
-    await expect(ensureProtocolV2WalletSessionUnlocked(device as any)).resolves.toBe(true);
-    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
-      source: 'unlock-coordinator',
-      reason: 'device-locked',
-      deviceOnly: true,
-    });
-  });
-
-  test('does not request PIN when wallet-session recovery finds the device unlocked', async () => {
-    const device = {
-      commands: {
-        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: true } }),
-      },
-      isBootloader: jest.fn().mockReturnValue(false),
-      isProtocolV2: jest.fn().mockReturnValue(true),
-      isRomloader: jest.fn().mockReturnValue(false),
-      state: { status: { unlocked: true } },
-      unlockDevice: jest.fn(),
-      updateProtocolV2Status: jest.fn(),
-    };
-
-    await expect(ensureProtocolV2WalletSessionUnlocked(device as any)).resolves.toBe(false);
-    expect(device.unlockDevice).not.toHaveBeenCalled();
-  });
-
   test.each([{ useEmptyPassphrase: true }, { initSession: true }, {}])(
     'requires the explicit mode in the new public API: %p',
     legacyParams => {
@@ -302,9 +133,7 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('keeps Legacy Protocol V1 getPassphraseState parameterless', async () => {
@@ -422,9 +251,7 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('refreshes Pro2 status and unlocks before selecting a hidden wallet when locked', async () => {
@@ -446,24 +273,10 @@ describe('openWalletSession', () => {
       typedCall,
       promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
     });
-    device.getDeviceState = jest
-      .fn()
-      .mockResolvedValueOnce({
-        identity: { deviceId: 'device-1' },
-        status: {
-          unlocked: false,
-          passphraseProtection: null,
-          unlockedAttachPin: null,
-        },
-      })
-      .mockResolvedValue({
-        identity: { deviceId: 'device-1' },
-        status: {
-          unlocked: true,
-          passphraseProtection: true,
-          unlockedAttachPin: false,
-        },
-      });
+    device.getDeviceState = jest.fn().mockResolvedValue({
+      identity: { deviceId: 'device-1' },
+      status: { unlocked: false, passphraseProtection: true },
+    });
     method.device = device as any;
 
     await expect(method.run()).resolves.toMatchObject({
@@ -517,12 +330,6 @@ describe('openWalletSession', () => {
         status.passphrase_enabled ?? device.features.passphraseProtection;
       return device.features;
     });
-    device.unlockDevice = jest.fn().mockImplementation(() => {
-      device.features.unlocked = true;
-      device.features.passphraseProtection = true;
-      device.features.unlockedAttachPin = false;
-      return Promise.resolve(device.features);
-    });
     method.device = device as any;
 
     await expect(method.run()).resolves.toEqual({
@@ -532,99 +339,11 @@ describe('openWalletSession', () => {
       passphraseState: 'hidden-state-after-unlock',
       resumed: false,
     });
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).not.toHaveBeenCalled();
     expect(promptPassphrase).toHaveBeenCalledTimes(1);
   });
 
-  test('unlocks before wallet selection when the Protocol V2 wallet status is unknown', async () => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: {} })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state-after-unknown-status',
-          session_id: 'hidden-session-after-unknown-status',
-        },
-      });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
-    const method = new OpenWalletSession({
-      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
-    });
-    method.init();
-    const device = createDevice({ typedCall, promptPassphrase });
-    device.getDeviceState = jest
-      .fn()
-      .mockResolvedValueOnce({
-        identity: { deviceId: 'device-1' },
-        status: {
-          unlocked: undefined,
-          passphraseProtection: null,
-          unlockedAttachPin: null,
-        },
-      })
-      .mockResolvedValue({
-        identity: { deviceId: 'device-1' },
-        status: {
-          unlocked: true,
-          passphraseProtection: true,
-          unlockedAttachPin: false,
-        },
-      });
-    device.unlockDevice = jest.fn().mockImplementation(() => {
-      device.features.unlocked = true;
-      device.features.passphraseProtection = true;
-      device.features.unlockedAttachPin = false;
-      return Promise.resolve(device.features);
-    });
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toMatchObject({
-      walletType: 'hidden',
-      passphraseState: 'hidden-state-after-unknown-status',
-    });
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
-    expect(device.unlockDevice.mock.invocationCallOrder[0]).toBeLessThan(
-      promptPassphrase.mock.invocationCallOrder[0]
-    );
-  });
-
-  test('rejects wallet selection when the post-unlock Protocol V2 status remains incomplete', async () => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: {} })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state-from-incomplete-status',
-          session_id: 'hidden-session-from-incomplete-status',
-        },
-      });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
-    const method = new OpenWalletSession({
-      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
-    });
-    method.init();
-    const device = createDevice({ typedCall, promptPassphrase });
-    device.getDeviceState = jest.fn().mockResolvedValue({
-      identity: { deviceId: 'device-1' },
-      status: {
-        unlocked: true,
-        passphraseProtection: null,
-        unlockedAttachPin: null,
-      },
-    });
-    device.unlockDevice = jest.fn().mockResolvedValue(device.features);
-    method.device = device as any;
-
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceInitializeFailed,
-    });
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
-    expect(promptPassphrase).not.toHaveBeenCalled();
-  });
-
-  test('rejects before prompting for a hidden wallet when Pro2 passphrase is disabled', async () => {
+  test('rejects a Pro2 standard-wallet fallback after selecting a hidden wallet', async () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
@@ -651,114 +370,6 @@ describe('openWalletSession', () => {
       errorCode: HardwareErrorCode.DeviceNotOpenedPassphrase,
     });
     expect(device.clearInternalState).toHaveBeenCalled();
-    expect(promptPassphrase).not.toHaveBeenCalled();
-    expect(typedCall).not.toHaveBeenCalledWith(
-      'DeviceSessionAskPassphrase',
-      'Success',
-      expect.anything()
-    );
-  });
-
-  test('reuses the current Attach PIN session without reopening wallet selection', async () => {
-    const typedCall = jest.fn((request: string) => {
-      if (request === 'ProtocolInfoRequest') {
-        return { message: { version: 2 } };
-      }
-      if (request === 'DeviceSessionAskPassphrase') {
-        return { message: {} };
-      }
-      if (request === 'DeviceSessionGet') {
-        return {
-          message: {
-            btc_test_address: 'attach-state',
-            session_id: 'attach-session',
-          },
-        };
-      }
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'must not be requested' });
-    const method = new OpenWalletSession({
-      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
-    });
-    method.init();
-    const device = createDevice({
-      typedCall,
-      promptPassphrase,
-      unlockedAttachPin: true,
-    });
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'attach-state',
-      resumed: false,
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
-    expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
-    expect(device.commands.typedCall).not.toHaveBeenCalledWith(
-      'DeviceSessionAskPassphrase',
-      'Success',
-      expect.anything()
-    );
-    expect(device.commands.typedCall).not.toHaveBeenCalledWith(
-      'DeviceSessionAskPin',
-      'Success',
-      expect.anything()
-    );
-  });
-
-  test('fails closed when the Attach PIN state changes before reading the current session', async () => {
-    const typedCall = jest.fn((request: string) => {
-      if (request === 'ProtocolInfoRequest') {
-        return { message: { version: 2 } };
-      }
-      if (request === 'DeviceSessionAskPassphrase') {
-        return { message: {} };
-      }
-      if (request === 'DeviceSessionGet') {
-        return {
-          message: {
-            btc_test_address: 'unexpected-state',
-            session_id: 'unexpected-session',
-          },
-        };
-      }
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'must not be requested' });
-    const method = new OpenWalletSession({
-      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
-    });
-    method.init();
-    const device = createDevice({
-      typedCall,
-      promptPassphrase,
-      unlockedAttachPin: true,
-      refreshedUnlockedAttachPin: false,
-    });
-    method.device = device as any;
-
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceCheckUnlockTypeError,
-    });
-    expect(device.clearInternalState).toHaveBeenCalled();
-    expect(promptPassphrase).not.toHaveBeenCalled();
-    expect(device.commands.typedCall).not.toHaveBeenCalledWith(
-      'DeviceSessionAskPassphrase',
-      'Success',
-      expect.anything()
-    );
-    expect(device.commands.typedCall).not.toHaveBeenCalledWith(
-      'DeviceSessionGet',
-      'DeviceSession',
-      expect.anything()
-    );
   });
 
   test('select-hidden starts a fresh hidden-wallet session on Protocol V2', async () => {
@@ -797,9 +408,7 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).toHaveBeenCalled();
     expect(deviceWalletSessionStore.get('device-1', 'new-hidden-state')).toBe('new-hidden-session');
   });
@@ -870,8 +479,6 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
-      btc_test_address: 'hidden-state',
-      seed_domains: [],
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -1023,7 +630,6 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'main-wallet-state',
@@ -1046,18 +652,12 @@ describe('openWalletSession', () => {
       passphraseState: null,
       resumed: false,
     });
-    expect(typedCall).toHaveBeenCalledTimes(3);
+    expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
-      passphrase: '',
-      on_device: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
   });
@@ -1066,7 +666,6 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'main-wallet-state',
@@ -1087,11 +686,7 @@ describe('openWalletSession', () => {
       })
       .mockResolvedValueOnce({
         identity: { deviceId: 'device-1' },
-        status: {
-          unlocked: true,
-          passphraseProtection: true,
-          unlockedAttachPin: false,
-        },
+        status: { passphraseProtection: true },
       });
     device.unlockDevice = jest.fn().mockImplementation(() => {
       device.features.unlocked = true;
@@ -1106,11 +701,7 @@ describe('openWalletSession', () => {
       passphraseState: null,
       resumed: false,
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
-      source: 'wallet-session-coordinator',
-      reason: 'open-wallet',
-      deviceOnly: true,
-    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
   });
 
@@ -1118,7 +709,6 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'main-wallet-state',
@@ -1131,24 +721,6 @@ describe('openWalletSession', () => {
     method.init();
     const device = createDevice({ typedCall });
     device.features.unlockedAttachPin = true;
-    device.getDeviceState = jest
-      .fn()
-      .mockResolvedValueOnce({
-        identity: { deviceId: 'device-1' },
-        status: {
-          unlocked: true,
-          unlockedAttachPin: true,
-          passphraseProtection: true,
-        },
-      })
-      .mockResolvedValue({
-        identity: { deviceId: 'device-1' },
-        status: {
-          unlocked: true,
-          unlockedAttachPin: false,
-          passphraseProtection: true,
-        },
-      });
     device.unlockDevice = jest.fn().mockImplementation(() => {
       device.features.unlockedAttachPin = false;
       return Promise.resolve(device.features);
@@ -1159,14 +731,8 @@ describe('openWalletSession', () => {
       walletType: 'standard',
       passphraseState: null,
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
-      source: 'wallet-session-coordinator',
-      reason: 'open-wallet',
-      deviceOnly: true,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('selects a hidden wallet without exposing the internal device session', async () => {
@@ -1200,9 +766,7 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
@@ -1231,9 +795,7 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('selects an on-device passphrase wallet with an explicit on_device request', async () => {
@@ -1249,28 +811,7 @@ describe('openWalletSession', () => {
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
     });
     method.init();
-    const device = createDevice({ typedCall, promptPassphrase });
-    const passphraseInteraction = {
-      interactionId: 'interaction-1',
-      phaseId: 'interaction-1:phase-1',
-      sequence: 1,
-      phase: 'passphrase',
-      transition: 'start',
-      protocol: 'V2',
-    } as const;
-    const passphraseOnDeviceInteraction = {
-      interactionId: 'interaction-1',
-      phaseId: 'interaction-1:phase-2',
-      sequence: 2,
-      phase: 'passphrase-on-device',
-      transition: 'start',
-      protocol: 'V2',
-    } as const;
-    device.createProtocolV2UiPhaseMetadata = jest
-      .fn()
-      .mockReturnValueOnce(passphraseInteraction)
-      .mockReturnValueOnce(passphraseOnDeviceInteraction);
-    method.device = device as any;
+    method.device = createDevice({ typedCall, promptPassphrase }) as any;
 
     await expect(method.run()).resolves.toMatchObject({
       walletType: 'hidden',
@@ -1279,19 +820,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       on_device: true,
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
-    expect(device.createProtocolV2UiPhaseMetadata).toHaveBeenNthCalledWith(
-      2,
-      'passphrase-on-device',
-      'start'
-    );
-    expect(device.emit).toHaveBeenCalledWith(DEVICE.PASSPHRASE_ON_DEVICE, device, {
-      source: 'wallet-session-coordinator',
-      reason: 'open-wallet',
-      interaction: passphraseOnDeviceInteraction,
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('forwards a host passphrase to Pro2 firmware', async () => {
@@ -1333,9 +862,7 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('normalizes a Unicode Host passphrase before sending it to Pro2 firmware', async () => {
@@ -1412,12 +939,8 @@ describe('openWalletSession', () => {
       },
       { cancelDeviceOnReject: false }
     );
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin, {
-      emitUiEvent: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('uses the complete Attach PIN wire flow without a main PIN unlock', async () => {
@@ -1446,7 +969,7 @@ describe('openWalletSession', () => {
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
       ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.AttachToPin }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
-      ['DeviceSessionGet', 'DeviceSession', { seed_domains: [] }],
+      ['DeviceSessionGet', 'DeviceSession', {}],
     ]);
     expect(device.commands.typedCall).not.toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
       type: DeviceSessionPinType.Main,
@@ -1503,7 +1026,7 @@ describe('openWalletSession', () => {
 
       await expect(method.run()).rejects.toThrow(message);
       expect(typedCall).toHaveBeenCalledTimes(2);
-      expect(typedCall.mock.calls.some(([name]) => name === 'DeviceSessionGet')).toBe(false);
+      expect(typedCall).not.toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     }
   );
 
@@ -1657,8 +1180,6 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
-      btc_test_address: 'hidden-state',
-      seed_domains: [],
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -1694,11 +1215,7 @@ describe('openWalletSession', () => {
       })
       .mockResolvedValueOnce({
         identity: { deviceId: 'device-1' },
-        status: {
-          unlocked: true,
-          passphraseProtection: true,
-          unlockedAttachPin: false,
-        },
+        status: { passphraseProtection: true },
       });
     device.unlockDevice = jest.fn().mockImplementation(() => {
       device.features.unlocked = true;
@@ -1717,8 +1234,6 @@ describe('openWalletSession', () => {
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
-      btc_test_address: 'hidden-state',
-      seed_domains: [],
     });
     const sessionGetCall = typedCall.mock.calls.findIndex(
       ([requestName]) => requestName === 'DeviceSessionGet'
@@ -1756,11 +1271,7 @@ describe('openWalletSession', () => {
       })
       .mockResolvedValueOnce({
         identity: { deviceId: 'other-device' },
-        status: {
-          unlocked: true,
-          passphraseProtection: true,
-          unlockedAttachPin: false,
-        },
+        status: { passphraseProtection: true },
       });
     device.unlockDevice = jest.fn().mockImplementation(() => {
       device.features.unlocked = true;
@@ -1815,8 +1326,6 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'expired-session',
-      btc_test_address: 'hidden-state',
-      seed_domains: [],
     });
     expect(promptPassphrase).toHaveBeenCalledTimes(1);
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
@@ -1826,6 +1335,7 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'hidden-state',
@@ -1852,48 +1362,7 @@ describe('openWalletSession', () => {
       passphraseState: 'hidden-state',
       resumed: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      btc_test_address: 'hidden-state',
-      seed_domains: [],
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(promptPassphrase).toHaveBeenCalledTimes(1);
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('new-session');
   });
-
-  test.each([false, true])('keeps deriveCardano API compatibility: %s', async deriveCardano => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: {} })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state',
-          session_id: 'new-session',
-        },
-      });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'select-hidden',
-        deriveCardano,
-      },
-    });
-    method.init();
-    method.device = createDevice({
-      typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
-    }) as any;
-
-    await expect(method.run()).resolves.toMatchObject({
-      walletType: 'hidden',
-      passphraseState: 'hidden-state',
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [
-        DeviceSessionSeedDomain.SeedDomain_Standard,
-        ...(deriveCardano ? [DeviceSessionSeedDomain.SeedDomain_Cardano] : []),
-      ],
-    });
-  });
 });