@onekeyfe/hd-transport-web-device 1.2.8-alpha.13 → 1.2.8-alpha.131

package/__tests__/webusb-protocol-cache.test.ts

@@ -1,5 +1,5 @@
 import transport from '@onekeyfe/hd-transport';
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import WebUsbTransport from '../src/webusb';
 
@@ -64,6 +64,157 @@ describe('WebUsbTransport protocol probe cache', () => {
     }
   );
 
+  test.each([undefined, 2, 1])(
+    'configures a replacement V1 handle only when needed during packet recovery: %s',
+    async configurationValue => {
+      const webusb = new WebUsbTransport();
+      const path = 'replacement-v1-device';
+      const state = webusb as unknown as {
+        Log: { debug: jest.Mock };
+        deviceProtocol: Map<string, 'V1' | 'V2'>;
+        reconnectForPacketIoRetry: (
+          path: string,
+          direction: 'in' | 'out',
+          attempt: number,
+          error: unknown
+        ) => Promise<void>;
+      };
+      state.Log = { debug: jest.fn() };
+      state.deviceProtocol.set(path, 'V1');
+      const replacement = {
+        opened: false,
+        configuration: configurationValue ? { configurationValue } : undefined,
+        configurations: [],
+        open: jest.fn().mockImplementation(() => {
+          replacement.opened = true;
+          return Promise.resolve();
+        }),
+        selectConfiguration: jest.fn().mockImplementation((value: number) => {
+          replacement.configuration = { configurationValue: value };
+          return Promise.resolve();
+        }),
+        reset: jest.fn(),
+        clearHalt: jest.fn(),
+        claimInterface: jest.fn().mockImplementation(() => {
+          if (replacement.configuration?.configurationValue !== 1) {
+            return Promise.reject(new Error('USB configuration is not selected'));
+          }
+          return Promise.resolve();
+        }),
+      };
+      let current = { opened: false } as USBDevice;
+      jest.spyOn(webusb, 'findDevice').mockImplementation(() => Promise.resolve(current));
+      jest.spyOn(webusb, 'getConnectedDevices').mockImplementation(() => {
+        current = replacement as unknown as USBDevice;
+        return Promise.resolve([]);
+      });
+
+      await state.reconnectForPacketIoRetry(path, 'in', 0, new Error('transferIn failed'));
+
+      expect(replacement.selectConfiguration).toHaveBeenCalledTimes(
+        configurationValue === 1 ? 0 : 1
+      );
+      if (configurationValue !== 1) {
+        expect(replacement.selectConfiguration).toHaveBeenCalledWith(1);
+      }
+      expect(replacement.open).toHaveBeenCalledTimes(1);
+      expect(replacement.claimInterface).toHaveBeenCalledWith(0);
+      expect(replacement.reset).not.toHaveBeenCalled();
+      expect(replacement.clearHalt).not.toHaveBeenCalled();
+    }
+  );
+
+  test('uses the SDK 1.1.31 WebUSB sequence with descriptor endpoints for Protocol V1', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const logger = { debug: jest.fn() };
+    const path = 'legacy-v1-device';
+    const device = {
+      opened: false,
+      configuration: { configurationValue: 1 },
+      configurations: [
+        {
+          interfaces: [
+            {
+              interfaceNumber: 7,
+              alternates: [
+                {
+                  interfaceClass: 0xff,
+                  endpoints: [
+                    { direction: 'in', endpointNumber: 3 },
+                    { direction: 'out', endpointNumber: 4 },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+      open: jest.fn().mockImplementation(() => {
+        device.opened = true;
+        return Promise.resolve();
+      }),
+      reset: jest.fn().mockResolvedValue(undefined),
+      selectConfiguration: jest.fn().mockResolvedValue(undefined),
+      claimInterface: jest.fn().mockResolvedValue(undefined),
+      clearHalt: jest.fn().mockResolvedValue(undefined),
+    };
+    webusb.Log = logger;
+    webusb.findDevice = jest.fn().mockResolvedValue(device);
+    webusb.getConnectedDevices = jest.fn().mockResolvedValue([]);
+
+    await webusb.connect(path, true, { expectedProtocol: 'V1' });
+
+    expect(device.open).toHaveBeenCalledTimes(1);
+    expect(device.selectConfiguration).toHaveBeenCalledWith(1);
+    expect(device.reset).toHaveBeenCalledTimes(1);
+    expect(device.claimInterface).toHaveBeenCalledWith(7);
+    expect(webusb.deviceEndpoints.get(path)).toEqual({
+      interfaceNumber: 7,
+      endpointIn: 3,
+      endpointOut: 4,
+    });
+    expect(device.selectConfiguration.mock.invocationCallOrder[0]).toBeLessThan(
+      device.reset.mock.invocationCallOrder[0]
+    );
+    expect(device.reset.mock.invocationCallOrder[0]).toBeLessThan(
+      device.claimInterface.mock.invocationCallOrder[0]
+    );
+    expect(webusb.getConnectedDevices).not.toHaveBeenCalled();
+    expect(device.clearHalt).not.toHaveBeenCalled();
+    expect(logger.debug).toHaveBeenCalledWith(
+      '[WebUsbTransport][lifecycle]',
+      expect.objectContaining({
+        event: 'connect-attempt',
+        phase: 'start',
+        connectionStrategy: 'protocol-v1-legacy-1.1.31',
+      })
+    );
+  });
+
+  test('keeps the current WebUSB sequence when a cached V1 protocol is force-reprobed', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'force-reprobe-device';
+    const device = {
+      opened: true,
+      configuration: { configurationValue: 1 },
+      configurations: [],
+      reset: jest.fn().mockResolvedValue(undefined),
+      selectConfiguration: jest.fn().mockResolvedValue(undefined),
+      claimInterface: jest.fn().mockResolvedValue(undefined),
+      clearHalt: jest.fn().mockResolvedValue(undefined),
+    };
+    webusb.Log = { debug: jest.fn() };
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.findDevice = jest.fn().mockResolvedValue(device);
+    webusb.getConnectedDevices = jest.fn().mockResolvedValue([]);
+
+    await webusb.connectToDevice(path, true, { forceProtocolDetection: true });
+
+    expect(device.reset).toHaveBeenCalledTimes(1);
+    expect(webusb.getConnectedDevices).toHaveBeenCalledTimes(1);
+    expect(device.clearHalt).toHaveBeenCalledTimes(2);
+  });
+
   test('reports claimInterface failures as WebUSB device access errors', async () => {
     const webusb = new WebUsbTransport();
     const path = 'connected-usb-device';
@@ -91,6 +242,151 @@ describe('WebUsbTransport protocol probe cache', () => {
     });
   });
 
+  test('does not retry a typed WebUSB handle error', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const logger = { debug: jest.fn() };
+    const path = 'sensitive-device-path';
+    const accessError = ERRORS.TypedError(
+      HardwareErrorCode.WebUsbDeviceAccessError,
+      'Unable to claim interface',
+      { operation: 'claimInterface' }
+    );
+    webusb.Log = logger;
+    webusb.connectToDevice = jest.fn().mockRejectedValue(accessError);
+
+    await expect(webusb.connect(path, true)).rejects.toBe(accessError);
+
+    expect(webusb.connectToDevice).toHaveBeenCalledTimes(1);
+    expect(logger.debug).toHaveBeenCalledWith(
+      '[WebUsbTransport][lifecycle]',
+      expect.objectContaining({
+        event: 'connect-attempt',
+        phase: 'error',
+        attempt: 1,
+        maxAttempts: 5,
+        willRetry: false,
+        errorCode: HardwareErrorCode.WebUsbDeviceAccessError,
+      })
+    );
+    expect(JSON.stringify(logger.debug.mock.calls)).not.toContain(path);
+  });
+
+  test('preserves the existing reconnect retry for a transient disconnect', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const disconnected = ERRORS.TypedError(HardwareErrorCode.BridgeDeviceDisconnected);
+    webusb.Log = { debug: jest.fn() };
+    webusb.connectToDevice = jest
+      .fn()
+      .mockRejectedValueOnce(disconnected)
+      .mockResolvedValueOnce(undefined);
+
+    await expect(webusb.connect('device-path', true)).resolves.toBeUndefined();
+
+    expect(webusb.connectToDevice).toHaveBeenCalledTimes(2);
+  });
+
+  test.each([false, true])('retains claim error when cleanup fails=%s', async cleanupFails => {
+    const webusb = new WebUsbTransport() as any;
+    const logger = { debug: jest.fn() };
+    const path = 'sensitive-device-path';
+    const claimError = Object.assign(new Error('Unable to claim interface'), {
+      name: 'NetworkError',
+    });
+    const usbInterface = {
+      interfaceNumber: 0,
+      claimed: false,
+      alternates: [],
+    };
+    const originalDevice = {
+      vendorId: 0x1209,
+      productId: 0x53c1,
+      serialNumber: path,
+      opened: false,
+      configuration: { configurationValue: 1, interfaces: [usbInterface] },
+      configurations: [],
+      open: jest.fn().mockImplementation(() => {
+        originalDevice.opened = true;
+        return Promise.resolve();
+      }),
+      reset: jest.fn().mockResolvedValue(undefined),
+      selectConfiguration: jest.fn().mockResolvedValue(undefined),
+      claimInterface: jest.fn().mockResolvedValue(undefined),
+      releaseInterface: jest.fn().mockResolvedValue(undefined),
+      close: jest.fn().mockImplementation(() => {
+        originalDevice.opened = false;
+        return Promise.resolve();
+      }),
+      clearHalt: jest.fn().mockResolvedValue(undefined),
+    };
+    const replacementDevice = {
+      ...originalDevice,
+      opened: false,
+      open: jest.fn().mockImplementation(() => {
+        replacementDevice.opened = true;
+        return Promise.resolve();
+      }),
+      reset: jest.fn().mockResolvedValue(undefined),
+      selectConfiguration: jest.fn().mockResolvedValue(undefined),
+      claimInterface: jest.fn().mockRejectedValue(claimError),
+      releaseInterface: jest.fn().mockResolvedValue(undefined),
+      close: jest.fn().mockImplementation(() => {
+        replacementDevice.opened = false;
+        return Promise.resolve();
+      }),
+      clearHalt: jest.fn().mockResolvedValue(undefined),
+    };
+    if (cleanupFails) {
+      replacementDevice.close.mockRejectedValueOnce(new Error('native close failed'));
+    }
+    webusb.Log = logger;
+    webusb.usb = { getDevices: jest.fn().mockResolvedValue([replacementDevice]) };
+    webusb.deviceList = [{ path, device: originalDevice, commType: 'webusb' }];
+    webusb.rotateProtocolV2UsbGeneration = jest.fn().mockResolvedValue(undefined);
+
+    await expect(webusb.acquire({ path })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.WebUsbDeviceAccessError,
+    });
+
+    expect(originalDevice.claimInterface).not.toHaveBeenCalled();
+    expect(replacementDevice.claimInterface).toHaveBeenCalledTimes(1);
+    expect(originalDevice.releaseInterface).not.toHaveBeenCalled();
+    expect(replacementDevice.releaseInterface).not.toHaveBeenCalled();
+    expect(originalDevice.close).toHaveBeenCalledTimes(1);
+    expect(replacementDevice.close).toHaveBeenCalledTimes(1);
+    expect(originalDevice.opened).toBe(false);
+    expect(replacementDevice.opened).toBe(cleanupFails);
+    if (cleanupFails) {
+      expect(logger.debug).toHaveBeenCalledWith(
+        '[WebUsbTransport][lifecycle]',
+        expect.objectContaining({
+          event: 'acquire-cleanup',
+          phase: 'error',
+          errorMessage: 'native close failed',
+        })
+      );
+      const competing = new WebUsbTransport();
+      jest
+        .spyOn(competing, 'findDevice')
+        .mockResolvedValue(replacementDevice as unknown as USBDevice);
+      await expect(competing.connectToDevice(path, true)).rejects.toThrow(
+        'USB device is already in use'
+      );
+      await webusb.release(path);
+      expect(replacementDevice.opened).toBe(false);
+    }
+    expect(logger.debug).toHaveBeenCalledWith(
+      '[WebUsbTransport][lifecycle]',
+      expect.objectContaining({
+        event: 'handle-operation',
+        operation: 'releaseInterface',
+        phase: 'skipped',
+        reason: 'interface-not-claimed',
+        deviceRefId: expect.any(Number),
+      })
+    );
+    expect(JSON.stringify(logger.debug.mock.calls)).not.toContain(path);
+  });
+
   test('reports transferIn failures as WebUSB device access errors', async () => {
     const webusb = new WebUsbTransport() as any;
     const path = 'connected-usb-device';
@@ -193,6 +489,10 @@ describe('WebUsbTransport protocol probe cache', () => {
 
     await expect(webusb.acquire({ path, expectedProtocol: 'V1' })).resolves.toBe(path);
 
+    expect(webusb.connect).toHaveBeenCalledWith(path, true, {
+      expectedProtocol: 'V1',
+      forceProtocolDetection: undefined,
+    });
     expect(webusb.detectProtocol).not.toHaveBeenCalled();
     expect(webusb.deviceProtocol.get(path)).toBe('V1');
     expect(webusb.acquiredPaths.has(path)).toBe(true);

package/__tests__/webusb-protocol-v2-timeout.test.ts

@@ -102,7 +102,7 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
     expect(webusb.deviceProtocol.get(path)).toBe('V2');
   });
 
-  test('reports DeviceNotFound when automatic protocol detection exhausts both probes', async () => {
+  test('reports a typed probe failure when automatic detection exhausts both protocols', async () => {
     const webusb = new WebUsbTransport() as any;
     const path = 'unresponsive-webusb';
     webusb.probeProtocolV1 = jest.fn().mockResolvedValue(false);
@@ -111,7 +111,7 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
     webusb.closeConnectionAfterProbe = jest.fn().mockResolvedValue(undefined);
 
     await expect(webusb.detectProtocol(path)).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotFound,
+      errorCode: HardwareErrorCode.TransportProtocolProbeFailed,
     });
 
     expect(webusb.probeProtocolV1).toHaveBeenCalledTimes(1);
@@ -154,7 +154,20 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
     expect(webusb.deviceProtocol.get(path)).toBe('V2');
   });
 
-  test('reports a device initialization failure only after the bounded retry is exhausted', async () => {
+  test('reports a strict V1 probe miss without falling back to another protocol', async () => {
+    const webusb = new WebUsbTransport() as any;
+    webusb.probeProtocolV1 = jest.fn().mockResolvedValue(false);
+    webusb.probeProtocolV2 = jest.fn();
+    webusb.closeConnectionAfterProbe = jest.fn().mockResolvedValue(undefined);
+    await expect(webusb.detectProtocol('classic-webusb', 'V1')).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.TransportProtocolProbeFailed,
+      params: { expectedProtocol: 'V1' },
+    });
+    expect(webusb.probeProtocolV2).not.toHaveBeenCalled();
+    expect(webusb.closeConnectionAfterProbe).toHaveBeenCalledTimes(1);
+  });
+
+  test('reports a typed protocol probe failure only after the bounded retry is exhausted', async () => {
     const webusb = new WebUsbTransport() as any;
     const path = 'pro2-webusb';
     webusb.probeProtocolV1 = jest.fn();
@@ -163,8 +176,8 @@ describe('WebUsbTransport Protocol V2 timeout recovery', () => {
     webusb.closeConnectionAfterProbe = jest.fn().mockResolvedValue(undefined);
 
     await expect(webusb.detectProtocol(path, 'V2')).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceInitializeFailed,
-      message: 'Protocol V2 probe timeout after 2 attempts',
+      errorCode: HardwareErrorCode.TransportProtocolProbeFailed,
+      params: { expectedProtocol: 'V2', attempts: 2 },
     });
 
     expect(webusb.probeProtocolV2).toHaveBeenCalledTimes(2);

package/dist/electron-ble-transport.d.ts

@@ -25,6 +25,8 @@ export default class ElectronBleTransport {
     Log?: any;
     emitter?: EventEmitter;
     private connectedDevices;
+    private retainedDevices;
+    private protocolV2CallCounts;
     private acquiringDevices;
     private deviceProtocol;
     private deviceProtocolHints;
@@ -59,9 +61,10 @@ export default class ElectronBleTransport {
         debug: boolean;
         id: string;
         name: string | null;
+        bleColorCode?: string | undefined;
         protocolType?: ProtocolType | undefined;
     }>;
-    release(id: string, _onclose?: boolean, keepSession?: boolean): Promise<void>;
+    release(id: string, onclose?: boolean, keepSession?: boolean): Promise<void>;
     disconnect(id: string): Promise<void>;
     private releaseNative;
     private releaseLogical;

package/dist/electron-ble-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"electron-ble-transport.d.ts","sourceRoot":"","sources":["../src/electron-ble-transport.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"electron-ble-transport.d.ts","sourceRoot":"","sources":["../src/electron-ble-transport.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -12,7 +12,16 @@ interface DeviceInfo extends OneKeyDeviceInfoBase {
     device: USBDevice;
     protocolType?: ProtocolType;
 }
+interface WebUsbConnectOptions {
+    expectedProtocol?: ProtocolType;
+    forceProtocolDetection?: boolean;
+}
 declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
+    private readonly identityProbe;
+    private readonly transportInstanceId;
+    private handleOperationSequence;
+    private deviceLogSequence;
+    private deviceLogIds;
     messages: ReturnType<typeof _onekeyfe_hd_transport__default.parseConfigure> | undefined;
     /** Protobuf schema for Protocol V2 transports. */
     messagesV2: ReturnType<typeof _onekeyfe_hd_transport__default.parseConfigure> | undefined;
@@ -29,6 +38,11 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     private staleProtocolPaths;
     /** Paths currently acquired (between a successful acquire() and its release()). */
     private acquiredPaths;
+    private identityProbeDevices;
+    private normalDevices;
+    private pendingHandleOperations;
+    private stopPromise?;
+    private identityProbeCleanupPaths;
     /**
      * The exact USBDevice object each cached protocol was probed against. The
      * browser returns the same object identity for a device as long as it stays
@@ -53,11 +67,22 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     configurationId: number;
     endpointId: number;
     interfaceId: number;
-    constructor();
+    constructor(identityProbe?: boolean);
     /**
      * Initialize WebUSB transport
      */
     init(logger: any, emitter?: EventEmitter): void;
+    stop(): Promise<void>;
+    private stopResources;
+    private assertRunning;
+    private runHandleOperation;
+    private getInterfaceClaimed;
+    private getDeviceLogId;
+    private getHandleLogState;
+    private getDiagnosticError;
+    private logLifecycle;
+    private logSkippedHandleOperation;
+    private runLoggedHandleOperation;
     /**
      * Announce that a USB device left. Called from the module-scoped disconnect
      * listener, which is why it is public rather than inlined.
@@ -118,7 +143,8 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     /**
      * Connect to device with retry mechanism
      */
-    connect(path: string, first: boolean): Promise<undefined>;
+    connect(path: string, first: boolean, options?: WebUsbConnectOptions): Promise<undefined>;
+    private shouldUseLegacyV1Connection;
     /**
      * Discover vendor-class (0xFF) interface and its IN/OUT endpoint numbers from USB descriptors.
      * Falls back to legacy hardcoded values if no vendor interface is found.
@@ -128,8 +154,16 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
      * Connect to specific device.
      * Discovers interface/endpoint numbers from USB descriptors on first connection.
      */
-    connectToDevice(path: string, first: boolean): Promise<undefined>;
+    connectToDevice(path: string, first: boolean, options?: WebUsbConnectOptions): Promise<undefined>;
+    private claimDeviceInterface;
+    private assertHandleAvailable;
+    private claimNormalHandle;
+    private releaseNormalHandles;
+    private isHandleOwnershipError;
+    private claimIdentityProbeHandle;
+    private releaseIdentityProbeHandle;
     private closeOpenDevice;
+    private closeDeviceHandle;
     private clearEndpointHalt;
     /**
      * With the protocol cache surviving release(), deviceProtocol presence no
@@ -221,6 +255,8 @@ declare class ElectronBleTransport {
     Log?: any;
     emitter?: EventEmitter;
     private connectedDevices;
+    private retainedDevices;
+    private protocolV2CallCounts;
     /**
      * Devices whose acquire() is still in flight.
      *
@@ -276,9 +312,10 @@ declare class ElectronBleTransport {
         debug: boolean;
         id: string;
         name: string | null;
+        bleColorCode?: string | undefined;
         protocolType?: ProtocolType | undefined;
     }>;
-    release(id: string, _onclose?: boolean, keepSession?: boolean): Promise<void>;
+    release(id: string, onclose?: boolean, keepSession?: boolean): Promise<void>;
     disconnect(id: string): Promise<void>;
     private releaseNative;
     private releaseLogical;