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

package/src/api/OpenWalletSession.ts

@@ -1,7 +1,6 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
-import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
 import { getProtocolV2WalletSession } from '../protocols/protocol-v2/walletSession';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
 import { BaseMethod } from './BaseMethod';
@@ -13,16 +12,6 @@ import type {
   OpenWalletSessionPayload,
 } from '../types/api/openWalletSession';
 
-const requiredString = (value: unknown, name: string) => {
-  if (value === undefined || value === null) {
-    throw invalidParameter(`Missing required parameter: ${name}`);
-  }
-  if (typeof value !== 'string' || !value.trim()) {
-    throw invalidParameter(`Parameter [${name}] must be a non-empty string.`);
-  }
-  return value.trim();
-};
-
 const wasResumed = (session: unknown) =>
   !!session &&
   typeof session === 'object' &&
@@ -53,34 +42,21 @@ const normalizeParams = (payload: Record<string, unknown>): OpenWalletSessionPar
   }
   if (
     payload.mode !== OpenWalletSessionMode.Standard &&
-    payload.mode !== OpenWalletSessionMode.SelectHidden &&
-    payload.mode !== OpenWalletSessionMode.ResumeHidden
+    payload.mode !== OpenWalletSessionMode.SelectHidden
   ) {
-    throw invalidParameter(
-      'Parameter [mode] must be one of standard, select-hidden, or resume-hidden.'
-    );
+    throw invalidParameter('Parameter [mode] must be one of standard or select-hidden.');
   }
   if (payload.useEmptyPassphrase !== undefined || payload.initSession !== undefined) {
     throw invalidParameter(
       'Legacy parameters [useEmptyPassphrase] and [initSession] are not supported by openWalletSession.'
     );
   }
-  if (
-    payload.mode === OpenWalletSessionMode.Standard ||
-    payload.mode === OpenWalletSessionMode.SelectHidden
-  ) {
-    if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
-      throw invalidParameter(
-        'Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].'
-      );
-    }
-    return { mode: payload.mode };
+  if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
+    throw invalidParameter(
+      'Parameters [deviceId] and [passphraseState] are not supported by openWalletSession. Pass passphraseState on later address and signing calls.'
+    );
   }
-  return {
-    mode: OpenWalletSessionMode.ResumeHidden,
-    deviceId: requiredString(payload.deviceId, 'deviceId'),
-    passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
-  };
+  return { mode: payload.mode };
 };
 
 export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParams> {
@@ -196,52 +172,6 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       };
     }
 
