@onekeyfe/hd-transport-web-device 1.2.0-alpha.18 → 1.2.0-alpha.180

package/__tests__/electron-ble-transport.test.ts

@@ -1,5 +1,6 @@
 import transport, { PROTOCOL_V2_CHANNEL_BLE_UART, bytesToHex } from '@onekeyfe/hd-transport';
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EBleDisconnectReason, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
+import EventEmitter from 'events';
 
 import ElectronBleTransport from '../src/electron-ble-transport';
 
@@ -10,6 +11,9 @@ const protocolV1Schema = {
     Initialize: {
       fields: {},
     },
+    GetFeatures: {
+      fields: {},
+    },
     Success: {
       fields: {
         message: {
@@ -22,6 +26,7 @@ const protocolV1Schema = {
       values: {
         MessageType_Initialize: 1,
         MessageType_Success: 2,
+        MessageType_GetFeatures: 55,
       },
     },
   },
@@ -100,6 +105,7 @@ const createNobleBle = (device = { id: 'flaky-pro2-id', name: 'Unknown BLE Devic
   unsubscribe: jest.fn(() => Promise.resolve()),
   write: jest.fn(() => Promise.resolve()),
   onNotification: jest.fn(() => jest.fn()),
+  onMtuChanged: jest.fn(() => jest.fn()),
   onDeviceDisconnected: jest.fn(() => jest.fn()),
   checkAvailability: jest.fn(() =>
     Promise.resolve({
@@ -111,7 +117,10 @@ const createNobleBle = (device = { id: 'flaky-pro2-id', name: 'Unknown BLE Devic
   ),
 });
 
-const configureTransport = (nobleBle: ReturnType<typeof createNobleBle>) => {
+const configureTransport = (
+  nobleBle: ReturnType<typeof createNobleBle>,
+  emitter?: EventEmitter
+) => {
   (global as any).window = {
     desktopApi: {
       nobleBle,
@@ -119,18 +128,164 @@ const configureTransport = (nobleBle: ReturnType<typeof createNobleBle>) => {
   };
 
   const transport = new ElectronBleTransport();
-  transport.init(createLogger());
+  transport.init(createLogger(), emitter);
   transport.configure(protocolV1Schema);
   transport.configureProtocolV2(protocolV2Schema);
   return transport;
 };
 
+/**
+ * Wire the mock so acquire()'s Protocol V2 probe gets an answer. Without it
+ * detectProtocol throws and the test never reaches the disconnect behaviour.
+ */
+const echoProtocolV2 = (nobleBle: ReturnType<typeof createNobleBle>, deviceId: string) => {
+  let notificationHandler: ((id: string, data: string) => void) | undefined;
+  nobleBle.onNotification.mockImplementation(handler => {
+    notificationHandler = handler;
+    return jest.fn();
+  });
+  let responseSeq = 0;
+  nobleBle.write.mockImplementation(() => {
+    responseSeq += 1;
+    const response = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART, seq: responseSeq }
+    );
+    setTimeout(() => notificationHandler?.(deviceId, bytesToHex(response)), 0);
+    return Promise.resolve();
+  });
+};
+
 describe('ElectronBleTransport protocol detection', () => {
   afterEach(() => {
     delete (global as any).window;
     jest.clearAllMocks();
   });
 
+  test('keeps raw BLE lifecycle payloads off the public device event channel', async () => {
+    const device = { id: 'lifecycle-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    const emitter = new EventEmitter();
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    let disconnectHandler: ((device: { id: string; name: string | null }) => void) | undefined;
+    let responseSeq = 0;
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.onDeviceDisconnected.mockImplementation(handler => {
+      disconnectHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      responseSeq += 1;
+      const response = ProtocolV2.encodeFrame(
+        schemas,
+        'Success',
+        { message: 'ok' },
+        { router: PROTOCOL_V2_CHANNEL_BLE_UART, seq: responseSeq }
+      );
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(response)), 0);
+      return Promise.resolve();
+    });
+
+    const publicConnect = jest.fn();
+    const publicDisconnect = jest.fn();
+    const transportDisconnect = jest.fn();
+    emitter.on('device-connect', publicConnect);
+    emitter.on('device-disconnect', publicDisconnect);
+    emitter.on('transport-device-disconnect', transportDisconnect);
+    const bleTransport = configureTransport(nobleBle, emitter);
+
+    await bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+    expect(nobleBle.subscribe.mock.invocationCallOrder[0]).toBeLessThan(
+      nobleBle.getDevice.mock.invocationCallOrder[1]
+    );
+    disconnectHandler?.(device);
+
+    expect(publicConnect).not.toHaveBeenCalled();
+    expect(publicDisconnect).not.toHaveBeenCalled();
+    expect(transportDisconnect).toHaveBeenCalledWith({
+      id: device.id,
+      connectId: device.id,
+      name: device.name,
+    });
+  });
+
+  test('uses the Protocol V2 BLE writer with the Electron packet size', async () => {
+    const device = { id: 'chunked-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    const bleTransport = configureTransport(nobleBle) as any;
+    const context = {
+      messageName: 'Ping',
+      timeoutMs: 1000,
+      highThroughput: false,
+      generation: 1,
+      signal: new AbortController().signal,
+    };
+
+    await bleTransport.writeProtocolV2Frame(device.id, new Uint8Array(193), context, jest.fn());
+
+    expect(nobleBle.write).toHaveBeenCalledTimes(2);
+    expect(nobleBle.write.mock.calls.map(([, hex]) => hex.length / 2)).toEqual([192, 1]);
+    expect(nobleBle.write.mock.calls.every(([, , options]) => options?.pacingDelayMs === 0)).toBe(
+      true
+    );
+  });
+
+  test('uses the negotiated Noble MTU for Protocol V2 BLE writes', async () => {
+    const device = { id: 'mtu-pro2-id', name: 'OneKey Pro 2', mtu: 247 };
+    const nobleBle = createNobleBle(device);
+    const bleTransport = configureTransport(nobleBle) as any;
+    const context = {
+      messageName: 'FilesystemFileWrite',
+      timeoutMs: 1000,
+      highThroughput: true,
+      generation: 1,
+      signal: new AbortController().signal,
+    };
+
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
+    try {
+      await bleTransport.refreshBlePacketCapacity(device.id);
+      await bleTransport.writeProtocolV2Frame(device.id, new Uint8Array(245), context, jest.fn());
+
+      expect(setTimeoutSpy).not.toHaveBeenCalled();
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(nobleBle.write).toHaveBeenCalledTimes(2);
+    expect(nobleBle.write.mock.calls.map(([, hex]) => hex.length / 2)).toEqual([244, 1]);
+  });
+
+  test('updates Protocol V2 packet capacity when Noble reports a new MTU', async () => {
+    const device = { id: 'mtu-event-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    let mtuHandler: ((changedDevice: { id: string; mtu: number }) => void) | undefined;
+    nobleBle.onMtuChanged.mockImplementation(handler => {
+      mtuHandler = handler;
+      return jest.fn();
+    });
+    const bleTransport = configureTransport(nobleBle) as any;
+    const context = {
+      messageName: 'FilesystemFileWrite',
+      timeoutMs: 1000,
+      highThroughput: true,
+      generation: 1,
+      signal: new AbortController().signal,
+    };
+
+    bleTransport.createMtuSubscription(device.id);
+    mtuHandler?.({ id: device.id, mtu: 247 });
+    await bleTransport.writeProtocolV2Frame(device.id, new Uint8Array(245), context, jest.fn());
+
+    expect(nobleBle.write.mock.calls.map(([, hex]) => hex.length / 2)).toEqual([244, 1]);
+  });
+
   test('detects Protocol V2 after Protocol V1 probe timeout', async () => {
     const device = { id: 'unknown-pro2-id', name: 'Unknown BLE Device' };
     const nobleBle = createNobleBle(device);
@@ -141,7 +296,6 @@ describe('ElectronBleTransport protocol detection', () => {
       { message: 'ok' },
       { router: PROTOCOL_V2_CHANNEL_BLE_UART }
     );
-
     nobleBle.onNotification.mockImplementation(handler => {
       notificationHandler = handler;
       return jest.fn();
@@ -164,12 +318,16 @@ describe('ElectronBleTransport protocol detection', () => {
         })
       );
       expect(transport.getProtocolType(device.id)).toBe('V2');
+      expect(nobleBle.connect).toHaveBeenCalledTimes(1);
+      expect(nobleBle.subscribe).toHaveBeenCalledTimes(1);
+      expect(nobleBle.unsubscribe).not.toHaveBeenCalled();
+      expect(nobleBle.disconnect).not.toHaveBeenCalled();
     } finally {
       await transport.release(device.id);
     }
   });
 
-  test('detects Protocol V1 when device responds to Initialize', async () => {
+  test('reconnects a declared Protocol V1 device without probing again', async () => {
     const device = { id: 'classic-id', name: 'OneKey Classic' };
     const nobleBle = createNobleBle(device);
     let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
@@ -183,11 +341,12 @@ describe('ElectronBleTransport protocol detection', () => {
       return jest.fn();
     });
     nobleBle.write.mockImplementation(() => {
-      // Respond to first write (V1 Initialize probe) with V1 Success
+      // The first write is the V1 GetFeatures probe; answer with a V1 Success response.
       setTimeout(() => notificationHandler?.(device.id, v1ResponseHex), 0);
       return Promise.resolve();
     });
     const transport = configureTransport(nobleBle);
+    const protocolV2Writer = jest.spyOn(transport as any, 'writeProtocolV2Frame');
 
     try {
       await expect(transport.acquire({ uuid: device.id })).resolves.toEqual(
@@ -196,11 +355,97 @@ describe('ElectronBleTransport protocol detection', () => {
         })
       );
       expect(transport.getProtocolType(device.id)).toBe('V1');
+      await expect(transport.acquire({ uuid: device.id, expectedProtocol: 'V1' })).resolves.toEqual(
+        expect.objectContaining({
+          uuid: device.id,
+        })
+      );
+      // The first acquire probes because the protocol is unknown; the second
+      // declares V1 and must send nothing at all, leaving the first frame on
+      // the link to Core — which is what carries the wallet session.
+      expect(nobleBle.write).toHaveBeenCalledTimes(1);
+      expect(nobleBle.write.mock.calls.every(([, hex]) => /^3f23230037/.test(hex))).toBe(true);
+      expect(protocolV2Writer).not.toHaveBeenCalled();
     } finally {
       await transport.release(device.id);
     }
   });
 
+  test('invalidates and disconnects a Protocol V1 link after a response timeout', async () => {
+    const device = { id: 'classic-timeout-id', name: 'OneKey Classic' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    const v1ResponseHex = '3f23230002000000040a026f6b';
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    // A declared V1 acquire writes nothing, so every write here belongs to the
+    // call under test and none of them is answered.
+    nobleBle.write.mockImplementation(() => Promise.resolve());
+    const bleTransport = configureTransport(nobleBle);
+
+    await bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V1' });
+    await expect(
+      bleTransport.call(device.id, 'Initialize', {}, { timeoutMs: 5 })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.BleTimeoutError });
+
+    expect(nobleBle.unsubscribe).toHaveBeenCalledWith(device.id);
+    expect(nobleBle.disconnect).toHaveBeenCalledWith(device.id);
+    expect(bleTransport.getProtocolType(device.id)).toBeUndefined();
+  });
+
+  test('keeps another device V2 reader when force-cleaning a V1 call', async () => {
+    const device = { id: 'classic-force-clean-id', name: 'OneKey Classic' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    const v1ResponseHex = '3f23230002000000040a026f6b';
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      setTimeout(() => notificationHandler?.(device.id, v1ResponseHex), 0);
+      return Promise.resolve();
+    });
+    const bleTransport = configureTransport(nobleBle) as any;
+    const activeV1Call = createDeferred<string>();
+    const otherDeviceReader = createDeferred<Uint8Array>();
+    activeV1Call.promise.catch(() => undefined);
+    otherDeviceReader.promise.catch(() => undefined);
+    bleTransport.runPromise = activeV1Call;
+    bleTransport.v2FramePromises.set('device-b', otherDeviceReader);
+
+    await bleTransport.acquire({
+      uuid: device.id,
+      expectedProtocol: 'V1',
+      forceCleanRunPromise: true,
+    });
+
+    expect(bleTransport.v2FramePromises.get('device-b')).toBe(otherDeviceReader);
+    await bleTransport.release(device.id);
+  });
+
+  test('rejects a pending V2 reader when its device frame state resets', async () => {
+    const nobleBle = createNobleBle();
+    const bleTransport = configureTransport(nobleBle) as any;
+    const reader = createDeferred<Uint8Array>();
+    bleTransport.v2FramePromises.set('device-a', reader);
+    const result = Promise.race([
+      reader.promise.then(
+        () => 'resolved',
+        () => 'rejected'
+      ),
+      new Promise(resolve => {
+        setTimeout(() => resolve('pending'), 20);
+      }),
+    ]);
+
+    bleTransport.resetProtocolV2Frames('device-a');
+
+    await expect(result).resolves.toBe('rejected');
+  });
+
   test('throws when both protocol probes fail', async () => {
     const device = { id: 'dead-device-id', name: 'Unknown Device' };
     const nobleBle = createNobleBle(device);
@@ -216,23 +461,82 @@ describe('ElectronBleTransport protocol detection', () => {
     expect(transport.getProtocolType(device.id)).toBeUndefined();
   });
 
-  test('probes Protocol V2 instead of trusting the Pro2 name hint', async () => {
+  test('keeps a first expected Protocol V2 probe miss retryable', async () => {
+    const device = { id: 'first-v2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    const transport = configureTransport(nobleBle);
+    jest.spyOn(transport as any, 'probeProtocolV2').mockResolvedValue(false);
+
+    await expect(
+      transport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+    });
+
+    expect(nobleBle.connect).toHaveBeenCalledTimes(1);
+    expect(transport.getProtocolType(device.id)).toBeUndefined();
+  });
+
+  test('keeps a second expected Protocol V2 probe miss retryable', async () => {
+    const device = { id: 'retry-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    const transport = configureTransport(nobleBle);
+    jest.spyOn(transport as any, 'probeProtocolV2').mockResolvedValue(false);
+
+    await expect(
+      transport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+    });
+    await expect(
+      transport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+    });
+
+    expect(transport.getProtocolType(device.id)).toBeUndefined();
+  });
+
+  test('reports a stale bond when a previously confirmed Protocol V2 device stops responding', async () => {
+    const device = { id: 'reset-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    const transport = configureTransport(nobleBle);
+    const probe = jest.spyOn(transport as any, 'probeProtocolV2').mockResolvedValue(true);
+
+    await transport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+    await transport.release(device.id);
+    probe.mockResolvedValue(false);
+
+    await expect(
+      transport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceBondError,
+    });
+
+    expect(nobleBle.unsubscribe).toHaveBeenCalledWith(device.id);
+    expect(nobleBle.disconnect).toHaveBeenCalledWith(device.id);
+    expect(transport.getProtocolType(device.id)).toBeUndefined();
+  });
+
+  test('does not take a Protocol V2 hint from the BLE name', async () => {
     const device = { id: 'named-pro2-id', name: 'OneKey Pro 2' };
     const nobleBle = createNobleBle(device);
     let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
-    const probeResponse = ProtocolV2.encodeFrame(
-      schemas,
-      'Success',
-      { message: 'ok' },
-      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
-    );
 
     nobleBle.onNotification.mockImplementation(handler => {
       notificationHandler = handler;
       return jest.fn();
     });
+    let responseSeq = 0;
     nobleBle.write.mockImplementation(() => {
-      setTimeout(() => notificationHandler?.(device.id, bytesToHex(probeResponse)), 0);
+      responseSeq += 1;
+      const response = ProtocolV2.encodeFrame(
+        schemas,
+        'Success',
+        { message: 'ok' },
+        { router: PROTOCOL_V2_CHANNEL_BLE_UART, seq: responseSeq }
+      );
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(response)), 0);
       return Promise.resolve();
     });
     const transport = configureTransport(nobleBle);
@@ -244,15 +548,15 @@ describe('ElectronBleTransport protocol detection', () => {
           protocolType: 'V2',
         })
       );
-      expect(nobleBle.write).toHaveBeenCalledTimes(1);
+      expect(nobleBle.write.mock.calls.length).toBeGreaterThan(1);
       expect(transport.getProtocolType(device.id)).toBe('V2');
       await expect(transport.call(device.id, 'Ping', { message: 'after-probe' })).resolves.toEqual({
         type: 'Success',
         message: { message: 'ok' },
       });
-      const sentSeqs = nobleBle.write.mock.calls.map(([, hex]) =>
-        Number.parseInt(hex.slice(12, 14), 16)
-      );
+      const sentSeqs = nobleBle.write.mock.calls
+        .map(([, hex]) => Number.parseInt(hex.slice(12, 14), 16))
+        .filter(seq => seq > 0);
       expect(sentSeqs).toEqual([1, 2]);
     } finally {
       await transport.release(device.id);
@@ -304,19 +608,20 @@ describe('ElectronBleTransport protocol detection', () => {
     const device = { id: 'repeated-acquire-pro2-id', name: 'OneKey Pro 2' };
     const nobleBle = createNobleBle(device);
     let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
-    const response = ProtocolV2.encodeFrame(
-      schemas,
-      'Success',
-      { message: 'ok' },
-      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
-    );
-
     nobleBle.onNotification.mockImplementation(handler => {
       notificationHandler = handler;
       return jest.fn();
     });
+    let responseSeq = 0;
     nobleBle.write.mockImplementation(() => {
-      setTimeout(() => notificationHandler?.(device.id, bytesToHex(response)), 0);
+      responseSeq += 1;
+      const sequencedResponse = ProtocolV2.encodeFrame(
+        schemas,
+        'Success',
+        { message: 'ok' },
+        { router: PROTOCOL_V2_CHANNEL_BLE_UART, seq: responseSeq }
+      );
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(sequencedResponse)), 0);
       return Promise.resolve();
     });
     const transport = configureTransport(nobleBle);
@@ -331,12 +636,228 @@ describe('ElectronBleTransport protocol detection', () => {
         message: { message: 'ok' },
       });
 
+      const sentSeqs = nobleBle.write.mock.calls
+        .map(([, hex]) => Number.parseInt(hex.slice(12, 14), 16))
+        .filter(seq => seq > 0);
+      expect(sentSeqs).toEqual([1, 2, 3]);
+    } finally {
+      await transport.release(device.id);
+    }
+  });
+
+  test('subscribes to host disconnects once for the transport lifetime', async () => {
+    // The previous design registered a listener inside every acquire() and
+    // overwrote the cleanup entry without disposing the old one, so each
+    // acquire leaked a live handler and a delayed event from a superseded
+    // connection could tear down the current one. One transport-lifetime
+    // subscription removes that whole class of bug.
+    const device = { id: 'single-subscription-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    let responseSeq = 0;
+    nobleBle.write.mockImplementation(() => {
+      responseSeq += 1;
+      const response = ProtocolV2.encodeFrame(
+        schemas,
+        'Success',
+        { message: 'ok' },
+        { router: PROTOCOL_V2_CHANNEL_BLE_UART, seq: responseSeq }
+      );
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(response)), 0);
+      return Promise.resolve();
+    });
+    const bleTransport = configureTransport(nobleBle);
+
+    try {
+      expect(nobleBle.onDeviceDisconnected).toHaveBeenCalledTimes(1);
+
+      await bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+      await bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+
+      expect(nobleBle.onDeviceDisconnected).toHaveBeenCalledTimes(1);
+      expect(bleTransport.getProtocolType(device.id)).toBe('V2');
+      await expect(
+        bleTransport.call(device.id, 'Ping', { message: 'after-reacquire' })
+      ).resolves.toEqual({
+        type: 'Success',
+        message: { message: 'ok' },
+      });
+    } finally {
+      await bleTransport.release(device.id);
+    }
+  });
+
+  test('reports a device that drops after a logical release (OK-60486)', async () => {
+    // A logical release keeps the native link alive for the keep-alive window.
+    // A drop during that window must still reach consumers, or the UI keeps
+    // showing the device as connected forever.
+    const device = { id: 'idle-drop-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    const emitter = new EventEmitter();
+    let disconnectHandler:
+      | ((d: { id: string; name: string; reason?: EBleDisconnectReason }) => void)
+      | undefined;
+    nobleBle.onDeviceDisconnected.mockImplementation(handler => {
+      disconnectHandler = handler;
+      return jest.fn();
+    });
+    echoProtocolV2(nobleBle, device.id);
+    const transportDisconnect = jest.fn();
+    emitter.on('transport-device-disconnect', transportDisconnect);
+    const bleTransport = configureTransport(nobleBle, emitter);
+
+    await bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+    await bleTransport.release(device.id);
+
+    disconnectHandler?.({ ...device, reason: EBleDisconnectReason.DeviceDisconnected });
+
+    expect(transportDisconnect).toHaveBeenCalledWith({
+      id: device.id,
+      connectId: device.id,
+      name: device.name,
+    });
+  });
+
+  test('reports an idle keep-alive release as a device disconnect', async () => {
+    // The main process reclaims idle links on its own timer. That is still a
+    // closed link, and consumers track link liveness, so it is reported like
+    // any other drop. Nothing reconnects on its own, so the state settles once
+    // until the user acts.
+    const device = { id: 'keep-alive-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    const emitter = new EventEmitter();
+    let disconnectHandler:
+      | ((d: { id: string; name: string; reason?: EBleDisconnectReason }) => void)
+      | undefined;
+    nobleBle.onDeviceDisconnected.mockImplementation(handler => {
+      disconnectHandler = handler;
+      return jest.fn();
+    });
+    echoProtocolV2(nobleBle, device.id);
+    const transportDisconnect = jest.fn();
+    emitter.on('transport-device-disconnect', transportDisconnect);
+    const bleTransport = configureTransport(nobleBle, emitter);
+
+    await bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+    disconnectHandler?.({ ...device, reason: EBleDisconnectReason.IdleKeepAlive });
+
+    expect(transportDisconnect).toHaveBeenCalledWith({
+      id: device.id,
+      connectId: device.id,
+      name: device.name,
+    });
+    // The link really is gone, so cached link state must be dropped too.
+    expect(bleTransport.getProtocolType(device.id)).toBeUndefined();
+  });
+
+  test('treats a disconnect with no reason as a real device drop', async () => {
+    // An older host bridge does not send `reason`; defaulting to "device left"
+    // preserves the pre-existing behaviour rather than silently ignoring it.
+    const device = { id: 'legacy-host-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    const emitter = new EventEmitter();
+    let disconnectHandler: ((d: { id: string; name: string }) => void) | undefined;
+    nobleBle.onDeviceDisconnected.mockImplementation(handler => {
+      disconnectHandler = handler;
+      return jest.fn();
+    });
+    echoProtocolV2(nobleBle, device.id);
+    const transportDisconnect = jest.fn();
+    emitter.on('transport-device-disconnect', transportDisconnect);
+    const bleTransport = configureTransport(nobleBle, emitter);
+
+    await bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+    disconnectHandler?.(device);
+
+    expect(transportDisconnect).toHaveBeenCalledWith({
+      id: device.id,
+      connectId: device.id,
+      name: device.name,
+    });
+  });
+
+  test('preserves the active Protocol V2 link when the same schema is configured again', async () => {
+    const device = { id: 'stable-schema-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    let responseSeq = 0;
+    nobleBle.write.mockImplementation(() => {
+      responseSeq += 1;
+      const response = ProtocolV2.encodeFrame(
+        schemas,
+        'Success',
+        { message: 'ok' },
+        { router: PROTOCOL_V2_CHANNEL_BLE_UART, seq: responseSeq }
+      );
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(response)), 0);
+      return Promise.resolve();
+    });
+    const bleTransport = configureTransport(nobleBle);
+
+    try {
+      await bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+      const invalidateAllLinks = jest.spyOn(
+        (bleTransport as any).protocolV2Links,
+        'invalidateAllLinks'
+      );
+      bleTransport.configureProtocolV2(protocolV2Schema);
+      await new Promise<void>(resolve => {
+        setTimeout(resolve, 0);
+      });
+      expect(invalidateAllLinks).not.toHaveBeenCalled();
+      await expect(
+        bleTransport.call(device.id, 'Ping', { message: 'same-schema' })
+      ).resolves.toEqual({
+        type: 'Success',
+        message: { message: 'ok' },
+      });
       const sentSeqs = nobleBle.write.mock.calls.map(([, hex]) =>
         Number.parseInt(hex.slice(12, 14), 16)
       );
       expect(sentSeqs).toEqual([1, 2]);
     } finally {
-      await transport.release(device.id);
+      await bleTransport.release(device.id);
+    }
+  });
+
+  test('rejects oversized Protocol V2 requests before writing to Electron BLE', async () => {
+    const device = { id: 'oversized-frame-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(probeResponse)), 0);
+      return Promise.resolve();
+    });
+    const bleTransport = configureTransport(nobleBle);
+
+    try {
+      await bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+      expect(nobleBle.write).toHaveBeenCalledTimes(1);
+
+      await expect(
+        bleTransport.call(device.id, 'Ping', { message: 'x'.repeat(2048) })
+      ).rejects.toThrow(/Protocol V2 frame too large for transport/);
+      expect(nobleBle.write).toHaveBeenCalledTimes(1);
+    } finally {
+      await bleTransport.release(device.id);
     }
   });
 });