@onekeyfe/hd-core 1.2.0-alpha.24 → 1.2.0-alpha.26

package/__tests__/protocol-v2.test.ts

@@ -1,4 +1,4 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceRebootType, DeviceSessionPinType, DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import * as firmwareBinaryApi from '../src/api/firmware/getBinary';
@@ -50,7 +50,7 @@ import TonSignProof from '../src/api/ton/TonSignProof';
 import TronGetAddress from '../src/api/tron/TronGetAddress';
 import StellarGetAddress from '../src/api/stellar/StellarGetAddress';
 import BenfenSignMessage from '../src/api/benfen/BenfenSignMessage';
-import { getBitcoinForkVersionRange } from '../src/api/btc/helpers/versionLimit';
+import { getBitcoinForkSupportedProtocols } from '../src/api/btc/helpers/versionLimit';
 import { DataManager } from '../src/data-manager';
 import { createCoreApi } from '../src/inject';
 import { Device, preloadSessionCache } from '../src/device/Device';
@@ -80,9 +80,9 @@ import {
   getFirmwareUpdateField,
   getFirmwareUpdateFieldArray,
   getMethodVersionRange,
-  isMethodVersionRangeUnsupported,
 } from '../src/utils';
 import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
+import { openFirmwareByteSource } from '../src/api/firmware/FirmwareArtifactSource';
 import {
   getPassphraseState,
   getPassphraseStateWithRefreshDeviceInfo,
@@ -129,7 +129,7 @@ describe('DeviceUploadWallpaper', () => {
     method.init();
     const result = await method.run();
 
-    expect(method.requireProtocolV2).toBe(true);
+    expect(method.getSupportedProtocols()).toEqual(['V2']);
     expect(method.unlockPolicy).toBe('unlock-before-run');
     expect(typedCall).toHaveBeenNthCalledWith(1, 'FilesystemDirMake', 'Success', {
       path: 'vol1:/wallpapers',
@@ -200,6 +200,42 @@ describe('DeviceUploadWallpaper', () => {
 });
 
 describe('UploadPortfolio', () => {
+  test('writes and applies the portfolio while the device is locked without unlocking', async () => {
+    const packageBytes = new Uint8Array([1, 2, 3]);
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { processed_byte: 3 } })
+      .mockResolvedValueOnce({ message: { message: 'Portfolio updated' } });
+    const unlockDevice = jest.fn().mockResolvedValue(undefined);
+    const device = stubDevice({
+      features: { unlocked: false },
+      commands: { typedCall },
+      isProtocolV2: () => true,
+      unlockDevice,
+    });
+    const method = new UploadPortfolio({
+      id: 1,
+      payload: {
+        method: 'uploadPortfolio',
+        packageBytes,
+      },
+    });
+    (method as any).device = device;
+
+    method.init();
+    await runMethodWithUnlockRetry(method, device as any);
+
+    expect(unlockDevice).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'FilesystemFileWrite',
+      'FilesystemFile',
+      expect.any(Object),
+      { timeoutMs: undefined }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'PortfolioUpdate', 'Success', {});
+  });
+
   test('stages the complete package before applying PortfolioUpdate', async () => {
     const packageBytes = new Uint8Array([1, 2, 3]);
     const typedCall = jest
@@ -219,7 +255,7 @@ describe('UploadPortfolio', () => {
     method.init();
     const result = await method.run();
 
-    expect(method.unlockPolicy).toBe('unlock-before-run');
+    expect(method.unlockPolicy).toBe('none');
     expect(method.protocolV2UiMode).toBe('none');
     expect(method.protocolV2UiInteraction).toBeUndefined();
     expect(method.payload.emitProgress).toBe(false);
@@ -971,7 +1007,7 @@ describe('Protocol V2 feature adapter', () => {
       wallet_initialized: false,
     });
     expect(typedCall).toHaveBeenCalledWith('DevGetOnboardingStatus', 'DevOnboardingStatus', {});
-    expect(method.requireProtocolV2).toBe(true);
+    expect(method.getSupportedProtocols()).toEqual(['V2']);
   });
 
   test('routes onboarding without exposing the raw session command through CoreApi', async () => {
@@ -1957,13 +1993,6 @@ describe('Protocol V2 feature adapter', () => {
   });
 
   test('marks known unsupported public-chain methods as unsupported on Protocol V2', () => {
-    const features = normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
-      fw: {
-        application: {
-          version: '9.9.9',
-        },
-      },
-    });
     const stellar = new StellarGetAddress({
       id: 1,
       payload: {
@@ -1992,21 +2021,10 @@ describe('Protocol V2 feature adapter', () => {
     benfen.init();
     lnurlAuth.init();
 
-    const stellarRange = getMethodVersionRange(features, type => stellar.getVersionRange()[type]);
-    const benfenRange = getMethodVersionRange(features, type => benfen.getVersionRange()[type]);
-    const lnurlAuthRange = getMethodVersionRange(
-      features,
-      type => lnurlAuth.getVersionRange()[type]
-    );
-    const neuraiRange = getMethodVersionRange(
-      features,
-      type => getBitcoinForkVersionRange(['Neurai'])[type]
-    );
-
-    expect(isMethodVersionRangeUnsupported(stellarRange)).toBe(true);
-    expect(isMethodVersionRangeUnsupported(benfenRange)).toBe(true);
-    expect(isMethodVersionRangeUnsupported(lnurlAuthRange)).toBe(true);
-    expect(isMethodVersionRangeUnsupported(neuraiRange)).toBe(true);
+    expect(stellar.supportsProtocol('V2')).toBe(false);
+    expect(benfen.supportsProtocol('V2')).toBe(false);
+    expect(lnurlAuth.supportsProtocol('V2')).toBe(false);
+    expect(getBitcoinForkSupportedProtocols(['Neurai'])).toEqual(['V1']);
   });
 
   test('does not block batch public key support checks on Protocol V2', async () => {
@@ -2045,7 +2063,7 @@ describe('Protocol V2 feature adapter', () => {
     });
   });
 
-  test('rejects legacy getOnekeyFeatures for Protocol V2 devices', async () => {
+  test('declares legacy getOnekeyFeatures unsupported on Protocol V2', () => {
     const method = new GetOnekeyFeatures({
       id: 1,
       payload: {
@@ -2059,9 +2077,9 @@ describe('Protocol V2 feature adapter', () => {
       commands: { typedCall },
     });
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: expect.any(Number),
-    });
+    expect(() => method.assertProtocolSupported('V2', EFirmwareType.Universal)).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotSupportMethod })
+    );
     expect(typedCall).not.toHaveBeenCalled();
   });
 
@@ -2594,16 +2612,8 @@ describe('API compatibility handling', () => {
 
     polkadotGetAddressMethod.init();
 
-    expect(
-      isMethodVersionRangeUnsupported(
-        getMethodVersionRange(features, type => tronMethod.getVersionRange()[type])
-      )
-    ).toBe(false);
-    expect(
-      isMethodVersionRangeUnsupported(
-        getMethodVersionRange(features, type => solMethod.getVersionRange()[type])
-      )
-    ).toBe(false);
+    expect(tronMethod.supportsProtocol('V2')).toBe(true);
+    expect(solMethod.supportsProtocol('V2')).toBe(true);
     expect(
       getMethodVersionRange(features, type => tonGetAddressMethod.getVersionRange()[type])
     ).toEqual({
@@ -2759,7 +2769,7 @@ describe('API compatibility handling', () => {
     expect(params.data_initial_chunk).toHaveLength(2048);
   });
 
-  test('returns a typed unsupported error for Dynex signing on Protocol V2', async () => {
+  test('declares Dynex signing unsupported on Protocol V2', () => {
     const method = new DnxSignTransaction({
       id: 1,
       payload: {
@@ -2781,17 +2791,14 @@ describe('API compatibility handling', () => {
     });
 
     method.init();
-    (method as any).device = stubDevice({
-      originalDescriptor: { protocolType: 'V2' },
-      features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-    });
-
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
-    });
+    expect(() => method.assertProtocolSupported('V2', EFirmwareType.Universal)).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.DeviceNotSupportMethod,
+      })
+    );
   });
 
-  test('returns a typed unsupported error for Dynex address on Protocol V2', async () => {
+  test('declares Dynex address unsupported on Protocol V2', () => {
     const method = new DnxGetAddress({
       id: 1,
       payload: {
@@ -2802,14 +2809,11 @@ describe('API compatibility handling', () => {
     });
 
     method.init();
-    (method as any).device = stubDevice({
-      originalDescriptor: { protocolType: 'V2' },
-      features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-    });
-
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
-    });
+    expect(() => method.assertProtocolSupported('V2', EFirmwareType.Universal)).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.DeviceNotSupportMethod,
+      })
+    );
   });
 });
 
@@ -2848,18 +2852,16 @@ describe('Protocol V2 firmware update targets', () => {
     return header;
   };
 
-  test('keeps Protocol V2 firmware updates off the firmwareUpdateV3 path', async () => {
+  test('keeps Protocol V2 firmware updates off the firmwareUpdateV3 path', () => {
     const method = new FirmwareUpdateV3({
       id: 1,
       payload: {
         method: 'firmwareUpdateV3',
       },
     });
-    (method as any).device = stubDevice({
-      originalDescriptor: { protocolType: 'V2' },
-    });
-
-    await expect(method.run()).rejects.toThrow('firmwareUpdateV4');
+    expect(() => method.assertProtocolSupported('V2', EFirmwareType.Universal)).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotSupportMethod })
+    );
   });
 
   test('uses Protocol V2 features after BLE final reconnect without V1 Initialize', async () => {
@@ -2946,7 +2948,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('enters Protocol V2 bootloader before upload', async () => {
+  test('delegates Protocol V2 mode transition to the phase executor', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -2981,7 +2983,7 @@ describe('Protocol V2 firmware update targets', () => {
 
     await method.run();
 
-    expect((method as any).enterProtocolV2BootloaderMode).toHaveBeenCalledTimes(1);
+    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
     expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
       fwBinaryMap: [
         {
@@ -3300,9 +3302,9 @@ describe('Protocol V2 firmware update targets', () => {
     const typedCall = jest
       .fn()
       .mockRejectedValue(
-        new DOMException(
-          "Failed to execute 'open' on 'USBDevice': The device was disconnected",
-          'NotFoundError'
+        Object.assign(
+          new Error("Failed to execute 'open' on 'USBDevice': The device was disconnected"),
+          { name: 'NotFoundError' }
         )
       );
 
@@ -3390,7 +3392,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('does not treat a missing firmware status handler as install completion', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -3409,12 +3411,88 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
     method.postProgressMessage = jest.fn();
 
-    await (method as any).waitForProtocolV2FirmwareUpdateComplete([
-      { target_id: 4, path: 'vol0:/application_p1.bin' },
-    ]);
+    await expect(
+      (method as any).waitForProtocolV2FirmwareUpdateComplete([
+        { target_id: 4, path: 'vol0:/application_p1.bin' },
+      ])
+    ).rejects.toThrow('Protocol V2 firmware install status is unavailable');
 
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceFirmwareUpdateStatusGet']);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceFirmwareUpdateStatusGet',
+      'DeviceInfoGet',
+    ]);
+  });
+
+  test('rejects a finished target whose payload version conflicts with the plan', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'desktop',
+        expectedTargetVersions: {
+          app_v1: '2.0.0',
+        },
+      },
+    });
+    method.init();
+    method.postProgressMessage = jest.fn();
+
+    expect(() =>
+      (method as any).assertProtocolV2TargetStatus(
+        [{ target_id: 4, status: 2, payload_version: 0x010000 }],
+        new Set([4])
+      )
+    ).toThrow('expected 131072');
+  });
+
+  test('does not fail a completed multi-app install when final app versions are unobservable', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'desktop',
+        targetsToUpdate: ['app_v1', 'app_v2'],
+        expectedTargetVersions: {
+          app_v1: '1.0.0',
+          app_v2: '2.0.0',
+        },
+      },
+    });
+    method.init();
+    (method as any).protocolV2LatestFinalFeatures = {
+      major_version: 3,
+      minor_version: 0,
+      patch_version: 0,
+    };
+    (method as any).protocolV2FinalStatusVerified = true;
+
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
+  });
+
+  test('rejects unobservable final versions after the status endpoint fallback', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'desktop',
+        targetsToUpdate: ['app_v1', 'app_v2'],
+        expectedTargetVersions: {
+          app_v1: '1.0.0',
+          app_v2: '2.0.0',
+        },
+      },
+    });
+    method.init();
+    (method as any).protocolV2LatestFinalFeatures = {
+      major_version: 3,
+      minor_version: 0,
+      patch_version: 0,
+    };
+
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).toThrow(
+      'has no observable final version after status fallback'
+    );
   });
 
   test('polls target status after update ACK and finishes when all targets complete', async () => {
@@ -3593,10 +3671,14 @@ describe('Protocol V2 firmware update targets', () => {
     const writtenPaths: string[] = [];
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockImplementation(params => {
+    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockImplementation(params => {
       writtenPaths.push(params.filePath);
-      return Number(params.processedSize ?? 0) + Number(params.payload.byteLength);
+      return Number(params.processedSize ?? 0) + Number(params.source.size);
     });
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({});
+    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
@@ -3636,10 +3718,12 @@ describe('Protocol V2 firmware update targets', () => {
       'vol0:/coprocessor.bin',
       1
     );
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(1);
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(2);
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenNthCalledWith(1, {
+      targets: [{ target_id: 3, path: 'vol0:/bootloader.bin' }],
+    });
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenNthCalledWith(2, {
       targets: [
-        { target_id: 3, path: 'vol0:/bootloader.bin' },
         { target_id: 6, path: 'vol0:/coprocessor.bin' },
         { target_id: 7, path: 'vol0:/se01.bin' },
         { target_id: 4, path: 'vol0:/application_p1.bin' },
@@ -3649,7 +3733,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect((method as any).waitForProtocolV2FirmwareUpdateComplete).toHaveBeenCalled();
   });
 
-  test('announces one transfer when syncing resource bundles and staging firmware', async () => {
+  test('announces separate resource and component transfer phases', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -3659,11 +3743,14 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest
+    (method as any).protocolV2SourceUpdateProcess = jest
       .fn()
       .mockImplementation(params =>
-        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.payload.byteLength))
+        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.source.size))
       );
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
@@ -3683,21 +3770,22 @@ describe('Protocol V2 firmware update targets', () => {
         {
           fileName: 'application_p1.bin',
           binary: new Uint8Array([3]).buffer,
-          targetId: 3,
+          targetId: 4,
         },
       ],
     });
 
-    expect(method.postTipMessage).toHaveBeenCalledTimes(2);
+    expect(method.postTipMessage).toHaveBeenCalledTimes(3);
     expect(method.postTipMessage).toHaveBeenNthCalledWith(1, 'StartTransferData');
-    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'ConfirmOnDevice');
-    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenNthCalledWith(
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'StartTransferData');
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(3, 'ConfirmOnDevice');
+    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenNthCalledWith(
       1,
-      expect.objectContaining({ processedSize: 0, totalSize: 3 })
+      expect.objectContaining({ processedSize: 0, totalSize: 2 })
     );
-    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenNthCalledWith(
+    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenNthCalledWith(
       2,
-      expect.objectContaining({ processedSize: 2, totalSize: 3 })
+      expect.objectContaining({ processedSize: 0, totalSize: 1 })
     );
   });
 
@@ -3711,7 +3799,8 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
     (method as any).device = stubDevice({
       getCommands: () => ({
         typedCall: jest.fn().mockResolvedValue({
@@ -3757,11 +3846,14 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest
+    (method as any).protocolV2SourceUpdateProcess = jest
       .fn()
       .mockImplementation(params =>
-        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.payload.byteLength))
+        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.source.size))
       );
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
@@ -4028,6 +4120,58 @@ describe('Protocol V2 firmware update targets', () => {
     getFirmwareLatestReleaseSpy.mockRestore();
   });
 
+  test('rejects prepared RESC bundle paths before opening an artifact source', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const openPreparedSource = jest.fn();
+    (method as any).params = {
+      targetsToUpdate: ['resource'],
+      resourceBundleArtifacts: [
+        {
+          name: 'images',
+          artifact: {
+            artifactRef: `fw:${'a'.repeat(64)}`,
+            size: 1,
+            sha256: 'a'.repeat(64),
+          },
+        },
+      ],
+    };
+    (method as any).openProtocolV2PreparedSource = openPreparedSource;
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        resourceBundles: [
+          {
+            name: 'images',
+            url: 'https://example.com/images.okpkg',
+            devicePath: 'vol0:/resource/../images.okpkg',
+          },
+        ],
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
+
+    await expect(
+      (method as any).prepareProtocolV2ResourceSources('universal', {
+        deviceType: 'pro2',
+      })
+    ).rejects.toThrow('resourceBundles[].devicePath');
+    expect(openPreparedSource).not.toHaveBeenCalled();
+
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
   test('downloads and validates remote RESC bundles before entering bootloader', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4080,7 +4224,9 @@ describe('Protocol V2 firmware update targets', () => {
       order.push('bootloader');
       return Promise.resolve(true);
     });
-    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
+    const executeProtocolV2UpdateSpy = jest.spyOn(method as any, 'executeProtocolV2Update');
+    (method as any).executeProtocolV2TransferPhase = jest.fn().mockResolvedValue(undefined);
+    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue(undefined);
     (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
       bootloaderVersion: '1.0.0',
@@ -4092,7 +4238,7 @@ describe('Protocol V2 firmware update targets', () => {
     await method.run();
 
     expect(order).toEqual(['download', 'bootloader']);
-    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
+    expect(executeProtocolV2UpdateSpy).toHaveBeenCalledWith({
       bootloaderBinary: null,
       fwBinaryMap: [],
       resourceBundles: [
@@ -4105,6 +4251,7 @@ describe('Protocol V2 firmware update targets', () => {
       ],
     });
 
+    executeProtocolV2UpdateSpy.mockRestore();
     getSysResourceBinarySpy.mockRestore();
     getFirmwareLatestReleaseSpy.mockRestore();
   });
@@ -4393,7 +4540,10 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
+    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
+    (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn();
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest.fn();
 
@@ -4409,7 +4559,7 @@ describe('Protocol V2 firmware update targets', () => {
       fwBinaryMap: [],
     });
 
-    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenCalledTimes(1);
     expect((method as any).protocolV2StartFirmwareUpdate).not.toHaveBeenCalled();
     expect((method as any).waitForProtocolV2FirmwareUpdateComplete).not.toHaveBeenCalled();
   });
@@ -4440,12 +4590,19 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postProgressMessage = jest.fn();
 
-    await (method as any).protocolV2CommonUpdateProcess({
-      payload: new Uint8Array(4097).buffer,
-      filePath: 'vol1:firmware.bin',
-      processedSize: 0,
-      totalSize: 4097,
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(4097).buffer,
     });
+    try {
+      await (method as any).protocolV2SourceUpdateProcess({
+        source,
+        filePath: 'vol1:firmware.bin',
+        processedSize: 0,
+        totalSize: 4097,
+      });
+    } finally {
+      await source?.close();
+    }
 
     const writePayloads = typedCall.mock.calls.map(call => call[2]);
     expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 4000]);
@@ -4496,12 +4653,16 @@ describe('Protocol V2 firmware update targets', () => {
     method.postProgressMessage = jest.fn();
 
     try {
-      await (method as any).protocolV2CommonUpdateProcess({
-        payload: new Uint8Array(8001).buffer,
+      const source = await openFirmwareByteSource({
+        binary: new Uint8Array(8001).buffer,
+      });
+      await (method as any).protocolV2SourceUpdateProcess({
+        source,
         filePath: 'vol0:/firmware.bin',
         processedSize: 0,
         totalSize: 8001,
       });
+      await source?.close();
     } finally {
       setTimeoutSpy.mockRestore();
     }
@@ -4533,16 +4694,21 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postProgressMessage = jest.fn();
     method.postTipMessage = jest.fn();
+    (method as any).recoverProtocolV2FileTransfer = jest.fn().mockResolvedValue(undefined);
 
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(4097).buffer,
+    });
     await expect(
-      (method as any).protocolV2WriteWholeFile({
-        payload: new Uint8Array(4097).buffer,
+      (method as any).protocolV2SourceUpdateProcess({
+        source,
         filePath: 'vol0:/firmware.bin',
         processedSize: 0,
         totalSize: 4097,
       })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.EmmcFileWriteFirmwareError });
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    await source?.close();
+    expect(typedCall).toHaveBeenCalledTimes(6);
   });
 
   test('caps native BLE firmware upload chunks below the WebUSB limit', async () => {
@@ -4575,12 +4741,19 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postProgressMessage = jest.fn();
 
-    await (method as any).protocolV2CommonUpdateProcess({
-      payload: new Uint8Array(1801).buffer,
-      filePath: 'vol1:ble-firmware.bin',
-      processedSize: 0,
-      totalSize: 1801,
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(1801).buffer,
     });
+    try {
+      await (method as any).protocolV2SourceUpdateProcess({
+        source,
+        filePath: 'vol1:ble-firmware.bin',
+        processedSize: 0,
+        totalSize: 1801,
+      });
+    } finally {
+      await source?.close();
+    }
 
     const writePayloads = typedCall.mock.calls.map(call => call[2]);
     expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 1800]);
@@ -4697,9 +4870,9 @@ describe('Protocol V2 firmware update method', () => {
     const typedCall = jest
       .fn()
       .mockRejectedValue(
-        new DOMException(
-          "Failed to execute 'open' on 'USBDevice': The device was disconnected",
-          'NotFoundError'
+        Object.assign(
+          new Error("Failed to execute 'open' on 'USBDevice': The device was disconnected"),
+          { name: 'NotFoundError' }
         )
       );
 
@@ -4864,6 +5037,21 @@ describe('Protocol V2 firmware update method', () => {
 });
 
 describe('Protocol V2 firmware reconnect identity', () => {
+  test('keeps the host plan identity as the V4 reconnect anchor', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'native',
+        expectedDeviceId: 'persisted-device-id',
+      },
+    });
+
+    method.init();
+
+    expect((method as any).params.expectedDeviceId).toBe('persisted-device-id');
+  });
+
   test('rejects a different physical serial before firmware transfer resumes', () => {
     expect(() => assertProtocolV2ReconnectIdentity('expected-serial', 'other-serial')).toThrow(
       'identity mismatch'
@@ -5207,6 +5395,93 @@ describe('Protocol V2 protected method execution', () => {
     ]);
   });
 
+  test('restores the expected hidden-wallet session after pre-unlock without selecting Attach PIN', async () => {
+    const calls: string[] = [];
+    const method = {
+      name: 'evmSignMessage',
+      payload: { passphraseState: 'hidden-state' },
+      useDevicePassphraseState: true,
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn(() => {
+        calls.push('run');
+        return Promise.resolve({ message: 'ok' });
+      }),
+    };
+    const typedCall = jest.fn((requestType: string, _responseType: string, request: any) => {
+      if (requestType === 'ProtocolInfoRequest') {
+        calls.push('negotiate-session');
+        return Promise.resolve({ message: { version: 2 } });
+      }
+      if (requestType === 'DeviceSessionGet') {
+        calls.push('resume-hidden-session');
+        expect(request).toEqual({ session_id: 'hidden-session' });
+        return Promise.resolve({
+          message: {
+            session_id: 'hidden-session',
+            btc_test_address: 'hidden-state',
+          },
+        });
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const features = {
+      unlocked: false,
+      unlockedAttachPin: true,
+      passphraseProtection: true,
+    };
+    const device = {
+      features,
+      passphraseState: 'hidden-state',
+      commands: { typedCall },
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn(() => {
+        calls.push('unlock-main');
+        features.unlocked = true;
+        features.unlockedAttachPin = false;
+        return Promise.resolve();
+      }),
+      getCurrentPassphraseProtection: () => true,
+      getInternalState: () => 'hidden-session',
+      clearInternalState: jest.fn(),
+      getCurrentDeviceId: () => 'wallet-device-id',
+      updateInternalState: jest.fn(() => calls.push('validate-hidden-session')),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+      message: 'ok',
+    });
+    expect(device.unlockDevice).toHaveBeenCalledWith();
+    expect(calls).toEqual([
+      'unlock-main',
+      'negotiate-session',
+      'resume-hidden-session',
+      'validate-hidden-session',
+      'run',
+    ]);
+  });
+
+  test('does not restore a hidden-wallet session for a standard-wallet pre-unlock', async () => {
+    const method = {
+      name: 'evmGetAddress',
+      payload: { useEmptyPassphrase: true },
+      useDevicePassphraseState: true,
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn().mockResolvedValue({ address: 'standard-wallet-address' }),
+    };
+    const device = {
+      features: { unlocked: false },
+      passphraseState: 'stale-hidden-state',
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn().mockResolvedValue(undefined),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+      address: 'standard-wallet-address',
+    });
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(method.run).toHaveBeenCalledTimes(1);
+  });
+
   test('unlocks before showing the method interaction when cached status is locked', async () => {
     const calls: string[] = [];
     const method = {
@@ -5292,10 +5567,10 @@ describe('Protocol V2 protected method execution', () => {
     }
   });
 
-  test('keeps auto unlock but suppresses all synthesized UI for eventless methods', async () => {
+  test('runs lock-free eventless methods without unlocking or synthesized UI', async () => {
     const method = {
       name: 'uploadPortfolio',
-      unlockPolicy: 'unlock-before-run',
+      unlockPolicy: 'none',
       protocolV2UiMode: 'none',
       run: jest.fn().mockResolvedValue({ message: 'ok' }),
     };
@@ -5313,17 +5588,17 @@ describe('Protocol V2 protected method execution', () => {
     await expect(
       runMethodWithUnlockRetry(method as any, device as any, uiCoordinator as any)
     ).resolves.toEqual({ message: 'ok' });
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).not.toHaveBeenCalled();
     expect(uiCoordinator.enterMethodInteraction).not.toHaveBeenCalled();
     expect(uiCoordinator.enterUnlockInteraction).not.toHaveBeenCalled();
     expect(uiCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
   });
 
-  test('does not replay a state-changing method after a locked response', async () => {
+  test('does not unlock or replay a lock-free state-changing method after a locked response', async () => {
     const error = deviceLockedError();
     const method = {
       name: 'uploadPortfolio',
-      unlockPolicy: 'unlock-before-run',
+      unlockPolicy: 'none',
       run: jest.fn().mockRejectedValue(error),
     };
     const device = {
@@ -5779,7 +6054,7 @@ describe('Protocol V2 raw device info method', () => {
     );
   });
 
-  test('rejects on Protocol V1 devices instead of sending an unknown message', async () => {
+  test('rejects on Protocol V1 devices instead of sending an unknown message', () => {
     const method = buildMethod();
     const typedCall = jest.fn();
     (method as any).device = stubDevice({
@@ -5787,7 +6062,9 @@ describe('Protocol V2 raw device info method', () => {
       commands: { typedCall },
     });
 
-    await expect(method.run()).rejects.toThrow();
+    expect(() => method.assertProtocolSupported('V1', EFirmwareType.Universal)).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotSupportMethod })
+    );
     expect(typedCall).not.toHaveBeenCalled();
   });
 });