@onekeyfe/hd-core 1.2.8-alpha.5 → 1.2.8-alpha.6

package/README.md

@@ -29,4 +29,31 @@ import Core from '@onekeyfe/hd-core';
 Documentation is available [Hardware SDK Getting Started](https://developer.onekey.so/en/hardware-sdk/getting-started)
 
 ## Examples
+
+### Babylon context hash
+
+`btcDeriveContextHash(connectId, deviceId, params)` requires Classic 1s firmware
+3.21.0 or later and Protocol V1. It uses the existing wallet session and device
+confirmation flow. Other device families and Protocol V2 are not supported.
+
+```typescript
+const result = await HardwareSDK.btcDeriveContextHash(connectId, deviceId, {
+  path: "m/84'/0'/0'/0/0", // The currently selected Bitcoin key, not the IKM path.
+  appName: 'babylon-btc-vault',
+  context: 'deadbeef',
+  network: 'bitcoin-mainnet',
+});
+// result.payload.secret is a 32-byte value encoded as 64 lowercase hex characters.
+```
+
+`appName` must contain 1–64 ASCII lowercase letters, digits or hyphens. `context`
+must be lowercase hex without `0x`, containing 1–1024 decoded bytes. `network` is
+required: `bitcoin-mainnet`, `bitcoin-testnet` (testnet3/testnet4), `bitcoin-signet`,
+or `bitcoin-regtest`. The SDK infers the Bitcoin input script type from `path` and
+encodes `appName` as ASCII bytes; the device performs the derivation internally.
+Device rejection and unsupported firmware errors propagate through the normal
+SDK response. Treat the returned secret as sensitive and do not log or persist it.
+
+See the [Babylon specification](https://github.com/babylonlabs-io/babylon-toolkit/blob/main/docs/specs/derive-context-hash.md).
+
 // TODO: add example url

package/__tests__/DeviceCommands.test.ts

@@ -130,6 +130,19 @@ describe('DeviceCommands failure mapping', () => {
     );
   });
 
+  it('preserves the Protocol V2 peer-removed pairing error code', async () => {
+    const commands = createCommands();
+    const transportError = Object.assign(new Error('Peer removed pairing information'), {
+      errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
+    });
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockRejectedValue(transportError),
+    } as any;
+
+    await expect(commands._commonCall('DeviceInfoGet', {})).rejects.toBe(transportError);
+  });
+
   it('logs canonical DeviceStatus response fields without exposing the device ID', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);
@@ -401,27 +414,6 @@ describe('DeviceCommands failure mapping', () => {
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceBusy });
   });
 
