@onekeyfe/hd-core 1.2.2-alpha.118 → 1.2.2-alpha.119

package/__tests__/search-devices.test.ts

@@ -106,9 +106,13 @@ describe('SearchDevices', () => {
     }
   );
 
-  test('owned WebUSB cache miss still reports a SearchDevice without probing', async () => {
-    mockGetDeviceByPath.mockReturnValue(undefined);
-    const usbDevice = { vendorId: 0x1209, productId: 0x4f4c };
+  const BOOTLOADER_PATH = '00000000000000000000000000000000';
+
+  const runOwnedSearch = (
+    path: string,
+    ownerDevice?: unknown,
+    usbHandles: unknown[] = [{ vendorId: 0x1209, productId: 0x4f4c }]
+  ) => {
     const method = new SearchDevices({
       id: 1,
       payload: { method: 'searchDevices' },
@@ -117,34 +121,95 @@ describe('SearchDevices', () => {
     method.context = {
       requestQueue: {
         getRequestTasksId: () => [2],
-        getRequestTasksIdByConnectId: (connectId: string) => (connectId === 'serial-V2' ? [2] : []),
+        getRequestTasksIdByConnectId: (connectId: string) => (connectId === path ? [2] : []),
+        getTask: (requestId: number) =>
+          requestId === 2 ? { method: { device: ownerDevice } } : undefined,
       },
     } as never;
     method.connector = {
       enumerate: jest.fn().mockResolvedValue({
-        descriptors: [
-          {
-            path: 'serial-V2',
-            device: usbDevice,
-            commType: 'webusb',
-          },
-        ],
+        descriptors: usbHandles.map(device => ({ path, device, commType: 'webusb' })),
       }),
     } as never;
+    return method.run();
+  };
 
-    await expect(method.run()).resolves.toEqual([
-      {
-        connectId: 'serial-V2',
-        uuid: 'serial-V2',
-        serialNo: 'serial-V2',
-        deviceId: null,
-        deviceType: 'unknown',
-        name: 'serial-V2',
-        commType: 'webusb',
-      },
+  const createOwnerDevice = (path: string, usbHandle: unknown, serialNo: string) => ({
+    mainId: path,
+    features: { serial_no: serialNo },
+    originalDescriptor: { path, device: usbHandle },
+    toMessageObject: () => ({ connectId: serialNo, serialNo, uuid: serialNo }),
+  });
+
+  test.each(['serial-V2', 'usb-1209-4f4c-onekey', BOOTLOADER_PATH])(
+    'owned WebUSB cache miss on %s reports the path without inventing an identity or probing',
+    async path => {
+      mockGetDeviceByPath.mockReturnValue(undefined);
+
+      await expect(runOwnedSearch(path)).resolves.toEqual([
+        {
+          connectId: path,
+          uuid: '',
+          serialNo: null,
+          deviceId: null,
+          deviceType: 'unknown',
+          name: path,
+          commType: 'webusb',
+        },
+      ]);
+      expect(mockGetDevices).not.toHaveBeenCalled();
+      expect(mockConfigureTransport).not.toHaveBeenCalled();
+    }
+  );
+
+  test('owned WebUSB cache miss reports the owning request device identity', async () => {
+    mockGetDeviceByPath.mockReturnValue(undefined);
+    const usbHandle = { vendorId: 0x1209, productId: 0x4f4c };
+    const ownerDevice = createOwnerDevice(BOOTLOADER_PATH, usbHandle, 'PRO2SERIAL');
+
+    await expect(runOwnedSearch(BOOTLOADER_PATH, ownerDevice, [usbHandle])).resolves.toEqual([
+      { connectId: 'PRO2SERIAL', serialNo: 'PRO2SERIAL', uuid: 'PRO2SERIAL' },
     ]);
     expect(mockGetDevices).not.toHaveBeenCalled();
-    expect(mockConfigureTransport).not.toHaveBeenCalled();
+  });
+
+  test('owned WebUSB cache miss ignores an owning request device bound to another path', async () => {
+    mockGetDeviceByPath.mockReturnValue(undefined);
+    const usbHandle = { vendorId: 0x1209, productId: 0x4f4c };
+    const ownerDevice = createOwnerDevice('other-path', usbHandle, 'OTHERSERIAL');
+
+    await expect(runOwnedSearch('usb-1209-4f4c-onekey', ownerDevice, [usbHandle])).resolves.toEqual(
+      [expect.objectContaining({ connectId: 'usb-1209-4f4c-onekey', uuid: '', serialNo: null })]
+    );
+  });
+
+  test('a second device on the shared bootloader path does not take the owner identity', async () => {
+    mockGetDeviceByPath.mockReturnValue(undefined);
+    const ownerHandle = { vendorId: 0x1209, productId: 0x4f4c };
+    const otherHandle = { vendorId: 0x1209, productId: 0x4f4c };
+    const ownerDevice = createOwnerDevice(BOOTLOADER_PATH, ownerHandle, 'MINISERIAL');
+
+    await expect(
+      runOwnedSearch(BOOTLOADER_PATH, ownerDevice, [ownerHandle, otherHandle])
+    ).resolves.toEqual([
+      { connectId: 'MINISERIAL', serialNo: 'MINISERIAL', uuid: 'MINISERIAL' },
+      expect.objectContaining({ connectId: BOOTLOADER_PATH, uuid: '', serialNo: null }),
+    ]);
+  });
+
+  test('a device swapped onto the bound bootloader path does not take the owner identity', async () => {
+    mockGetDeviceByPath.mockReturnValue(undefined);
+    const ownerDevice = createOwnerDevice(
+      BOOTLOADER_PATH,
+      { vendorId: 0x1209, productId: 0x4f4c },
+      'MINISERIAL'
+    );
+
+    await expect(
+      runOwnedSearch(BOOTLOADER_PATH, ownerDevice, [{ vendorId: 0x1209, productId: 0x4f4c }])
+    ).resolves.toEqual([
+      expect.objectContaining({ connectId: BOOTLOADER_PATH, uuid: '', serialNo: null }),
+    ]);
   });
 
   test('searchDevices resolves empty when WebUSB bring-up is unavailable', async () => {

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;AAuC7D,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU;IACnD,SAAS,CAAC,EAAE,eAAe,CAAC;IAE5B,IAAI;IAME,GAAG,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;CAsFrC"}
+{"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"}

package/dist/index.js

@@ -47277,18 +47277,38 @@ class PreInitialize extends BaseMethod {
 }
 
 const Log$e = getLogger(exports.LoggerNames.DevicePool);
+const getDescriptorKeys = (descriptor) => [descriptor.path, descriptor.id].filter((key) => typeof key === 'string' && key.length > 0);
 const isOwnedByActiveWebUsbRequest = (descriptor, requestQueue) => {
     if (!requestQueue)
         return false;
-    const keys = [descriptor.path, descriptor.id].filter((key) => typeof key === 'string' && key.length > 0);
-    return keys.some(key => requestQueue.getRequestTasksIdByConnectId(key).length > 0);
+    return getDescriptorKeys(descriptor).some(key => requestQueue.getRequestTasksIdByConnectId(key).length > 0);
+};
+const getUsbHandle = (descriptor) => descriptor === null || descriptor === void 0 ? void 0 : descriptor.device;
+const getOwningRequestDevice = (descriptor, requestQueue) => {
+    var _a, _b;
+    if (!requestQueue)
+        return undefined;
+    const usbHandle = getUsbHandle(descriptor);
+    if (usbHandle === undefined)
+        return undefined;
+    for (const key of getDescriptorKeys(descriptor)) {
+        for (const requestId of requestQueue.getRequestTasksIdByConnectId(key)) {
+            const device = (_a = requestQueue.getTask(requestId)) === null || _a === void 0 ? void 0 : _a.method.device;
+            if ((device === null || device === void 0 ? void 0 : device.features) &&
+                (device.mainId === key || ((_b = device.originalDescriptor) === null || _b === void 0 ? void 0 : _b.path) === key) &&
+                getUsbHandle(device.originalDescriptor) === usbHandle) {
+                return device;
+            }
+        }
+    }
+    return undefined;
 };
 const toSearchDeviceFromDescriptor = (descriptor) => {
     const connectId = descriptor.path || descriptor.id || null;
     return {
         connectId,
-        uuid: connectId !== null && connectId !== void 0 ? connectId : '',
-        serialNo: connectId,
+        uuid: '',
+        serialNo: null,
         deviceId: null,
         deviceType: hdShared.EDeviceType.Unknown,
         name: descriptor.name || connectId || '',
@@ -47342,7 +47362,8 @@ class SearchDevices extends BaseMethod {
             for (const descriptor of devicesDescriptor) {
                 if (hasActiveWebUsbRequest && isOwnedByActiveWebUsbRequest(descriptor, requestQueue)) {
                     const cached = DevicePool.getDeviceByPath(descriptor.path);
-                    const message = (cached === null || cached === void 0 ? void 0 : cached.features) ? toSearchDevice(cached) : null;
+                    const known = (cached === null || cached === void 0 ? void 0 : cached.features) ? cached : getOwningRequestDevice(descriptor, requestQueue);
+                    const message = known ? toSearchDevice(known) : null;
                     deviceList.push(message !== null && message !== void 0 ? message : toSearchDeviceFromDescriptor(descriptor));
                 }
                 else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.2-alpha.118",
+  "version": "1.2.2-alpha.119",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.2-alpha.118",
-    "@onekeyfe/hd-transport": "1.2.2-alpha.118",
+    "@onekeyfe/hd-shared": "1.2.2-alpha.119",
+    "@onekeyfe/hd-transport": "1.2.2-alpha.119",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "buffer": "^6.0.3",
@@ -46,5 +46,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "f73c3ec61e0ffe97c1d38b18058a18e169a72217"
+  "gitHead": "222ec4a49467e77a73766a07227069d76d9116f6"
 }

package/src/api/SearchDevices.ts

@@ -15,25 +15,59 @@ const Log = getLogger(LoggerNames.DevicePool);
 
 type RequestQueueLookup = {
   getRequestTasksIdByConnectId: (connectId: string) => number[];
+  getTask: (requestId: number) => { method: { device?: Device } } | undefined;
 };
 
+const getDescriptorKeys = (descriptor: DeviceDescriptor) =>
+  [descriptor.path, descriptor.id].filter(
+    (key): key is string => typeof key === 'string' && key.length > 0
+  );
+
 const isOwnedByActiveWebUsbRequest = (
   descriptor: DeviceDescriptor,
   requestQueue?: RequestQueueLookup
 ) => {
   if (!requestQueue) return false;
-  const keys = [descriptor.path, descriptor.id].filter(
-    (key): key is string => typeof key === 'string' && key.length > 0
+  return getDescriptorKeys(descriptor).some(
+    key => requestQueue.getRequestTasksIdByConnectId(key).length > 0
   );
-  return keys.some(key => requestQueue.getRequestTasksIdByConnectId(key).length > 0);
 };
 
+const getUsbHandle = (descriptor?: DeviceDescriptor) =>
+  (descriptor as { device?: unknown } | undefined)?.device;
+
+const getOwningRequestDevice = (
+  descriptor: DeviceDescriptor,
+  requestQueue?: RequestQueueLookup
+) => {
+  if (!requestQueue) return undefined;
+  const usbHandle = getUsbHandle(descriptor);
+  // A path alone can be shared (the all-zero bootloader path, a synthesized serial-less
+  // path), so the owner's identity is only reported for the USB handle it actually bound.
+  if (usbHandle === undefined) return undefined;
+  for (const key of getDescriptorKeys(descriptor)) {
+    for (const requestId of requestQueue.getRequestTasksIdByConnectId(key)) {
+      const device = requestQueue.getTask(requestId)?.method.device;
+      if (
+        device?.features &&
+        (device.mainId === key || device.originalDescriptor?.path === key) &&
+        getUsbHandle(device.originalDescriptor) === usbHandle
+      ) {
+        return device;
+      }
+    }
+  }
+  return undefined;
+};
+
+// A USB path is a routing key (the USB serial, a synthesized usb-vid-pid-name, or the
+// bootloader placeholder), not a hardware identity, so it never fills uuid/serialNo.
 const toSearchDeviceFromDescriptor = (descriptor: DeviceDescriptor): SearchDevice => {
   const connectId = descriptor.path || descriptor.id || null;
   return {
     connectId,
-    uuid: connectId ?? '',
-    serialNo: connectId,
+    uuid: '',
+    serialNo: null,
     deviceId: null,
     deviceType: EDeviceType.Unknown,
     name: descriptor.name || connectId || '',
@@ -108,9 +142,10 @@ export default class SearchDevices extends BaseMethod {
     for (const descriptor of devicesDescriptor) {
       if (hasActiveWebUsbRequest && isOwnedByActiveWebUsbRequest(descriptor, requestQueue)) {
         const cached = DevicePool.getDeviceByPath(descriptor.path);
-        const message = cached?.features ? toSearchDevice(cached) : null;
-        // Do not probe a path an in-flight request already owns. A cache miss
-        // (passphrase switch / initSession) is still a connected device.
+        const known = cached?.features ? cached : getOwningRequestDevice(descriptor, requestQueue);
+        const message = known ? toSearchDevice(known) : null;
+        // Do not probe a path an in-flight request already owns. A cache miss is still a
+        // connected device: report the owning request's device, or the path with no identity.
         deviceList.push(message ?? toSearchDeviceFromDescriptor(descriptor));
       } else {
         try {