@onekeyfe/hd-core 1.2.3-alpha.1 → 1.2.3-alpha.11

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) =>
@@ -31,58 +84,39 @@ 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 = {
-        bundle: params.map(param => ({
-          ...param.params,
-        })),
-      };
-
-      if (this.abortController?.signal.aborted) {
-        throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
-      }
-      // call method
-      const response = await this.callMethod(methodName, methodParams, rootFingerprint);
+    let processed = 0;
+    for (const [methodName, params] of methodGroups.entries()) {
+      this.checkAborted();
+      const response = await this.callAddressGroup(methodName, params, rootFingerprint);
+      this.checkAborted();
 
-      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];
+        responses[_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++) {
-      responses.push(resultMap[i]);
     }
 
     this.abortController = null;
-    return Promise.resolve(responses);
+    return responses;
   }
 }

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -1,5 +1,6 @@
 import semver from 'semver';
 import {
+  EDeviceType,
   ERRORS,
   HardwareError,
   HardwareErrorCode,
@@ -15,6 +16,7 @@ import { DEVICE, IFRAME, createUiMessage } from '../../events';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { onDeviceButtonHandler } from '../../core';
 import { runMethodWithUnlockPolicy } from '../../protocols/protocol-v2/unlockPolicyRunner';
+import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
 import {
   completeRequestContext,
   createRequestContext,
@@ -22,6 +24,7 @@ import {
 } from '../../utils/tracing';
 
 import type { Device, DeviceEvents } from '../../device/Device';
+import type { DeviceCommands } from '../../device/DeviceCommands';
 import type { CoreApi } from '../../types';
 import type {
   AllNetworkAddress,
@@ -266,6 +269,16 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
 
   abortController: AbortController | null = null;
 
+  protected loadingCleanupInBackground = false;
+
+  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];
@@ -313,12 +326,30 @@ 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 & {
       bundle: (any & { _originRequestParams: CommonResponseParams })[];
     },
-    rootFingerprint: number
+    rootFingerprint: number,
+    postMessage = this.postMessage
   ) {
     const method: BaseMethod = findMethod({
       event: IFRAME.CALL,
@@ -332,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);
     }
@@ -388,16 +419,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,
@@ -408,6 +440,7 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
             if (!passphraseStateSafety) {
               throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
             }
+            this.markProtocolV2WalletResumed(deriveCardano);
           }
         },
       });
@@ -457,30 +490,68 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
 
   abstract getAllNetworkAddress(rootFingerprint: number): Promise<AllNetworkAddress[]>;
 
+  protected async stopAllNetworkLoading(canSend = true) {
+    const commands = this.loadingCommands;
+    this.loadingCommands = undefined;
+    // Never send cleanup through a replacement or disposed connection.
+    if (!canSend || !commands || commands.disposed || commands !== this.device.commands) return;
+    try {
+      await commands.typedCall('DeviceAnimationControl', 'Success', {
+        action: PROTO.DeviceAnimationAction.AnimationAction_Stop,
+      });
+    } catch {
+      // Cleanup must not mask the operation result. Firmware also has an idle timeout.
+    }
+  }
+
   async run() {
-    const res = await this.device.commands.typedCall('GetPublicKey', 'PublicKey', {
-      address_n: [toHardened(44), toHardened(1), toHardened(0)],
-      coin_name: 'Testnet',
-      script_type: 'SPENDADDRESS',
-      show_display: false,
-    });
+    this.loadingCleanupInBackground = false;
+    try {
+      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;
+          await commands.typedCall('DeviceAnimationControl', 'Success', {
+            action: PROTO.DeviceAnimationAction.AnimationAction_Start,
+          });
+          this.loadingCommands = commands;
+        }
+      }
 
-    if (!this.device.isProtocolV2()) {
-      this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
-    }
+      const res = await this.device.commands.typedCall('GetPublicKey', 'PublicKey', {
+        address_n: [toHardened(44), toHardened(1), toHardened(0)],
+        coin_name: 'Testnet',
+        script_type: 'SPENDADDRESS',
+        show_display: false,
+      });
 
