@onekeyfe/hd-common-connect-sdk 1.2.8-alpha.13 → 1.2.8-alpha.15

package/README.md

@@ -28,6 +28,33 @@ function init() {
 }
 ```
 
+## Desktop USB identity discovery
+
+`probeUsbDeviceIdentities({ commType: 'webusb' | 'bridge' })` is a named export for
+choosing a Desktop connection before switching the active SDK. It does not require
+SDK initialization, dispose Core, change BLE settings, or open a wallet session.
+Concurrent probes for the same mode share one pending request.
+
+```typescript
+import { probeUsbDeviceIdentities } from '@onekeyfe/hd-common-connect-sdk';
+
+const devices = await probeUsbDeviceIdentities({ commType: 'webusb' });
+```
+
+Each result contains `path`, `serialNo`, `deviceId`, `deviceType`, `connectProtocol`,
+and `commType`. `path` locates the USB endpoint; compare `serialNo` with the target's
+physical identity, or `deviceId` for legacy devices without a physical serial.
+Missing identities remain `null`; a descriptor path is never substituted for them.
+The protocol comes from an active device response. V1 uses read-only Features;
+V2 uses hardware DeviceInfo and does not query a wallet session.
+
+Busy, ambiguous, disconnected, or unverified endpoints are omitted. An active
+WebUSB request's identity can be reused only for the exact USB handle it owns.
+Discovery releases only handles it acquired and does not replace the active SDK's
+disconnect observer. An empty result is not proof that the device is absent.
+Keep the selected transport fixed during a hardware operation; reevaluate it
+between operations. Firmware updates must separately validate their live target.
+
 ## Docs
 
 Documentation is available [Hardware SDK Getting Started](https://developer.onekey.so/en/hardware-sdk/getting-started)

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

@@ -1,10 +1,15 @@
 import { readFileSync } from 'fs';
 import { resolve } from 'path';
 import EventEmitter from 'events';
-import { CORE_EVENT, UI_REQUEST, initCore } from '@onekeyfe/hd-core';
+import {
+  CORE_EVENT,
+  UI_REQUEST,
+  initCore,
+  probeUsbDeviceIdentitiesWithTransport,
+} from '@onekeyfe/hd-core';
 import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
-import sdkExport, { messagePromises } from '../src';
+import sdkExport, { messagePromises, probeUsbDeviceIdentities } from '../src';
 
 jest.mock('../../core/src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0-test'),
@@ -15,9 +20,10 @@ jest.mock('@onekeyfe/hd-core', () => ({
   __esModule: true,
   default: (options: unknown) => options,
   initCore: jest.fn(),
+  probeUsbDeviceIdentitiesWithTransport: jest.fn(),
 }));
-jest.mock('@onekeyfe/hd-transport-http', () => ({}));
-jest.mock('@onekeyfe/hd-transport-web-device', () => ({}));
+jest.mock('@onekeyfe/hd-transport-http', () => ({ __esModule: true, default: jest.fn() }));
+jest.mock('@onekeyfe/hd-transport-web-device', () => ({ WebUsbTransport: jest.fn() }));
 jest.mock('@onekeyfe/hd-transport-lowlevel', () => ({}));
 jest.mock('@onekeyfe/hd-transport-emulator', () => ({}));
 
@@ -82,6 +88,34 @@ describe('SDK request cleanup', () => {
     expect(Object.keys(messagePromises)).toHaveLength(0);
   });
 
+  test.each(['webusb', 'bridge'] as const)(
+    'probes %s without disposing an outstanding BLE request and coalesces concurrent probes',
+    async commType => {
+      const pending = createDeferred<unknown>();
+      const discovery = createDeferred<never[]>();
+      core.handleMessage.mockReturnValueOnce(pending.promise);
+      const request = sdk.call({ method: 'getDeviceState' });
+      jest
+        .mocked(probeUsbDeviceIdentitiesWithTransport)
+        .mockReset()
+        .mockReturnValueOnce(discovery.promise);
+      const initializationCount = jest.mocked(initCore).mock.calls.length;
+      const first = probeUsbDeviceIdentities({ commType });
+      const second = probeUsbDeviceIdentities({ commType });
+      expect(second).toBe(first);
+      expect(probeUsbDeviceIdentitiesWithTransport).toHaveBeenCalledTimes(1);
+      discovery.resolve([]);
+      await first;
+      expect(core.dispose).not.toHaveBeenCalled();
+      expect(initCore).toHaveBeenCalledTimes(initializationCount);
+      expect(core.listenerCount(CORE_EVENT)).toBe(1);
+      expect(Object.keys(messagePromises)).toHaveLength(1);
+      pending.resolve({ success: true, payload: {} });
+      await expect(request).resolves.toMatchObject({ success: true });
+      expect(Object.keys(messagePromises)).toHaveLength(0);
+    }
+  );
+
   test('waits for Core disposal and does not retain old listeners after reinitialization', async () => {
     const cleanup = createDeferred<void>();
     core.dispose.mockImplementationOnce(async () => {

package/dist/index.d.ts

@@ -1,9 +1,14 @@
 import * as _onekeyfe_hd_core from '@onekeyfe/hd-core';
+import { UsbDeviceIdentity } from '@onekeyfe/hd-core';
 import { Deferred } from '@onekeyfe/hd-shared';
 
+/** Identify USB without disposing the current SDK, changing settings, or opening a wallet. */
+declare const probeUsbDeviceIdentities: ({ commType, }: {
+    commType: UsbDeviceIdentity['commType'];
+}) => Promise<UsbDeviceIdentity[]>;
 declare const messagePromises: {
     [key: number]: Deferred<any>;
 };
 declare const HardwareCommonConnectSdk: _onekeyfe_hd_core.CoreApi;
 
-export { HardwareCommonConnectSdk as default, messagePromises };
+export { HardwareCommonConnectSdk as default, messagePromises, probeUsbDeviceIdentities };

package/dist/index.js

@@ -607,6 +607,31 @@ var getTransport = function (env) { return __awaiter(void 0, void 0, void 0, fun
 }); };
 var _core;
 var _settings = HardwareSdk.parseConnectSettings();
+var usbIdentityProbeTransports = {};
+var usbIdentityProbes = {};
+/** Identify USB without disposing the current SDK, changing settings, or opening a wallet. */
+var probeUsbDeviceIdentities = function (_a) {
+    var commType = _a.commType;
+    if (commType !== 'webusb' && commType !== 'bridge') {
+        return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter));
+    }
+    var pending = usbIdentityProbes[commType];
+    if (pending)
+        return pending;
+    var transport = usbIdentityProbeTransports[commType];
+    if (!transport) {
+        transport =
+            commType === 'webusb' ? new hdTransportWebDevice.WebUsbTransport(true) : new HttpTransport__default["default"](undefined, 3000);
+        usbIdentityProbeTransports[commType] = transport;
+    }
+    var probe = HardwareSdk.probeUsbDeviceIdentitiesWithTransport(transport, commType, function (descriptor) {
+        return _core === null || _core === void 0 ? void 0 : _core.getOwnedUsbDeviceIdentity(descriptor);
+    }).finally(function () {
+        delete usbIdentityProbes[commType];
+    });
+    usbIdentityProbes[commType] = probe;
+    return probe;
+};
 var _messageID = 0;
 var messagePromises = {};
 var dispose = function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -790,3 +815,4 @@ var HardwareCommonConnectSdk = HardwareSdk__default["default"]({
 
 exports["default"] = HardwareCommonConnectSdk;
 exports.messagePromises = messagePromises;
+exports.probeUsbDeviceIdentities = probeUsbDeviceIdentities;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-common-connect-sdk",
-  "version": "1.2.8-alpha.13",
+  "version": "1.2.8-alpha.15",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "ISC",
@@ -21,13 +21,13 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.8-alpha.13",
-    "@onekeyfe/hd-shared": "1.2.8-alpha.13",
-    "@onekeyfe/hd-transport-emulator": "1.2.8-alpha.13",
-    "@onekeyfe/hd-transport-http": "1.2.8-alpha.13",
-    "@onekeyfe/hd-transport-lowlevel": "1.2.8-alpha.13",
-    "@onekeyfe/hd-transport-usb": "1.2.8-alpha.13",
-    "@onekeyfe/hd-transport-web-device": "1.2.8-alpha.13"
+    "@onekeyfe/hd-core": "1.2.8-alpha.15",
+    "@onekeyfe/hd-shared": "1.2.8-alpha.15",
+    "@onekeyfe/hd-transport-emulator": "1.2.8-alpha.15",
+    "@onekeyfe/hd-transport-http": "1.2.8-alpha.15",
+    "@onekeyfe/hd-transport-lowlevel": "1.2.8-alpha.15",
+    "@onekeyfe/hd-transport-usb": "1.2.8-alpha.15",
+    "@onekeyfe/hd-transport-web-device": "1.2.8-alpha.15"
   },
-  "gitHead": "ed22eddce37ce0562b329c42a6985b50949ca412"
+  "gitHead": "e84d88f3866ddfb99e18eed9188a583f56a30b17"
 }

package/src/index.ts

@@ -17,6 +17,7 @@ import HardwareSdk, {
   getLogger,
   initCore,
   parseConnectSettings,
+  probeUsbDeviceIdentitiesWithTransport,
   setLoggerPostMessage,
 } from '@onekeyfe/hd-core';
 import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
@@ -32,6 +33,7 @@ import type {
   CoreMessage,
   LowLevelCoreApi,
   UiResponseEvent,
+  UsbDeviceIdentity,
 } from '@onekeyfe/hd-core';
 import type { LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
 
@@ -57,6 +59,39 @@ const getTransport = async (env: ConnectSettings['env']) => {
 let _core: Core | undefined;
 let _settings = parseConnectSettings();
 
+const usbIdentityProbeTransports: Partial<
+  Record<UsbDeviceIdentity['commType'], WebUsbTransport | HttpTransport>
+> = {};
+const usbIdentityProbes: Partial<
+  Record<UsbDeviceIdentity['commType'], Promise<UsbDeviceIdentity[]>>
+> = {};
+
+/** Identify USB without disposing the current SDK, changing settings, or opening a wallet. */
+export const probeUsbDeviceIdentities = ({
+  commType,
+}: {
+  commType: UsbDeviceIdentity['commType'];
+}): Promise<UsbDeviceIdentity[]> => {
+  if (commType !== 'webusb' && commType !== 'bridge') {
+    return Promise.reject(ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter));
+  }
+  const pending = usbIdentityProbes[commType];
+  if (pending) return pending;
+  let transport = usbIdentityProbeTransports[commType];
+  if (!transport) {
+    transport =
+      commType === 'webusb' ? new WebUsbTransport(true) : new HttpTransport(undefined, 3000);
+    usbIdentityProbeTransports[commType] = transport;
+  }
+  const probe = probeUsbDeviceIdentitiesWithTransport(transport, commType, descriptor =>
+    _core?.getOwnedUsbDeviceIdentity(descriptor)
+  ).finally(() => {
+    delete usbIdentityProbes[commType];
+  });
+  usbIdentityProbes[commType] = probe;
+  return probe;
+};
+
 let _messageID = 0;
 export const messagePromises: { [key: number]: Deferred<any> } = {};