-    if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
-      if (isProtocolV2) {
-        await ensureProtocolV2WalletStatus();
-        const refreshedDeviceId = requireDeviceId();
-        if (refreshedDeviceId !== this.params.deviceId) {
-          deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
-          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
-        }
-      } else if (requireDeviceId() !== this.params.deviceId) {
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
-      }
-      this.device.passphraseState = this.params.passphraseState;
-      const cachedSessionId = deviceWalletSessionStore.get(
-        this.params.deviceId,
-        this.params.passphraseState
-      );
-      if (!cachedSessionId && !isProtocolV2) {
-        throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
-      }
-      if (!isProtocolV2) {
-        await this.device.initialize({
-          deviceId: this.params.deviceId,
-          passphraseState: this.params.passphraseState,
-        });
-      }
-      const session = isProtocolV2
-        ? await getProtocolV2WalletSession(this.device, {
-            expectedPassphraseState: this.params.passphraseState,
-          })
-        : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
-            expectPassphraseState: this.params.passphraseState,
-          });
-      const deviceId = requireDeviceId();
-      if (session.passphraseState !== this.params.passphraseState) {
-        this.device.clearInternalState();
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
-      }
-      return {
-        protocol,
-        walletType: 'hidden',
-        deviceId,
-        ...requireHiddenWalletResponse(session),
-        resumed: wasResumed(session) || (!isProtocolV2 && session.newSession === cachedSessionId),
-      };
-    }
-
     this.device.passphraseState = undefined;
     const walletStatus = await ensureProtocolV2WalletStatus();
     if (isProtocolV2 && walletStatus.status.passphraseProtection !== true) {

package/src/api/UploadPortfolio.ts

@@ -7,6 +7,8 @@ import FileWrite from './FileWrite';
 export type UploadPortfolioParams = {
   packageBase64: string;
   timeoutMs?: number | string;
+  /** Controls transfer progress UI events. Defaults to `silent`. */
+  uiMode?: 'silent' | 'progress';
 };
 
 const PORTFOLIO_PENDING_PATH = 'vol1:/portfolio/portfolio.okpkg.pending';
@@ -17,7 +19,7 @@ const PORTFOLIO_UPDATE_MESSAGE_TYPE = 61400;
 
 export default class UploadPortfolio extends FileWrite {
   init() {
-    const { packageBase64, timeoutMs } = this.payload as UploadPortfolioParams;
+    const { packageBase64, timeoutMs, uiMode = 'silent' } = this.payload as UploadPortfolioParams;
     const packageBytes = decodeCanonicalBase64({
       value: packageBase64,
       parameterName: 'packageBase64',
@@ -31,13 +33,12 @@ export default class UploadPortfolio extends FileWrite {
       chunkSize: PORTFOLIO_CHUNK_SIZE,
       overwrite: true,
       append: false,
-      emitProgress: false,
+      emitProgress: uiMode === 'progress',
       timeoutMs,
     };
     super.init();
     this.unlockPolicy = 'none';
-    // Portfolio is a background write/apply flow and never synthesizes UI events.
-    this.protocolV2UiMode = 'none';
+    this.protocolV2UiMode = uiMode === 'progress' ? 'auto' : 'none';
   }
 
   async run() {

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

@@ -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,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 & {
@@ -388,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,
@@ -408,6 +439,7 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
             if (!passphraseStateSafety) {
               throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
             }
+            this.markProtocolV2WalletResumed(deriveCardano);
           }
         },
       });
@@ -457,30 +489,64 @@ 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) {
+        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/api/solana/SolSignOffchainMessage.ts

@@ -1,11 +1,36 @@
 import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
-import { validateParams } from '../helpers/paramsValidator';
-import { stripHexPrefix } from '../helpers/hexUtils';
+import { invalidParameter, validateParams } from '../helpers/paramsValidator';
+import { addHexPrefix, isHexString, stripHexPrefix } from '../helpers/hexUtils';
 
 import type { SolanaSignOffChainMessage as HardwareSolSignOffChainMessage } from '@onekeyfe/hd-transport';
 
+const SOLANA_PUBLIC_KEY_LENGTH = 32;
+const SOLANA_APPLICATION_DOMAIN_LENGTH = 32;
+
+const normalizeRequiredSigners = (requiredSigners: unknown[] = []): string[] => {
+  const normalized = requiredSigners.map((signer, index) => {
+    if (
+      typeof signer !== 'string' ||
+      !isHexString(addHexPrefix(signer), SOLANA_PUBLIC_KEY_LENGTH)
+    ) {
+      throw invalidParameter(
+        `Parameter [requiredSigners][${index}] must be a ${SOLANA_PUBLIC_KEY_LENGTH}-byte hex public key.`
+      );
+    }
+    return stripHexPrefix(signer).toLowerCase();
+  });
+
+  for (let index = 1; index < normalized.length; index += 1) {
+    if (normalized[index - 1] >= normalized[index]) {
+      throw invalidParameter('Parameter [requiredSigners] must be strictly sorted and unique.');
+    }
+  }
+
+  return normalized;
+};
+
 export default class SolSignOffchainMessage extends BaseMethod<HardwareSolSignOffChainMessage> {
   getSupportedProtocols() {
     return ['V1', 'V2'] as const;
@@ -23,10 +48,24 @@ export default class SolSignOffchainMessage extends BaseMethod<HardwareSolSignOf
       { name: 'messageVersion', type: 'number', required: false },
       { name: 'messageFormat', type: 'number', required: false },
       { name: 'applicationDomainHex', type: 'hexString', required: false },
+      { name: 'requiredSigners', type: 'array', required: false, allowEmpty: true },
     ]);
 
-    const { path, messageHex, messageVersion, messageFormat, applicationDomainHex } = this.payload;
+    const {
+      path,
+      messageHex,
+      messageVersion,
+      messageFormat,
+      applicationDomainHex,
+      requiredSigners,
+    } = this.payload;
     const addressN = validatePath(path, 3);
+    if (
+      applicationDomainHex !== undefined &&
+      !isHexString(addHexPrefix(applicationDomainHex), SOLANA_APPLICATION_DOMAIN_LENGTH)
+    ) {
+      throw invalidParameter('Parameter [applicationDomainHex] must be 32 bytes.');
+    }
 
     // init params
     this.params = {
@@ -34,7 +73,8 @@ export default class SolSignOffchainMessage extends BaseMethod<HardwareSolSignOf
       message: stripHexPrefix(messageHex),
       message_version: messageVersion ?? undefined,
       message_format: messageFormat ?? undefined,
-      application_domain: applicationDomainHex ?? undefined,
+      application_domain: applicationDomainHex ? stripHexPrefix(applicationDomainHex) : undefined,
+      required_signers: normalizeRequiredSigners(requiredSigners),
     };
   }
 

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;