@onekeyfe/hd-core 1.2.0-alpha.9 → 1.2.0-alpha.90

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

@@ -0,0 +1,109 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import { DeviceStateStore, createEmptyDeviceState } from '../src/device/DeviceStateStore';
+import { projectFeatures } from '../src/device/DeviceStateProjector';
+
+describe('DeviceStateStore', () => {
+  test('merges identity patches and ignores undefined', () => {
+    const store = new DeviceStateStore(
+      createEmptyDeviceState({
+        deviceType: EDeviceType.Pro2,
+        firmwareType: EFirmwareType.Universal,
+      })
+    );
+
+    store.update({ identity: { bleName: 'Pro2 1234', label: null } }, 'initialize');
+    const result = store.update(
+      { identity: { label: 'My Wallet', bleName: undefined } },
+      'settings-write'
+    );
+
+    expect(result.state.identity).toMatchObject({
+      label: 'My Wallet',
+      bleName: 'Pro2 1234',
+    });
+    expect(result.revision).toBe(2);
+    expect(result.changedKeys).toContain('identity.label');
+  });
+
+  test('does not advance revision when the patch has no real changes', () => {
+    const store = new DeviceStateStore(createEmptyDeviceState());
+    const first = store.update({ status: { unlocked: null } }, 'device-status');
+    const second = store.update({ status: { unlocked: null } }, 'device-status');
+
+    expect(first.revision).toBe(0);
+    expect(second.revision).toBe(0);
+    expect(second.changedKeys).toEqual([]);
+  });
+
+  test('stores the wire protocol version independently from the protocol family', () => {
+    const store = new DeviceStateStore(createEmptyDeviceState());
+
+    const result = store.update({ protocol: 'V2', protocolVersion: 7 }, 'device-info');
+
+    expect(result.state.protocol).toBe('V2');
+    expect(result.state.protocolVersion).toBe(7);
+    expect(result.changedKeys).toContain('protocolVersion');
+  });
+
+  test('merges raw protocol sources instead of replacing the previous source', () => {
+    const store = new DeviceStateStore(createEmptyDeviceState());
+    const deviceInfo = { protocol_version: 2, hw: { serial_no: 'SERIAL-1' } };
+    const deviceStatus = { device_id: 'DEVICE-1', unlocked: true };
+
+    store.update({ raw: { protocolV2DeviceInfo: deviceInfo } }, 'device-info');
+    const result = store.update({ raw: { protocolV2DeviceStatus: deviceStatus } }, 'device-status');
+
+    expect(result.state.raw).toEqual({
+      protocolV2DeviceInfo: deviceInfo,
+      protocolV2DeviceStatus: deviceStatus,
+    });
+  });
+
+  test('removes only the explicitly cleared raw protocol source', () => {
+    const store = new DeviceStateStore(createEmptyDeviceState());
+    const deviceInfo = { protocol_version: 2, hw: { serial_no: 'SERIAL-1' } };
+    const deviceStatus = { device_id: 'DEVICE-1', unlocked: true };
+
+    store.update(
+      {
+        raw: {
+          protocolV2DeviceInfo: deviceInfo,
+          protocolV2DeviceStatus: deviceStatus,
+        },
+      },
+      'initialize'
+    );
+    const result = store.update({ raw: { protocolV2DeviceStatus: null } }, 'device-info');
+
+    expect(result.state.raw).toEqual({
+      protocolV2DeviceInfo: deviceInfo,
+    });
+  });
+
+  test('merges partial secure-element patches without discarding existing metadata', () => {
+    const store = new DeviceStateStore(createEmptyDeviceState());
+
+    store.update(
+      {
+        securityElements: {
+          se01: { type: 'THD89', state: 'APP' },
+          se02: { type: 'SE608A', state: 'APP' },
+        },
+      },
+      'device-info'
+    );
+    const result = store.update({ securityElements: { se01: { state: 'BOOT' } } }, 'device-status');
+
+    expect(result.state.securityElements).toEqual({
+      se01: { type: 'THD89', state: 'BOOT' },
+      se02: { type: 'SE608A', state: 'APP' },
+    });
+    expect(result.changedKeys).toContain('securityElements');
+    expect(projectFeatures(result.state)).toMatchObject({
+      onekey_se_type: 'THD89',
+      onekey_se01_state: 'BOOT',
+      onekey_se02_state: 'APP',
+    });
+  });
+});

