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

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

@@ -1,5 +1,5 @@
 import transport, { PROTOCOL_V2_CHANNEL_BLE_UART, bytesToHex } from '@onekeyfe/hd-transport';
-import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
+import { EBleDisconnectReason, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 import EventEmitter from 'events';
 
 import ElectronBleTransport from '../src/electron-ble-transport';
@@ -73,8 +73,26 @@ const protocolV2Schema = {
         },
       },
     },
+    Failure: {
+      fields: {
+        code: {
+          type: 'FailureType',
+          id: 1,
+        },
+        message: {
+          type: 'string',
+          id: 2,
+        },
+      },
+    },
+    FailureType: {
+      values: {
+        Failure_ProcessError: 5,
+      },
+    },
     MessageType: {
       values: {
+        MessageType_Failure: 3,
         MessageType_ProtocolInfoRequest: 60200,
         MessageType_ProtocolInfo: 60201,
         MessageType_Ping: 60206,
@@ -134,6 +152,30 @@ const configureTransport = (
   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;
@@ -294,12 +336,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('reconnects Protocol V1 with a non-destructive GetFeatures probe', 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;
@@ -332,7 +378,10 @@ describe('ElectronBleTransport protocol detection', () => {
           uuid: device.id,
         })
       );
-      expect(nobleBle.write).toHaveBeenCalledTimes(2);
+      // 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 {
@@ -345,19 +394,13 @@ describe('ElectronBleTransport protocol detection', () => {
     const nobleBle = createNobleBle(device);
     let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
     const v1ResponseHex = '3f23230002000000040a026f6b';
-    let writeCount = 0;
-
     nobleBle.onNotification.mockImplementation(handler => {
       notificationHandler = handler;
       return jest.fn();
     });
-    nobleBle.write.mockImplementation(() => {
-      writeCount += 1;
-      if (writeCount === 1) {
-        setTimeout(() => notificationHandler?.(device.id, v1ResponseHex), 0);
-      }
-      return Promise.resolve();
-    });
+    // 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' });
@@ -436,7 +479,133 @@ describe('ElectronBleTransport protocol detection', () => {
     expect(transport.getProtocolType(device.id)).toBeUndefined();
   });
 
-  test('probes Protocol V2 instead of trusting the Pro2 name hint', async () => {
+  test('surfaces Protocol V2 link disabled while the initial V1 probe is active', async () => {
+    const device = { id: 'usb-priority-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();
+    });
+    nobleBle.write.mockImplementation(() => {
+      const response = ProtocolV2.encodeFrame(
+        schemas,
+        'Failure',
+        { code: 5, message: 'link disabled' },
+        { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+      );
+      const splitAt = 4;
+      setTimeout(() => {
+        notificationHandler?.(device.id, bytesToHex(response.subarray(0, splitAt)));
+        notificationHandler?.(device.id, bytesToHex(response.subarray(splitAt)));
+      }, 0);
+      return Promise.resolve();
+    });
+    const transport = configureTransport(nobleBle);
+
+    await expect(transport.acquire({ uuid: device.id })).rejects.toMatchObject({
+      name: 'ProtocolV2LinkDisabledError',
+      failureCode: 'Failure_ProcessError',
+      firmwareMessage: 'link disabled',
+    });
+    expect(nobleBle.write).toHaveBeenCalledTimes(1);
+    expect(nobleBle.unsubscribe).toHaveBeenCalledWith(device.id);
+    expect(nobleBle.disconnect).toHaveBeenCalledWith(device.id);
+  });
+
+  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('fails Protocol V2 acquire immediately when subscribe reports insufficient encryption', async () => {
+    const device = { id: 'stale-bond-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    nobleBle.subscribe.mockRejectedValue(new Error('Encryption is insufficient'));
+    const transport = configureTransport(nobleBle);
+    const probe = jest.spyOn(transport as any, 'probeProtocolV2');
+
+    await expect(
+      transport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceBondError,
+    });
+
+    expect(probe).not.toHaveBeenCalled();
+    expect(nobleBle.unsubscribe).toHaveBeenCalledWith(device.id);
+    expect(nobleBle.disconnect).toHaveBeenCalledWith(device.id);
+  });
+
+  test('keeps stale-bond subscribe mapping out of Protocol V1 acquire', async () => {
+    const device = { id: 'classic-v1-id', name: 'OneKey Classic' };
+    const nobleBle = createNobleBle(device);
+    nobleBle.subscribe.mockRejectedValue(new Error('Encryption is insufficient'));
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await transport.acquire({ uuid: device.id, expectedProtocol: 'V1' });
+      throw new Error('Expected Protocol V1 acquire to fail');
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error);
+      expect((error as Error).message).toBe('Encryption is insufficient');
+      expect((error as { errorCode?: unknown }).errorCode).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;
@@ -466,15 +635,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);
@@ -554,30 +723,28 @@ describe('ElectronBleTransport protocol detection', () => {
         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, 3]);
     } finally {
       await transport.release(device.id);
     }
   });
 
-  test('ignores a delayed disconnect event from the previous BLE connection', async () => {
-    const device = { id: 'delayed-disconnect-pro2-id', name: 'OneKey Pro 2' };
+  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;
-    const disconnectHandlers: Array<
-      (disconnectedDevice: { id: string; name: string | null }) => void
-    > = [];
     nobleBle.onNotification.mockImplementation(handler => {
       notificationHandler = handler;
       return jest.fn();
     });
-    nobleBle.onDeviceDisconnected.mockImplementation(handler => {
-      disconnectHandlers.push(handler);
-      return jest.fn();
-    });
     let responseSeq = 0;
     nobleBle.write.mockImplementation(() => {
       responseSeq += 1;
@@ -593,14 +760,15 @@ describe('ElectronBleTransport protocol detection', () => {
     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' });
 
-      disconnectHandlers[0]?.(device);
-
+      expect(nobleBle.onDeviceDisconnected).toHaveBeenCalledTimes(1);
       expect(bleTransport.getProtocolType(device.id)).toBe('V2');
       await expect(
-        bleTransport.call(device.id, 'Ping', { message: 'after-stale-disconnect' })
+        bleTransport.call(device.id, 'Ping', { message: 'after-reacquire' })
       ).resolves.toEqual({
         type: 'Success',
         message: { message: 'ok' },
@@ -610,6 +778,95 @@ describe('ElectronBleTransport protocol detection', () => {
     }
   });
 
+  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);