@onekeyfe/hd-core 1.2.0-alpha.22 → 1.2.0-alpha.23

package/__tests__/protocol-v2.test.ts

@@ -1,5 +1,5 @@
 import { EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceRebootType, DeviceSettingsPage } from '@onekeyfe/hd-transport';
+import { DeviceRebootType, DeviceSessionPinType, DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import * as firmwareBinaryApi from '../src/api/firmware/getBinary';
 import DnxGetAddress from '../src/api/dynex/DnxGetAddress';
@@ -898,9 +898,15 @@ describe('Protocol V2 feature adapter', () => {
     });
 
     expect(promptPassphrase).toHaveBeenCalled();
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { host_passphrase: { passphrase: 'hidden secret' } },
-    });
+    expect(typedCall).toHaveBeenCalledWith(
+      'DeviceSessionAskPassphrase',
+      'Success',
+      {},
+      {
+        timeoutMs: 120_000,
+      }
+    );
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('deviceStatusGet returns raw DeviceStatus and updates dynamic features', async () => {
@@ -1004,8 +1010,8 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'session-b',
     });
 
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      resume: { session_id: 'session-a' },
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'session-a',
     });
     expect(device.getInternalState()).toBe('session-b');
   });
@@ -1072,7 +1078,7 @@ describe('Protocol V2 feature adapter', () => {
     });
     expect(typedCall.mock.calls).toEqual([
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
-      ['DeviceSessionOpen', 'DeviceSession', { resume: { session_id: 'session-a' } }],
+      ['DeviceSessionGet', 'DeviceSession', { session_id: 'session-a' }],
     ]);
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.getInternalState()).toBeUndefined();
@@ -1112,11 +1118,7 @@ describe('Protocol V2 feature adapter', () => {
     });
     expect(typedCall.mock.calls).toEqual([
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
-      [
-        'DeviceSessionOpen',
-        'DeviceSession',
-        { select: { host_passphrase: { passphrase: 'new-secret' } } },
-      ],
+      ['DeviceSessionAskPassphrase', 'Success', {}, { timeoutMs: 120_000 }],
     ]);
   });
 
@@ -1155,7 +1157,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
   });
 