package/__tests__/device-utils.test.ts

@@ -0,0 +1,154 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { DeviceType } from '@onekeyfe/hd-transport';
+
+import {
+  getDeviceSerialNo,
+  getDeviceType,
+  getDeviceTypeByBleName,
+  getDeviceUUID,
+  getFirmwareType,
+  getMethodVersionRange,
+} from '../src/utils/deviceInfoUtils';
+import {
+  getDeviceBLEFirmwareVersion,
+  getDeviceBoardloaderVersion,
+  getDeviceBootloaderVersion,
+  getDeviceFirmwareVersion,
+} from '../src/utils/deviceVersionUtils';
+import {
+  buildProtocolV1FeaturesPayload,
+  buildProtocolV2FeaturesPayload,
+} from '../src/deviceProfile';
+
+import type { PROTO } from '../src/constants';
+
+describe('device feature selectors', () => {
+  test('reads legacy Protocol V1 features without exposing the internal builder', () => {
+    const features = {
+      onekey_device_type: 'CLASSIC1S',
+      onekey_serial_no: 'CP123456',
+      fw_vendor: 'OneKey Bitcoin-only',
+      onekey_firmware_version: 'v3.5.0',
+      onekey_boot_version: '2.8.0-alpha.1',
+      onekey_board_version: '1.2.3+board',
+      onekey_ble_version: '1.4.0+ble',
+    } as PROTO.Features;
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Classic1s);
+    expect(getDeviceSerialNo(features)).toBe('CP123456');
+    expect(getFirmwareType(features)).toBe(EFirmwareType.BitcoinOnly);
+    expect(getDeviceFirmwareVersion(features)).toEqual([3, 5, 0]);
+    expect(getDeviceBootloaderVersion(features)).toEqual([2, 8, 0]);
+    expect(getDeviceBoardloaderVersion(features)).toEqual([1, 2, 3]);
+    expect(getDeviceBLEFirmwareVersion(features)).toEqual([1, 4, 0]);
+  });
+
+  test('keeps getDeviceUUID as a compatibility alias', () => {
+    const features = {
+      onekey_serial_no: 'PR123456',
+      fw_vendor: 'OneKey Bitcoin-only',
+      onekey_board_version: '1.2.3',
+      onekey_ble_version: '2.3.4',
+    } as PROTO.Features;
+
+    expect(getDeviceUUID(features)).toBe(getDeviceSerialNo(features));
+  });
+
+  test('uses bootloader version parts from old Protocol V1 firmware', () => {
+    const features = {
+      bootloader_mode: true,
+      major_version: 1,
+      minor_version: 8,
+      patch_version: 3,
+      model: '1',
+    } as PROTO.Features;
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Classic);
+    expect(getDeviceFirmwareVersion(features)).toEqual([0, 0, 0]);
+    expect(getDeviceBootloaderVersion(features)).toEqual([1, 8, 3]);
+  });
+
+  test('shares Protocol V1 compatibility semantics with the internal builder', () => {
+    const rawFeatures = {
+      onekey_device_type: 'PRO',
+      onekey_serial_no: 'PR123456',
+      onekey_firmware_version: '4.16.0',
+      onekey_boot_version: '2.8.0',
+      fw_vendor: 'OneKey Bitcoin-only',
+    } as PROTO.Features;
+    const normalized = buildProtocolV1FeaturesPayload(rawFeatures);
+
+    expect(getDeviceType(normalized)).toBe(getDeviceType(rawFeatures));
+    expect(getDeviceSerialNo(normalized)).toBe(getDeviceSerialNo(rawFeatures));
+    expect(getFirmwareType(normalized)).toBe(getFirmwareType(rawFeatures));
+    expect(getDeviceFirmwareVersion(normalized)).toEqual(getDeviceFirmwareVersion(rawFeatures));
+    expect(getDeviceBootloaderVersion(normalized)).toEqual(getDeviceBootloaderVersion(rawFeatures));
+  });
+
+  test('reads normalized Protocol V2 features through the same public selectors', () => {
+    const features = buildProtocolV2FeaturesPayload({
+      deviceInfo: {
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'P2-001' },
+        fw: {
+          application: { version: '5.0.0' },
+          bootloader: { version: '2.0.0' },
+          romloader: { version: '1.0.0' },
+        },
+        coprocessor: {
+          application: { version: '3.0.0' },
+        },
+      },
+    });
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Pro2);
+    expect(getDeviceSerialNo(features)).toBe('P2-001');
+    expect(getDeviceFirmwareVersion(features)).toEqual([5, 0, 0]);
+    expect(getDeviceBootloaderVersion(features)).toEqual([2, 0, 0]);
+    expect(getDeviceBoardloaderVersion(features)).toEqual([1, 0, 0]);
+    expect(getDeviceBLEFirmwareVersion(features)).toEqual([3, 0, 0]);
+  });
+
+  test('preserves the real Neo type in Protocol V2 compatibility features', () => {
+    const features = buildProtocolV2FeaturesPayload({
+      deviceInfo: {
+        hw: { Device_type: DeviceType.NEO, serial_no: 'NEO-001' },
+      },
+    });
+
+    expect(features.deviceType).toBe(EDeviceType.Neo);
+    expect(features.onekey_device_type).toBe('NEO');
+    expect(getDeviceType(features)).toBe(EDeviceType.Neo);
+  });
+
+  test('recognizes Neo discovery names before initialization', () => {
+    expect(getDeviceTypeByBleName('OneKey Neo 1234')).toBe(EDeviceType.Neo);
+    expect(getDeviceTypeByBleName('Neo 1234')).toBe(EDeviceType.Neo);
+  });
+
+  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
+    'uses the Pro2 product model as the chain capability fallback for %s',
+    deviceType => {
+      const checkedTypes: string[] = [];
+      const versionRange = getMethodVersionRange({ deviceType } as PROTO.Features, type => {
+        checkedTypes.push(type);
+        return type === 'model_pro2' ? { min: '1.0.0' } : undefined;
+      });
+
+      expect(versionRange).toEqual({ min: '1.0.0' });
+      expect(checkedTypes).toEqual([deviceType, 'model_pro2']);
+    }
+  );
+
+  test('prefers a Neo-specific chain range over the shared Pro2 product model', () => {
+    const versionRange = getMethodVersionRange(
+      { deviceType: EDeviceType.Neo } as PROTO.Features,
+      type => {
+        if (type === EDeviceType.Neo) return { min: '2.0.0' };
+        if (type === 'model_pro2') return { min: '1.0.0' };
+        return undefined;
+      }
+    );
+
+    expect(versionRange).toEqual({ min: '2.0.0' });
+  });
+});

