@onekeyfe/hd-core 1.2.0-alpha.42 → 1.2.0-alpha.44

package/__tests__/deviceUploadNft.test.ts

@@ -1,3 +1,5 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import DeviceUploadNft from '../src/api/protocol-v2/DeviceUploadNft';
 
 jest.mock('../src/data/config', () => ({
@@ -13,7 +15,7 @@ const createRgba = (width: number, height: number) => {
 
 const createMethod = ({
   typedCall,
-  supportedMessages = [60805, 61500],
+  supportedMessages = [60805, 60808, 61500],
   useFullBundle = false,
 }: {
   typedCall: jest.Mock;
@@ -67,9 +69,23 @@ const fileWriteSuccess = (params: { file: { offset: number; data: Uint8Array } }
   },
 });
 
+const nftFileList = (count: number, basenameAt?: number) =>
+  Array.from({ length: count }, (_, index) => {
+    const basename =
+      index === basenameAt
+        ? 'nft-deadbeef-1760000000000'
+        : `nft-${index.toString(16).padStart(8, '0')}-${1760000000001 + index}`;
+    return [`${basename}.bin`, `${basename}_m.bin`, `${basename}.json`];
+  })
+    .flat()
+    .join('\n');
+
 describe('DeviceUploadNft', () => {
   test('uploads the triplet in order without creating the firmware-owned directory', async () => {
     const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
       if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
       if (request === 'NftUpdate') return { message: { message: 'NFT updated' } };
       throw new Error(`Unexpected request: ${request}`);
@@ -79,7 +95,14 @@ describe('DeviceUploadNft', () => {
     const result = await method.run();
 
     const requests = typedCall.mock.calls.map(call => call[0]);
-    expect(requests[0]).toBe('FilesystemFileWrite');
+    expect(requests[0]).toBe('FilesystemDirList');
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'FilesystemDirList',
+      'FilesystemDir',
+      { path: 'vol1:/nft', depth: 1 },
+      { timeoutMs: 15_000 }
+    );
     expect(requests).not.toContain('FilesystemDirMake');
     expect(requests.at(-1)).toBe('NftUpdate');
     const fileWrites = typedCall.mock.calls.filter(call => call[0] === 'FilesystemFileWrite');
@@ -122,6 +145,9 @@ describe('DeviceUploadNft', () => {
     });
     let updateCalls = 0;
     const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
       if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
       if (request === 'NftUpdate') {
         updateCalls += 1;
@@ -141,6 +167,9 @@ describe('DeviceUploadNft', () => {
 
   test('does not retry a non-timeout NftUpdate failure', async () => {
     const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
       if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
       if (request === 'NftUpdate') throw new Error('Invalid NFT metadata');
       throw new Error(`Unexpected request: ${request}`);
@@ -156,6 +185,9 @@ describe('DeviceUploadNft', () => {
       code: 'response-timeout',
     });
     const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
       if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
       if (request === 'NftUpdate') throw timeout;
       throw new Error(`Unexpected request: ${request}`);
@@ -168,6 +200,9 @@ describe('DeviceUploadNft', () => {
 
   test('does not publish when a file write fails', async () => {
     const typedCall = jest.fn((request: string) => {
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
       if (request === 'FilesystemFileWrite') throw new Error('Filesystem full');
       throw new Error(`Unexpected request: ${request}`);
     });
@@ -184,4 +219,54 @@ describe('DeviceUploadNft', () => {
     await expect(method.run()).rejects.toBeDefined();
     expect(typedCall).not.toHaveBeenCalled();
   });
+
+  test('rejects a new NFT before writing when ten complete NFT bundles exist', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: nftFileList(10) } };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.NftStorageLimitReached,
+      params: { count: 10, limit: 10 },
+    });
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['FilesystemDirList']);
+  });
+
+  test('allows an idempotent retry for a basename already counted at the limit', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: nftFileList(10, 0) } };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: {} };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).resolves.toMatchObject({ nftUpdated: true });
+    expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemFileWrite')).toBe(true);
+  });
+
+  test('does not count unrelated or incomplete files as stored NFTs', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemDirList') {
+        return {
+          message: {
+            path: 'vol1:/nft',
+            child_files: `${nftFileList(9)}\nnft-ffffffff-1760000009999.json\nnotes.txt`,
+          },
+        };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: {} };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).resolves.toMatchObject({ nftUpdated: true });
+  });
 });

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

@@ -1,11 +1,14 @@
 import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+import { DeviceSessionPinType, DeviceSessionSeedDomain } from '@onekeyfe/hd-transport';
 
 import GetPassphraseState from '../src/api/GetPassphraseState';
 import OpenWalletSession from '../src/api/OpenWalletSession';
 import { Device } from '../src/device/Device';
 import { deviceWalletSessionStore } from '../src/device/DeviceWalletSessionStore';
-import { ensureProtocolV2WalletSessionUnlocked } from '../src/protocols/protocol-v2/walletSession';
+import {
+  ensureProtocolV2WalletSessionUnlocked,
+  getProtocolV2WalletSession,
+} from '../src/protocols/protocol-v2/walletSession';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -95,6 +98,104 @@ describe('openWalletSession', () => {
     deviceWalletSessionStore.clear();
   });
 
+  test('selects the standard wallet explicitly when passphrase is enabled', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({ typedCall });
+
+    await expect(
+      getProtocolV2WalletSession(device as any, {
+        onlyMainPin: true,
+      })
+    ).resolves.toMatchObject({
+      passphraseState: 'standard-state',
+      newSession: 'standard-session',
+    });
+
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+      passphrase: '',
+      on_device: false,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
+    });
+  });
+
+  test('opens the standard wallet directly when passphrase is disabled', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({ passphraseProtection: false, typedCall });
+
+    await getProtocolV2WalletSession(device as any, { onlyMainPin: true });
+
+    expect(typedCall).not.toHaveBeenCalledWith(
+      'DeviceSessionAskPassphrase',
+      'Success',
+      expect.anything()
+    );
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
+    });
+  });
+
+  test('does not treat an Attach PIN DeviceStatus as the Main wallet', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({ typedCall });
+    device.features.unlockedAttachPin = true;
+
+    await getProtocolV2WalletSession(device as any, { onlyMainPin: true });
+
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'wallet-session-coordinator',
+      reason: 'open-wallet',
+      deviceOnly: true,
+    });
+  });
+
   test('unlocks a locked Protocol V2 device before restoring a wallet session', async () => {
     const device = {
       commands: {
@@ -190,7 +291,9 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
+    });
   });
 
   test('keeps Legacy Protocol V1 getPassphraseState parameterless', async () => {
@@ -308,7 +411,9 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
+    });
   });
 
   test('refreshes Pro2 status and unlocks before selecting a hidden wallet when locked', async () => {
@@ -573,7 +678,9 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
+    });
     expect(promptPassphrase).toHaveBeenCalled();
     expect(deviceWalletSessionStore.get('device-1', 'new-hidden-state')).toBe('new-hidden-session');
   });
