@onekeyfe/hd-core 1.2.2-alpha.120 → 1.2.2-alpha.122

package/src/api/SearchDevices.ts

@@ -1,4 +1,4 @@
-import { canonicalizePro2BleAdvertisementName } from '@onekeyfe/hd-shared';
+import { EDeviceType, canonicalizePro2BleAdvertisementName } from '@onekeyfe/hd-shared';
 
 import { BaseMethod } from './BaseMethod';
 import TransportManager from '../data-manager/TransportManager';
@@ -6,10 +6,80 @@ import { DataManager } from '../data-manager';
 import { LoggerNames, getDeviceTypeByBleName, getLogger } from '../utils';
 import { DevicePool } from '../device/DevicePool';
 
+import type { SearchDevice } from '../types/device';
 import type DeviceConnector from '../device/DeviceConnector';
+import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+import type { Device } from '../device/Device';
 
 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;
+  return getDescriptorKeys(descriptor).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: '',
+    serialNo: null,
+    deviceId: null,
+    deviceType: EDeviceType.Unknown,
+    name: descriptor.name || connectId || '',
+    commType: descriptor.commType,
+  };
+};
+
+const toSearchDevice = (device: Device): SearchDevice | null => {
+  const message = device.toMessageObject();
+  return message ? (message as SearchDevice) : null;
+};
+
 export default class SearchDevices extends BaseMethod {
   connector?: DeviceConnector;
 
@@ -19,19 +89,31 @@ export default class SearchDevices extends BaseMethod {
     this.skipForceUpdateCheck = true;
   }
 
-  async run() {
-    await TransportManager.configure();
+  async run(): Promise<SearchDevice[]> {
+    const env = DataManager.getSettings('env');
+    const isWebUsb = env === 'webusb' || env === 'desktop-webusb';
+    const requestQueue = this.context?.requestQueue;
+    const hasActiveWebUsbRequest = isWebUsb && (requestQueue?.getRequestTasksId().length ?? 0) > 0;
+    // Bring up WebUSB even when schema configuration is deferred while a
+    // business request owns the discovery lock. Failures here used to be
+    // swallowed by configure(); keep searchDevices resolving empty.
+    if (isWebUsb) {
+      try {
+        await TransportManager.ensureInitialized();
+      } catch (error) {
+        Log.debug('WebUSB bring-up unavailable', error);
+      }
+    }
+    if (!hasActiveWebUsbRequest) await TransportManager.configure();
     const deviceDiff = await this.connector?.enumerate();
     const devicesDescriptor = deviceDiff?.descriptors ?? [];
 
-    const env = DataManager.getSettings('env');
-
     /**
      * No need to call features during Bluetooth scaning
      * to avoid device pairing
      */
     if (DataManager.isBleConnect(env)) {
-      const devices = [];
+      const devices: SearchDevice[] = [];
       const seenIds = new Set<string>();
 
       for (const device of devicesDescriptor) {
@@ -56,30 +138,42 @@ export default class SearchDevices extends BaseMethod {
       return devices;
     }
 
-    const deviceList = [];
+    const deviceList: SearchDevice[] = [];
     for (const descriptor of devicesDescriptor) {
-      try {
-        // Discovery is best effort. Browsers may retain WebUSB grants for devices that
-        // are offline, busy, or not ready, so one descriptor must not abort the scan.
-        const result = await DevicePool.getDevices([descriptor], descriptor.path, {
-          // Discovery must actively identify the protocol instead of trusting a caller hint.
-          connectProtocol: undefined,
-          forceProtocolDetection: true,
-          refreshRuntimeState: true,
-        });
-        deviceList.push(...result.deviceList);
-      } catch (error) {
-        const errorCode =
-          error && typeof error === 'object' && 'errorCode' in error
-            ? (error as { errorCode?: unknown }).errorCode
-            : undefined;
-        Log.debug('Skip unavailable device during search', {
-          path: descriptor.path,
-          ...(errorCode !== undefined ? { errorCode } : {}),
-        });
+      if (hasActiveWebUsbRequest && isOwnedByActiveWebUsbRequest(descriptor, requestQueue)) {
+        const cached = DevicePool.getDeviceByPath(descriptor.path);
+        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 {
+          // Discovery is best effort. Browsers may retain WebUSB grants for devices that
+          // are offline, busy, or not ready, so one descriptor must not abort the scan.
+          const result = await DevicePool.getDevices([descriptor], descriptor.path, {
+            // Discovery must actively identify the protocol instead of trusting a caller hint.
+            connectProtocol: undefined,
+            forceProtocolDetection: true,
+            refreshRuntimeState: true,
+          });
+          for (const device of result.deviceList) {
+            const message = toSearchDevice(device);
+            if (message) deviceList.push(message);
+          }
+        } catch (error) {
+          const errorCode =
+            error && typeof error === 'object' && 'errorCode' in error
+              ? (error as { errorCode?: unknown }).errorCode
+              : undefined;
+          Log.debug('Skip unavailable device during search', {
+            path: descriptor.path,
+            ...(errorCode !== undefined ? { errorCode } : {}),
+          });
+        }
       }
     }
 
-    return deviceList.map(device => device.toMessageObject());
+    return deviceList;
   }
 }

package/src/api/allnetwork/AllNetworkGetAddress.ts

@@ -7,21 +7,74 @@ import AllNetworkGetAddressBase from './AllNetworkGetAddressBase';
 import type { CoreApi } from '../../types';
 import type {
   AllNetworkAddress,
-  AllNetworkAddressParams,
   AllNetworkGetAddressParams,
 } from '../../types/api/allNetworkGetAddress';
 
-type MethodParams = {
-  methodName: keyof CoreApi;
-  params: Parameters<CoreApi[keyof CoreApi]>[0];
-  _originRequestParams: AllNetworkAddressParams;
-  _originalIndex: number;
-};
+type MethodParams = ReturnType<AllNetworkGetAddressBase['generateMethodName']>;
 
 export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
+  private checkAborted() {
+    if (this.abortController?.signal.aborted) {
+      throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
+    }
+  }
+
+  private async callAddressGroup(
+    methodName: keyof CoreApi,
+    params: MethodParams[],
+    rootFingerprint: number
+  ): Promise<AllNetworkAddress[]> {
+    const methodCallParams = { bundle: params.map(param => ({ ...param.params })) };
+    if (!this.device.isProtocolV2() || params.length === 1) {
+      return this.callMethod(methodName, methodCallParams, rootFingerprint);
+    }
+
+    const postedAddressCounts = new Map<string, number>();
+    let runningIndividually = false;
+    const postMessage: typeof this.postMessage = message => {
+      if (message.type === UI_REQUEST.PREVIOUS_ADDRESS_RESULT) {
+        const { path, address } = message.payload.data;
+        const key = JSON.stringify([path, address]);
+        const count = postedAddressCounts.get(key) ?? 0;
+        if (runningIndividually && count > 0) {
+          postedAddressCounts.set(key, count - 1);
+          return;
+        }
+        if (!runningIndividually) postedAddressCounts.set(key, count + 1);
+      }
+      this.postMessage(message);
+    };
+
+    // Only silent reads may be replayed. Forward their notifications immediately,
+    // then suppress matching retry copies by count so repeated inputs still emit.
+    if (params.every(param => param._originRequestParams.showOnOneKey === false)) {
+      const response = await this.callMethod(
+        methodName,
+        methodCallParams,
+        rootFingerprint,
+        postMessage
+      );
+      // Skippable errors become failed items; link, cancellation and wallet errors throw.
+      if (response.some(item => item.success)) return response;
+    }
+
+    runningIndividually = true;
+    const responses: AllNetworkAddress[] = [];
+    for (const param of params) {
+      this.checkAborted();
+      const response = await this.callMethod(
+        methodName,
+        { bundle: [{ ...param.params }] },
+        rootFingerprint,
+        postMessage
+      );
+      responses.push(...response);
+    }
+    return responses;
+  }
+
   async getAllNetworkAddress(rootFingerprint: number) {
     const responses: AllNetworkAddress[] = [];
-    const resultMap: Record<string, AllNetworkAddress> = {};
     const { bundle } = this.payload as AllNetworkGetAddressParams;
 
     const methodParams = bundle.map((param, index) =>
@@ -44,55 +97,13 @@ export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
 
     let processed = 0;
     for (const [methodName, params] of methodGroups.entries()) {
-      const methodCallParams = {
-        bundle: params.map(param => ({
-          ...param.params,
-        })),
-      };
-
-      if (this.abortController?.signal.aborted) {
-        throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
-      }
-      const isProtocolV2 = this.device.isProtocolV2();
-      // Displayed addresses must not be replayed if a later item fails.
-      const runIndividually =
-        isProtocolV2 &&
-        params.length > 1 &&
-        params.some(param => param._originRequestParams.showOnOneKey !== false);
-      let response: AllNetworkAddress[] = [];
-      if (!runIndividually) {
-        response = await this.callMethod(methodName, methodCallParams, rootFingerprint);
-      }
-
-      // callMethod returns failures only for skippable errors; link, cancellation,
-      // and wallet errors throw. Retry silent reads separately to isolate a bad
-      // path or unsupported coin while reusing the already selected wallet.
-      if (
-        isProtocolV2 &&
-        params.length > 1 &&
-        (runIndividually || response.every(item => !item.success))
-      ) {
-        response = [];
-        for (const param of params) {
-          if (this.abortController?.signal.aborted) {
-            throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
-          }
-          const itemResponse = await this.callMethod(
-            methodName,
-            { bundle: [{ ...param.params }] },
-            rootFingerprint
-          );
-          response.push(...itemResponse);
-        }
-      }
-
-      if (this.abortController?.signal.aborted) {
-        throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
-      }
+      this.checkAborted();
+      const response = await this.callAddressGroup(methodName, params, rootFingerprint);
+      this.checkAborted();
 
       for (let index = 0; index < params.length; index++) {
         const { _originRequestParams, _originalIndex } = params[index];
-        resultMap[`${_originalIndex}`] = {
+        responses[_originalIndex] = {
           ..._originRequestParams,
           ...response[index],
         };
@@ -105,11 +116,7 @@ export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
       }
     }
 
-    for (let i = 0; i < bundle.length; i++) {
-      responses.push(resultMap[i]);
-    }
-
     this.abortController = null;
-    return Promise.resolve(responses);
+    return responses;
   }
 }

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -348,7 +348,8 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
     params: any & {
       bundle: (any & { _originRequestParams: CommonResponseParams })[];
     },
-    rootFingerprint: number
+    rootFingerprint: number,
+    postMessage = this.postMessage
   ) {
     const method: BaseMethod = findMethod({
       event: IFRAME.CALL,
@@ -362,7 +363,7 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
     });
 
     method.connector = this.connector;
-    method.postMessage = this.postMessage;
+    method.postMessage = postMessage;
     if (this.context) {
       method.setContext?.(this.context);
     }
@@ -506,7 +507,11 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
   async run() {
     this.loadingCleanupInBackground = false;
     try {
-      if (this.device.isProtocolV2() && this.device.getCurrentDeviceType() === EDeviceType.Pro2) {
+      if (
+        this.device.isProtocolV2() &&
+        (this.device.getCurrentDeviceType() === EDeviceType.Pro2 ||
+          this.device.getCurrentDeviceType() === EDeviceType.Neo)
+      ) {
         const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
         if (supportsProtocolV2Message(protocolInfo, 60461)) {
           const { commands } = this.device;

package/src/core/index.ts

@@ -84,7 +84,7 @@ import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
 const PRE_INITIALIZE_TTL_MS = 60 * 1000;
-const PRE_PENDING_CALL_TIMEOUT_MS = 15 * 1000;
+const PRE_PENDING_CALL_TIMEOUT_MS = 5 * 1000;
 const PRO2_USB_SIGNING_COOLDOWN_MS = 1000;
 
 // Dedup/coalesce state for "pre-warm signal" methods (isPreWarmSignal),
@@ -183,6 +183,7 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
       }
     };
     method.setContext?.(context);
+    method.context = context;
 
     method.requestContext = createRequestContext(method.responseID, method.name, {
       sdkInstanceId: context.sdkInstanceId,
@@ -203,7 +204,12 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   if (!method.useDevice) {
     updateMethodRequestContext(method, { status: 'running' });
     try {
-      const response = await method.run();
+      const env = DataManager.getSettings('env');
+      const response =
+        method.name === 'searchDevices' &&
+        (DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env))
+          ? await context.methodSynchronize(() => method.run(), 'webusb-discovery')
+          : await method.run();
       completeMethodRequestContext(method);
       return createResponseMessage(method.responseID, true, response);
     } catch (error) {
@@ -315,25 +321,27 @@ const waitForPendingPromise = async (
   if (pendingPromise) {
     Log.debug('pre pending call promise before call method, wait for it');
     let timer: ReturnType<typeof setTimeout> | undefined;
+    let timedOut = false;
+    let completed = false;
     try {
       await Promise.race([
         pendingPromise,
-        new Promise<void>((_, reject) => {
+        new Promise<void>(resolve => {
           timer = setTimeout(() => {
-            reject(
-              ERRORS.TypedError(
-                HardwareErrorCode.DeviceBusy,
-                'Previous device cancellation is still draining'
-              )
-            );
+            timedOut = true;
+            resolve();
           }, PRE_PENDING_CALL_TIMEOUT_MS);
         }),
       ]);
-      // A deadline is not evidence that old I/O is safe to reuse. Keep the
-      // barrier on failure; a later call may proceed only after cleanup settles.
-      removePrePendingCallPromise?.(connectId, pendingPromise);
+      completed = !timedOut;
     } finally {
       if (timer) clearTimeout(timer);
+      // Keep a rejected cleanup barrier for the next caller's safety check;
+      // only a completed cleanup or a timeout may clear it.
+      if (timedOut || completed) removePrePendingCallPromise?.(connectId, pendingPromise);
+    }
+    if (timedOut) {
+      Log.warn('pre pending call promise timed out before call method', { connectId });
     }
     Log.debug('pre pending call promise before call method done');
   }
@@ -411,7 +419,26 @@ const onCallDevice = async (
      * Polling to ensure successful connection
      */
     const pollingId = pollingManager.start(connectId);
-    device = await ensureConnected(context, method, connectId, pollingId, method.abortSignal);
+    const env = DataManager.getSettings('env');
+    const connect = () =>
+      ensureConnected(context, method, connectId, pollingId, method.abortSignal);
+    // Discovery may acquire USB endpoints. Finish it before initializing a public
+    // request; once registered, that request makes discovery use cached state only.
+    if (DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env)) {
+      // Synchronization can keep the connect action queued after the caller is
+      // cancelled. Observe that promise so a late device-not-found error does
+      // not become an unhandled rejection.
+      const connectPromise = context.methodSynchronize(async () => {
+        if (method.abortSignal?.aborted) {
+          throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
+        }
+        return connect();
+      }, 'webusb-discovery');
+      connectPromise.catch(() => undefined);
+      device = await requestQueue.waitForTask(task, () => connectPromise);
+    } else {
+      device = await connect();
+    }
     if (method.abortSignal?.aborted) {
       throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
     }
@@ -1200,6 +1227,7 @@ const ensureConnected = async (
   const POLL_INTERVAL_TIME = (method.payload && method.payload.pollIntervalTime) || 1000;
   const TIME_OUT = (method.payload && method.payload.timeout) || 10000;
   let timer: ReturnType<typeof setTimeout> | null = null;
+  let lastInitializeError: any;
   Log.debug(
     `EnsureConnected function start, MAX_RETRY_COUNT=${MAX_RETRY_COUNT}, POLL_INTERVAL_TIME=${POLL_INTERVAL_TIME}  `
   );
@@ -1240,7 +1268,9 @@ const ensureConnected = async (
       Log.debug('EnsureConnected function try count: ', tryCount, ' poll interval time: ', time);
       try {
         await initDeviceList(method);
+        lastInitializeError = undefined;
       } catch (error) {
+        lastInitializeError = error;
         Log.debug('device list error: ', error);
         if (
           [
@@ -1255,6 +1285,7 @@ const ensureConnected = async (
         }
         if (error.errorCode === HardwareErrorCode.TransportNotConfigured) {
           await TransportManager.configure();
+          lastInitializeError = undefined;
         }
       }
 
@@ -1352,14 +1383,22 @@ const ensureConnected = async (
           clearTimeout(timer);
         }
         Log.debug('EnsureConnected get to max try count, will return: ', tryCount);
-        // Browser WebUSB needs permission prompt, desktop WebUSB doesn't
-        // skipWebDevicePrompt can override this behavior for special cases
-        if (DataManager.isBrowserWebUsb(env) && !method.payload?.skipWebDevicePrompt) {
+        const preserveWebUsbInitError =
+          DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env);
+        const needsPermissionPrompt =
+          DataManager.isBrowserWebUsb(env) && !method.payload?.skipWebDevicePrompt;
+        const fallbackError = needsPermissionPrompt
+          ? ERRORS.TypedError(HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission)
+          : ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
+        const errorToReject =
+          preserveWebUsbInitError && lastInitializeError ? lastInitializeError : fallbackError;
+        // Only ask the host for a WebUSB grant when the failure is actually
+        // "not found / needs permission". A preserved initialize error must
+        // not fire that prompt with a different public code.
+        if (needsPermissionPrompt && errorToReject === fallbackError) {
           postMessage(createUiMessage(UI_REQUEST.WEB_DEVICE_PROMPT_ACCESS_PERMISSION));
-          reject(ERRORS.TypedError(HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission));
-        } else {
-          reject(ERRORS.TypedError(HardwareErrorCode.DeviceNotFound));
         }
+        reject(errorToReject);
         return;
       }
 

package/src/data-manager/TransportManager.ts

@@ -33,6 +33,8 @@ export default class TransportManager {
 
   static reactNativeInit = false;
 
+  static webUsbInit = false;
+
   static protocolV1MessageSchema: ProtocolV1MessageSchema = 'v1CurrentSchema';
 
   static plugin: LowlevelTransportSharedPlugin | null = null;
@@ -42,6 +44,17 @@ export default class TransportManager {
     this.defaultMessages = DataManager.getProtobufMessages();
     this.currentMessages = this.defaultMessages;
     this.protocolV1MessageSchema = 'v1CurrentSchema';
+    this.webUsbInit = false;
+  }
+
+  static async ensureInitialized() {
+    const env = DataManager.getSettings('env');
+    if (env !== 'webusb' && env !== 'desktop-webusb') return;
+    if (this.webUsbInit) return;
+    // The emitter registers USB disconnect events; this must happen even when
+    // schema configuration is intentionally deferred during discovery.
+    await this.transport.init(WebUsbLogger, DevicePool.emitter);
+    this.webUsbInit = true;
   }
 
   static async configure() {
@@ -69,9 +82,7 @@ export default class TransportManager {
       } else if (env === 'desktop-web-ble') {
         await this.transport.init(WebBleLogger, DevicePool.emitter);
       } else if (env === 'webusb' || env === 'desktop-webusb') {
-        // The emitter is what turns a navigator.usb 'disconnect' into a
-        // DEVICE.DISCONNECT; without it WebUSB never reports device removal.
-        await this.transport.init(WebUsbLogger, DevicePool.emitter);
+        await this.ensureInitialized();
       } else {
         await this.transport.init(HttpLogger);
       }

package/src/device/Device.ts

@@ -1624,6 +1624,13 @@ export class Device extends EventEmitter {
         } else if (!acquired) {
           // Abort setup without acquiring a session just to send Cancel.
           if (mainId && deviceConnector?.disconnect) {
+            // The connector drops the link silently, so without this line a
+            // user-cancel teardown is indistinguishable in field logs from an
+            // idle keep-alive release or a device that left on its own.
+            Log.debug(
+              'interruptionFromUser: disconnecting device without acquire, mainId:',
+              mainId
+            );
             await deviceConnector.disconnect(mainId);
           }
           if (this.connectionAttempt === attempt) this.markTransportDisconnected();