package/__tests__/device-wallet-session-store.test.ts

@@ -1,9 +1,15 @@
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import ClearSessionCache from '../src/api/ClearSessionCache';
+import GetPassphraseState from '../src/api/GetPassphraseState';
+import DeviceWipe from '../src/api/device/DeviceWipe';
 import {
   DeviceWalletSessionStore,
   deviceWalletSessionStore,
 } from '../src/device/DeviceWalletSessionStore';
+import { Device } from '../src/device/Device';
 import { createCoreApi } from '../src/inject';
+import TransportManager from '../src/data-manager/TransportManager';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -30,6 +36,38 @@ describe('DeviceWalletSessionStore', () => {
     expect(store.get('device-2', 'hidden-a')).toBe('session-c');
   });
 
+  test('keeps SDK session handles without mirroring hardware eviction policy', () => {
+    const store = new DeviceWalletSessionStore();
+    store.setStandard('device-1', 'wallet-a', 'session-a');
+    store.set('device-1', 'wallet-b', 'session-b');
+    store.set('device-1', 'wallet-c', 'session-c');
+    store.set('device-1', 'wallet-d', 'session-d');
+
+    expect(store.get('device-1', 'wallet-a')).toBe('session-a');
+    expect(store.getStandard('device-1')).toEqual({
+      passphraseState: 'wallet-a',
+      sessionId: 'session-a',
+    });
+    expect(store.get('device-1', 'wallet-b')).toBe('session-b');
+    expect(store.get('device-1', 'wallet-c')).toBe('session-c');
+    expect(store.get('device-1', 'wallet-d')).toBe('session-d');
+  });
+
+  test('indexes the standard wallet without replacing hidden-wallet sessions', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'hidden-session-a');
+
+    store.setStandard('device-1', 'standard-state', 'standard-session-1');
+    store.setStandard('device-1', 'standard-state', 'standard-session-2');
+
+    expect(store.getStandard('device-1')).toEqual({
+      passphraseState: 'standard-state',
+      sessionId: 'standard-session-2',
+    });
+    expect(store.get('device-1', 'standard-state')).toBe('standard-session-2');
+    expect(store.get('device-1', 'hidden-a')).toBe('hidden-session-a');
+  });
+
   test('keeps pending sessions unreadable until wallet binding', () => {
     const store = new DeviceWalletSessionStore();
     store.setPending('device-1', 'pending-session');
@@ -41,25 +79,80 @@ describe('DeviceWalletSessionStore', () => {
   test('migrates descriptor keys to stable device ids', () => {
     const store = new DeviceWalletSessionStore();
     store.set('ble-path', 'hidden-a', 'session-a');
+    store.setStandard('ble-path', 'standard-state', 'standard-session');
     store.setPending('ble-path', 'pending-session');
 
-    store.migrateDeviceKey('ble-path', 'stable-device-id');
+    store.reconcileDeviceIdentity({
+      temporaryKey: 'ble-path',
+      nextDeviceId: 'stable-device-id',
+    });
 
     expect(store.get('ble-path', 'hidden-a')).toBeUndefined();
     expect(store.get('stable-device-id', 'hidden-a')).toBe('session-a');
+    expect(store.getStandard('ble-path')).toBeUndefined();
+    expect(store.getStandard('stable-device-id')).toEqual({
+      passphraseState: 'standard-state',
+      sessionId: 'standard-session',
+    });
     expect(store.getPending('ble-path')).toBeUndefined();
     expect(store.getPending('stable-device-id')).toBe('pending-session');
   });
 
+  test('keeps every known handle when descriptor sessions merge into a stable device id', () => {
+    const store = new DeviceWalletSessionStore();
+    store.setStandard('stable-device-id', 'wallet-a', 'session-a');
+    store.set('stable-device-id', 'wallet-b', 'session-b');
+    store.set('ble-path', 'wallet-c', 'session-c');
+    store.set('ble-path', 'wallet-d', 'session-d');
+
+    store.reconcileDeviceIdentity({
+      temporaryKey: 'ble-path',
+      nextDeviceId: 'stable-device-id',
+    });
+
+    expect(store.get('stable-device-id', 'wallet-a')).toBe('session-a');
+    expect(store.getStandard('stable-device-id')).toEqual({
+      passphraseState: 'wallet-a',
+      sessionId: 'session-a',
+    });
+    expect(store.get('stable-device-id', 'wallet-b')).toBe('session-b');
+    expect(store.get('stable-device-id', 'wallet-c')).toBe('session-c');
+    expect(store.get('stable-device-id', 'wallet-d')).toBe('session-d');
+  });
+
+  test('drops sessions from an old stable identity without overwriting the new device', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-a', 'hidden-a', 'session-a');
+    store.setPending('device-a', 'pending-a');
+    store.set('device-b', 'hidden-a', 'session-b');
+    store.setPending('device-b', 'pending-b');
+
+    store.reconcileDeviceIdentity({
+      temporaryKey: 'ble-path',
+      previousDeviceId: 'device-a',
+      nextDeviceId: 'device-b',
+    });
+
+    expect(store.get('device-a', 'hidden-a')).toBeUndefined();
+    expect(store.getPending('device-a')).toBeUndefined();
+    expect(store.get('device-b', 'hidden-a')).toBe('session-b');
+    expect(store.getPending('device-b')).toBe('pending-b');
+  });
+
   test('clears one wallet, one device, or all sessions', () => {
     const store = new DeviceWalletSessionStore();
     store.set('device-1', 'hidden-a', 'session-a');
     store.set('device-1', 'hidden-b', 'session-b');
+    store.setStandard('device-1', 'standard-state', 'standard-session');
     store.set('device-2', 'hidden-a', 'session-c');
 
     store.delete('device-1', 'hidden-a');
     expect(store.get('device-1', 'hidden-a')).toBeUndefined();
     expect(store.get('device-1', 'hidden-b')).toBe('session-b');
+    expect(store.getStandard('device-1')?.sessionId).toBe('standard-session');
+
+    store.delete('device-1', 'standard-state');
+    expect(store.getStandard('device-1')).toBeUndefined();
 
     store.deleteDevice('device-1');
     expect(store.get('device-1', 'hidden-b')).toBeUndefined();
@@ -70,11 +163,134 @@ describe('DeviceWalletSessionStore', () => {
   });
 });
 
+describe('Device wipe lifecycle invalidation', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+  });
+
+  test('clears the old Protocol V2 identity and wallet sessions after wipe succeeds', async () => {
+    const device = Device.fromDescriptor({
+      id: 'pro2-descriptor',
+      path: 'pro2-path',
+      protocolType: 'V2',
+    } as never);
+    device.features = {
+      protocol: 'V2',
+      deviceId: 'old-device-id',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    device.passphraseState = 'hidden-a';
+    deviceWalletSessionStore.set('old-device-id', 'hidden-a', 'old-session');
+    deviceWalletSessionStore.set('pro2-path', 'hidden-a', 'temporary-session');
+    device.markPreInitialized({ passphraseState: 'hidden-a' });
+    device.commands = {
+      typedCall: jest.fn().mockResolvedValue({ message: { message: 'accepted' } }),
+    } as never;
+
+    const method = new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'accepted' });
+
+    expect(device.features).toBeUndefined();
+    expect(device.passphraseState).toBeUndefined();
+    expect(device.needReloadDevice).toBe(true);
+    expect(device.isPreInitializedValid(60_000)).toBe(false);
+    expect(deviceWalletSessionStore.get('old-device-id', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('pro2-path', 'hidden-a')).toBeUndefined();
+  });
+});
+
 describe('ClearSessionCache', () => {
   beforeEach(() => {
     deviceWalletSessionStore.clear();
   });
 
+  test('uses DeviceWalletSessionStore as the only cache source', async () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
+
+    const method = new ClearSessionCache({
+      payload: {
+        method: 'clearSessionCache',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-a',
+      },
+    });
+    method.init();
+    await method.run();
+
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
+  });
+
+  test('rejects passphraseState without a deviceId instead of clearing every device', () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
+    const method = new ClearSessionCache({
+      payload: { method: 'clearSessionCache', passphraseState: 'hidden-a' },
+    });
+
+    expect(() => method.init()).toThrow('Parameter [deviceId] is required with [passphraseState].');
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBe('session-a');
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
+  });
+
+  test('keeps wallet sessions internal instead of projecting them through Features', async () => {
+    const device = Device.fromDescriptor({ id: 'one', path: 'one' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-1',
+      passphraseState: 'hidden-a',
+      sessionId: 'session-a',
+      session_id: 'session-a',
+      raw: {
+        protocolV1Features: {
+          sessionId: 'session-a',
+          session_id: 'session-a',
+        },
+      },
+    } as never;
+
+    expect(device.state).not.toHaveProperty('session');
+    expect(device.getInternalState()).toBe('session-a');
+    expect(device.features).toMatchObject({
+      sessionId: null,
+      session_id: null,
+    });
+    expect(device.features).not.toHaveProperty('passphraseState');
+    expect(device.features).not.toHaveProperty('raw');
+
+    const method = new ClearSessionCache({
+      payload: {
+        method: 'clearSessionCache',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-a',
+      },
+    });
+    method.init();
+    await method.run();
+
+    expect(device.features?.sessionId).toBeNull();
+    expect(device.features?.session_id).toBeNull();
+    expect(device.state?.raw?.protocolV1Features).not.toHaveProperty('sessionId');
+    expect(device.state?.raw?.protocolV1Features).not.toHaveProperty('session_id');
+  });
+
+  test('uses only the transport path as the temporary Protocol V2 cache key', () => {
+    const device = Device.fromDescriptor({ id: 'descriptor-id' } as never);
+    device.features = {
+      protocol: 'V2',
+      passphraseState: 'hidden-a',
+      sessionId: 'session-a',
+    } as never;
+
+    expect(device.getInternalState()).toBeUndefined();
+    expect(deviceWalletSessionStore.get('descriptor-id', 'hidden-a')).toBeUndefined();
+  });
+
   test('clears one wallet without using a device', async () => {
     deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
     deviceWalletSessionStore.set('device-1', 'hidden-b', 'session-b');
@@ -129,3 +345,134 @@ describe('ClearSessionCache', () => {
     });
   });
 });