-  test('unlocks and retries DeviceSessionOpen when wallet selection is locked', async () => {
+  test('unlocks and retries DeviceSessionAskPassphrase when wallet selection is locked', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-4',
       path: 'cache-path-4',
@@ -1172,6 +1174,7 @@ describe('Protocol V2 feature adapter', () => {
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
       .mockRejectedValueOnce(lockedError)
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
       .mockResolvedValueOnce({
         message: {
           session_id: 'session-after-unlock',
@@ -1189,7 +1192,7 @@ describe('Protocol V2 feature adapter', () => {
       passphraseState: 'state-after-unlock',
     });
     expect(unlockDevice).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledTimes(3);
+    expect(typedCall).toHaveBeenCalledTimes(4);
   });
 
   test('does not request a Pro2 wallet session before features are initialized', async () => {
@@ -1321,24 +1324,29 @@ describe('Protocol V2 feature adapter', () => {
     );
   });
 
-  test('does not expose getPassphraseState on Pro2 devices', async () => {
+  test('maps the legacy getPassphraseState App flow to the Pro2 wallet session protocol', async () => {
     const features = {
-      deviceId: null,
+      deviceId: 'pro2-device-id',
       deviceType: 'pro2',
       firmwareVersion: '4.15.0',
       passphraseProtection: true,
       sessionId: 'feature-session',
       unlockedAttachPin: true,
     };
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        btc_test_address: 'state-pro2',
-        session_id: 'session-pro2',
-      },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { eventless_wallet_session: true } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'state-pro2',
+          session_id: 'session-pro2',
+        },
+      });
     const updateInternalState = jest.fn();
     const getFeatures = jest.fn().mockResolvedValue(features);
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'legacy app secret' });
     const method = new GetPassphraseState({
       payload: {
         method: 'getPassphraseState',
@@ -1350,21 +1358,91 @@ describe('Protocol V2 feature adapter', () => {
       features,
       commands: {
         typedCall,
-        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-pro2-new-secret' }),
+        promptPassphrase,
       },
+      emit: jest.fn(),
       updateInternalState,
       getFeatures,
       getCurrentDeviceType: () => 'pro2',
-      getCurrentDeviceId: () => undefined,
+      getCurrentDeviceId: () => 'pro2-device-id',
       getCurrentPassphraseProtection: () => true,
     }) as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
-    });
+    await expect(method.run()).resolves.toBe('state-pro2');
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      expect.objectContaining({ deviceOnly: true }),
+      expect.anything()
+    );
+    expect(updateInternalState).toHaveBeenCalledWith(
+      true,
+      'state-pro2',
+      'pro2-device-id',
+      'session-pro2',
+      null
+    );
+    expect(JSON.stringify(typedCall.mock.calls)).not.toContain('legacy app secret');
     expect(getFeatures).not.toHaveBeenCalled();
   });
 
+  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) => {
+      if (request === 'ProtocolInfoRequest') {
+        return Promise.resolve({ message: { eventless_wallet_session: true } });
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return Promise.resolve({ message: { message: 'passphrase prepared' } });
+      }
+      if (request === 'DeviceSessionGet') {
+        return Promise.resolve({
+          type: 'DeviceSession',
+          message: {
+            btc_test_address: 'state-pro2-app',
+            session_id: 'session-pro2-app',
+          },
+        });
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: 'pro2-app-device-id',
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    (device as any).commands = {
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+    };
+
+    const method = new GetPassphraseState({
+      payload: {
+        method: 'getPassphraseState',
+        connectId: 'connect-id',
+        initSession: true,
+      },
+    });
+    method.device = device;
+
+    await expect(method.run()).resolves.toBe('state-pro2-app');
+
+    await device.initialize({ passphraseState: 'state-pro2-app' });
+    typedCall.mockClear();
+
+    await expect(device.checkPassphraseStateSafety('state-pro2-app', false, false)).resolves.toBe(
+      true
+    );
+    expect(typedCall.mock.calls).toEqual([
+      ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
+      ['DeviceSessionGet', 'DeviceSession', { session_id: 'session-pro2-app' }],
+    ]);
+  });
+
   test('uses the Pro2 standard wallet without passphraseState when passphrase is disabled', async () => {
     const features = {
       deviceId: 'pro2-device-id',
@@ -1379,6 +1457,7 @@ describe('Protocol V2 feature adapter', () => {
       payload: {
         method: 'getPassphraseState',
         connectId: 'connect-id',
+        useEmptyPassphrase: true,
       },
     });
     method.device = stubDevice({
@@ -1394,10 +1473,10 @@ describe('Protocol V2 feature adapter', () => {
       getCurrentPassphraseProtection: () => false,
     }) as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
+    await expect(method.run()).resolves.toBeUndefined();
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
     });
-    expect(typedCall).not.toHaveBeenCalled();
     expect(updateInternalState).not.toHaveBeenCalled();
   });
 
@@ -1410,12 +1489,17 @@ describe('Protocol V2 feature adapter', () => {
       sessionId: 'old-feature-session',
       unlockedAttachPin: false,
     };
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        btc_test_address: 'state-pro2-new',
-      },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { eventless_wallet_session: true } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'state-pro2-new',
+          session_id: 'session-pro2-new',
+        },
+      });
     const clearInternalState = jest.fn();
     const updateInternalState = jest.fn();
     const method = new GetPassphraseState({
@@ -1428,21 +1512,28 @@ describe('Protocol V2 feature adapter', () => {
     method.device = stubDevice({
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features,
+      passphraseState: 'state-pro2-old',
       commands: {
         typedCall,
         promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-pro2-new-secret' }),
       },
+      emit: jest.fn(),
       clearInternalState,
       updateInternalState,
       getCurrentDeviceId: () => 'pro2-device-id',
       getCurrentPassphraseProtection: () => true,
     }) as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
-    });
-    expect(clearInternalState).not.toHaveBeenCalled();
-    expect(updateInternalState).not.toHaveBeenCalled();
+    await expect(method.run()).resolves.toBe('state-pro2-new');
+    expect(clearInternalState).toHaveBeenCalledTimes(1);
+    expect((method.device as any).passphraseState).toBeUndefined();
+    expect(updateInternalState).toHaveBeenCalledWith(
+      true,
+      'state-pro2-new',
+      'pro2-device-id',
+      'session-pro2-new',
+      null
+    );
   });
 
   test('stores Pro2 passphrase session cache without synthetic device id', async () => {
@@ -1517,9 +1608,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
     device.passphraseState = 'state-auto';
     expect(device.getInternalState()).toBe('session-auto');
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { host_passphrase: { passphrase: 'state-auto-secret' } },
-    });
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('does not mark Pro2 passphrase enabled from a main PIN session alone', async () => {
@@ -1592,9 +1681,15 @@ describe('Protocol V2 feature adapter', () => {
     );
 
     expect(device.getInternalState()).toBeUndefined();
-    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionOpen', 'DeviceSession', {
-      select: { host_passphrase: { passphrase: 'expected-secret' } },
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'DeviceSessionAskPassphrase',
+      'Success',
+      {},
+      {
+        timeoutMs: 120_000,
+      }
+    );
   });
 
   test('useEmptyPassphrase ignores a stale hidden-wallet state during Protocol V2 safety check', async () => {
@@ -1696,7 +1791,7 @@ describe('Protocol V2 feature adapter', () => {
       uuid: 'CACHED-SERIAL',
       deviceId: null,
       bleName: 'Cached BLE',
-      name: 'Cached BLE',
+      name: 'Cached Label',
       label: 'Cached Label',
       deviceType: 'pro2',
     });
@@ -1705,6 +1800,38 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.hasUsePassphrase()).toBe(true);
   });
 
