@onekeyfe/hd-core 1.2.0-alpha.40 → 1.2.0-alpha.41

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

@@ -1,4 +1,4 @@
-import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceType } from '@onekeyfe/hd-transport';
 
 import { Device } from '../src/device/Device';
@@ -43,70 +43,6 @@ const getProtocolV2LoaderInfo = (mode: 'bootloader' | 'romloader') => ({
 });
 
 describe('getDeviceState', () => {
-  test('coalesces concurrent Protocol V2 runtime-context negotiation', async () => {
-    let resolveProtocolInfo:
-      | ((value: { message: typeof protocolV2ApplicationInfo }) => void)
-      | undefined;
-    const typedCall = jest.fn(
-      () =>
-        new Promise<{ message: typeof protocolV2ApplicationInfo }>(resolve => {
-          resolveProtocolInfo = resolve;
-        })
-    );
-    const device = createV2Device(typedCall);
-
-    const first = device.ensureProtocolV2RuntimeContext();
-    const second = device.ensureProtocolV2RuntimeContext();
-    resolveProtocolInfo?.({ message: protocolV2ApplicationInfo });
-
-    await expect(Promise.all([first, second])).resolves.toEqual([
-      protocolV2ApplicationInfo,
-      protocolV2ApplicationInfo,
-    ]);
-    expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
-      eventless_wallet_session: true,
-    });
-  });
-
-  test('renegotiates Protocol V2 runtime context after transport disconnect', async () => {
-    const typedCall = jest.fn().mockResolvedValue({ message: protocolV2ApplicationInfo });
-    const device = createV2Device(typedCall);
-
-    await device.ensureProtocolV2RuntimeContext();
-    await device.ensureProtocolV2RuntimeContext();
-    device.markTransportDisconnected();
-    await device.ensureProtocolV2RuntimeContext();
-
-    expect(typedCall).toHaveBeenCalledTimes(2);
-  });
-
-  test('rejects every waiter when runtime-context negotiation is invalidated', async () => {
-    let resolveProtocolInfo:
-      | ((value: { message: typeof protocolV2ApplicationInfo }) => void)
-      | undefined;
-    const typedCall = jest.fn(
-      () =>
-        new Promise<{ message: typeof protocolV2ApplicationInfo }>(resolve => {
-          resolveProtocolInfo = resolve;
-        })
-    );
-    const device = createV2Device(typedCall);
-
-    const first = device.ensureProtocolV2RuntimeContext();
-    const second = device.ensureProtocolV2RuntimeContext();
-    const firstExpectation = expect(first).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceInitializeFailed,
-    });
-    const secondExpectation = expect(second).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceInitializeFailed,
-    });
-    device.markTransportDisconnected();
-    resolveProtocolInfo?.({ message: protocolV2ApplicationInfo });
-
-    await Promise.all([firstExpectation, secondExpectation]);
-  });
-
   test('does not expose the internal wallet session', async () => {
     const device = createV2Device(jest.fn());
     device.updateState({ protocol: 'V2' }, 'initialize');
@@ -223,20 +159,15 @@ describe('getDeviceState', () => {
         throw new Error(`Unexpected request: ${requestType}`);
       });
       const device = createV2Device(typedCall);
-      device.updateState(
-        {
-          protocol: 'V2',
-          identity: { deviceType: EDeviceType.Pro2 },
-          status: { mode },
-          raw: { protocolV2ProtocolInfo: getProtocolV2LoaderInfo(mode) },
-        },
-        'initialize'
-      );
+      device.updateState({ protocol: 'V2', status: { mode } }, 'initialize');
 
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
       expect(state.status.mode).toBe(mode);
-      expect(typedCall).not.toHaveBeenCalled();
+      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+        'DeviceInfoGet',
+        'ProtocolInfoRequest',
+      ]);
     }
   );
 
@@ -256,14 +187,7 @@ describe('getDeviceState', () => {
       return { message: { init_states: true, unlocked: true, device_id: 'device-1' } };
     });
     const device = createV2Device(typedCall);
-    device.updateState(
-      {
-        protocol: 'V2',
-        status: { mode: 'normal' },
-        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
-      },
-      'initialize'
-    );
+    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
 
     const state = await device.getDeviceState({ refreshSections: ['status'] });
 
@@ -281,14 +205,7 @@ describe('getDeviceState', () => {
       },
     });
     const device = createV2Device(typedCall);
-    device.updateState(
-      {
-        protocol: 'V2',
-        status: { mode: 'normal' },
-        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
-      },
-      'initialize'
-    );
+    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
     const onState = jest.fn();
     device.on(DEVICE.STATE, onState);
 
@@ -333,18 +250,13 @@ describe('getDeviceState', () => {
       throw new Error(`Unexpected request: ${requestType}`);
     });
     const device = createV2Device(typedCall);
-    device.updateState(
-      {
-        protocol: 'V2',
-        status: { mode: 'normal' },
-        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
-      },
-      'initialize'
-    );
+    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
 
     const state = await device.getDeviceState({ refreshSections: ['status', 'settings'] });
 
     expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceInfoGet',
+      'ProtocolInfoRequest',
       'DeviceStatusGet',
       'DeviceSettingsGet',
     ]);
@@ -376,11 +288,7 @@ describe('getDeviceState', () => {
     });
     const device = createV2Device(typedCall);
     device.updateState(
-      {
-        protocol: 'V2',
-        status: { mode: 'normal', unlocked: true },
-        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
-      },
+      { protocol: 'V2', status: { mode: 'normal', unlocked: true } },
       'initialize'
     );
 