-  it('maps commands rejected during a Protocol V2 firmware update to DeviceBusy', async () => {
-    const commands = createCommands();
-    const message = 'Requested command not allowed while a firmware update is in progress';
-
-    await expect(
-      commands._filterCommonTypes(
-        {
-          type: 'Failure',
-          message: { code: 'Failure_ProcessError', message },
-        } as any,
-        'ProtocolInfoRequest'
-      )
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceBusy,
-      params: {
-        failureCode: 'Failure_ProcessError',
-        firmwareMessage: message,
-      },
-    });
-  });
-
   it('maps the current AskPin passphrase-disabled response without relying on a subcode', async () => {
     const commands = createCommands();
 
@@ -559,51 +551,6 @@ describe('DeviceCommands failure mapping', () => {
     }
   );
 
-  it('maps the Protocol V2 seed-session busy response to DeviceBusy', async () => {
-    const commands = createCommands();
-
-    await expect(
-      commands._filterCommonTypes(
-        {
-          type: 'Failure',
-          message: {
-            code: 'Failure_ProcessError',
-            subcode: DeviceSessionErrorCode.DeviceSessionError_UserCancelled,
-            message: 'PIN cancelled',
-          },
-        } as any,
-        'SignTx'
-      )
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceBusy,
-      params: {
-        failureCode: 'Failure_ProcessError',
-        subcode: DeviceSessionErrorCode.DeviceSessionError_UserCancelled,
-        firmwareMessage: 'PIN cancelled',
-      },
-    });
-  });
-
-  it('keeps the same Protocol V2 response as ActionCancelled for DeviceSession calls', async () => {
-    const commands = createCommands();
-
-    await expect(
-      commands._filterCommonTypes(
-        {
-          type: 'Failure',
-          message: {
-            code: 'Failure_ProcessError',
-            subcode: DeviceSessionErrorCode.DeviceSessionError_UserCancelled,
-            message: 'PIN cancelled',
-          },
-        } as any,
-        'DeviceSessionAskPin'
-      )
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.ActionCancelled,
-    });
-  });
-
   it('does not use the legacy cancellation-message fallback for Protocol V1', async () => {
     const commands = createCommands();
     (commands.device.isProtocolV2 as jest.Mock).mockReturnValue(false);

package/__tests__/btc-derive-context-hash.test.ts

@@ -0,0 +1,200 @@
+import { EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import BTCDeriveContextHash from '../src/api/btc/BTCDeriveContextHash';
+import { findMethod } from '../src/api/utils';
+import { getLogBlockLabel, getSafeLogPayload } from '../src/events/logBlockEvent';
+import { createCoreApi } from '../src/inject';
+import { Device } from '../src/device/Device';
+
+import type { DeviceFirmwareRange } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+const createMethod = (overrides: Record<string, unknown> = {}) =>
+  new BTCDeriveContextHash({
+    id: 1,
+    payload: {
+      method: 'btcDeriveContextHash',
+      path: "m/84'/0'/0'/0/0",
+      appName: 'test-app',
+      context: 'deadbeef',
+      network: 'bitcoin-mainnet',
+      ...overrides,
+    },
+  });
+
+describe('btcDeriveContextHash', () => {
+  test('forwards the public API call through the existing dispatcher', async () => {
+    const call = jest
+      .fn()
+      .mockResolvedValue({ success: true, payload: { secret: '00'.repeat(32) } });
+    const api = createCoreApi(call);
+    const params = {
+      path: "m/84'/0'/0'/0/0",
+      appName: 'test-app',
+      context: 'deadbeef',
+      network: 'bitcoin-mainnet' as const,
+    };
+    await api.btcDeriveContextHash('connect-id', 'device-id', params);
+    expect(call).toHaveBeenCalledWith({
+      ...params,
+      connectId: 'connect-id',
+      deviceId: 'device-id',
+      method: 'btcDeriveContextHash',
+    });
+  });
+
+  test.each([
+    ['bitcoin-mainnet', 'BITCOIN_MAINNET'],
+    ['bitcoin-testnet', 'BITCOIN_TESTNET'],
+    ['bitcoin-signet', 'BITCOIN_SIGNET'],
+    ['bitcoin-regtest', 'BITCOIN_REGTEST'],
+  ])('maps %s and returns the device result', async (network, wireNetwork) => {
+    const method = createMethod({ network });
+    method.init();
+    const response = { secret: '00'.repeat(32) };
+    const typedCall = jest.fn().mockResolvedValue({ message: response });
+    method.device = { commands: { typedCall } } as unknown as Device;
+
+    await expect(method.run()).resolves.toBe(response);
+    expect(typedCall).toHaveBeenCalledWith(
+      'BabylonDeriveContextHash',
+      'BabylonDerivedContextHash',
+      {
+        address_n: [2147483732, 2147483648, 2147483648, 0, 0],
+        script_type: 'SPENDWITNESS',
+        app_name: '746573742d617070',
+        context: 'deadbeef',
+        network: wireNetwork,
+      }
+    );
+  });
+
+  test.each([
+    ["m/44'/0'/0'/0/0", 'SPENDADDRESS'],
+    ["m/49'/0'/0'/0/0", 'SPENDP2SHWITNESS'],
+    [[2147483734, 2147483648, 2147483648, 0, 0], 'SPENDTAPROOT'],
+  ])('uses the selected path script type for %s', (path, scriptType) => {
+    const method = createMethod({ path });
+    method.init();
+    expect(method.params.script_type).toBe(scriptType);
+  });
+
+  test('accepts the maximum app name and context sizes', () => {
+    const method = createMethod({ appName: 'a'.repeat(64), context: 'ab'.repeat(1024) });
+    expect(() => method.init()).not.toThrow();
+    expect(method.params.context).toHaveLength(2048);
+  });
+
+  test.each([
+    { appName: '' },
+    { appName: 'a'.repeat(65) },
+    { appName: 'Test-App' },
+    { appName: 'test_app' },
+    { appName: '你好' },
+    { appName: null },
+    { context: '' },
+    { context: 'abc' },
+    { context: 'DEADBEEF' },
+    { context: '0xdeadbeef' },
+    { context: 'gg' },
+    { context: 'ab'.repeat(1025) },
+    { context: null },
+    { network: '' },
+    { network: 'litecoin' },
+    { network: 'toString' },
+    { network: 1 },
+    { path: 'm' },
+    { path: "m/84x'/0'/0'/0/0" },
+    { path: "m/2147483648'/0'/0'/0/0" },
+    { path: [2147483732, 2147483648, 2147483648, 0, 0.5] },
+    { path: [2147483732, 2147483648, 2147483648, 0, 4294967296] },
+  ])('rejects invalid inputs before a device call: %j', overrides => {
+    expect(() => createMethod(overrides).init()).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.CallMethodInvalidParameter })
+    );
+  });
+
+  test('rejects sparse numeric paths before a device call', () => {
+    const sparsePath = [2147483732, 2147483648, 2147483648, 0, 5];
+    delete sparsePath[3];
+
+    [Array<number>(3), sparsePath].forEach(path => {
+      expect(() => createMethod({ path }).init()).toThrow(
+        expect.objectContaining({ errorCode: HardwareErrorCode.CallMethodInvalidParameter })
+      );
+    });
+  });
+
+  test('registers the public method and restricts it to supported firmware and protocol', () => {
+    const method = findMethod({ id: 1, payload: { ...createMethod().payload } });
+    method.init();
+    expect(method).toBeInstanceOf(BTCDeriveContextHash);
+    expect(method.strictCheckDeviceSupport).toBe(true);
+    expect(() => method.assertProtocolSupported('V2', EFirmwareType.Universal)).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotSupportMethod })
+    );
+  });
+
+  test.each([EDeviceType.Classic1s, EDeviceType.ClassicPure])(
+    'resolves the firmware requirement for %s through the device support check',
+    deviceType => {
+      const method = createMethod();
+      const device = Object.create(Device.prototype) as Device;
+      device.getCurrentDeviceType = jest.fn(() => deviceType);
+      const range: DeviceFirmwareRange = method.getVersionRange();
+
+      expect(device.getCurrentMethodVersionRange(type => range[type])).toEqual({ min: '3.21.0' });
+      expect(() => method.assertProtocolSupported('V1', EFirmwareType.Universal)).not.toThrow();
+    }
+  );
+
+  test.each([EDeviceType.Classic, EDeviceType.Mini, EDeviceType.Touch, EDeviceType.Pro])(
+    'keeps %s outside the supported firmware range',
+    deviceType => {
+      const method = createMethod();
+      const device = Object.create(Device.prototype) as Device;
+      device.getCurrentDeviceType = jest.fn(() => deviceType);
+      const range: DeviceFirmwareRange = method.getVersionRange();
+
+      expect(device.getCurrentMethodVersionRange(type => range[type])).toBeUndefined();
+    }
+  );
+
+  test('propagates device rejection without returning a secret', async () => {
+    const method = createMethod();
+    method.init();
+    const error = new Error('User rejected');
+    method.device = {
+      commands: { typedCall: jest.fn().mockRejectedValue(error) },
+    } as unknown as Device;
+    await expect(method.run()).rejects.toBe(error);
+  });
+
+  test.each([undefined, '00', '00'.repeat(33)])(
+    'rejects malformed device responses',
+    async secret => {
+      const method = createMethod();
+      method.init();
+      method.device = {
+        commands: { typedCall: jest.fn().mockResolvedValue({ message: { secret } }) },
+      } as unknown as Device;
+      await expect(method.run()).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.CallMethodError,
+      });
+    }
+  );
+
+  test('blocks API request and response payloads in logs', () => {
+    const request = { payload: { method: 'btcDeriveContextHash' } };
+    const label = getLogBlockLabel(request);
+    expect(label).toBe('btcDeriveContextHash');
+    expect(getSafeLogPayload({ payload: { secret: '00'.repeat(32) } }, label)).toEqual({
+      method: 'btcDeriveContextHash',
+      payload: '[REDACTED]',
+    });
+  });
+});

