@onekeyfe/hd-transport-web-device 1.2.8-alpha.103 → 1.2.8-alpha.104

package/__tests__/webusb-identity-probe.test.ts

@@ -120,53 +120,6 @@ describe('WebUSB identity probe ownership', () => {
     }
   );
 
-  test('clears the Core session while retaining ownership after normal native close fails', async () => {
-    const previous = TransportManager.transport;
-    const { settings } = DataManager;
-    const active = createAcquiredTransport();
-    TransportManager.transport = active as unknown as Transport;
-    const selected = new Device({
-      path: 'USB_PATH',
-      id: 'USB_PATH',
-      name: 'Mock device',
-      commType: 'webusb',
-      session: 'USB_PATH',
-      debug: false,
-    });
-    selected.mainId = 'USB_PATH';
-    selected.deviceConnector = {
-      release: (path: string) => active.release(path),
-    } as never;
-    (selected as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
-
-    try {
-      await active.acquire({ path: 'USB_PATH' });
-      device.close.mockRejectedValueOnce(new Error('native close failed'));
-
-      await selected.release();
-
-      expect(selected.originalDescriptor.session).toBeNull();
-      expect(selected.hasDeviceAcquire()).toBe(false);
-      expect(device.opened).toBe(true);
-
-      const competing = new WebUsbTransport();
-      competing.init({ debug: jest.fn() });
-      await expect(competing.connectToDevice('USB_PATH', true)).rejects.toThrow(
-        'USB device is already in use'
-      );
-    } finally {
-      device.close.mockImplementation(() => {
-        device.opened = false;
-        return Promise.resolve();
-      });
-      await active.release('USB_PATH');
-      await active.stop();
-      TransportManager.transport = previous;
-      DataManager.settings = settings;
-      jest.restoreAllMocks();
-    }
-  });
-
   test('does not replace the transport until USB cleanup completes, or after it fails', async () => {
     const previous = TransportManager.transport;
     const { settings } = DataManager;

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

@@ -1,5 +1,5 @@
 import transport from '@onekeyfe/hd-transport';
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import WebUsbTransport from '../src/webusb';
 
@@ -64,97 +64,6 @@ describe('WebUsbTransport protocol probe cache', () => {
     }
   );
 
-  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';
@@ -182,129 +91,6 @@ 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('closes every owned handle after claimInterface fails across re-enumeration', async () => {
-    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),
-    };
-    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(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';
@@ -407,10 +193,6 @@ 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/dist/index.d.ts

@@ -12,16 +12,8 @@ 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;
@@ -76,13 +68,6 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     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.
@@ -143,8 +128,7 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     /**
      * Connect to device with retry mechanism
      */
-    connect(path: string, first: boolean, options?: WebUsbConnectOptions): Promise<undefined>;
-    private shouldUseLegacyV1Connection;
+    connect(path: string, first: boolean): Promise<undefined>;
     /**
      * 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.
@@ -154,8 +138,7 @@ 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, options?: WebUsbConnectOptions): Promise<undefined>;
-    private claimDeviceInterface;
+    connectToDevice(path: string, first: boolean): Promise<undefined>;
     private assertHandleAvailable;
     private claimNormalHandle;
     private releaseNormalHandles;
@@ -163,7 +146,6 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     private claimIdentityProbeHandle;
     private releaseIdentityProbeHandle;
     private closeOpenDevice;
-    private closeDeviceHandle;
     private clearEndpointHalt;
     /**
      * With the protocol cache surviving release(), deviceProtocol presence no