+  test('keeps an empty Protocol V2 label distinct from the BLE name', () => {
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = {
+      ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
+      serialNo: 'PR9999999999',
+      label: null,
+      bleName: 'Pro2 6136',
+    };
+
+    expect(device.toMessageObject()).toMatchObject({
+      serialNo: 'PR9999999999',
+      bleName: 'Pro2 6136',
+      name: 'Pro2 6136',
+      label: '',
+    });
+  });
+
+  test('prefers the real Protocol V2 label over the BLE name for display', () => {
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = {
+      ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
+      label: 'My Pro 2',
+      bleName: 'Pro2 6136',
+    };
+
+    expect(device.toMessageObject()).toMatchObject({
+      bleName: 'Pro2 6136',
+      name: 'My Pro 2',
+      label: 'My Pro 2',
+    });
+  });
+
   test('syncs Protocol V2 cached features without cached profile', () => {
     const cached = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (cached as any).features = {
@@ -2166,7 +2293,7 @@ describe('Protocol V2 feature adapter', () => {
     await expect(method.run()).resolves.toEqual({ address: '0x0', signature: '0x1' });
   });
 
-  test('unlocks Protocol V2 devices via DeviceSessionAskPin regardless of Pro-series version gates', async () => {
+  test('unlocks Protocol V2 devices with the main PIN regardless of Pro-series version gates', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
@@ -2206,7 +2333,12 @@ describe('Protocol V2 feature adapter', () => {
     const features = await device.unlockDevice();
 
     expect(typedCall.mock.calls).toEqual([
-      ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
+      [
+        'DeviceSessionAskPin',
+        'Success',
+        { type: DeviceSessionPinType.Main },
+        { timeoutMs: 120_000 },
+      ],
       ['DeviceStatusGet', 'DeviceStatus', {}],
     ]);
     expect(typedCall).not.toHaveBeenCalledWith('GetAddress', 'Address', expect.anything());
@@ -2254,7 +2386,12 @@ describe('Protocol V2 feature adapter', () => {
     await device.unlockDevice();
 
     expect(typedCall.mock.calls).toEqual([
-      ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
+      [
+        'DeviceSessionAskPin',
+        'Success',
+        { type: DeviceSessionPinType.Main },
+        { timeoutMs: 120_000 },
+      ],
       ['DeviceStatusGet', 'DeviceStatus', {}],
     ]);
     expect((device as any).profile).toBeUndefined();
@@ -2284,10 +2421,15 @@ describe('Protocol V2 feature adapter', () => {
     );
     expect(typedCall).toHaveBeenCalledTimes(1);
     expect(typedCall.mock.calls).toEqual([
-      ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
+      [
+        'DeviceSessionAskPin',
+        'Success',
+        { type: DeviceSessionPinType.Main },
+        { timeoutMs: 120_000 },
+      ],
     ]);
     expect(typedCall).not.toHaveBeenCalledWith(
-      'DeviceSessionOpen',
+      'DeviceSessionGet',
       'DeviceSession',
       expect.anything()
     );
@@ -3298,6 +3440,29 @@ describe('Protocol V2 firmware update targets', () => {
     ).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,
+    };
+
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
+  });
+
   test('polls target status after update ACK and finishes when all targets complete', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -3923,6 +4088,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,
@@ -4803,19 +5020,19 @@ describe('Protocol V2 firmware reconnect identity', () => {
     expect((method as any).params.expectedDeviceId).toBe('persisted-device-id');
   });
 
-  test('requires the same physical serial before firmware transfer resumes', () => {
+  test('rejects a different physical serial before firmware transfer resumes', () => {
     expect(() => assertProtocolV2ReconnectIdentity('expected-serial', 'other-serial')).toThrow(
       'identity mismatch'
     );
-    expect(() => assertProtocolV2ReconnectIdentity('expected-serial', undefined)).toThrow(
-      'identity unavailable'
-    );
     expect(() =>
       assertProtocolV2ReconnectIdentity('expected-serial', 'expected-serial')
     ).not.toThrow();
-    expect(() => assertProtocolV2ReconnectIdentity(undefined, 'actual-serial')).toThrow(
-      'identity unavailable'
-    );
+  });
+
+  test('allows firmware update when the optional physical serial is unavailable', () => {
+    expect(() => assertProtocolV2ReconnectIdentity('expected-serial', undefined)).not.toThrow();
+    expect(() => assertProtocolV2ReconnectIdentity(undefined, 'actual-serial')).not.toThrow();
+    expect(() => assertProtocolV2ReconnectIdentity(undefined, undefined)).not.toThrow();
   });
 
   test('captures physical identity from active DeviceInfo instead of wallet deviceId', async () => {
@@ -5218,22 +5435,27 @@ describe('Protocol V2 protected method execution', () => {
 describe('Protocol V2 current low-level methods', () => {
   test('routes device wipe to the Pro2 reset page until the operation completes', async () => {
     const v1TypedCall = jest.fn().mockResolvedValue({ message: { message: 'wiped' } });
+    const v1InvalidateAfterWipe = jest.fn();
     const v1Method = new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } });
     v1Method.init();
     (v1Method as any).device = stubDevice({
       isProtocolV2: () => false,
       commands: { typedCall: v1TypedCall },
+      invalidateAfterWipe: v1InvalidateAfterWipe,
     });
 
     await v1Method.run();
     expect(v1TypedCall).toHaveBeenCalledWith('WipeDevice', 'Success');
+    expect(v1InvalidateAfterWipe).toHaveBeenCalledTimes(1);
 
     const v2TypedCall = jest.fn().mockResolvedValue({ message: { message: 'accepted' } });
+    const v2InvalidateAfterWipe = jest.fn();
     const v2Method = new DeviceWipe({ id: 2, payload: { method: 'deviceWipe' } });
     v2Method.init();
     (v2Method as any).device = stubDevice({
       isProtocolV2: () => true,
       commands: { typedCall: v2TypedCall },
+      invalidateAfterWipe: v2InvalidateAfterWipe,
     });
 
     await expect(v2Method.run()).resolves.toEqual({ message: 'accepted' });
@@ -5241,6 +5463,7 @@ describe('Protocol V2 current low-level methods', () => {
     expect(v2TypedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
       page: DeviceSettingsPage.DeviceReset,
     });
+    expect(v2InvalidateAfterWipe).toHaveBeenCalledTimes(1);
     expect(v2Method.protocolV2UiInteraction).toEqual({
       request: 'button',
       source: 'method-lifecycle',
@@ -5252,6 +5475,21 @@ describe('Protocol V2 current low-level methods', () => {
     });
   });
 
+  test('keeps the existing identity cache when device wipe fails', async () => {
+    const wipeError = new Error('wipe failed');
+    const invalidateAfterWipe = jest.fn();
+    const method = new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } });
+    method.init();
+    (method as any).device = stubDevice({
+      isProtocolV2: () => true,
+      commands: { typedCall: jest.fn().mockRejectedValue(wipeError) },
+      invalidateAfterWipe,
+    });
+
+    await expect(method.run()).rejects.toBe(wipeError);
+    expect(invalidateAfterWipe).not.toHaveBeenCalled();
+  });
+
   test('routes Change PIN by protocol and waits for the Pro2 operation result', async () => {
     const v1TypedCall = jest.fn().mockResolvedValue({ message: { message: 'ok' } });
     const v1Method = new DeviceChangePin({
@@ -5402,14 +5640,12 @@ describe('Protocol V2 current low-level methods', () => {
   });
 
   test.each([
-    ['label', { label: 'My Pro 2' }],
     ['language', { language: 'ja' }],
     ['brightness', { brightness: 80 }],
     ['haptic feedback', { hapticFeedback: true }],
     [
       'combined lock-free settings',
       {
-        label: 'My Pro 2',
         language: 'ja',
         brightness: 80,
         hapticFeedback: true,
@@ -5427,8 +5663,10 @@ describe('Protocol V2 current low-level methods', () => {
   });
 
   test.each([
+    ['label', { label: 'My Pro 2' }],
     ['auto lock', { autoLockDelayMs: 60_000 }],
     ['auto shutdown', { autoShutdownDelayMs: 120_000 }],
+    ['label mixed with lock-free settings', { label: 'My Pro 2', brightness: 80 }],
     ['mixed protected settings', { brightness: 80, autoLockDelayMs: 60_000 }],
     ['other protected settings', { usbLockEnabled: true }],
   ])('unlocks before changing unified Protocol V2 %s', (_name, settings) => {

package/dist/api/CheckAllFirmwareRelease.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAW1C,OAAO,KAAK,EACV,kBAAkB,EAEnB,MAAM,sCAAsC,CAAC;AAE9C,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,IAAI;IAME,GAAG;CA8DV"}
+{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAW1C,OAAO,KAAK,EACV,kBAAkB,EAEnB,MAAM,sCAAsC,CAAC;AAE9C,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,IAAI;IAME,GAAG;CAqEV"}

package/dist/api/FirmwareUpdateV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdateV2.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAEb,KAAK,aAAa,EAKnB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAqB1C,OAAO,KAAK,EAAE,QAAQ,EAAe,MAAM,UAAU,CAAC;AAEtD,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAE1F,KAAK,MAAM,GAAG;IACZ,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,yBAAyB,CAAC;IACrC,gBAAgB,CAAC,EAAE,yBAAyB,CAAC;IAC7C,eAAe,CAAC,EAAE,KAAK,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,yBAAyB,CAAC;KACrC,CAAC,CAAC;IACH,cAAc,CAAC,EAAE,sBAAsB,CAAC;IACxC,YAAY,CAAC,EAAE,0BAA0B,CAAC;IAC1C,QAAQ,CAAC,EAAE,0BAA0B,CAAC,UAAU,CAAC,CAAC;IAClD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,UAAU,GAAG,KAAK,CAAC;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,YAAY,CAAC,EAAE,aAAa,CAAC;CAC9B,CAAC;AAkFF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,UAAU,CAAC,MAAM,CAAC;IAC9D,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,CAAQ;IAE1C,IAAI;IA6EJ,cAAc,YAAa,MAAM,UAS/B;YAEY,qCAAqC;IAkBnD,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS;YAkFvC,4BAA4B;IAuB1C,qBAAqB;IAUrB,uBAAuB,CAAC,UAAU,EAAE,MAAM;IAc1C,gCAAgC,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAAE,YAAY,EAAE,aAAa;IAwBtF,GAAG;CAsQV"}
+{"version":3,"file":"FirmwareUpdateV2.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAEb,KAAK,aAAa,EAKnB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAsB1C,OAAO,KAAK,EAAE,QAAQ,EAAe,MAAM,UAAU,CAAC;AAEtD,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAE1F,KAAK,MAAM,GAAG;IACZ,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,yBAAyB,CAAC;IACrC,gBAAgB,CAAC,EAAE,yBAAyB,CAAC;IAC7C,eAAe,CAAC,EAAE,KAAK,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,yBAAyB,CAAC;KACrC,CAAC,CAAC;IACH,cAAc,CAAC,EAAE,sBAAsB,CAAC;IACxC,YAAY,CAAC,EAAE,0BAA0B,CAAC;IAC1C,QAAQ,CAAC,EAAE,0BAA0B,CAAC,UAAU,CAAC,CAAC;IAClD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,UAAU,GAAG,KAAK,CAAC;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,YAAY,CAAC,EAAE,aAAa,CAAC;CAC9B,CAAC;AAkFF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,UAAU,CAAC,MAAM,CAAC;IAC9D,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,CAAQ;IAE1C,IAAI;IA6EJ,cAAc,YAAa,MAAM,UAS/B;YAEY,qCAAqC;IAkBnD,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS;YAkFvC,4BAA4B;IAuB1C,qBAAqB;IAUrB,uBAAuB,CAAC,UAAU,EAAE,MAAM;IAc1C,gCAAgC,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAAE,YAAY,EAAE,aAAa;IAwBtF,GAAG;CA4QV"}

package/dist/api/FirmwareUpdateV3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdateV3.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV3.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAW/E,OAAO,KAAK,EAEV,sBAAsB,EACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,QAAQ,EAAiB,MAAM,qBAAqB,CAAC;AAMnE,eAAO,MAAM,gCAAgC,UAAU,CAAC;AAaxD,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,wBAAwB,CAAC,sBAAsB,CAAC;IAC5F,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,CAAQ;IAE1C,OAAO,CAAC,gBAAgB,CAAS;IAEjC,OAAO,CAAC,eAAe,CAA4B;IAEnD,IAAI;IAmFE,GAAG;;;;;YAcK,aAAa;IAuD3B,OAAO,CAAC,wBAAwB;YAiBlB,kBAAkB;YAelB,oBAAoB;IAKlC,OAAO,CAAC,wBAAwB;YAgBlB,oBAAoB;YA2DpB,uBAAuB;YAuBvB,4BAA4B;YA+E5B,aAAa;IAwN3B,OAAO,CAAC,yBAAyB;IAajC,OAAO,CAAC,yBAAyB;IAQjC,OAAO,CAAC,qBAAqB;IAmB7B,OAAO,CAAC,sCAAsC;IAexC,sBAAsB,CAAC,OAAO,EAAE,MAAM;CAuE7C"}
+{"version":3,"file":"FirmwareUpdateV3.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV3.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAY/E,OAAO,KAAK,EAEV,sBAAsB,EACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,QAAQ,EAAiB,MAAM,qBAAqB,CAAC;AAMnE,eAAO,MAAM,gCAAgC,UAAU,CAAC;AAaxD,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,wBAAwB,CAAC,sBAAsB,CAAC;IAC5F,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,CAAQ;IAE1C,OAAO,CAAC,gBAAgB,CAAS;IAEjC,OAAO,CAAC,eAAe,CAA4B;IAEnD,IAAI;IAmFE,GAAG;;;;;YAcK,aAAa;IA6D3B,OAAO,CAAC,wBAAwB;YAiBlB,kBAAkB;YAelB,oBAAoB;IAKlC,OAAO,CAAC,wBAAwB;YAgBlB,oBAAoB;YA2DpB,uBAAuB;YAuBvB,4BAA4B;YA+E5B,aAAa;IAwN3B,OAAO,CAAC,yBAAyB;IAajC,OAAO,CAAC,yBAAyB;IAQjC,OAAO,CAAC,qBAAqB;IAmB7B,OAAO,CAAC,sCAAsC;IAexC,sBAAsB,CAAC,OAAO,EAAE,MAAM;CAuE7C"}

package/dist/api/FirmwareUpdateV4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAe/E,OAAO,KAAK,EAEV,sBAAsB,EAEvB,MAAM,6BAA6B,CAAC;AA4VrC,eAAO,MAAM,iCAAiC,0BACrB,MAAM,uBACR,MAAM,SAc5B,CAAC;AAUF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,wBAAwB,CAAC,sBAAsB,CAAC;IAC5F,OAAO,CAAC,8BAA8B,CAAC,CAAS;IAEhD,OAAO,CAAC,yBAAyB,CAA4B;IAE7D,OAAO,CAAC,2BAA2B,CAAS;IAE5C,OAAO,CAAC,iCAAiC,CAA6B;IAEtE,OAAO,CAAC,6BAA6B,CAAC,CAAW;IAEjD,IAAI;IA2HJ,OAAO,CAAC,8BAA8B;IAgBhC,GAAG;;;;;YAYK,aAAa;YAsEb,4BAA4B;YAkB5B,0BAA0B;YAY1B,8BAA8B;YAK9B,+BAA+B;YAqD/B,gCAAgC;YA+ChC,8BAA8B;IAsB5C,OAAO,CAAC,8BAA8B;IA0BtC,OAAO,CAAC,kCAAkC;IAc1C,OAAO,CAAC,gCAAgC;IAiDxC,OAAO,CAAC,6BAA6B;YAsBvB,2BAA2B;IAWzC,OAAO,CAAC,yBAAyB;IAKjC,OAAO,CAAC,kCAAkC;YAO5B,iCAAiC;YAOjC,iCAAiC;YAOjC,iCAAiC;IAM/C,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,4BAA4B;IAQpC,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,yBAAyB;IAiBjC,OAAO,CAAC,wBAAwB;IAkBhC,OAAO,CAAC,6BAA6B;YAMvB,8BAA8B;YA6C9B,iCAAiC;YAmBjC,+BAA+B;IA+D7C,OAAO,CAAC,gCAAgC;YAyC1B,oCAAoC;YAkCpC,kCAAkC;IAgChD,OAAO,CAAC,0BAA0B;IAO5B,6BAA6B;YA0BrB,+BAA+B;IA4C7C,OAAO,CAAC,6BAA6B;IAkCrC,OAAO,CAAC,8BAA8B;YA8CxB,uBAAuB;YAiCvB,6BAA6B;YAa7B,uBAAuB;YA6CvB,8BAA8B;YA2D9B,6BAA6B;IA0D3C,OAAO,CAAC,mCAAmC;YAI7B,0BAA0B;IAaxC,OAAO,CAAC,4BAA4B;YA+FtB,uCAAuC;YA0GvC,gCAAgC;YAShC,8BAA8B;YAsB9B,mCAAmC;YAWnC,qCAAqC;YA2CrC,yBAAyB;YAiDzB,8BAA8B;IAU5C,OAAO,CAAC,kCAAkC;YAI5B,cAAc;YA+Bd,6BAA6B;YAU7B,0BAA0B;YAS1B,6BAA6B;YAmB7B,gBAAgB;IAiB9B,OAAO,CAAC,qBAAqB;CAM9B"}
+{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAkB/E,OAAO,KAAK,EAEV,sBAAsB,EAEvB,MAAM,6BAA6B,CAAC;AA4VrC,eAAO,MAAM,iCAAiC,0BACrB,MAAM,uBACR,MAAM,SAW5B,CAAC;AAUF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,wBAAwB,CAAC,sBAAsB,CAAC;IAC5F,OAAO,CAAC,8BAA8B,CAAC,CAAS;IAEhD,OAAO,CAAC,yBAAyB,CAA4B;IAE7D,OAAO,CAAC,2BAA2B,CAAS;IAE5C,OAAO,CAAC,iCAAiC,CAA6B;IAEtE,OAAO,CAAC,6BAA6B,CAAC,CAAW;IAEjD,IAAI;IAoHJ,OAAO,CAAC,8BAA8B;IAgBhC,GAAG;;;;;YAYK,aAAa;YAsEb,4BAA4B;YAkB5B,0BAA0B;YAY1B,8BAA8B;YAK9B,+BAA+B;YAqD/B,gCAAgC;YAmDhC,8BAA8B;IAsB5C,OAAO,CAAC,8BAA8B;IA0BtC,OAAO,CAAC,kCAAkC;IAc1C,OAAO,CAAC,gCAAgC;IA+CxC,OAAO,CAAC,6BAA6B;YAsBvB,2BAA2B;IAWzC,OAAO,CAAC,yBAAyB;IAKjC,OAAO,CAAC,kCAAkC;YAO5B,iCAAiC;YAOjC,iCAAiC;YAcjC,iCAAiC;IAM/C,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,4BAA4B;IAQpC,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,yBAAyB;IAiBjC,OAAO,CAAC,wBAAwB;IAkBhC,OAAO,CAAC,6BAA6B;YAMvB,8BAA8B;YA6C9B,iCAAiC;YAmBjC,+BAA+B;IA+D7C,OAAO,CAAC,gCAAgC;YAyC1B,oCAAoC;YAkCpC,kCAAkC;IAgChD,OAAO,CAAC,0BAA0B;IAO5B,6BAA6B;YA0BrB,+BAA+B;IA4C7C,OAAO,CAAC,6BAA6B;IAkCrC,OAAO,CAAC,8BAA8B;YA8CxB,uBAAuB;YAiCvB,6BAA6B;YAa7B,uBAAuB;YA6CvB,8BAA8B;YA2D9B,6BAA6B;IA0D3C,OAAO,CAAC,mCAAmC;YAI7B,0BAA0B;IAaxC,OAAO,CAAC,4BAA4B;YA+FtB,uCAAuC;YA0GvC,gCAAgC;YAShC,8BAA8B;YAsB9B,mCAAmC;YAWnC,qCAAqC;YA2CrC,yBAAyB;YAiDzB,8BAA8B;IAU5C,OAAO,CAAC,kCAAkC;YAI5B,cAAc;YA+Bd,6BAA6B;YAU7B,0BAA0B;YAS1B,6BAA6B;YAmB7B,gBAAgB;IAiB9B,OAAO,CAAC,qBAAqB;CAM9B"}

package/dist/api/GetPassphraseState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GetPassphraseState.d.ts","sourceRoot":"","sources":["../../src/api/GetPassphraseState.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,UAAU;IACxD,IAAI;IAKE,GAAG;CAcV"}
+{"version":3,"file":"GetPassphraseState.d.ts","sourceRoot":"","sources":["../../src/api/GetPassphraseState.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,UAAU;IACxD,IAAI;IAKE,GAAG;CAoBV"}

package/dist/api/device/DeviceUpdateBootloader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeviceUpdateBootloader.d.ts","sourceRoot":"","sources":["../../../src/api/device/DeviceUpdateBootloader.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAWhF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAE7E,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,wBAAwB,CAAC,GAAG,CAAC;IAC/E,IAAI;IAOE,iCAAiC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW;IAoBtE,2CAA2C,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB;IAcvF,qBAAqB,CAAC,EAC1B,MAAM,EACN,QAAQ,EACR,YAAY,EACZ,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,GACvB,EAAE;QACD,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,QAAQ,CAAC;QACpB,YAAY,EAAE,aAAa,CAAC;QAC5B,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,MAAM,CAAC,EAAE,kBAAkB,CAAC;KAC7B;IA0EK,GAAG;CAoEV"}
+{"version":3,"file":"DeviceUpdateBootloader.d.ts","sourceRoot":"","sources":["../../../src/api/device/DeviceUpdateBootloader.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAehF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAE7E,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,wBAAwB,CAAC,GAAG,CAAC;IAC/E,IAAI;IAOE,iCAAiC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW;IAoBtE,2CAA2C,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB;IAcvF,qBAAqB,CAAC,EAC1B,MAAM,EACN,QAAQ,EACR,YAAY,EACZ,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,GACvB,EAAE;QACD,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,QAAQ,CAAC;QACpB,YAAY,EAAE,aAAa,CAAC;QAC5B,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,MAAM,CAAC,EAAE,kBAAkB,CAAC;KAC7B;IA0EK,GAAG;CAwEV"}