@@ -644,6 +751,8 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
+      btc_test_address: 'hidden-state',
+      seed_domains: [],
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -795,6 +904,7 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'main-wallet-state',
@@ -817,16 +927,18 @@ describe('openWalletSession', () => {
       passphraseState: null,
       resumed: false,
     });
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(3);
     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).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+      passphrase: '',
+      on_device: false,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
   });
@@ -835,6 +947,7 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'main-wallet-state',
@@ -886,6 +999,7 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'main-wallet-state',
@@ -931,7 +1045,9 @@ describe('openWalletSession', () => {
       reason: 'open-wallet',
       deviceOnly: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
+    });
   });
 
   test('selects a hidden wallet without exposing the internal device session', async () => {
@@ -965,7 +1081,9 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
+    });
     expect(promptPassphrase).toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
@@ -994,7 +1112,9 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
+    });
   });
 
   test('selects an on-device passphrase wallet with an explicit on_device request', async () => {
@@ -1019,7 +1139,9 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       on_device: true,
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
+    });
   });
 
   test('forwards a host passphrase to Pro2 firmware', async () => {
@@ -1061,7 +1183,9 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
+    });
   });
 
   test('normalizes a Unicode Host passphrase before sending it to Pro2 firmware', async () => {
@@ -1141,7 +1265,9 @@ describe('openWalletSession', () => {
     expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin, {
       emitUiEvent: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [],
+    });
   });
 
   test('uses the complete Attach PIN wire flow without a main PIN unlock', async () => {
@@ -1170,7 +1296,7 @@ describe('openWalletSession', () => {
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
       ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.AttachToPin }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
-      ['DeviceSessionGet', 'DeviceSession', {}],
+      ['DeviceSessionGet', 'DeviceSession', { seed_domains: [] }],
     ]);
     expect(device.commands.typedCall).not.toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
       type: DeviceSessionPinType.Main,
@@ -1227,7 +1353,7 @@ describe('openWalletSession', () => {
 
       await expect(method.run()).rejects.toThrow(message);
       expect(typedCall).toHaveBeenCalledTimes(2);
-      expect(typedCall).not.toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+      expect(typedCall.mock.calls.some(([name]) => name === 'DeviceSessionGet')).toBe(false);
     }
   );
 
@@ -1381,6 +1507,8 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
+      btc_test_address: 'hidden-state',
+      seed_domains: [],
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -1439,6 +1567,8 @@ describe('openWalletSession', () => {
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
+      btc_test_address: 'hidden-state',
+      seed_domains: [],
     });
     const sessionGetCall = typedCall.mock.calls.findIndex(
       ([requestName]) => requestName === 'DeviceSessionGet'
@@ -1535,6 +1665,8 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'expired-session',
+      btc_test_address: 'hidden-state',
+      seed_domains: [],
     });
     expect(promptPassphrase).toHaveBeenCalledTimes(1);
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
@@ -1570,7 +1702,10 @@ describe('openWalletSession', () => {
       passphraseState: 'hidden-state',
       resumed: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      btc_test_address: 'hidden-state',
+      seed_domains: [],
+    });
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('new-session');
   });
