@onekeyfe/hd-core 1.2.8-alpha.52 → 1.2.8-alpha.53

package/__tests__/core-dispose.test.ts

@@ -1,4 +1,7 @@
-import Core, { initConnector } from '../src/core';
+import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
+
+import Core, { init, initConnector, initCore, switchTransport } from '../src/core';
+import DataManager from '../src/data-manager/DataManager';
 import TransportManager from '../src/data-manager/TransportManager';
 import { DevicePool } from '../src/device/DevicePool';
 
@@ -31,4 +34,114 @@ describe('Core.dispose', () => {
     expect(transportStop).toHaveBeenCalledTimes(1);
     expect(disposeDevicePool).toHaveBeenCalledTimes(1);
   });
+
+  test('disposal rejects a queued switch without recreating a transport or connector', async () => {
+    const previous = TransportManager.transport;
+    const { settings } = DataManager;
+    const active = { stop: jest.fn().mockResolvedValue(undefined) };
+    const replacement = jest.fn(() => ({ stop: jest.fn().mockResolvedValue(undefined) }));
+    TransportManager.transport = active as never;
+    const core = initCore();
+    initConnector();
+    const switching = switchTransport({ env: 'emulator', Transport: replacement });
+    const rejected = expect(switching).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.NotInitialized,
+    });
+    try {
+      await core.dispose();
+      await rejected;
+      expect(replacement).not.toHaveBeenCalled();
+      expect(TransportManager.transport).toBe(active);
+      expect(DataManager.settings).toBe(settings);
+      expect(DevicePool.emitter.eventNames()).toHaveLength(0);
+    } finally {
+      await Promise.allSettled([switching]);
+      await core.dispose();
+      TransportManager.transport = previous;
+      DataManager.settings = settings;
+    }
+  });
+
+  test.each(['dispose/reinit', 'init', 'initCore'] as const)(
+    '%s invalidates running and queued switches without blocking a new lifecycle',
+    async lifecycle => {
+      const previous = TransportManager.transport;
+      const { settings } = DataManager;
+      const entered = createDeferred<void>();
+      const closing = createDeferred<void>();
+      const loading = createDeferred<void>();
+      const active = {
+        stop: jest.fn(() => {
+          entered.resolve();
+          return closing.promise;
+        }),
+      };
+      const intermediate = jest.fn(() => ({ stop: jest.fn().mockResolvedValue(undefined) }));
+      const stale = jest.fn(() => ({ stop: jest.fn().mockResolvedValue(undefined) }));
+      const fresh = { stop: jest.fn().mockResolvedValue(undefined) };
+      const current = { stop: jest.fn().mockResolvedValue(undefined) };
+      const Fresh = jest.fn(() => fresh);
+      jest.spyOn(DataManager, 'load').mockImplementation(async next => {
+        await loading.promise;
+        DataManager.settings = next;
+      });
+      TransportManager.transport = active as never;
+      let core = initCore();
+      initConnector();
+      const first = switchTransport({ env: 'emulator', Transport: intermediate });
+      await entered.promise;
+      const second = switchTransport({ env: 'webusb', Transport: stale });
+      const rejected = Promise.all([
+        expect(first).rejects.toMatchObject({ errorCode: HardwareErrorCode.NotInitialized }),
+        expect(second).rejects.toMatchObject({ errorCode: HardwareErrorCode.NotInitialized }),
+      ]);
+      rejected.catch(() => undefined);
+      let initializing: ReturnType<typeof init> | undefined;
+      try {
+        if (lifecycle === 'dispose/reinit') {
+          const disposing = core.dispose();
+          closing.resolve();
+          await disposing;
+        }
+        if (lifecycle === 'initCore') {
+          TransportManager.transport = fresh as never;
+          DataManager.settings = { ...settings, env: 'desktop-web-ble' };
+          core = initCore();
+          initConnector();
+        } else {
+          initializing = init({ ...settings, env: 'desktop-web-ble' }, Fresh);
+          if (lifecycle === 'init') {
+            closing.resolve();
+            await rejected;
+          }
+          loading.resolve();
+          const initialized = await initializing;
+          if (!initialized) throw new Error('Core initialization failed');
+          core = initialized;
+        }
+        await switchTransport({
+          env: 'emulator',
+          Transport: function Current() {
+            return current;
+          },
+        });
+        closing.resolve();
+        await rejected;
+        expect(intermediate).not.toHaveBeenCalled();
+        expect(stale).not.toHaveBeenCalled();
+        expect(TransportManager.transport).toBe(current);
+        expect(DataManager.getSettings('env')).toBe('emulator');
+        expect(fresh.stop).toHaveBeenCalledTimes(1);
+        expect(current.stop).not.toHaveBeenCalled();
+      } finally {
+        closing.resolve();
+        loading.resolve();
+        await initializing;
+        await Promise.allSettled([first, second, rejected]);
+        await core.dispose();
+        TransportManager.transport = previous;
+        DataManager.settings = settings;
+      }
+    }
+  );
 });

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

