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

package/src/api/SearchDevices.ts

@@ -1,4 +1,4 @@
-import { EDeviceType, canonicalizePro2BleAdvertisementName } from '@onekeyfe/hd-shared';
+import { canonicalizePro2BleAdvertisementName } from '@onekeyfe/hd-shared';
 
 import { BaseMethod } from './BaseMethod';
 import TransportManager from '../data-manager/TransportManager';
@@ -6,80 +6,10 @@ 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;
 
@@ -89,31 +19,19 @@ export default class SearchDevices extends BaseMethod {
     this.skipForceUpdateCheck = true;
   }
 
-  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();
+  async run() {
+    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: SearchDevice[] = [];
+      const devices = [];
       const seenIds = new Set<string>();
 
       for (const device of devicesDescriptor) {
@@ -138,42 +56,30 @@ export default class SearchDevices extends BaseMethod {
       return devices;
     }
 
-    const deviceList: SearchDevice[] = [];
+    const deviceList = [];
     for (const descriptor of devicesDescriptor) {
-      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 } : {}),
-          });
-        }
+      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 } : {}),
+        });
       }
     }
 
-    return deviceList;
+    return deviceList.map(device => device.toMessageObject());
   }
 }

package/src/api/allnetwork/AllNetworkGetAddress.ts

@@ -31,22 +31,20 @@ export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
         originalIndex: index,
       })
     );