@@ -466,34 +374,6 @@ describe('getDeviceState', () => {
     });
   });
 
-  test.each([
-    EDeviceType.Classic,
-    EDeviceType.Classic1s,
-    EDeviceType.ClassicPure,
-    EDeviceType.Mini,
-  ])('keeps the GetFeatures-only firmware path for %s', async deviceType => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        onekey_device_type: deviceType.toUpperCase(),
-        initialized: true,
-        onekey_firmware_version: '3.5.0',
-        se_ver: '1.1.0.2',
-      },
-    });
-    const device = createV1Device(typedCall);
-
-    const state = await device.getDeviceState({
-      refreshSections: ['identity', 'versions', 'verification'],
-    });
-
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['GetFeatures']);
-    expect(state.versions).toMatchObject({
-      firmware: '3.5.0',
-      se: '1.1.0.2',
-      se01: '1.1.0.2',
-    });
-  });
-
   test('does not clear Protocol V1 firmware details during a later runtime refresh', async () => {
     let getFeaturesCount = 0;
     const typedCall = jest.fn().mockImplementation((requestType: string) => {

package/__tests__/homescreen.test.ts

@@ -1,6 +1,6 @@
 import { EDeviceType } from '@onekeyfe/hd-shared';
 
-import { getHomeScreenSize, getNftSize } from '../src/utils/homescreen';
+import { getHomeScreenSize } from '../src/utils/homescreen';
 
 describe('getHomeScreenSize', () => {
   it('returns the Pro 2 wallpaper dimensions', () => {
@@ -21,44 +21,4 @@ describe('getHomeScreenSize', () => {
       })
     ).toBeUndefined();
   });
-
-  it('does not reuse the wallpaper homeScreenType for Pro 2 NFT dimensions', () => {
-    expect(
-      getHomeScreenSize({
-        deviceType: EDeviceType.Pro2,
-        homeScreenType: 'Nft',
-        thumbnail: false,
-      })
-    ).toEqual({ width: 604, height: 1024 });
-    expect(
-      getHomeScreenSize({
-        deviceType: EDeviceType.Pro2,
-        homeScreenType: 'Nft',
-        thumbnail: true,
-      })
-    ).toBeUndefined();
-  });
-});
-
-describe('getNftSize', () => {
-  it('returns the Pro 2 NFT image and thumbnail dimensions independently', () => {
-    expect(getNftSize({ deviceType: EDeviceType.Pro2 })).toEqual({ width: 540, height: 540 });
-    expect(getNftSize({ deviceType: EDeviceType.Pro2, thumbnail: true })).toEqual({
-      width: 263,
-      height: 263,
-    });
-  });
-
-  it('preserves the legacy NFT dimensions', () => {
-    expect(getNftSize({ deviceType: EDeviceType.Touch })).toEqual({ width: 480, height: 800 });
-    expect(getNftSize({ deviceType: EDeviceType.Touch, thumbnail: true })).toEqual({
-      width: 238,
-      height: 238,
-    });
-    expect(getNftSize({ deviceType: EDeviceType.Pro, thumbnail: true })).toEqual({
-      width: 226,
-      height: 226,
-      radius: 40,
-    });
-  });
 });

package/__tests__/logBlockEvent.test.ts

@@ -104,7 +104,7 @@ describe('getLogBlockLabel', () => {
     });
   });
 
-  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
+  it.each(['deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
     'keeps metadata and replaces binary payloads with their size for %s',
     method => {
       const request = { method, path: 'resource.bin', data: new Uint8Array(1024) };

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

@@ -5,7 +5,6 @@ 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 { ensureProtocolV2WalletSessionUnlocked } from '../src/protocols/protocol-v2/walletSession';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -27,7 +26,6 @@ const createDevice = ({
       unlocked: true,
       passphraseProtection,
       attachToPinEnabled: false,
-      unlockedAttachPin: false,
     },
     commands: {
       typedCall: jest.fn((request: string, ...args: unknown[]) => {
@@ -45,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: () =>
@@ -95,50 +82,6 @@ describe('openWalletSession', () => {
     deviceWalletSessionStore.clear();
   });
 
-  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 => {
@@ -330,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({
@@ -401,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({
@@ -416,98 +339,10 @@ 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 a Pro2 standard-wallet fallback after selecting a hidden wallet', async () => {
     const typedCall = jest
       .fn()
@@ -821,11 +656,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
-      source: 'wallet-session-coordinator',
-      reason: 'open-wallet',
-      deviceOnly: true,
-    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
@@ -855,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;
@@ -874,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);
   });
 
@@ -898,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);
@@ -926,11 +731,7 @@ describe('openWalletSession', () => {
       walletType: 'standard',
       passphraseState: null,
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
-      source: 'wallet-session-coordinator',
-      reason: 'open-wallet',
-      deviceOnly: true,
-    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
@@ -1138,9 +939,7 @@ describe('openWalletSession', () => {
       },
       { cancelDeviceOnReject: false }
     );
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin, {
-      emitUiEvent: false,
-    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin);
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
@@ -1416,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;
@@ -1476,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;
@@ -1544,6 +1335,7 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'hidden-state',
@@ -1570,40 +1362,7 @@ describe('openWalletSession', () => {
       passphraseState: 'hidden-state',
       resumed: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
-    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', {});
-  });
 });