@@ -45,6 +45,23 @@ describe('Core 错误输出边界', () => {
     });
   });
 
+  test.each([
+    [HardwareErrorCode.TransportProtocolProbeFailed, { expectedProtocol: 'V1' }],
+    [
+      HardwareErrorCode.TransportProtocolMismatch,
+      { expectedProtocol: 'V2', detectedProtocol: 'V1' },
+    ],
+  ] as const)(
+    'preserves protocol error %s and structured context across the public boundary',
+    (code, params) => {
+      const error = ERRORS.TypedError(code, undefined, params);
+      expect(JSON.parse(JSON.stringify(createErrorMessage(error)))).toEqual({
+        success: false,
+        payload: { code, error: error.message, params },
+      });
+    }
+  );
+
   test.each([
     ['webusb', false],
     ['desktop-webusb', false],
@@ -129,6 +146,8 @@ describe('Core 错误输出边界', () => {
     HardwareErrorCode.BleUnsupported,
     HardwareErrorCode.BridgeNeedsPermission,
     HardwareErrorCode.WebUsbDeviceAccessError,
+    HardwareErrorCode.TransportProtocolProbeFailed,
+    HardwareErrorCode.TransportProtocolMismatch,
   ])(
     'preserves terminal transport error %s in the public response without polling again',
     async errorCode => {
@@ -138,6 +157,8 @@ describe('Core 错误输出边界', () => {
           [
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.WebUsbDeviceAccessError,
+            HardwareErrorCode.TransportProtocolProbeFailed,
+            HardwareErrorCode.TransportProtocolMismatch,
           ].includes(errorCode)
             ? ('desktop-webusb' as never)
             : ('react-native' as never)

package/__tests__/device-connector-protocol.test.ts

@@ -75,8 +75,11 @@ describe('DeviceConnector protocol validation', () => {
     });
     const connector = new DeviceConnector();
 
-    await expect(connector.acquire('classic-id', undefined, undefined, 'V2')).rejects.toThrow(
-      'Device protocol mismatch: expected V2, detected V1'
+    await expect(connector.acquire('classic-id', undefined, undefined, 'V2')).rejects.toMatchObject(
+      {
+        errorCode: HardwareErrorCode.TransportProtocolMismatch,
+        params: { expectedProtocol: 'V2', detectedProtocol: 'V1' },
+      }
     );
   });
 

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

@@ -610,7 +610,9 @@ describe('public device lifecycle events', () => {
   );
 
   test.each([
-    [HardwareErrorCode.RuntimeError, true],
+    [HardwareErrorCode.TransportProtocolProbeFailed, true],
+    [HardwareErrorCode.TransportProtocolMismatch, false],
+    [HardwareErrorCode.RuntimeError, false],
     [HardwareErrorCode.BleDeviceBondError, false],
   ] as const)(
     'retries a Protocol V2 probe mismatch with error code %s: %s',
@@ -618,8 +620,8 @@ describe('public device lifecycle events', () => {
       const method = { payload: { connectProtocol: 'V2' } } as never;
       const error = {
         errorCode,
-        message:
-          'Device protocol mismatch: expected V2, but device did not respond to expected protocol',
+        message: 'diagnostic wording is not used for classification',
+        params: { expectedProtocol: 'V2' },
       };
 
       expect(isRetryableBleProtocolV2ProbeError(method, error)).toBe(expected);
@@ -629,6 +631,8 @@ describe('public device lifecycle events', () => {
   test.each([
     [HardwareErrorCode.BleConnectedError, true],
     [HardwareErrorCode.BleTimeoutError, true],
+    [HardwareErrorCode.TransportProtocolProbeFailed, true],
+    [HardwareErrorCode.TransportProtocolMismatch, false],
     [HardwareErrorCode.PollingTimeout, false],
     [HardwareErrorCode.BleDeviceBondError, false],
   ] as const)('retries a BLE connection error with error code %s: %s', (errorCode, expected) => {
@@ -641,6 +645,21 @@ describe('public device lifecycle events', () => {
     expect(isRetryableBleConnectionError(method, error)).toBe(expected);
   });
 
+  test('does not retry a failed strict V1 probe as a V2 probe or after user cancellation', () => {
+    const error = ERRORS.TypedError(HardwareErrorCode.TransportProtocolProbeFailed, undefined, {
+      expectedProtocol: 'V1',
+    });
+    const method = { payload: { connectProtocol: 'V2' } } as never;
+    expect(isRetryableBleProtocolV2ProbeError(method, error)).toBe(false);
+    expect(isRetryableBleConnectionError(method, error)).toBe(false);
+    expect(
+      isRetryableBleConnectionError(
+        { payload: {}, device: { wasInterruptedByUser: () => true } } as never,
+        ERRORS.TypedError(HardwareErrorCode.TransportProtocolProbeFailed)
+      )
+    ).toBe(false);
+  });
+
   test('does not retry the desktop acquire deadline fallback', () => {
     const method = { payload: { connectProtocol: 'V2' } } as never;
     const error = {

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

@@ -0,0 +1,358 @@
+import protocolTransport, { DeviceType } from '@onekeyfe/hd-transport';
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import {
+  getOwnedUsbDeviceIdentity,
+  probeUsbDeviceIdentitiesWithTransport,
+} from '../src/api/SearchDevices';
+import DataManager from '../src/data-manager/DataManager';
+import TransportManager from '../src/data-manager/TransportManager';
+
+import type { UsbIdentityProbeTransport } from '../src/api/SearchDevices';
+import type { OneKeyDeviceInfo, Transport } from '@onekeyfe/hd-transport';
+import type { ConnectSettings } from '../src/types';
+import type { Device } from '../src/device/Device';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: () => '1.2.8-alpha.12',
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.2.8-alpha.12/',
+}));
+
+const descriptor = { path: 'USB_DESCRIPTOR_PATH', commType: 'webusb' } as OneKeyDeviceInfo;
+const createTransport = () => ({
+  init: jest.fn(),
+  configure: jest.fn(),
+  configureProtocolV2: jest.fn(),
+  enumerate: jest.fn().mockResolvedValue([descriptor]),
+  acquire: jest.fn().mockResolvedValue('usb-transport-handle'),
+  release: jest.fn().mockResolvedValue(undefined),
+  getProtocolType: jest.fn().mockReturnValue('V1'),
+  call: jest.fn().mockResolvedValue({
+    type: 'Features',
+    message: {
+      onekey_serial_no: 'PHYSICAL_SERIAL',
+      onekey_device_type: 'CLASSIC1S',
+      device_id: 'WALLET_ID',
+    },
+  }),
+});
+
+describe('isolated USB identity probe', () => {
+  test('identifies V1 by live identity while preserving the active BLE settings and transport', async () => {
+    const previousSettings = DataManager.settings;
+    const previousTransport = TransportManager.transport;
+    const activeBLE = { name: 'active-ble', pendingOperation: true } as unknown as Transport;
+    const settings = { env: 'desktop-web-ble' } as ConnectSettings;
+    DataManager.settings = settings;
+    TransportManager.transport = activeBLE;
+    const transport = createTransport();
+    try {
+      await expect(probeUsbDeviceIdentitiesWithTransport(transport, 'webusb')).resolves.toEqual([
+        {
+          path: 'USB_DESCRIPTOR_PATH',
+          serialNo: 'PHYSICAL_SERIAL',
+          deviceId: 'WALLET_ID',
+          deviceType: EDeviceType.Classic1s,
+          connectProtocol: 'V1',
+          commType: 'webusb',
+          mode: 'normal',
+        },
+      ]);
+      expect(DataManager.settings).toBe(settings);
+      expect(TransportManager.transport).toBe(activeBLE);
+      expect(transport.call).toHaveBeenCalledWith(
+        'usb-transport-handle',
+        'GetFeatures',
+        {},
+        { timeoutMs: 3000 }
+      );
+      expect(transport.release).toHaveBeenCalledWith('usb-transport-handle', false);
+    } finally {
+      DataManager.settings = previousSettings;
+      TransportManager.transport = previousTransport;
+    }
+  });
+
+  test.each([
+    EDeviceType.Classic,
+    EDeviceType.Classic1s,
+    EDeviceType.ClassicPure,
+    EDeviceType.Mini,
+    EDeviceType.Touch,
+    EDeviceType.Pro,
+  ])('reads the V1 identity for %s without initializing a wallet', async deviceType => {
+    const transport = createTransport();
+    transport.call.mockResolvedValue({
+      type: 'Features',
+      message: {
+        onekey_serial_no: 'V1_PHYSICAL_SERIAL',
+        onekey_device_type:
+          deviceType === EDeviceType.ClassicPure ? 'PURE' : deviceType.toUpperCase(),
+        device_id: 'V1_WALLET_ID',
+      },
+    });
+    const result = await probeUsbDeviceIdentitiesWithTransport(transport, 'webusb');
+    expect(result).toMatchObject([
+      {
+        serialNo: 'V1_PHYSICAL_SERIAL',
+        deviceId: 'V1_WALLET_ID',
+        deviceType,
+        connectProtocol: 'V1',
+      },
+    ]);
+    expect(transport.call.mock.calls.map(call => call[1])).toEqual(['GetFeatures']);
+    expect(transport.release).toHaveBeenCalledTimes(1);
+  });
+
+  test('continues identifying other devices after one device disconnects', async () => {
+    const transport = createTransport();
+    transport.enumerate.mockResolvedValue([descriptor, { ...descriptor, path: 'SECOND_USB_PATH' }]);
+    transport.call.mockRejectedValueOnce(new Error('Disconnected'));
+    const result = await probeUsbDeviceIdentitiesWithTransport(transport, 'webusb');
+    expect(result).toMatchObject([{ path: 'SECOND_USB_PATH', serialNo: 'PHYSICAL_SERIAL' }]);
+    expect(transport.release).toHaveBeenCalledTimes(2);
+  });
+
+  test.each([DeviceType.PRO2, DeviceType.NEO])(
+    'reads V2 hardware identity without opening a wallet (%s)',
+    async deviceType => {
+      const transport = createTransport();
+      transport.getProtocolType.mockReturnValue('V2');
+      transport.call.mockResolvedValue({
+        type: 'DeviceInfo',
+        message: { hw: { Device_type: deviceType, serial_no: 'V2_PHYSICAL_SERIAL' } },
+      });
+      const result = await probeUsbDeviceIdentitiesWithTransport(transport, 'webusb');
+      expect(result[0]).toMatchObject({
+        serialNo: 'V2_PHYSICAL_SERIAL',
+        connectProtocol: 'V2',
+        deviceId: null,
+      });
+      expect(transport.call.mock.calls.map(call => call[1])).toEqual(['DeviceInfoGet']);
+      expect(transport.release).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  test('reads vendor identity when legacy Features do not report a physical serial', async () => {
+    const transport = createTransport();
+    transport.call
+      .mockResolvedValueOnce({
+        type: 'Features',
+        message: { device_id: 'WALLET_ID', onekey_device_type: 'CLASSIC1S' },
+      })
+      .mockResolvedValueOnce({
+        type: 'OnekeyFeatures',
+        message: { onekey_serial_no: 'VENDOR_SERIAL' },
+      });
+    await expect(probeUsbDeviceIdentitiesWithTransport(transport, 'webusb')).resolves.toMatchObject(
+      [{ serialNo: 'VENDOR_SERIAL', deviceId: 'WALLET_ID' }]
+    );
+  });
+
+  test.each([
+    { onekey_device_type: 'CLASSIC', major_version: 2, minor_version: 8, patch_version: 0 },
+    { onekey_device_type: 'TOUCH', major_version: 4, minor_version: 4, patch_version: 0 },
+  ])(
+    'preserves GetFeatures identity when the legacy V1 schema has no vendor query (%s)',
+    async firmware => {
+      const transport = createTransport();
+      let messages = protocolTransport.parseConfigure(
+        JSON.stringify(DataManager.getProtobufMessages())
+      );
+      transport.configure.mockImplementation((schema: string) => {
+        messages = protocolTransport.parseConfigure(schema);
+      });
+      transport.call.mockImplementation((_session, name, data) => {
+        protocolTransport.ProtocolV1.encodeMessageChunks(messages, name, data);
+        return Promise.resolve({
+          type: 'Features',
+          message: { ...firmware, device_id: 'LEGACY_WALLET_ID' },
+        });
+      });
+      await expect(
+        probeUsbDeviceIdentitiesWithTransport(transport, 'webusb')
+      ).resolves.toMatchObject([
+        {
+          path: descriptor.path,
+          serialNo: null,
+          deviceId: 'LEGACY_WALLET_ID',
+          connectProtocol: 'V1',
+        },
+      ]);
+      expect(transport.call.mock.calls.map(call => call[1])).toEqual(['GetFeatures']);
+      expect(transport.release).toHaveBeenCalledWith('usb-transport-handle', false);
+    }
+  );
+
+  test('does not substitute a USB path for a missing business identity', async () => {
+    const transport = createTransport();
+    transport.call
+      .mockResolvedValueOnce({ type: 'Features', message: { onekey_device_type: 'MINI' } })
+      .mockResolvedValueOnce({ type: 'Failure', message: {} });
+    await expect(probeUsbDeviceIdentitiesWithTransport(transport, 'webusb')).resolves.toMatchObject(
+      [{ path: 'USB_DESCRIPTOR_PATH', serialNo: null, deviceId: null }]
+    );
+  });
+
+  test.each([
+    ['CLASSIC1S', EDeviceType.Classic1s],
+    ['PURE', EDeviceType.ClassicPure],
+  ])(
+    'retains %s bootloader state without querying unsupported vendor features',
+    async (model, deviceType) => {
+      const transport = createTransport();
+      const path = '000000000000000000000000';
+      transport.enumerate.mockResolvedValue([{ ...descriptor, path }]);
+      transport.call.mockImplementation((_session, method) => {
+        if (method !== 'GetFeatures')
+          return Promise.reject(new Error('Unsupported loader query timed out'));
+        return Promise.resolve({
+          type: 'Features',
+          message: {
+            onekey_device_type: model,
+            model: '1',
+            bootloader_mode: true,
+            firmware_present: true,
+            major_version: 3,
+            minor_version: 0,
+            patch_version: 0,
+          },
+        });
+      });
+      await expect(probeUsbDeviceIdentitiesWithTransport(transport, 'webusb')).resolves.toEqual([
+        {
+          path,
+          serialNo: null,
+          deviceId: null,
+          deviceType,
+          mode: 'bootloader',
+          connectProtocol: 'V1',
+          commType: 'webusb',
+        },
+      ]);
+      expect(transport.call.mock.calls.map(call => call[1])).toEqual(['GetFeatures']);
+      expect(transport.release).toHaveBeenCalledWith('usb-transport-handle', false);
+    }
+  );
+
+  test.each(['TOUCH', 'PRO'])(
+    'preserves the existing %s loader vendor-identity query',
+    async model => {
+      const transport = createTransport();
+      transport.call
+        .mockResolvedValueOnce({
+          type: 'Features',
+          message: { onekey_device_type: model, bootloader_mode: true },
+        })
+        .mockResolvedValueOnce({
+          type: 'OnekeyFeatures',
+          message: { onekey_serial_no: 'VENDOR_SERIAL' },
+        });
+      await expect(
+        probeUsbDeviceIdentitiesWithTransport(transport, 'webusb')
+      ).resolves.toMatchObject([{ serialNo: 'VENDOR_SERIAL', mode: 'bootloader' }]);
+      expect(transport.call.mock.calls.map(call => call[1])).toEqual([
+        'GetFeatures',
+        'OnekeyGetFeatures',
+      ]);
+    }
+  );
+
+  test.each([
+    { ...descriptor, device: { opened: true } },
+    { ...descriptor, commType: 'bridge', session: 'owned-bridge-transport' },
+  ])('leaves an owned USB connection untouched', async occupied => {
+    const transport = createTransport();
+    transport.enumerate.mockResolvedValue([occupied]);
+    await expect(
+      probeUsbDeviceIdentitiesWithTransport(transport, occupied.commType as 'webusb' | 'bridge')
+    ).resolves.toEqual([]);
+    expect(transport.acquire).not.toHaveBeenCalled();
+    expect(transport.release).not.toHaveBeenCalled();
+  });
+
+  test.each([undefined, 'occupied-transport-handle'])(
+    'does not initialize or acquire a Bridge identity probe (session: %s)',
+    async session => {
+      const transport = createTransport();
+      transport.enumerate.mockResolvedValue([{ ...descriptor, commType: 'bridge', session }]);
+      await expect(probeUsbDeviceIdentitiesWithTransport(transport, 'bridge')).resolves.toEqual([]);
+      expect(transport.init).not.toHaveBeenCalled();
+      expect(transport.enumerate).not.toHaveBeenCalled();
+      expect(transport.acquire).not.toHaveBeenCalled();
+      expect(transport.release).not.toHaveBeenCalled();
+    }
+  );
+
+  test('reuses identity only for the exact active WebUSB handle', () => {
+    const handle = {};
+    const endpoint = { ...descriptor, device: handle };
+    const device = {
+      features: {},
+      mainId: descriptor.path,
+      originalDescriptor: endpoint,
+      getCurrentSerialNo: () => 'OWNER_SERIAL',
+      getCurrentDeviceId: () => 'OWNER_WALLET',
+      getCurrentDeviceType: () => EDeviceType.Pro,
+      getProtocol: () => 'V1',
+    } as unknown as Device;
+    const queue = {
+      getRequestTasksIdByConnectId: () => [1],
+      getTask: () => ({ method: { device } }),
+    };
+    expect(getOwnedUsbDeviceIdentity(endpoint, queue)).toMatchObject({ serialNo: 'OWNER_SERIAL' });
+    expect(
+      getOwnedUsbDeviceIdentity({ ...endpoint, device: {} } as typeof endpoint, queue)
+    ).toBeUndefined();
+    expect(getOwnedUsbDeviceIdentity({ ...endpoint, commType: 'ble' }, queue)).toBeUndefined();
+  });
+
+  test('returns the active request owner identity without acquiring its USB handle', async () => {
+    const transport = createTransport();
+    transport.enumerate.mockResolvedValue([{ ...descriptor, device: { opened: true } }]);
+    const owner = {
+      path: descriptor.path,
+      serialNo: 'OWNER_SERIAL',
+      deviceId: 'OWNER_WALLET',
+      deviceType: EDeviceType.Pro,
+      connectProtocol: 'V1' as const,
+      commType: 'webusb' as const,
+    };
+    await expect(
+      probeUsbDeviceIdentitiesWithTransport(transport, 'webusb', () => owner)
+    ).resolves.toEqual([owner]);
+    expect(transport.acquire).not.toHaveBeenCalled();
+  });
+
+  test('rejects ambiguous paths rather than probing a different USB handle', async () => {
+    const transport = createTransport();
+    transport.enumerate.mockResolvedValue([descriptor, { ...descriptor }]);
+    await expect(probeUsbDeviceIdentitiesWithTransport(transport, 'webusb')).resolves.toEqual([]);
+    expect(transport.acquire).not.toHaveBeenCalled();
+  });
+
+  test.each(['read failure', 'unexpected response', 'release failure'] as const)(
+    'cleans up without approving the target after %s',
+    async failure => {
+      const transport = createTransport();
+      if (failure === 'read failure')
+        transport.call.mockRejectedValue(new Error('USB disconnected'));
+      if (failure === 'unexpected response')
+        transport.call.mockResolvedValue({ type: 'Failure', message: {} });
+      if (failure === 'release failure')
+        transport.release.mockRejectedValue(new Error('release failed'));
+      await expect(probeUsbDeviceIdentitiesWithTransport(transport, 'webusb')).resolves.toEqual([]);
+      expect(transport.release).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  test('does not approve an endpoint without a wire-confirmed protocol', async () => {
+    const transport = createTransport();
+    transport.getProtocolType.mockReturnValue(undefined);
+    await expect(
+      probeUsbDeviceIdentitiesWithTransport(transport as UsbIdentityProbeTransport, 'webusb')
+    ).resolves.toEqual([]);
+    expect(transport.call).not.toHaveBeenCalled();
+    expect(transport.release).toHaveBeenCalledTimes(1);
+  });
+});

package/dist/api/FirmwareUpdateV4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkD,MAAM,qBAAqB,CAAC;AA0BlG,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAiC/E,OAAO,KAAK,EAEV,sBAAsB,EAEvB,MAAM,6BAA6B,CAAC;AAuErC,wBAAgB,wCAAwC,CACtD,UAAU,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,EAC5C,MAAM,EAAE,sBAAsB,EAC9B,0BAA0B,UAAQ,QAiCnC;AA0UD,eAAO,MAAM,oCAAoC,WACvC,WAAW,GAAG,UAAU,eACnB,MAAM,GAAG,SAAS,YAKhC,CAAC;AAEF,eAAO,MAAM,iCAAiC,0BACrB,MAAM,uBACR,MAAM,iBACZ,MAAM,eACR,MAAM,SAsBpB,CAAC;AAUF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,wBAAwB,CAAC,sBAAsB,CAAC;IAC5F,OAAO,CAAC,8BAA8B,CAAC,CAAS;IAEhD,OAAO,CAAC,sBAAsB,CAAC,CAAS;IAExC,OAAO,CAAC,oCAAoC,CAAS;IAErD,qBAAqB;IAIrB,OAAO,CAAC,yBAAyB,CAA4B;IAE7D,OAAO,CAAC,2BAA2B,CAAS;IAE5C,OAAO,CAAC,iCAAiC,CAAS;IAElD,OAAO,CAAC,iCAAiC,CAA6B;IAEtE,OAAO,CAAC,4BAA4B,CAAqB;IAEzD,OAAO,CAAC,6BAA6B,CAAC,CAAW;IAEjD,OAAO,CAAC,+BAA+B,CAAC,CAAuB;IAE/D,OAAO,CAAC,2BAA2B,CAAC,CAAuB;IAE3D,OAAO,CAAC,iCAAiC,CAA6B;IAEtE,OAAO,CAAC,+BAA+B,CAAS;IAEhD,OAAO,CAAC,mCAAmC,CAAS;IAEpD,OAAO,CAAC,wCAAwC,CAAS;IAEzD,OAAO,CAAC,kCAAkC,CAAC,CAAW;IAEtD,OAAO,CAAC,8BAA8B,CAAC,CAAS;IAEhD,OAAO,CAAC,gCAAgC,CAAK;IAE7C,OAAO,CAAC,8BAA8B,CAAK;IAE3C,IAAI;IA6LJ,OAAO,CAAC,8BAA8B;IAwBhC,GAAG;;;;;YAKK,aAAa;YA4Ib,4BAA4B;YAkB5B,0BAA0B;YAY1B,8BAA8B;YAK9B,+BAA+B;YAqG/B,4BAA4B;YA+C5B,0CAA0C;YAkB1C,qCAAqC;YAoFrC,gCAAgC;YAgBhC,uCAAuC;YAmDvC,8BAA8B;IA8B5C,OAAO,CAAC,8BAA8B;IA0BtC,OAAO,CAAC,kCAAkC;IAc1C,OAAO,CAAC,gCAAgC;YA2D1B,2BAA2B;IAmBzC,OAAO,CAAC,yBAAyB;IAKjC,OAAO,CAAC,oCAAoC;IAY5C,OAAO,CAAC,4BAA4B;IAUpC,OAAO,CAAC,kCAAkC;IAS1C,OAAO,CAAC,8BAA8B;YAMxB,iCAAiC;YAOjC,iCAAiC;YAoBjC,iCAAiC;IAU/C,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,mCAAmC;IAe3C,OAAO,CAAC,iCAAiC;IAWzC,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,yBAAyB;IAiBjC,OAAO,CAAC,wBAAwB;YAkBlB,iCAAiC;YA6CjC,uCAAuC;YA0CvC,+BAA+B;IAmF7C,OAAO,CAAC,6BAA6B;IAMrC,OAAO,CAAC,gCAAgC;YAM1B,8BAA8B;YAmD9B,kCAAkC;IA+BhD,OAAO,CAAC,0BAA0B;IAUlC,OAAO,CAAC,yBAAyB;YAcnB,4BAA4B;IAkBpC,6BAA6B;YAkBrB,+BAA+B;IAkD7C,OAAO,CAAC,6BAA6B;YAkCvB,6BAA6B;YA0B7B,0CAA0C;YA6B1C,uBAAuB;YAiCvB,8BAA8B;YAkF9B,6BAA6B;IAuF3C,OAAO,CAAC,mCAAmC;YAI7B,0BAA0B;IAaxC,OAAO,CAAC,8BAA8B;IAiBtC,OAAO,CAAC,4BAA4B;IAoLpC,OAAO,CAAC,6BAA6B;IAcrC,OAAO,CAAC,qCAAqC;IAoC7C,OAAO,CAAC,kCAAkC;IAyC1C,OAAO,CAAC,8CAA8C;YAIxC,uCAAuC;YA8UvC,gCAAgC;YAehC,yBAAyB;IAUvC,OAAO,CAAC,2BAA2B;YAMrB,8BAA8B;IAQ5C,OAAO,CAAC,0BAA0B;YAkBpB,mCAAmC;YAWnC,qCAAqC;YAmDrC,yBAAyB;YAgGzB,8BAA8B;IAU5C,OAAO,CAAC,kCAAkC;YAQ5B,cAAc;YAyCd,6BAA6B;YAW7B,0BAA0B;YAoB1B,6BAA6B;YAwD7B,gBAAgB;IA0B9B,OAAO,CAAC,qBAAqB;CAM9B"}

package/dist/api/SearchDevices.d.ts

@@ -1,9 +1,29 @@
 import { BaseMethod } from './BaseMethod';
-import type { SearchDevice } from '../types/device';
+import type { SearchDevice, UsbDeviceIdentity } from '../types/device';
 import type DeviceConnector from '../device/DeviceConnector';
+import type { AcquireInput, OneKeyDeviceInfo as DeviceDescriptor, Transport } from '@onekeyfe/hd-transport';
+import type { Device } from '../device/Device';
+type RequestQueueLookup = {
+    getRequestTasksIdByConnectId: (connectId: string) => number[];
+    getTask: (requestId: number) => {
+        method: {
+            device?: Device;
+        };
+    } | undefined;
+};
+export type UsbIdentityProbeDescriptor = Pick<DeviceDescriptor, 'path' | 'commType'> & Partial<Pick<DeviceDescriptor, 'id' | 'session'>>;
+export declare const getOwnedUsbDeviceIdentity: (descriptor: UsbIdentityProbeDescriptor, requestQueue: RequestQueueLookup) => UsbDeviceIdentity | undefined;
+export type UsbIdentityProbeTransport = Pick<Transport, 'release' | 'call' | 'getProtocolType' | 'configureProtocolV2'> & {
+    init: (logger: object) => unknown;
+    enumerate: () => Promise<UsbIdentityProbeDescriptor[]>;
+    acquire: (input: AcquireInput) => Promise<string | undefined>;
+    configure: (signedData: string) => void | Promise<void>;
+};
+export declare const probeUsbDeviceIdentitiesWithTransport: (transport: UsbIdentityProbeTransport, commType: UsbDeviceIdentity['commType'], getOwnedIdentity?: ((descriptor: UsbIdentityProbeDescriptor) => UsbDeviceIdentity | undefined) | undefined) => Promise<UsbDeviceIdentity[]>;
 export default class SearchDevices extends BaseMethod {
     connector?: DeviceConnector;
     init(): void;
     run(): Promise<SearchDevice[]>;
 }
+export {};
 //# sourceMappingURL=SearchDevices.d.ts.map

package/dist/api/SearchDevices.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SearchDevices.d.ts","sourceRoot":"","sources":["../../src/api/SearchDevices.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAM1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,eAAe,MAAM,2BAA2B,CAAC;AAyE7D,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU;IACnD,SAAS,CAAC,EAAE,eAAe,CAAC;IAE5B,IAAI;IAME,GAAG,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;CAuFrC"}
+{"version":3,"file":"SearchDevices.d.ts","sourceRoot":"","sources":["../../src/api/SearchDevices.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAU1C,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEvE,OAAO,KAAK,eAAe,MAAM,2BAA2B,CAAC;AAC7D,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,IAAI,gBAAgB,EAEpC,SAAS,EACV,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAI/C,KAAK,kBAAkB,GAAG;IACxB,4BAA4B,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;IAC9D,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK;QAAE,MAAM,EAAE;YAAE,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,GAAG,SAAS,CAAC;CAC7E,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,UAAU,CAAC,GAClF,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC;AA4CpD,eAAO,MAAM,yBAAyB,eACxB,0BAA0B,gBACxB,kBAAkB,KAC/B,iBAAiB,GAAG,SAatB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,SAAS,EACT,SAAS,GAAG,MAAM,GAAG,iBAAiB,GAAG,qBAAqB,CAC/D,GAAG;IACF,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IAClC,SAAS,EAAE,MAAM,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAAC;IACvD,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC9D,SAAS,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzD,CAAC;AAYF,eAAO,MAAM,qCAAqC,cACrC,yBAAyB,YAC1B,iBAAiB,CAAC,UAAU,CAAC,mCACP,0BAA0B,KAAK,iBAAiB,GAAG,SAAS,kBAC3F,QAAQ,iBAAiB,EAAE,CA4G7B,CAAC;AAsBF,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU;IACnD,SAAS,CAAC,EAAE,eAAe,CAAa;IAExC,IAAI;IAME,GAAG,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;CAuFrC"}

package/dist/core/index.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import { getOwnedUsbDeviceIdentity } from '../api/SearchDevices';
 import EventEmitter from 'events';
 import { type LowlevelTransportSharedPlugin, type ProtocolType } from '@onekeyfe/hd-transport';
 import { Device } from '../device/Device';
@@ -20,6 +21,7 @@ export default class Core extends EventEmitter {
     private tracingContext;
     readonly sdkInstanceId: string;
     private requestQueue;
+    getOwnedUsbDeviceIdentity(descriptor: Parameters<typeof getOwnedUsbDeviceIdentity>[0]): import("../types").UsbDeviceIdentity | undefined;
     private disposePromise?;
     private prePendingCallPromises;
     private methodSynchronize;
@@ -36,5 +38,5 @@ export declare const switchTransport: ({ env, Transport, plugin, }: {
     env: ConnectSettings['env'];
     Transport: any;
     plugin?: LowlevelTransportSharedPlugin | undefined;
-}) => void;
+}) => Promise<void>;
 //# sourceMappingURL=index.d.ts.map