@@ -1604,6 +1739,11 @@ describe('openWalletSession', () => {
       walletType: 'hidden',
       passphraseState: 'hidden-state',
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      seed_domains: [
+        DeviceSessionSeedDomain.SeedDomain_Standard,
+        ...(deriveCardano ? [DeviceSessionSeedDomain.SeedDomain_Cardano] : []),
+      ],
+    });
   });
 });

package/__tests__/protocol-v2-ui-lifecycle.test.ts

@@ -9,6 +9,41 @@ jest.mock('../src/data/config', () => ({
 }));
 
 describe('Protocol V2 UI interaction lifecycle', () => {
+  test('synthesizes finish metadata for a progress-only operation', () => {
+    const device = new Device({ id: 'connect-progress' } as any);
+    device.isProtocolV2 = jest.fn(() => true);
+    device.beginProtocolV2UiInteraction();
+
+    const metadata = device.finishProtocolV2UiInteraction('succeeded', {
+      ensureMetadata: true,
+    });
+
+    expect(metadata).toMatchObject({
+      phase: 'processing',
+      transition: 'finish',
+      outcome: 'succeeded',
+      protocol: 'V2',
+    });
+  });
+
+  test('keeps finish metadata after the Protocol V2 transport is released', () => {
+    const device = new Device({ id: 'connect-released' } as any);
+    const isProtocolV2 = jest.fn().mockReturnValueOnce(true).mockReturnValue(false);
+    device.isProtocolV2 = isProtocolV2;
+    device.beginProtocolV2UiInteraction();
+
+    const metadata = device.finishProtocolV2UiInteraction('succeeded', {
+      ensureMetadata: true,
+    });
+
+    expect(metadata).toMatchObject({
+      phase: 'processing',
+      transition: 'finish',
+      outcome: 'succeeded',
+      protocol: 'V2',
+    });
+  });
+
   test('emits a matching PIN phase completion after DeviceSessionAskPin succeeds', async () => {
     const device = new Device({ id: 'connect-1' } as any);
     device.isProtocolV2 = jest.fn(() => true);

package/__tests__/protocol-v2-unlock-policy.test.ts

@@ -61,6 +61,116 @@ describe('Protocol V2 unlock semantics', () => {
     expect(method.run).toHaveBeenCalledTimes(1);
   });
 
+  test('lets the standard wallet session own the Main PIN unlock', async () => {
+    const calls: string[] = [];
+    const features = {
+      unlocked: false,
+      passphraseProtection: true,
+    };
+    const method = {
+      name: 'btcGetPublicKey',
+      unlockPolicy: 'none',
+      useDevicePassphraseState: true,
+      payload: { useEmptyPassphrase: true },
+      run: jest.fn().mockImplementation(() => {
+        calls.push('run');
+        return Promise.resolve({ message: 'ok' });
+      }),
+    };
+    const device = {
+      features,
+      commands: {
+        typedCall: jest.fn().mockImplementation(() => {
+          calls.push('status');
+          return Promise.resolve({
+            message: {
+              unlocked: false,
+              passphraseProtection: true,
+            },
+          });
+        }),
+      },
+      isProtocolV2: () => true,
+      isBootloader: () => false,
+      isRomloader: () => false,
+      updateProtocolV2Status: jest.fn(() => features),
+      unlockDevice: jest.fn().mockImplementation(() => {
+        calls.push('wallet-session-unlock');
+        features.unlocked = true;
+        return Promise.resolve(features);
+      }),
+    };
+
+    await expect(
+      runMethodWithUnlockPolicy(method as any, device as any, {
+        prepare: async () => {
+          await device.unlockDevice();
+        },
+      })
+    ).resolves.toEqual({ message: 'ok' });
+
+    expect(calls).toEqual(['status', 'wallet-session-unlock', 'run']);
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+  });
+
+  test('reuses a Main PIN selected by pre-unlock when locked status hides passphrase state', async () => {
+    const calls: string[] = [];
+    const features: {
+      unlocked: boolean;
+      passphraseProtection?: boolean;
+      unlockedAttachPin?: boolean;
+    } = {
+      unlocked: false,
+    };
+    const method: any = {
+      name: 'btcGetPublicKey',
+      unlockPolicy: 'none',
+      useDevicePassphraseState: true,
+      payload: { useEmptyPassphrase: true },
+      run: jest.fn().mockImplementation(() => {
+        calls.push('run');
+        return Promise.resolve({ message: 'ok' });
+      }),
+    };
+    const device = {
+      features,
+      commands: {
+        typedCall: jest.fn().mockImplementation(() => {
+          calls.push('status');
+          return Promise.resolve({
+            message: {
+              unlocked: false,
+            },
+          });
+        }),
+      },
+      isProtocolV2: () => true,
+      isBootloader: () => false,
+      isRomloader: () => false,
+      updateProtocolV2Status: jest.fn(() => features),
+      unlockDevice: jest.fn().mockImplementation(() => {
+        calls.push('main-pin');
+        features.unlocked = true;
+        features.passphraseProtection = true;
+        features.unlockedAttachPin = false;
+        return Promise.resolve(features);
+      }),
+    };
+
+    await expect(
+      runMethodWithUnlockPolicy(method, device as any, {
+        prepare: async () => {
+          if (!(features.unlocked && features.unlockedAttachPin === false)) {
+            await device.unlockDevice();
+          }
+        },
+      })
+    ).resolves.toEqual({ message: 'ok' });
+
+    expect(calls).toEqual(['status', 'main-pin', 'run']);
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+  });
+
   test('runs fresh-status validation before starting unlock', async () => {
     const identityError = new Error('Unexpected device');
     const method = {