-    const groupedMethodParams = methodParams.reduce((groups, param) => {
+    // Protocol V2 DeviceSessionGet is the Initialize(session_id) equivalent: the
+    // SE wallet stays selected until the next Ask/Get or lock. Nested chain
+    // methods still resume once in callMethod; same-method addresses can share
+    // that session the way Protocol V1 bundles do.
+    const methodGroups = methodParams.reduce((groups, param) => {
       const group = groups.get(param.methodName) ?? [];
       group.push(param);
       groups.set(param.methodName, group);
       return groups;
     }, new Map<keyof CoreApi, MethodParams[]>());
-    const requiresProtocolV2WalletHandoff =
-      this.device.isProtocolV2() &&
-      (this.payload.useEmptyPassphrase === true || !!this.payload.passphraseState);
-    const methodGroups: [keyof CoreApi, MethodParams[]][] = requiresProtocolV2WalletHandoff
-      ? methodParams.map(param => [param.methodName, [param]])
-      : Array.from(groupedMethodParams.entries());
 
-    let i = 0;
-    for (const [methodName, params] of methodGroups) {
-      const methodParams = {
+    let processed = 0;
+    for (const [methodName, params] of methodGroups.entries()) {
+      const methodCallParams = {
         bundle: params.map(param => ({
           ...param.params,
         })),
@@ -55,27 +53,56 @@ export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
       if (this.abortController?.signal.aborted) {
         throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
       }
-      // call method
-      const response = await this.callMethod(methodName, methodParams, rootFingerprint);
+      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]);
       }
 
-      for (let i = 0; i < params.length; i++) {
-        const { _originRequestParams, _originalIndex } = params[i];
-        const responseKey = `${_originalIndex}`;
-        resultMap[responseKey] = {
+      for (let index = 0; index < params.length; index++) {
+        const { _originRequestParams, _originalIndex } = params[index];
+        resultMap[`${_originalIndex}`] = {
           ..._originRequestParams,
-          ...response[i],
+          ...response[index],
         };
       }
 
-      if (this.payload?.bundle?.length > 1) {
-        const progress = Math.round(((i + 1) / this.payload.bundle.length) * 100);
+      processed += params.length;
+      if (bundle.length > 1) {
+        const progress = Math.round((processed / bundle.length) * 100);
         this.postMessage(createUiMessage(UI_REQUEST.DEVICE_PROGRESS, { progress }));
       }
-      i++;
     }
 
     for (let i = 0; i < bundle.length; i++) {

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -273,6 +273,12 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
 
   private loadingCommands?: DeviceCommands;
 
+  // DeviceSessionGet selects the SE wallet like Initialize(session_id). Nested
+  // all-network methods skip callAPI, so the first chain call still resumes;
+  // later same-domain calls reuse that session. Cardano may Ask [Standard,
+  // Cardano] once, which also covers later non-Cardano commands.
+  private protocolV2ResumedSeedDomains = new Set<'standard' | 'cardano'>();
+
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
@@ -320,6 +326,23 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
     };
   }
 
+  private hasProtocolV2WalletResume(deriveCardano?: boolean) {
+    if (deriveCardano) {
+      return this.protocolV2ResumedSeedDomains.has('cardano');
+    }
+    return (
+      this.protocolV2ResumedSeedDomains.has('standard') ||
+      this.protocolV2ResumedSeedDomains.has('cardano')
+    );
+  }
+
+  private markProtocolV2WalletResumed(deriveCardano?: boolean) {
+    this.protocolV2ResumedSeedDomains.add('standard');
+    if (deriveCardano) {
+      this.protocolV2ResumedSeedDomains.add('cardano');
+    }
+  }
+
   async callMethod(
     methodName: keyof CoreApi,
     params: any & {
@@ -395,16 +418,17 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
             }
           }
 
-          // Protocol V2 hands a wallet session to exactly one blockchain request.
-          // The parent all-network call consumes its first handoff while fetching
-          // the root fingerprint, so each nested chain method must resume the
-          // requested standard or hidden wallet before sending its device command.
+          // Nested chain methods skip callAPI's session gate. Resume the requested
+          // wallet once per seed domain; DeviceSessionGet is sticky like V1
+          // Initialize, so later addresses and chains reuse it.
           const useEmptyPassphrase = this.payload.useEmptyPassphrase === true;
-          // Nested Cardano methods opt in to [Standard, Cardano] if Ask rebuilds.
-          // Other chains stay Standard-only.
           const deriveCardano = method.name.startsWith('cardano') ? true : undefined;
           const shouldResumeWalletSession = useEmptyPassphrase || !!this.payload.passphraseState;
-          if (this.device.isProtocolV2() && shouldResumeWalletSession) {
+          if (
+            this.device.isProtocolV2() &&
+            shouldResumeWalletSession &&
+            !this.hasProtocolV2WalletResume(deriveCardano)
+          ) {
             const passphraseStateSafety = await this.device.checkPassphraseStateSafety(
               this.payload.passphraseState,
               useEmptyPassphrase,
@@ -415,6 +439,7 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
             if (!passphraseStateSafety) {
               throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
             }
+            this.markProtocolV2WalletResumed(deriveCardano);
           }
         },
       });

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 = 5 * 1000;
+const PRE_PENDING_CALL_TIMEOUT_MS = 15 * 1000;
 const PRO2_USB_SIGNING_COOLDOWN_MS = 1000;
 
 // Dedup/coalesce state for "pre-warm signal" methods (isPreWarmSignal),
@@ -183,7 +183,6 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
       }
     };
     method.setContext?.(context);
-    method.context = context;
 
     method.requestContext = createRequestContext(method.responseID, method.name, {
       sdkInstanceId: context.sdkInstanceId,
@@ -204,12 +203,7 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   if (!method.useDevice) {
     updateMethodRequestContext(method, { status: 'running' });
     try {
-      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();
+      const response = await method.run();
       completeMethodRequestContext(method);
       return createResponseMessage(method.responseID, true, response);
     } catch (error) {
@@ -321,27 +315,25 @@ 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>(resolve => {
+        new Promise<void>((_, reject) => {
           timer = setTimeout(() => {
-            timedOut = true;
-            resolve();
+            reject(
+              ERRORS.TypedError(
+                HardwareErrorCode.DeviceBusy,
+                'Previous device cancellation is still draining'
+              )
+            );
           }, PRE_PENDING_CALL_TIMEOUT_MS);
         }),
       ]);
-      completed = !timedOut;
+      // 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);
     } 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');
   }
@@ -419,26 +411,7 @@ const onCallDevice = async (
      * Polling to ensure successful connection
      */
     const pollingId = pollingManager.start(connectId);
-    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();
-    }
+    device = await ensureConnected(context, method, connectId, pollingId, method.abortSignal);
     if (method.abortSignal?.aborted) {
       throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
     }
@@ -1227,7 +1200,6 @@ 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}  `
   );
@@ -1268,9 +1240,7 @@ 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 (
           [
@@ -1285,7 +1255,6 @@ const ensureConnected = async (
         }
         if (error.errorCode === HardwareErrorCode.TransportNotConfigured) {
           await TransportManager.configure();
-          lastInitializeError = undefined;
         }
       }
 
@@ -1383,22 +1352,14 @@ const ensureConnected = async (
           clearTimeout(timer);
         }
         Log.debug('EnsureConnected get to max try count, will return: ', tryCount);
-        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) {
+        // Browser WebUSB needs permission prompt, desktop WebUSB doesn't
+        // skipWebDevicePrompt can override this behavior for special cases
+        if (DataManager.isBrowserWebUsb(env) && !method.payload?.skipWebDevicePrompt) {
           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,8 +33,6 @@ export default class TransportManager {
 
   static reactNativeInit = false;
 
-  static webUsbInit = false;
-
   static protocolV1MessageSchema: ProtocolV1MessageSchema = 'v1CurrentSchema';
 
   static plugin: LowlevelTransportSharedPlugin | null = null;
@@ -44,17 +42,6 @@ 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() {
@@ -82,7 +69,9 @@ export default class TransportManager {
       } else if (env === 'desktop-web-ble') {
         await this.transport.init(WebBleLogger, DevicePool.emitter);
       } else if (env === 'webusb' || env === 'desktop-webusb') {
-        await this.ensureInitialized();
+        // 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);
       } else {
         await this.transport.init(HttpLogger);
       }

package/src/device/Device.ts

@@ -1624,13 +1624,6 @@ 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();