@onekeyfe/hd-core 1.2.0-alpha.32 → 1.2.0-alpha.34

package/__tests__/protocol-v2.test.ts

@@ -1,5 +1,10 @@
 import { EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceRebootType, DeviceSessionPinType, DeviceSettingsPage } from '@onekeyfe/hd-transport';
+import {
+  DeviceRebootType,
+  DeviceSessionPinType,
+  DeviceSettingsPage,
+  DeviceType,
+} from '@onekeyfe/hd-transport';
 
 import * as firmwareBinaryApi from '../src/api/firmware/getBinary';
 import DnxGetAddress from '../src/api/dynex/DnxGetAddress';
@@ -54,6 +59,7 @@ import { getBitcoinForkSupportedProtocols } from '../src/api/btc/helpers/version
 import { DataManager } from '../src/data-manager';
 import { createCoreApi } from '../src/inject';
 import { Device, preloadSessionCache } from '../src/device/Device';
+import { deviceWalletSessionStore } from '../src/device/DeviceWalletSessionStore';
 import { DevicePool } from '../src/device/DevicePool';
 import { UI_REQUEST } from '../src/events/ui-request';
 import {
@@ -96,11 +102,19 @@ jest.mock('../src/data/config', () => ({
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
-const createWalletSessionTypedCall = (implementation = jest.fn()) =>
+const createWalletSessionTypedCall = (
+  implementation = jest.fn(),
+  status: Partial<DeviceStatus> = { passphrase_enabled: true }
+) =>
   jest.fn((request: string, ...args: unknown[]) => {
     if (request === 'ProtocolInfoRequest') {
       return Promise.resolve({ message: { version: 2 } });
     }
+    if (request === 'DeviceStatusGet') {
+      return Promise.resolve({
+        message: { unlocked: true, unlocked_attach_pin: false, ...status },
+      });
+    }
     return implementation(request, ...args);
   });
 
@@ -464,6 +478,10 @@ async function requestProtocolV2Features({
 }
 
 describe('Protocol V2 feature adapter', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+  });
+
   test('treats passphrase status as unknown until the Protocol V2 device is unlocked', () => {
     const features = buildProtocolV2FeaturesPayload({
       deviceInfo: {
@@ -575,6 +593,7 @@ describe('Protocol V2 feature adapter', () => {
     const features = normalizeProtocolV2Features(descriptor as any, {
       protocol_version: 1,
       hw: {
+        Device_type: DeviceType.PRO2,
         serial_no: 'PR2SERIAL',
       },
       fw: {
@@ -733,12 +752,23 @@ describe('Protocol V2 feature adapter', () => {
     features.firmwareVersion = '1.2.3';
     features.passphraseProtection = true;
     const typedCall = createWalletSessionTypedCall(
-      jest.fn().mockResolvedValue({
-        type: 'DeviceSession',
-        message: {
-          btc_test_address: 'state-1',
-          session_id: 'session-1',
-        },
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionAskPin') {
+          return { type: 'Success', message: { message: 'PIN verified' } };
+        }
+        if (request === 'DeviceStatusGet') {
+          return { type: 'DeviceStatus', message: { unlocked: true } };
+        }
+        if (request === 'DeviceSessionGet') {
+          return {
+            type: 'DeviceSession',
+            message: {
+              btc_test_address: 'state-1',
+              session_id: 'session-1',
+            },
+          };
+        }
+        throw new Error(`Unexpected request: ${request}`);
       })
     );
     const commands = { typedCall } as unknown as DeviceCommands;
@@ -751,18 +781,236 @@ describe('Protocol V2 feature adapter', () => {
         onlyMainPin: true,
       })
     ).resolves.toEqual({
-      passphraseState: undefined,
-      newSession: undefined,
-      unlockedAttachPin: false,
+      passphraseState: 'state-1',
+      newSession: 'session-1',
+      unlockedAttachPin: undefined,
       resumed: false,
     });
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(device.getInternalState()).toBeUndefined();
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
+      type: DeviceSessionPinType.Main,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    device.passphraseState = 'state-1';
+    expect(device.getInternalState()).toBe('session-1');
   });
 
-  test('keeps Protocol V2 on the standard wallet when passphrase protection is disabled', async () => {
+  test('reuses the cached Protocol V2 standard wallet instead of asking Main PIN again', async () => {
+    const deviceId = 'standard-reuse-device';
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: deviceId,
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') return { message: { version: 2 } };
+      if (request === 'DeviceSessionAskPin') {
+        return { type: 'Success', message: { message: 'PIN verified' } };
+      }
+      if (request === 'DeviceStatusGet') {
+        return {
+          message: {
+            device_id: deviceId,
+            unlocked: true,
+            passphrase_enabled: true,
+          },
+        };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    (device as any).commands = { typedCall };
+
+    await getProtocolV2WalletSession(device, { onlyMainPin: true });
+    await getProtocolV2WalletSession(device, { onlyMainPin: true });
+
+    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionAskPin')).toHaveLength(1);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'standard-session',
+    });
+    expect(deviceWalletSessionStore.getStandard(deviceId)).toEqual({
+      passphraseState: 'standard-state',
+      sessionId: 'standard-session',
+    });
+  });
+
+  test('reopens the Protocol V2 standard wallet when the cached session resolves to another wallet', async () => {
+    const deviceId = 'standard-invalid-device';
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: deviceId,
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    deviceWalletSessionStore.set(deviceId, 'hidden-state', 'hidden-session');
+    deviceWalletSessionStore.setStandard(deviceId, 'old-standard-state', 'old-standard-session');
+
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'ProtocolInfoRequest') return { message: { version: 2 } };
+      if (request === 'DeviceSessionGet' && params.session_id) {
+        return {
+          message: {
+            btc_test_address: 'hidden-state',
+            session_id: 'hidden-session',
+          },
+        };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'old-standard-state',
+            session_id: 'new-standard-session',
+          },
+        };
+      }
+      if (request === 'DeviceSessionAskPin') {
+        return { type: 'Success', message: { message: 'PIN verified' } };
+      }
+      if (request === 'DeviceStatusGet') {
+        return { message: { device_id: deviceId, unlocked: true, passphrase_enabled: true } };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    (device as any).commands = { typedCall };
+
+    await expect(getProtocolV2WalletSession(device, { onlyMainPin: true })).resolves.toMatchObject({
+      passphraseState: 'old-standard-state',
+      newSession: 'new-standard-session',
+      resumed: false,
+    });
+    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionAskPin')).toHaveLength(1);
+    expect(deviceWalletSessionStore.getStandard(deviceId)).toEqual({
+      passphraseState: 'old-standard-state',
+      sessionId: 'new-standard-session',
+    });
+    expect(deviceWalletSessionStore.get(deviceId, 'hidden-state')).toBe('hidden-session');
+  });
+
+  test('opens Main PIN directly instead of resuming a standard session while locked', async () => {
+    const deviceId = 'standard-locked-device';
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: deviceId,
+          unlocked: false,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    deviceWalletSessionStore.setStandard(deviceId, 'standard-state', 'cached-standard-session');
+
+    let sessionGetCalls = 0;
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') return { message: { version: 2 } };
+      if (request === 'DeviceSessionAskPin') {
+        return { type: 'Success', message: { message: 'PIN verified' } };
+      }
+      if (request === 'DeviceStatusGet') {
+        return { message: { device_id: deviceId, unlocked: true, passphrase_enabled: true } };
+      }
+      if (request === 'DeviceSessionGet') {
+        sessionGetCalls += 1;
+        if (sessionGetCalls === 1) {
+          throw Object.assign(new Error('Device is locked'), {
+            errorCode: HardwareErrorCode.DeviceLocked,
+          });
+        }
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'cached-standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    (device as any).commands = { typedCall };
+
+    await expect(getProtocolV2WalletSession(device, { onlyMainPin: true })).resolves.toMatchObject({
+      newSession: 'cached-standard-session',
+      resumed: true,
+    });
+    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet')).toHaveLength(2);
+    expect(deviceWalletSessionStore.getStandard(deviceId)?.sessionId).toBe(
+      'cached-standard-session'
+    );
+  });
+
+  test('recovers a mismatched cached standard wallet without deleting hidden sessions', async () => {
+    const deviceId = 'standard-mismatch-device';
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: deviceId,
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    deviceWalletSessionStore.set(deviceId, 'hidden-state', 'hidden-session');
+    deviceWalletSessionStore.setStandard(deviceId, 'standard-state', 'standard-session');
+    let sessionGetCalls = 0;
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') return { message: { version: 2 } };
+      if (request === 'DeviceSessionAskPin') return { message: { message: 'PIN verified' } };
+      if (request === 'DeviceStatusGet') {
+        return { message: { device_id: deviceId, unlocked: true, passphrase_enabled: true } };
+      }
+      if (request === 'DeviceSessionGet') {
+        sessionGetCalls += 1;
+        return {
+          message: {
+            btc_test_address: sessionGetCalls === 1 ? 'unexpected-wallet-state' : 'standard-state',
+            session_id: sessionGetCalls === 1 ? 'unexpected-session' : 'renewed-standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    (device as any).commands = { typedCall };
+
+    await expect(getProtocolV2WalletSession(device, { onlyMainPin: true })).resolves.toMatchObject({
+      passphraseState: 'standard-state',
+      newSession: 'renewed-standard-session',
+      resumed: false,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
+      type: DeviceSessionPinType.Main,
+    });
+    expect(deviceWalletSessionStore.getStandard(deviceId)).toEqual({
+      passphraseState: 'standard-state',
+      sessionId: 'renewed-standard-session',
+    });
+    expect(deviceWalletSessionStore.get(deviceId, 'hidden-state')).toBe('hidden-session');
+  });
+
+  test('selects a Protocol V2 wallet explicitly even when passphrase protection was disabled', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
@@ -783,13 +1031,13 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(getProtocolV2WalletSession(device)).resolves.toEqual({
-      passphraseState: undefined,
-      newSession: undefined,
-      unlockedAttachPin: false,
+      passphraseState: 'main-wallet-state',
+      newSession: 'main-wallet-session',
+      unlockedAttachPin: undefined,
       resumed: false,
     });
 
-    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(promptPassphrase).toHaveBeenCalled();
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
@@ -846,15 +1094,20 @@ describe('Protocol V2 feature adapter', () => {
         },
       }
     );
+    const lockedError = Object.assign(new Error('Device is locked'), {
+      errorCode: HardwareErrorCode.DeviceLocked,
+    });
     const typedCall = createWalletSessionTypedCall(
-      jest.fn().mockImplementation((request: string) => {
-        if (request === 'DeviceStatusGet') {
-          return Promise.resolve({
-            message: { passphrase_enabled: false, unlocked: true },
-          });
-        }
-        throw new Error(`Unexpected request: ${request}`);
-      })
+      jest
+        .fn()
+        .mockRejectedValueOnce(lockedError)
+        .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
+        .mockResolvedValueOnce({
+          message: {
+            btc_test_address: 'hidden-after-unlock-state',
+            session_id: 'hidden-after-unlock-session',
+          },
+        })
     );
     const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden-after-unlock' });
     const unlockDevice = jest.spyOn(device, 'unlockDevice').mockImplementation(() => {
@@ -868,14 +1121,14 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(getProtocolV2WalletSession(device)).resolves.toEqual({
-      passphraseState: undefined,
-      newSession: undefined,
-      unlockedAttachPin: false,
+      passphraseState: 'hidden-after-unlock-state',
+      newSession: 'hidden-after-unlock-session',
+      unlockedAttachPin: undefined,
       resumed: false,
     });
 
     expect(unlockDevice).toHaveBeenCalledTimes(1);
-    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(promptPassphrase).toHaveBeenCalled();
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
@@ -905,8 +1158,8 @@ describe('Protocol V2 feature adapter', () => {
         onlyMainPin: true,
       })
     ).resolves.toMatchObject({
-      passphraseState: undefined,
-      newSession: undefined,
+      passphraseState: 'main-wallet-state',
+      newSession: 'main-wallet-session',
     });
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
@@ -933,9 +1186,17 @@ describe('Protocol V2 feature adapter', () => {
       }
     );
     const typedCall = createWalletSessionTypedCall(
-      jest.fn().mockResolvedValue({
-        type: 'DeviceSession',
-        message: { session_id: 'hidden-session', btc_test_address: 'hidden-state' },
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionAskPassphrase') {
+          return { type: 'Success', message: { message: 'Passphrase prepared' } };
+        }
+        if (request === 'DeviceSessionGet') {
+          return {
+            type: 'DeviceSession',
+            message: { session_id: 'hidden-session', btc_test_address: 'hidden-state' },
+          };
+        }
+        throw new Error(`Unexpected request: ${request}`);
       })
     );
     const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
@@ -1148,11 +1409,14 @@ describe('Protocol V2 feature adapter', () => {
       }
     );
     const typedCall = createWalletSessionTypedCall(
-      jest.fn().mockRejectedValue(
-        Object.assign(new Error('Invalid session'), {
-          errorCode: HardwareErrorCode.WalletSessionInvalid,
-        })
-      )
+      jest
+        .fn()
+        .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
+        .mockRejectedValueOnce(
+          Object.assign(new Error('Invalid session'), {
+            errorCode: HardwareErrorCode.WalletSessionInvalid,
+          })
+        )
     );
     (device as any).commands = {
       typedCall,
@@ -1165,10 +1429,12 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall.mock.calls).toEqual([
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
       ['DeviceSessionAskPassphrase', 'Success', { on_device: true }],
+      ['DeviceStatusGet', 'DeviceStatus', {}],
+      ['DeviceSessionGet', 'DeviceSession', {}],
     ]);
   });
 
-  test('rejects a mismatched Pro2 wallet state and clears the selected cache entry', async () => {
+  test('reselects a hidden wallet when the cached Pro2 session resolves to another wallet', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-mismatch',
       path: 'cache-path-mismatch',
@@ -1186,25 +1452,147 @@ describe('Protocol V2 feature adapter', () => {
     );
     device.passphraseState = 'state-a';
     preloadSessionCache('stable-device-mismatch', 'state-a', 'session-a');
-    (device as any).commands = {
-      typedCall: createWalletSessionTypedCall(
-        jest.fn().mockResolvedValue({
-          type: 'DeviceSession',
-          message: { session_id: 'session-b', btc_test_address: 'state-b' },
-        })
-      ),
-    };
+    let sessionGetCalls = 0;
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionAskPassphrase') return { message: { message: 'prepared' } };
+        if (request === 'DeviceSessionGet') {
+          sessionGetCalls += 1;
+          return {
+            type: 'DeviceSession',
+            message:
+              sessionGetCalls === 1
+                ? { session_id: 'session-b', btc_test_address: 'state-b' }
+                : { session_id: 'session-a-new', btc_test_address: 'state-a' },
+          };
+        }
+        throw new Error(`Unexpected request: ${request}`);
+      })
+    );
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(
       getPassphraseStateWithRefreshDeviceInfo(device, { expectPassphraseState: 'state-a' })
-    ).rejects.toEqual(
+    ).resolves.toMatchObject({
+      passphraseState: 'state-a',
+      newSession: 'session-a-new',
+      resumed: false,
+    });
+    expect(promptPassphrase).toHaveBeenCalledWith(
       expect.objectContaining({
-        errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
+        source: 'wallet-session-coordinator',
+        reason: 'session-recovery',
+        expectedPassphraseState: 'state-a',
+      }),
+      { cancelDeviceOnReject: false }
+    );
+    expect(device.getInternalState()).toBe('session-a-new');
+  });
+
+  test('rejects a hidden wallet when one recovery still returns the wrong state', async () => {
+    const device = Device.fromDescriptor({
+      id: 'cache-device-final-mismatch',
+      path: 'cache-path-final-mismatch',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: 'stable-device-final-mismatch',
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    device.passphraseState = 'state-a';
+    preloadSessionCache('stable-device-final-mismatch', 'state-a', 'session-a');
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionAskPassphrase') return { message: { message: 'prepared' } };
+        if (request === 'DeviceSessionGet') {
+          return {
+            type: 'DeviceSession',
+            message: { session_id: 'wrong-session', btc_test_address: 'wrong-state' },
+          };
+        }
+        throw new Error(`Unexpected request: ${request}`);
       })
     );
+    (device as any).commands = {
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+    };
+
+    await expect(
+      getPassphraseStateWithRefreshDeviceInfo(device, { expectPassphraseState: 'state-a' })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
+    });
     expect(device.getInternalState()).toBeUndefined();
   });
 
+  test('recovers an expired Attach PIN wallet through the unified wallet selector', async () => {
+    const device = Device.fromDescriptor({
+      id: 'cache-device-attach-recovery',
+      path: 'cache-path-attach-recovery',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: 'stable-device-attach-recovery',
+          unlocked: true,
+          passphrase_enabled: true,
+          attach_to_pin_enabled: true,
+        },
+      }
+    );
+    device.passphraseState = 'attach-state';
+    preloadSessionCache('stable-device-attach-recovery', 'attach-state', 'expired-attach-session');
+    let sessionGetCalls = 0;
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionGet') {
+          sessionGetCalls += 1;
+          return {
+            type: 'DeviceSession',
+            message:
+              sessionGetCalls === 1
+                ? { session_id: 'current-standard-session', btc_test_address: 'standard-state' }
+                : { session_id: 'new-attach-session', btc_test_address: 'attach-state' },
+          };
+        }
+        throw new Error(`Unexpected request: ${request}`);
+      })
+    );
+    const promptPassphrase = jest.fn().mockResolvedValue({ attachPinOnDevice: true });
+    (device as any).commands = { typedCall, promptPassphrase };
+    const unlockDevice = jest
+      .spyOn(device, 'unlockDevice')
+      .mockResolvedValue(device.features as any);
+
+    await expect(
+      getProtocolV2WalletSession(device, { expectedPassphraseState: 'attach-state' })
+    ).resolves.toMatchObject({
+      passphraseState: 'attach-state',
+      newSession: 'new-attach-session',
+      resumed: false,
+    });
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: 'session-recovery',
+        expectedPassphraseState: 'attach-state',
+        existsAttachPinUser: true,
+      }),
+      { cancelDeviceOnReject: false }
+    );
+    expect(unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin);
+    expect(device.getInternalState()).toBe('new-attach-session');
+  });
+
   test('unlocks and retries DeviceSessionAskPassphrase when wallet selection is locked', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-4',
@@ -1222,7 +1610,7 @@ describe('Protocol V2 feature adapter', () => {
       jest
         .fn()
         .mockRejectedValueOnce(lockedError)
-        .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+        .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
         .mockResolvedValueOnce({
           message: {
             session_id: 'session-after-unlock',
@@ -1241,7 +1629,7 @@ describe('Protocol V2 feature adapter', () => {
       passphraseState: 'state-after-unlock',
     });
     expect(unlockDevice).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledTimes(4);
+    expect(typedCall).toHaveBeenCalledTimes(5);
   });
 
   test('does not request a Pro2 wallet session before features are initialized', async () => {
@@ -1385,7 +1773,8 @@ describe('Protocol V2 feature adapter', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
+      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
       .mockResolvedValueOnce({
         type: 'DeviceSession',
         message: {
@@ -1421,7 +1810,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(promptPassphrase).toHaveBeenCalledWith(
       {
         existsAttachPinUser: false,
-        deviceOnly: true,
+        deviceOnly: false,
         source: 'wallet-session-coordinator',
         reason: 'open-wallet',
       },
@@ -1438,6 +1827,51 @@ describe('Protocol V2 feature adapter', () => {
     expect(getFeatures).not.toHaveBeenCalled();
   });
 
+  test('marks an interactive cache miss as a wallet-session recovery', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
+      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'expected-state',
+          session_id: 'recovered-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const device = stubDevice({
+      originalDescriptor: { ...descriptor, protocolType: 'V2' },
+      passphraseState: 'expected-state',
+      features: {
+        unlocked: true,
+        passphraseProtection: true,
+        attachToPinEnabled: false,
+      },
+      commands: { typedCall, promptPassphrase },
+      getInternalState: jest.fn().mockReturnValue(undefined),
+      getCurrentDeviceId: () => 'pro2-device-id',
+      getCurrentPassphraseProtection: () => true,
+      updateInternalState: jest.fn(),
+      clearInternalState: jest.fn(),
+      emit: jest.fn(),
+    }) as any;
+
+    await expect(
+      getProtocolV2WalletSession(device, { expectedPassphraseState: 'expected-state' })
+    ).resolves.toMatchObject({ passphraseState: 'expected-state' });
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      {
+        existsAttachPinUser: false,
+        deviceOnly: false,
+        source: 'wallet-session-coordinator',
+        reason: 'session-recovery',
+        expectedPassphraseState: 'expected-state',
+      },
+      { cancelDeviceOnReject: false }
+    );
+  });
+
   test('reuses the Pro2 session opened by legacy getPassphraseState on the next App call', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     const typedCall = jest.fn().mockImplementation((request: string) => {
@@ -1445,7 +1879,16 @@ describe('Protocol V2 feature adapter', () => {
         return Promise.resolve({ message: { version: 2 } });
       }
       if (request === 'DeviceSessionAskPassphrase') {
-        return Promise.resolve({ message: { message: 'passphrase prepared' } });
+        return Promise.resolve({
+          type: 'Success',
+          message: { message: 'Passphrase prepared' },
+        });
+      }
+      if (request === 'DeviceStatusGet') {
+        return Promise.resolve({
+          type: 'DeviceStatus',
+          message: { unlocked: true, unlocked_attach_pin: false, passphrase_enabled: true },
+        });
       }
       if (request === 'DeviceSessionGet') {
         return Promise.resolve({
@@ -1497,7 +1940,7 @@ describe('Protocol V2 feature adapter', () => {
     ]);
   });
 
-  test('uses the Pro2 standard wallet without passphraseState when passphrase is disabled', async () => {
+  test('returns the Pro2 standard-wallet passphraseState when passphrase is disabled', async () => {
     const features = {
       deviceId: 'pro2-device-id',
       deviceType: 'pro2',
@@ -1505,7 +1948,15 @@ describe('Protocol V2 feature adapter', () => {
       passphraseProtection: false,
       unlocked: true,
     };
-    const typedCall = createWalletSessionTypedCall();
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'main-wallet-state',
+          session_id: 'main-wallet-session',
+        },
+      })
+    );
     const updateInternalState = jest.fn();
     const method = new GetPassphraseState({
       payload: {
@@ -1514,7 +1965,7 @@ describe('Protocol V2 feature adapter', () => {
         useEmptyPassphrase: true,
       },
     });
-    method.device = stubDevice({
+    const device = stubDevice({
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features,
       commands: {
@@ -1526,12 +1977,14 @@ describe('Protocol V2 feature adapter', () => {
       getCurrentDeviceId: () => 'pro2-device-id',
       getCurrentPassphraseProtection: () => false,
     }) as any;
+    device.unlockDevice = jest.fn().mockResolvedValue(features);
+    method.device = device;
 
-    await expect(method.run()).resolves.toBeUndefined();
+    await expect(method.run()).resolves.toBe('main-wallet-state');
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(updateInternalState).not.toHaveBeenCalled();
+    expect(updateInternalState).toHaveBeenCalled();
   });
 
   test('honors initSession when getting Pro2 passphrase state', async () => {
@@ -1546,7 +1999,8 @@ describe('Protocol V2 feature adapter', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
+      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
       .mockResolvedValueOnce({
         type: 'DeviceSession',
         message: {
@@ -1666,6 +2120,9 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
     device.passphraseState = 'state-auto';
     expect(device.getInternalState()).toBe('session-auto');
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
+      on_device: true,
+    });
     expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
@@ -1678,7 +2135,8 @@ describe('Protocol V2 feature adapter', () => {
           session_id: 'main-pin-session',
           btc_test_address: 'main-wallet-state',
         },
-      })
+      }),
+      { passphrase_enabled: false }
     );
 
     (device as any).features = normalizeProtocolV2Features(
@@ -1700,8 +2158,8 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       getPassphraseStateWithRefreshDeviceInfo(device, { onlyMainPin: true })
     ).resolves.toMatchObject({
-      passphraseState: undefined,
-      newSession: undefined,
+      passphraseState: 'main-wallet-state',
+      newSession: 'main-pin-session',
     });
 
     expect(device.features?.passphraseProtection).toBe(false);
@@ -1746,6 +2204,8 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       on_device: true,
     });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceStatusGet', 'DeviceStatus', {});
+    expect(typedCall).toHaveBeenNthCalledWith(4, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('useEmptyPassphrase ignores a stale hidden-wallet state during Protocol V2 safety check', async () => {
@@ -1778,7 +2238,7 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.checkPassphraseStateSafety('stale-hidden-state', true, false)
     ).resolves.toBe(true);
-    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledTimes(4);
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
@@ -1836,7 +2296,9 @@ describe('Protocol V2 feature adapter', () => {
   test('uses Protocol V2 features directly when profile is absent', () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = {
-      ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
+      ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
+        hw: { Device_type: DeviceType.PRO2 },
+      }),
       serialNo: 'CACHED-SERIAL',
       label: 'Cached Label',
       bleName: 'Cached BLE',
@@ -1845,6 +2307,7 @@ describe('Protocol V2 feature adapter', () => {
 
     const message = device.toMessageObject();
     expect(message).toMatchObject({
+      connectProtocol: 'V2',
       serialNo: 'CACHED-SERIAL',
       uuid: 'CACHED-SERIAL',
       deviceId: null,
@@ -1916,7 +2379,7 @@ describe('Protocol V2 feature adapter', () => {
       typedCall: jest.fn().mockResolvedValueOnce({
         type: 'DeviceInfo',
         message: {
-          hw: { serial_no: 'PR2SERIAL' },
+          hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
           fw: { application: { version: '1.2.3' } },
         },
       }),
@@ -2097,7 +2560,7 @@ describe('Protocol V2 feature adapter', () => {
       .mockResolvedValueOnce({
         type: 'DeviceInfo',
         message: {
-          hw: { serial_no: 'PR2SERIAL' },
+          hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
           fw: { application: { version: '1.2.3' } },
         },
       })
@@ -2229,7 +2692,7 @@ describe('Protocol V2 feature adapter', () => {
       .mockResolvedValueOnce({
         type: 'DeviceInfo',
         message: {
-          hw: { serial_no: 'PR2SERIAL' },
+          hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
           fw: { application: { version: '1.2.3' } },
         },
       })
@@ -2240,7 +2703,7 @@ describe('Protocol V2 feature adapter', () => {
       .mockResolvedValueOnce({
         type: 'DeviceInfo',
         message: {
-          hw: { serial_no: 'PR2SERIAL' },
+          hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
           fw: { application: { version: '1.2.4' } },
         },
       })
@@ -2343,7 +2806,7 @@ describe('Protocol V2 feature adapter', () => {
       if (requestType === 'DeviceSessionAskPin') {
         return {
           type: 'Success',
-          message: { message: 'ok' },
+          message: { message: 'PIN verified' },
         };
       }
       if (requestType === 'DeviceStatusGet') {
@@ -2365,7 +2828,7 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
       {
-        hw: { serial_no: 'PR2SERIAL' },
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
         fw: { application: { version: '1.2.3' } },
         status: { init_states: true },
       }
@@ -2400,7 +2863,7 @@ describe('Protocol V2 feature adapter', () => {
       if (requestType === 'DeviceSessionAskPin') {
         return {
           type: 'Success',
-          message: { message: 'ok' },
+          message: { message: 'PIN verified' },
         };
       }
       if (requestType === 'DeviceStatusGet') {
@@ -3396,7 +3859,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('accepts a missing firmware status handler as an app reboot signal', async () => {
+  test('accepts a missing firmware status handler only after confirming normal mode', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -3412,7 +3875,9 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => ({ typedCall }),
     });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
-    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
+    (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
     method.postProgressMessage = jest.fn();
 
     await (method as any).waitForProtocolV2FirmwareUpdateComplete([
@@ -3421,6 +3886,70 @@ describe('Protocol V2 firmware update targets', () => {
 
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
     expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceFirmwareUpdateStatusGet']);
+    expect((method as any).probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
+  });
+
+  test.each([
+    [{ mode: 'normal', bootloaderMode: false }, true],
+    [{ mode: 'bootloader', bootloaderMode: true }, false],
+  ])('derives firmware completion from the runtime-state probe: %o', async (features, expected) => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    const probeProtocolV2RuntimeState = jest.fn().mockResolvedValue(features);
+    (method as any).device = stubDevice({ probeProtocolV2RuntimeState });
+
+    await expect((method as any).probeProtocolV2NormalMode(deviceInfo)).resolves.toBe(expected);
+    expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000);
+  });
+
+  test('keeps polling when the firmware status handler is missing in loader mode', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValueOnce(new Error('Failure: Handler not registered for this message'))
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 2 }] },
+      });
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
+    (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(false);
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await (method as any).waitForProtocolV2FirmwareUpdateComplete([
+        { target_id: 4, path: 'vol0:/application_p1.bin' },
+      ]);
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceFirmwareUpdateStatusGet',
+      'DeviceFirmwareUpdateStatusGet',
+    ]);
+    expect((method as any).probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
   });
 
   test('polls target status after update ACK and finishes when all targets complete', async () => {
@@ -3926,6 +4455,62 @@ describe('Protocol V2 firmware update targets', () => {
     getFirmwareLatestReleaseSpy.mockRestore();
   });
 
+  test('ignores an unsupported remote ROMLOADER component when installing selected targets', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        targetsToUpdate: ['app_v1'],
+      },
+    });
+    method.init();
+    const applicationBinary = new Uint8Array([1]).buffer;
+    const downloadRemoteComponent = jest.fn().mockResolvedValue({
+      fileName: 'application_p1.bin',
+      binary: applicationBinary,
+      targetId: 4,
+      kind: 'firmware',
+    });
+    (method as any).downloadRemoteProtocolV2Component = downloadRemoteComponent;
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        installOrder: ['romloader', 'applicationP1'],
+        components: {
+          romloader: {
+            target: 'ROMLOADER',
+            url: 'https://example.com/romloader.bin',
+          },
+          applicationP1: {
+            target: 'APPLICATION_P1',
+            url: 'https://example.com/application-p1.bin',
+          },
+        },
+        fingerprint: '',
+        changelog: { 'zh-CN': '', 'en-US': '' },
+      });
+
+    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '0.0.0',
+    });
+
+    expect(downloadRemoteComponent).toHaveBeenCalledTimes(1);
+    expect(downloadRemoteComponent).toHaveBeenCalledWith(
+      'applicationP1',
+      expect.objectContaining({ target: 'APPLICATION_P1' })
+    );
+    expect(remoteBinaries.fwBinaryMap).toEqual([
+      { fileName: 'application_p1.bin', binary: applicationBinary, targetId: 4 },
+    ]);
+
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
   test('maps remote Pro2 resource bundles to direct-write descriptors', () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4496,8 +5081,14 @@ describe('Protocol V2 firmware update targets', () => {
       return 0 as any;
     }) as typeof setTimeout);
 
+    const initialize = jest.fn().mockResolvedValue(undefined);
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
+      initialize,
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue({
+      hw: { serial_no: 'PRO2-PHYSICAL-1' },
     });
     method.postProgressMessage = jest.fn();
 
@@ -4513,6 +5104,9 @@ describe('Protocol V2 firmware update targets', () => {
     }
 
     expect(writeOffsets).toEqual([0, 4000, 0, 4000, 8000]);
+    expect((method as any).reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+    expect((method as any).verifyProtocolV2ReconnectIdentity).toHaveBeenCalledTimes(1);
+    expect(initialize).toHaveBeenCalledTimes(1);
   });
 
   test('rejects a chunk-relative processed_byte during firmware staging', async () => {
@@ -5213,6 +5807,45 @@ describe('Protocol V2 protected method execution', () => {
     ]);
   });
 
+  test('does not replay a business method when the hidden-wallet session cannot be restored after unlock', async () => {
+    const initialError = deviceLockedError();
+    const restoreError = new Error('Invalid wallet session');
+    const method = {
+      name: 'evmSignMessage',
+      payload: { passphraseState: 'hidden-state' },
+      useDevicePassphraseState: true,
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn().mockRejectedValueOnce(initialError),
+    };
+    const typedCall = jest.fn((requestType: string) => {
+      if (requestType === 'ProtocolInfoRequest') {
+        return Promise.resolve({ message: { version: 2 } });
+      }
+      if (requestType === 'DeviceSessionGet') {
+        return Promise.reject(restoreError);
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const device = {
+      features: { unlocked: true, passphraseProtection: true },
+      passphraseState: 'hidden-state',
+      commands: { typedCall },
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn().mockResolvedValue(undefined),
+      getCurrentPassphraseProtection: () => true,
+      getInternalState: () => 'hidden-session',
+      clearInternalState: jest.fn(),
+      getCurrentDeviceId: () => 'wallet-device-id',
+      updateInternalState: jest.fn(),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).rejects.toBe(restoreError);
+    expect(method.run).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.clearInternalState).toHaveBeenCalledTimes(1);
+    expect(device.updateInternalState).not.toHaveBeenCalled();
+  });
+
   test('restores the expected hidden-wallet session after pre-unlock without selecting Attach PIN', async () => {
     const calls: string[] = [];
     const method = {