-    if (res.message.root_fingerprint == null) {
-      throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);
-    }
+      if (!this.device.isProtocolV2()) {
+        this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+      }
+
+      if (res.message.root_fingerprint == null) {
+        throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);
+      }
 
-    this.abortController = new AbortController();
+      this.abortController = new AbortController();
 
-    return this.getAllNetworkAddress(res.message.root_fingerprint).catch(e => {
+      return await this.getAllNetworkAddress(res.message.root_fingerprint);
+    } catch (e) {
+      // A failed call may have invalidated the transport link without disposing
+      // DeviceCommands. Let firmware time out instead of reconnecting for Stop.
+      await this.stopAllNetworkLoading(false);
       if (e instanceof HardwareError && e.errorCode === HardwareErrorCode.RepeatUnlocking) {
         throw ERRORS.TypedError(HardwareErrorCode.RepeatUnlocking, e.message);
       }
       throw e;
-    });
+    } finally {
+      // The callback API returns before its chain requests finish.
+      if (!this.loadingCleanupInBackground) await this.stopAllNetworkLoading();
+    }
   }
 }
 

package/src/api/allnetwork/AllNetworkGetAddressByLoop.ts

@@ -28,6 +28,7 @@ export default class AllNetworkGetAddressByLoop extends AllNetworkGetAddressBase
     const bundle = this.payload.bundle || [this.payload];
 
     // process callbacks in background
+    this.loadingCleanupInBackground = true;
     const callbackPromise = this.processCallbacksInBackground(
       bundle,
       rootFingerprint,
@@ -95,6 +96,7 @@ export default class AllNetworkGetAddressByLoop extends AllNetworkGetAddressBase
         data: allResults,
       });
     } catch (error: any) {
+      await this.stopAllNetworkLoading(false);
       let errorCode = error.errorCode || error.code;
       let errorMessage = error.message;
 
@@ -121,6 +123,7 @@ export default class AllNetworkGetAddressByLoop extends AllNetworkGetAddressBase
         },
       });
     } finally {
+      await this.stopAllNetworkLoading();
       this.context?.cancelCallbackTasks(this.payload.connectId);
       this.abortController = null;
     }

package/src/api/device/DeviceVerify.ts

@@ -22,6 +22,14 @@ export default class DeviceVerify extends BaseMethod<BixinVerifyDeviceRequest> {
     // the main PIN or an Attach PIN may authorize them.
     this.protocolV2PreUnlockPinType = DeviceSessionPinType.Any;
     this.useDevicePassphraseState = false;
+    this.protocolV2UiInteraction = {
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'device-management',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      operation: 'deviceVerify',
+    };
 
     // check payload
     validateParams(this.payload, [{ name: 'dataHex', type: 'hexString' }]);

package/src/core/RequestQueue.ts

@@ -1,3 +1,5 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import { LoggerNames, getLogger } from '../utils';
 
 import type { Deferred } from '@onekeyfe/hd-shared';
@@ -40,6 +42,24 @@ export default class RequestQueue {
     return this.requestQueue.get(requestId);
   }
 
+  public async waitForTask<T>(task: RequestTask, pending: () => Promise<T>): Promise<T> {
+    const signal = task.method.abortSignal;
+    const cancellationError = () => ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
+    if (signal?.aborted) throw cancellationError();
+    let onAbort: (() => void) | undefined;
+    try {
+      const cancelled = new Promise<never>((_, reject) => {
+        onAbort = () => reject(cancellationError());
+        signal?.addEventListener('abort', onAbort, { once: true });
+      });
+      const result = await Promise.race([pending(), cancelled]);
+      if (signal?.aborted) throw cancellationError();
+      return result;
+    } finally {
+      if (onAbort) signal?.removeEventListener('abort', onAbort);
+    }
+  }
+
   // 获取请求的AbortController
   public getAbortController(requestId: number) {
     return this.requestQueue.get(requestId)?.abortController;