package/__tests__/core-error-output.test.ts

@@ -3,7 +3,7 @@ import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { initConnector, initCore } from '../src/core';
 import { DataManager } from '../src/data-manager';
 import TransportManager from '../src/data-manager/TransportManager';
-import { IFRAME, createErrorMessage } from '../src/events';
+import { IFRAME } from '../src/events';
 import SearchDevices from '../src/api/SearchDevices';
 import { DeviceList } from '../src/device/DeviceList';
 import { Device } from '../src/device/Device';
@@ -28,23 +28,6 @@ describe('Core 错误输出边界', () => {
     jest.restoreAllMocks();
   });
 
-  test('entry-point errors preserve USB recovery context across JSON serialization', () => {
-    const params = {
-      operation: 'open',
-      nativeErrorName: 'SecurityError',
-      nativeErrorMessage: 'Access denied',
-    };
-    const error = ERRORS.TypedError(
-      HardwareErrorCode.BridgeNeedsPermission,
-      'Access denied',
-      params
-    );
-    expect(JSON.parse(JSON.stringify(createErrorMessage(error)))).toEqual({
-      success: false,
-      payload: { code: HardwareErrorCode.BridgeNeedsPermission, error: 'Access denied', params },
-    });
-  });
-
   test.each([
     ['webusb', false],
     ['desktop-webusb', false],
@@ -125,28 +108,14 @@ describe('Core 错误输出边界', () => {
     HardwareErrorCode.BleDeviceBondedCanceled,
     HardwareErrorCode.BleDeviceDisconnected,
     HardwareErrorCode.PollingTimeout,
-    HardwareErrorCode.BlePoweredOff,
-    HardwareErrorCode.BleUnsupported,
-    HardwareErrorCode.BridgeNeedsPermission,
-    HardwareErrorCode.WebUsbDeviceAccessError,
   ])(
-    'preserves terminal transport error %s in the public response without polling again',
+    'preserves terminal BLE error %s in the public response without polling again',
     async errorCode => {
-      jest
-        .spyOn(DataManager, 'getSettings')
-        .mockReturnValue(
-          [
-            HardwareErrorCode.BridgeNeedsPermission,
-            HardwareErrorCode.WebUsbDeviceAccessError,
-          ].includes(errorCode)
-            ? ('desktop-webusb' as never)
-            : ('react-native' as never)
-        );
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
       const error = ERRORS.TypedError(errorCode);
       const acquire = jest.fn().mockRejectedValue(error);
       jest.spyOn(TransportManager, 'getTransport').mockReturnValue({
         acquire,
-        enumerate: jest.fn().mockResolvedValue([{ path: 'ble-pairing-test' }]),
         release: jest.fn().mockResolvedValue(true),
         stop: jest.fn().mockResolvedValue(undefined),
       } as never);

package/__tests__/device-lifecycle-events.test.ts

@@ -10,6 +10,7 @@ import {
   isMissingDetectedProtocolV2Error,
   isRetryableBleConnectionError,
   isRetryableBleProtocolV2ProbeError,
+  isTerminalBleStaleBondError,
   resolveBleConnectProtocol,
 } from '../src/core';
 import { DataManager } from '../src/data-manager';
@@ -610,6 +611,7 @@ describe('public device lifecycle events', () => {
   test.each([
     [HardwareErrorCode.RuntimeError, true],
     [HardwareErrorCode.BleDeviceBondError, false],
+    [HardwareErrorCode.BlePeerRemovedPairingInformation, false],
   ] as const)(
     'retries a Protocol V2 probe mismatch with error code %s: %s',
     (errorCode, expected) => {
@@ -629,6 +631,8 @@ describe('public device lifecycle events', () => {
     [HardwareErrorCode.BleTimeoutError, true],
     [HardwareErrorCode.PollingTimeout, false],
     [HardwareErrorCode.BleDeviceBondError, false],
+    [HardwareErrorCode.BlePeerRemovedPairingInformation, false],
+    [HardwareErrorCode.BleBondInvalid, false],
   ] as const)('retries a BLE connection error with error code %s: %s', (errorCode, expected) => {
     const method = { payload: { connectProtocol: 'V2' } } as never;
     const error = {
@@ -681,6 +685,19 @@ describe('public device lifecycle events', () => {
     }
   );
 
+  test.each([
+    [HardwareErrorCode.BleDeviceBondError, true],
+    [HardwareErrorCode.BlePeerRemovedPairingInformation, true],
+    [HardwareErrorCode.BleBondInvalid, true],
+    [HardwareErrorCode.DeviceNotFound, false],
+  ] as const)('treats BLE stale-bond error code %s as terminal: %s', (errorCode, expected) => {
+    const error = {
+      errorCode,
+    };
+
+    expect(isTerminalBleStaleBondError(error)).toBe(expected);
+  });
+
   test.each([
     [HardwareErrorCode.DeviceCheckDeviceIdError, true],
     [HardwareErrorCode.DeviceNotFound, false],
@@ -712,48 +729,6 @@ describe('public device lifecycle events', () => {
     expect(() => JSON.stringify(disconnectMessage?.payload.device)).not.toThrow();
   });
 
-  test.each(['V1', 'V2'] as const)(
-    'preserves the %s connection identity for a transport disconnect after wipe',
-    protocol => {
-      jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
-      core = initCore();
-      initConnector();
-      const messages: CoreMessage[] = [];
-      core.on(CORE_EVENT, message => messages.push(message));
-      const device = createInitializedDevice(protocol);
-      const connectId = device.getConnectId();
-      DevicePool.devicesCache[connectId] = device;
-
-      device.invalidateAfterWipe();
-      expect(device.toMessageObject()).toBeNull();
-      DevicePool.emitter.emit(DEVICE.CONNECT, device);
-      expect(messages.some(message => message.type === DEVICE.CONNECT)).toBe(false);
-      DevicePool.emitter.emit(TRANSPORT_EVENT.DEVICE_DISCONNECT, { connectId });
-
-      const disconnects = messages.filter(message => message.type === DEVICE.DISCONNECT);
-      expect(disconnects).toHaveLength(1);
-      expect(disconnects[0].payload.device).toMatchObject({
-        connectId,
-        serialNo: 'SERIAL-001',
-        deviceId: 'wallet-device-id',
-      });
-      expect(() => JSON.stringify(disconnects[0].payload.device)).not.toThrow();
-
-      device.features = {
-        ...createInitializedDevice(protocol).features,
-        deviceId: 'new-device-id',
-        initialized: false,
-        mode: 'notInitialized',
-      } as never;
-      DevicePool.emitter.emit(TRANSPORT_EVENT.DEVICE_DISCONNECT, { connectId });
-      const nextDisconnects = messages.filter(message => message.type === DEVICE.DISCONNECT);
-      expect(nextDisconnects[1].payload.device).toMatchObject({
-        deviceId: 'new-device-id',
-        mode: 'notInitialized',
-      });
-    }
-  );
-
   test('treats an acquired BLE device as reusable until the transport disconnects', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('desktop-web-ble' as never);
     const device = createInitializedDevice('V2');
@@ -1039,28 +1014,6 @@ describe('public device lifecycle events', () => {
     expect(device.wasInterruptedByUser()).toBe(false);
   });
 
-  test.each(['V1', 'V2'] as const)(
-    'retires a failed USB %s session before the next user attempt',
-    async protocol => {
-      jest.spyOn(DataManager, 'getSettings').mockReturnValue('desktop-webusb' as never);
-      const device = createInitializedDevice(protocol);
-      device.originalDescriptor = { ...device.originalDescriptor, session: device.mainId };
-      const disconnect = jest.fn().mockResolvedValue(undefined);
-      const release = jest.fn().mockResolvedValue(undefined);
-      device.deviceConnector = { disconnect, release } as never;
-      device.commands = { disposed: false, dispose: jest.fn() } as never;
-      (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
-      const error = ERRORS.TypedError(HardwareErrorCode.WebUsbDeviceAccessError);
-      await expect(device.run(() => Promise.reject(error))).rejects.toBe(error);
-      await new Promise(resolve => {
-        setImmediate(resolve);
-      });
-      expect(disconnect).toHaveBeenCalledWith(device.mainId);
-      expect(release).toHaveBeenCalledTimes(1);
-      expect(device.hasDeviceAcquire()).toBe(false);
-    }
-  );
-
   test('waits for the canceled run to finish releasing before cancellation completes', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     const device = createInitializedDevice('V2');

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

@@ -85,56 +85,6 @@ describe('DevicePool state lifecycle', () => {
     expect(result.deviceList).toEqual([device]);
   });
 
-  test.each([
-    ['V1', undefined],
-    ['V1', 'wipe-path'],
-    ['V2', undefined],
-    ['V2', 'wipe-path'],
-  ] as const)('rediscovers a wiped %s device with connect id %s', async (protocol, connectId) => {
-    const descriptor = { path: 'wipe-path', protocolType: protocol } as never;
-    const device = Device.fromDescriptor(descriptor);
-    device.features = {
-      protocol,
-      deviceType: protocol === 'V2' ? 'pro2' : 'classic',
-      deviceId: 'old-device-id',
-      serialNo: 'wipe-path',
-      initialized: true,
-      mode: 'normal',
-    } as never;
-    DevicePool.devicesCache = { 'wipe-path': device };
-    device.invalidateAfterWipe();
-    expect(device.toMessageObject()).toBeNull();
-    const connect = jest.spyOn(device, 'connect').mockResolvedValue(true);
-    const initialize = jest.spyOn(device, 'initialize').mockImplementation(() => {
-      device.features = {
-        protocol,
-        deviceType: protocol === 'V2' ? 'pro2' : 'classic',
-        deviceId: 'new-device-id',
-        serialNo: 'wipe-path',
-        initialized: false,
-        mode: 'notInitialized',
-      } as never;
-      return Promise.resolve();
-    });
-    const release = jest.spyOn(device, 'release').mockResolvedValue(undefined);
-
-    try {
-      const result = await DevicePool.getDevices([descriptor], connectId);
-      expect(initialize).toHaveBeenCalledTimes(1);
-      expect(connect).toHaveBeenCalledTimes(1);
-      expect(release).toHaveBeenCalledTimes(1);
-      expect(result.deviceList[0].toMessageObject()).toMatchObject({
-        deviceId: 'new-device-id',
-        mode: 'notInitialized',
-        features: { initialized: false },
-      });
-      await DevicePool.getDevices([descriptor], connectId);
-      expect(initialize).toHaveBeenCalledTimes(1);
-    } finally {
-      jest.restoreAllMocks();
-    }
-  });
-
   test('keeps a discovered device when its Protocol V2 label cannot be read', async () => {
     const labelError = new Error('settings unavailable');
     const getDeviceState = jest

package/__tests__/protocol-v2-bootloader-mode.test.ts

@@ -1,5 +1,3 @@
-import { EDeviceType } from '@onekeyfe/hd-shared';
-
 import { Device } from '../src/device/Device';
 import { UI_REQUEST } from '../src/events/ui-request';
 
@@ -25,39 +23,12 @@ const createBootloaderDevice = (protocolType: 'V1' | 'V2') => {
 };
 
 describe('Pro2 bootloader mode', () => {
-  test('blocks Protocol V2 methods that are not allowed in bootloader mode', () => {
-    const device = createBootloaderDevice('V2');
-
-    expect(device.hasUnexpectedMode([], [])).toBe(UI_REQUEST.BOOTLOADER);
-  });
-
-  test('allows Protocol V2 methods that explicitly support bootloader mode', () => {
+  test('does not block Protocol V2 methods in bootloader mode', () => {
     const device = createBootloaderDevice('V2');
 
-    expect(device.hasUnexpectedMode([UI_REQUEST.BOOTLOADER], [])).toBeNull();
+    expect(device.hasUnexpectedMode([], [])).toBeNull();
   });
 
-  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
-    'blocks unsupported Protocol V2 methods in %s romloader mode',
-    deviceType => {
-      const device = createBootloaderDevice('V2');
-      device.updateState(
-        {
-          protocol: 'V2',
-          identity: { deviceType },
-          status: { mode: 'romloader', initialized: null },
-        },
-        'initialize'
-      );
-
-      expect(device.hasUnexpectedMode([], [])).toBe(UI_REQUEST.BOOTLOADER);
-      expect(device.hasUnexpectedMode([UI_REQUEST.NOT_INITIALIZE], [])).toBe(UI_REQUEST.BOOTLOADER);
-      expect(
-        device.hasUnexpectedMode([UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE], [])
-      ).toBeNull();
-    }
-  );
-
   test('keeps the Protocol V1 bootloader restriction', () => {
     const device = createBootloaderDevice('V1');
 

package/__tests__/protocol-v2.test.ts

@@ -4991,6 +4991,23 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceInfoGet']);
   });
 
+  test('stops V4 bootloader reconnect polling on a stale BLE bond', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const staleBondError = ERRORS.TypedError(HardwareErrorCode.BlePeerRemovedPairingInformation);
+    const reconnectProtocolV2Device = jest.fn().mockRejectedValue(staleBondError);
+    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+
+    await expect((method as any).waitForProtocolV2BootloaderMode(60_000, 0)).rejects.toBe(
+      staleBondError
+    );
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+  });
+
   test('polls again when Protocol V2 bootloader serial is temporarily unavailable', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -8992,6 +9009,36 @@ describe('Protocol V2 firmware update targets', () => {
     );
   });
 
+  test('does not retry or wrap a stale BLE bond during a V4 file transfer', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const staleBondError = ERRORS.TypedError(HardwareErrorCode.BlePeerRemovedPairingInformation);
+    (method as any).fileWriteChunk = jest.fn().mockRejectedValue(staleBondError);
+    const recoverProtocolV2FileTransfer = jest.fn();
+    (method as any).recoverProtocolV2FileTransfer = recoverProtocolV2FileTransfer;
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array([1]).buffer,
+    });
+
+    try {
+      await expect(
+        (method as any).protocolV2SourceUpdateProcess({
+          source,
+          filePath: 'vol1:firmware.bin',
+          processedSize: 0,
+          totalSize: 1,
+        })
+      ).rejects.toBe(staleBondError);
+    } finally {
+      await source?.close();
+    }
+    expect(recoverProtocolV2FileTransfer).not.toHaveBeenCalled();
+  });
+
   test('does not recover or wrap a cancelled V4 file transfer', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,