+
+describe('Protocol V1 wallet identity initialization', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+    jest.restoreAllMocks();
+  });
+
+  test('verifies the live device id without resetting the cached wallet session', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'cached-device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'live-device-b' },
+    });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await expect(
+      device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith('GetFeatures', 'Features', {});
+  });
+
+  test('resumes a cached V1 wallet after a non-destructive live identity read', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
+      .mockResolvedValueOnce({
+        type: 'Features',
+        message: { device_id: 'device-a', session_id: 'session-a' },
+      });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'Initialize',
+      'Features',
+      expect.objectContaining({
+        session_id: 'session-a',
+        passphrase_state: 'hidden-a',
+      }),
+      expect.any(Object)
+    );
+  });
+
+  test('selects the standard V1 wallet after a non-destructive live identity read', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-a',
+      unlocked: true,
+      passphraseProtection: false,
+    } as never;
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a' });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'Initialize',
+      'Features',
+      {
+        passphrase_state: undefined,
+        is_contains_attach: true,
+      },
+      expect.any(Object)
+    );
+  });
+});
+
+describe('Protocol V1 passphrase state classification', () => {
+  test('does not expose a standard-wallet address as passphrase state', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Address',
+      message: { address: 'standard-wallet-address' },
+    });
+    const method = new GetPassphraseState({
+      payload: {
+        method: 'getPassphraseState',
+        connectId: 'connect-a',
+      },
+    });
+    method.device = {
+      features: {},
+      commands: { typedCall },
+      isProtocolV2: () => false,
+      getCurrentDeviceType: () => EDeviceType.Classic,
+      getCurrentFirmwareVersionString: () => '1.0.0',
+      getCurrentPassphraseProtection: () => false,
+      getCurrentDeviceId: () => 'device-a',
+      getFeatures: jest.fn(),
+      getInternalState: () => undefined,
+      updateInternalState: jest.fn(),
+    } as never;
+
+    await expect(method.run()).resolves.toBeUndefined();
+    expect(typedCall).toHaveBeenCalledWith('GetAddress', 'Address', {
+      address_n: expect.any(Array),
+      coin_name: 'Testnet',
+      script_type: 'SPENDADDRESS',
+      show_display: false,
+    });
+  });
+});