@onekeyfe/hd-core 1.2.2-alpha.0 → 1.2.2-alpha.10

package/src/api/FirmwareUpdateV4.ts

@@ -374,6 +374,22 @@ const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
   );
 };
 
+const isProtocolV2InstallResponseTimeout = (error: unknown) => {
+  if (!error || typeof error !== 'object') return false;
+  const { code } = error as { code?: number | string };
+  return (
+    code === 'response-timeout' ||
+    /\bresponse timeout\b/i.test(getProtocolV2UnknownErrorText(error))
+  );
+};
+
+const getProtocolV2ErrorCode = (error: unknown): number | string | undefined => {
+  if (!error || typeof error !== 'object') return undefined;
+  const { errorCode, code } = error as { errorCode?: unknown; code?: unknown };
+  const causeCode = errorCode ?? code;
+  return typeof causeCode === 'number' || typeof causeCode === 'string' ? causeCode : undefined;
+};
+
 const isProtocolV2TerminalInstallStatusError = (error: unknown) =>
   isBleStaleBondHardwareError(error) ||
   (error instanceof HardwareError &&
@@ -565,6 +581,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2InstallNeedsReconnect = false;
 
+  private protocolV2InstallDisconnectObserved = false;
+
   private protocolV2InstallTerminalSuccessObserved = false;
 
   private protocolV2LastRuntimeProbeFeatures?: Features;
@@ -573,6 +591,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2LastTransferProgressAt = 0;
 
+  private protocolV2LastTransferredBytes = 0;
+
   init() {
     this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
     this.requireDeviceMode = [];
@@ -2103,6 +2123,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
     this.protocolV2LastTransferProgress = undefined;
     this.protocolV2LastTransferProgressAt = 0;
+    this.protocolV2LastTransferredBytes = 0;
+    const transferStartedAt = Date.now();
     let processedSize = 0;
     for (const resource of resourcesToSync) {
       // The bootloader keeps its live resource package mounted. FatFs rejects
@@ -2113,6 +2135,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         filePath: writePath,
         processedSize,
         totalSize,
+        transferStartedAt,
       });
       await this.verifyProtocolV2StagedFile(writePath, resource.source.size);
       if (isProtocolV2BootResourcePackagePath(resource.devicePath)) {
@@ -2128,6 +2151,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         filePath,
         processedSize,
         totalSize,
+        transferStartedAt,
       });
       await this.verifyProtocolV2StagedFile(filePath, item.source.size);
       stagedInstallTargets.push({
@@ -2137,7 +2161,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     if (totalSize > 0) {
-      this.postProgressMessage(100, 'transferData');
+      const elapsedMs = Math.max(Date.now() - transferStartedAt, 0);
+      this.postProgressMessage(100, 'transferData', {
+        transferredBytes: totalSize,
+        totalBytes: totalSize,
+        rateBytesPerSecond: elapsedMs > 0 ? Math.round((totalSize / elapsedMs) * 1000) : undefined,
+        elapsedMs,
+      });
     }
     if (stagedInstallTargets.length === 0) {
       return;
@@ -2162,20 +2192,23 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     filePath,
     processedSize,
     totalSize,
+    transferStartedAt = Date.now(),
   }: {
     source: FirmwareByteSource;
     filePath: string;
     processedSize: number;
     totalSize: number;
+    transferStartedAt?: number;
   }) {
     let lastError: unknown;
     for (let attempt = 1; attempt <= PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT; attempt += 1) {
+      this.throwIfAborted();
       try {
-        const transferStartedAt = Date.now();
         await writeFirmwareByteSource({
           source,
           chunkSize: this.getProtocolV2FirmwareChunkSize('write', filePath),
           write: async ({ data, sourceOffset, length, first }) => {
+            this.throwIfAborted();
             const chunkEnd = sourceOffset + length;
             const deviceProgress = getProtocolV2DeviceTransferProgress(
               processedSize + sourceOffset,
@@ -2203,18 +2236,20 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             const elapsedMs = Math.max(now - transferStartedAt, 0);
             const progress = Math.min(Math.ceil((transferredBytes / totalSize) * 100), 99);
             const shouldPostProgress =
-              progress !== this.protocolV2LastTransferProgress ||
-              now - this.protocolV2LastTransferProgressAt >=
-                PROTOCOL_V2_TRANSFER_PROGRESS_HEARTBEAT_MS ||
-              chunkEnd === source.size;
+              transferredBytes >= this.protocolV2LastTransferredBytes &&
+              (progress !== this.protocolV2LastTransferProgress ||
+                now - this.protocolV2LastTransferProgressAt >=
+                  PROTOCOL_V2_TRANSFER_PROGRESS_HEARTBEAT_MS ||
+                chunkEnd === source.size);
             if (shouldPostProgress) {
               this.protocolV2LastTransferProgress = progress;
               this.protocolV2LastTransferProgressAt = now;
+              this.protocolV2LastTransferredBytes = transferredBytes;
               this.postProgressMessage(progress, 'transferData', {
                 transferredBytes,
                 totalBytes: totalSize,
                 rateBytesPerSecond:
-                  elapsedMs > 0 ? Math.round((chunkEnd / elapsedMs) * 1000) : undefined,
+                  elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
                 elapsedMs,
               });
             }
@@ -2223,18 +2258,22 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         });
         return processedSize + source.size;
       } catch (error) {
+        this.throwIfAborted();
         if (isBleStaleBondHardwareError(error)) {
           throw error;
         }
         lastError = error;
         if (attempt < PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
           await this.recoverProtocolV2FileTransfer();
+          this.throwIfAborted();
         }
       }
     }
+    const causeCode = getProtocolV2ErrorCode(lastError);
     throw ERRORS.TypedError(
       HardwareErrorCode.EmmcFileWriteFirmwareError,
-      `transfer data error: ${getProtocolV2UnknownErrorText(lastError)}`
+      `transfer data error: ${getProtocolV2UnknownErrorText(lastError)}`,
+      causeCode === undefined ? undefined : { causeCode }
     );
   }
 
@@ -2517,9 +2556,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   ) {
     const expectedTargetIds = new Set(targets.map(target => target.target_id));
     const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
-    const isBleCoprocessorInstall =
-      this.isBleReconnect() &&
-      expectedTargetIds.has(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR);
+    const isBleInstall = this.isBleReconnect();
     const startTime = Date.now();
     let lastError: unknown;
     // The loader may release either USB or BLE as installation starts. Recovery reconnects
@@ -2528,7 +2565,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     this.protocolV2InstallNeedsReconnect = false;
     let deviceInfo: ProtocolV2DeviceInfo | undefined;
     let bleInstallLinkReady = false;
-    let installStatusDisconnectObserved = false;
+    let installStatusDisconnectObserved = isBleInstall && this.protocolV2InstallDisconnectObserved;
+    this.protocolV2InstallDisconnectObserved = false;
     let installReconnectObserved = false;
     let finishedStatusSnapshotKey: string | undefined;
     let finishedStatusSnapshotPolls = 0;
@@ -2536,6 +2574,19 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     let installEvidenceObserved = this.protocolV2InstallTerminalSuccessObserved;
     let currentInstallStatusObserved = false;
     const liveTargetIds = new Set<number>();
+    const recordBleInstallDisconnect = (error: unknown) => {
+      if (
+        !isBleInstall ||
+        !isProtocolV2DeviceDisconnectedError(error) ||
+        isProtocolV2InstallResponseTimeout(error)
+      ) {
+        return;
+      }
+      installStatusDisconnectObserved = true;
+      installReconnectObserved = false;
+      finishedStatusSnapshotKey = undefined;
+      finishedStatusSnapshotPolls = 0;
+    };
 
     while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
       // A transport release caused by an explicit workflow cancellation must not
@@ -2682,7 +2733,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           if (!hasCurrentInstallEvidence) {
             // A successful status poll clears DeviceCommands' cancel action. Keep cancellation
             // available while UpdateRequest is still waiting for confirmation on the device.
-            this.device.setCancelableAction(() => this.device.getCommands().cancelDevice());
+            // Bootloader does not register the protocol Cancel message. Keep the
+            // operation locally cancellable; interruptionFromUser() disposes the link.
+            this.device.setCancelableAction(() => Promise.resolve());
           }
 
           if (
@@ -2787,15 +2840,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               );
             }
           } else {
-            if (
-              isBleCoprocessorInstall &&
-              isProtocolV2DeviceDisconnectedError(error) &&
-              !isProtocolV2ResponseTimeout(error)
-            ) {
-              installStatusDisconnectObserved = true;
-              finishedStatusSnapshotKey = undefined;
-              finishedStatusSnapshotPolls = 0;
-            }
+            recordBleInstallDisconnect(error);
             shouldReconnect = true;
             deviceInfo = undefined;
             bleInstallLinkReady = false;
@@ -2820,6 +2865,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         ) {
           throw error;
         }
+        recordBleInstallDisconnect(error);
         shouldReconnect = true;
         deviceInfo = undefined;
         bleInstallLinkReady = false;
@@ -3154,10 +3200,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }) {
     this.protocolV2LastRuntimeProbeFeatures = undefined;
     this.protocolV2InstallNeedsReconnect = false;
+    this.protocolV2InstallDisconnectObserved = false;
     this.protocolV2InstallTerminalSuccessObserved = false;
     const commands = this.device.getCommands();
     await commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
-    this.device.setCancelableAction(() => this.device.getCommands().cancelDevice());
+    // Bootloader does not register the protocol Cancel message. Keep the
+    // operation locally cancellable; interruptionFromUser() disposes the link.
+    this.device.setCancelableAction(() => Promise.resolve());
     const interaction = this.device.createProtocolV2UiPhaseMetadata('button', 'start');
     this.postMessage(
       createUiMessage(UI_REQUEST.REQUEST_BUTTON, {
@@ -3196,6 +3245,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         '[FirmwareUpdateV4] transport released while writing install request; continue status polling'
       );
       this.protocolV2InstallNeedsReconnect = true;
+      this.protocolV2InstallDisconnectObserved = !isProtocolV2InstallResponseTimeout(error);
     }
   }
 

package/src/api/OpenWalletSession.ts

@@ -160,7 +160,6 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       const session = isProtocolV2
         ? await getProtocolV2WalletSession(this.device, {
             onlyMainPin: true,
-            deriveCardano: this.payload.deriveCardano,
             selectMainWalletBeforeRestore:
               !hasAuthoritativeProtocolV2WalletStatus(state) ||
               state.status.unlockedAttachPin === true,
@@ -225,7 +224,6 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       const session = isProtocolV2
         ? await getProtocolV2WalletSession(this.device, {
             expectedPassphraseState: this.params.passphraseState,
-            deriveCardano: this.payload.deriveCardano,
           })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             expectPassphraseState: this.params.passphraseState,
@@ -257,7 +255,6 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
           ...(readCurrentAttachPinSession
             ? { readCurrentAttachPinSession: true }
             : { forceWalletSelection: true }),
-          deriveCardano: this.payload.deriveCardano,
         })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
     const refreshedState = isProtocolV2

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -393,7 +393,9 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
           // the root fingerprint, so each nested chain method must resume the
           // requested standard or hidden wallet before sending its device command.
           const useEmptyPassphrase = this.payload.useEmptyPassphrase === true;
-          const deriveCardano = method.name.startsWith('cardano');
+          // 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) {
             const passphraseStateSafety = await this.device.checkPassphraseStateSafety(

package/src/api/helpers/protocolV2FileWrite.ts

@@ -36,6 +36,8 @@ export type ProtocolV2FileWriteOptions = {
   chunkSize?: number;
   chunkLen?: number;
   chunkSizeLimit?: number;
+  /** BLE-only limit for a caller whose fixed short path has a verified larger frame budget. */
+  bleChunkSizeLimit?: number;
   overwrite?: boolean;
   append?: boolean;
   uiPercentage?: number;
@@ -114,11 +116,15 @@ export function isProtocolV2ResponseTimeout(error: unknown) {
   );
 }
 
-function getProtocolV2FileChunkLimit() {
+function getProtocolV2FileChunkLimit(bleChunkSizeLimit?: number) {
   const env = DataManager.getSettings('env');
-  return env && DataManager.isBleConnect(env)
-    ? PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
-    : PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+  if (env && DataManager.isBleConnect(env)) {
+    const configuredLimit = Number(bleChunkSizeLimit);
+    return Number.isFinite(configuredLimit) && configuredLimit > 0
+      ? Math.floor(configuredLimit)
+      : PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+  }
+  return PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
 }
 
 async function dataToUint8Array(data: ProtocolV2FileWriteData): Promise<Uint8Array> {
@@ -178,7 +184,7 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
     );
   }
 
-  const defaultChunkSizeLimit = getProtocolV2FileChunkLimit();
+  const defaultChunkSizeLimit = getProtocolV2FileChunkLimit(options.bleChunkSizeLimit);
   const configuredChunkSizeLimit = Number(options.chunkSizeLimit);
   const chunkSizeLimit =
     Number.isFinite(configuredChunkSizeLimit) && configuredChunkSizeLimit > 0

package/src/api/protocol-v2/DeviceUploadNft.ts

@@ -42,8 +42,11 @@ export type DeviceUploadNftParams = {
 
 export type DeviceUploadNftResponse = {
   basename: string;
+  /** Final image path after firmware extracts a host-asset package. */
   imagePath: string;
+  /** Final thumbnail path after firmware extracts a host-asset package. */
   thumbnailPath: string;
+  /** Final metadata path after firmware extracts a host-asset package. */
   metadataPath: string;
   totalSize: number;
   nftUpdated: true;
@@ -197,7 +200,7 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     if (!bundle) throw invalidParameter('NFT data has not been initialized.');
 
     const useHostAssetPackage = supportsPro2HostAssetPackage(
-      this.device.getCurrentFirmwareVersionString()
+      this.device.state?.versions.firmware ?? undefined
     );
     await this.assertCapabilities(useHostAssetPackage);
     this.throwIfAborted();

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -23,11 +23,19 @@ import {
 
 export type DeviceUploadWallpaperParams = {
   jpegBase64: string;
+  /**
+   * Legacy firmware uses this name for the uploaded `.bin` file. Firmware
+   * 1.0.1+ always consumes the fixed `wallpaper.okpkg` package path.
+   */
   fileName?: string;
   chunkSize?: number;
 };
 
 export type DeviceUploadWallpaperResponse = {
+  /**
+   * Filesystem path sent to `DeviceSettingsSet`. On firmware 1.0.1+ this is
+   * the temporary package path; firmware extracts and persists wallpaper.bin.
+   */
   path: string;
   size: number;
   colorFormat: Pro2WallpaperColorFormat;
@@ -41,6 +49,7 @@ const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
 const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
 const FILESYSTEM_DIR_MAKE_MESSAGE_TYPE = 60809;
+const WALLPAPER_PACKAGE_BLE_CHUNK_SIZE = 1960;
 const Log = getLogger(LoggerNames.Method);
 
 function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
@@ -122,7 +131,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     this.directoryReady = true;
   }
 
-  private async upload(path: string, data: Uint8Array) {
+  private async upload(path: string, data: Uint8Array, bleChunkSizeLimit?: number) {
     if (this.uploaded) return;
 
     await writeProtocolV2File({
@@ -131,6 +140,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
       data,
       totalSize: data.byteLength,
       chunkSize: this.params.chunkSize,
+      bleChunkSizeLimit,
       maxChunkRetries: 3,
       overwrite: true,
       append: false,
@@ -150,13 +160,17 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     await this.assertCapabilities();
     await this.ensureDirectory();
     const useHostAssetPackage = supportsPro2HostAssetPackage(
-      this.device.getCurrentFirmwareVersionString()
+      this.device.state?.versions.firmware ?? undefined
     );
     const data = useHostAssetPackage
       ? buildPro2HostAssetPackage([{ name: WALLPAPER_PACKAGE_ENTRY, data: encoded.data }])
       : encoded.data;
     if (useHostAssetPackage) this.path = WALLPAPER_PACKAGE_PATH;
-    await this.upload(this.path, data);
+    await this.upload(
+      this.path,
+      data,
+      useHostAssetPackage ? WALLPAPER_PACKAGE_BLE_CHUNK_SIZE : undefined
+    );
     const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
       settings: { wallpaper_path: this.path },
     });

package/src/core/RequestQueue.ts

@@ -56,11 +56,20 @@ export default class RequestQueue {
     return false;
   }
 
+  private isRequestForConnectId(request: RequestTask, connectId: string) {
+    const { method } = request;
+    return (
+      method.connectId === connectId ||
+      method.device?.mainId === connectId ||
+      method.device?.getConnectId() === connectId
+    );
+  }
+
   // 取消与指定connectId相关的所有请求
   public abortRequestsByConnectId(connectId: string) {
     let count = 0;
     this.requestQueue.forEach((request, _) => {
-      if (request.abortController && request.method.connectId === connectId) {
+      if (request.abortController && this.isRequestForConnectId(request, connectId)) {
         request.abortController.abort();
         request.abortController = undefined;
         count++;
@@ -69,6 +78,12 @@ export default class RequestQueue {
     return count;
   }
 
+  public getRequestTasksIdByConnectId(connectId: string) {
+    return Array.from(this.requestQueue.values())
+      .filter(request => this.isRequestForConnectId(request, connectId))
+      .map(request => request.id);
+  }
+
   // 取消所有请求
   public abortAllRequests() {
     let count = 0;

package/src/core/index.ts

@@ -2,7 +2,11 @@ import semver from 'semver';
 import EventEmitter from 'events';
 import {
   DeviceSessionPinType,
+  type LowlevelTransportSharedPlugin,
+  type OneKeyDeviceInfo,
+  type ProtocolType,
   TRANSPORT_EVENT,
+  type TransportDeviceDisconnectEvent,
   isProtocolV2LinkDisabledError,
 } from '@onekeyfe/hd-transport';
 import {
@@ -74,11 +78,6 @@ import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } fro
 import type { DeviceEvents, InitOptions, RunOptions } from '../device/Device';
 import type { SdkTracingContext } from '../utils/tracing';
 import type { Deferred } from '@onekeyfe/hd-shared';
-import type {
-  LowlevelTransportSharedPlugin,
-  OneKeyDeviceInfo,
-  TransportDeviceDisconnectEvent,
-} from '@onekeyfe/hd-transport';
 import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
@@ -92,7 +91,7 @@ const preWarmDoneAt = new Map<string, number>();
 
 export type CoreContext = ReturnType<Core['getCoreContext']>;
 
-function hasDeriveCardano(method: BaseMethod): boolean {
+function resolveDeriveCardano(method: BaseMethod): boolean | undefined {
   if (
     method.name.startsWith('allNetworkGetAddress') &&
     method.payload &&
@@ -102,15 +101,22 @@ function hasDeriveCardano(method: BaseMethod): boolean {
   ) {
     return true;
   }
-
-  return method.name.startsWith('cardano') || method.payload?.deriveCardano;
+  if (method.name.startsWith('cardano')) {
+    return true;
+  }
+  // V1 Initialize only sends derive_cardano on an explicit true.
+  // V2 AskPassphrase maps true to [Standard, Cardano] and anything else to [Standard].
+  if (method.payload?.deriveCardano === true) {
+    return true;
+  }
+  return undefined;
 }
 
 const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   initSession: method?.payload.initSession,
   passphraseState: method?.payload.useEmptyPassphrase ? undefined : method?.payload.passphraseState,
   deviceId: method?.payload.deviceId,
-  deriveCardano: method && hasDeriveCardano(method),
+  deriveCardano: method ? resolveDeriveCardano(method) : undefined,
   connectProtocol: method?.payload.connectProtocol,
   forceProtocolDetection: method?.payload.forceProtocolDetection,
   protocolV2DeviceInfoTimeoutMs: method?.payload.protocolV2DeviceInfoTimeoutMs,
@@ -651,7 +657,7 @@ const onCallDevice = async (
                 method.payload?.passphraseState,
                 method.payload?.useEmptyPassphrase,
                 method.payload?.skipPassphraseCheck,
-                hasDeriveCardano(method),
+                resolveDeriveCardano(method),
                 method.protocolV2UnlockContext?.preflightMainPinSelected
               );
 
@@ -1037,6 +1043,7 @@ async function connectDeviceForBle(
       !device.commands ||
       device.commands.disposed;
     if (shouldAcquire) {
+      const connectProtocol = resolveBleConnectProtocol(method);
       // The deadline/abort guards are scoped to the desktop electron
       // transport: its IPC acquire is the only path with a proven
       // never-settling failure mode, while react-native/lowlevel acquire may
@@ -1048,13 +1055,13 @@ async function connectDeviceForBle(
         throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
       }
       if (!useAcquireGuards) {
-        await device.acquire(method.payload.connectProtocol, {
+        await device.acquire(connectProtocol, {
           forceProtocolDetection: method.payload.forceProtocolDetection,
         });
       } else {
         try {
           await raceBleAcquire(
-            device.acquire(method.payload.connectProtocol, {
+            device.acquire(connectProtocol, {
               forceProtocolDetection: method.payload.forceProtocolDetection,
             }),
             abortSignal
@@ -1120,6 +1127,14 @@ async function connectDeviceForBle(
   }
 }
 
+export function resolveBleConnectProtocol(method: BaseMethod): ProtocolType | undefined {
+  if (method.payload.connectProtocol === 'V1' || method.payload.connectProtocol === 'V2') {
+    return method.payload.connectProtocol;
+  }
+  const supportedProtocols = method.getSupportedProtocols();
+  return supportedProtocols.length === 1 && supportedProtocols[0] === 'V2' ? 'V2' : undefined;
+}
+
 type IPollFn<T> = (time?: number) => T;
 // eslint-disable-next-line @typescript-eslint/require-await
 const ensureConnected = async (
@@ -1318,7 +1333,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
       // cancel callback tasks
       requestQueue.cancelCallbackTasks(connectId);
 
-      const requestIds = requestQueue.getRequestTasksId();
+      const requestIds = requestQueue.getRequestTasksIdByConnectId(connectId);
       Log.debug(
         `Cancel Api connect requestQueues: length:${requestIds.length} requestIds:${requestIds.join(
           ','
@@ -1326,6 +1341,8 @@ export const cancel = (context: CoreContext, connectId?: string) => {
       );
       // Abort before rejecting: rejectRequest releases the task and would make
       // its AbortController unreachable to an in-flight method loop.
+      // Match both the requested connectId and a device selected internally by the
+      // method, such as Desktop WebUSB firmwareUpdateV4.
       requestQueue.abortRequestsByConnectId(connectId);
       const canceledDevices: Device[] = [];
       const interruptDevice = (device: Device | undefined, deviceConnectId: string) => {
@@ -1342,7 +1359,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
           // During ensureConnected the method has a connectId but device is
           // assigned only after the poll succeeds. Interrupt the cached BLE
           // Device so an in-flight acquire/initialize cannot finish.
-          interruptDevice(task.method?.device, task.method.connectId ?? connectId);
+          interruptDevice(task.method?.device, connectId);
           interruptDevice(deviceCacheMap.get(connectId), connectId);
           requestQueue.rejectRequest(
             requestId,
@@ -1357,10 +1374,11 @@ export const cancel = (context: CoreContext, connectId?: string) => {
     }
   } else {
     const env = DataManager.getSettings('env');
+    // Abort every method before rejecting its queue task. Non-BLE methods also
+    // use the signal to stop recovery loops after the public promise is rejected.
+    requestQueue.abortAllRequests();
     if (DataManager.isBleConnect(env)) {
       Log.debug('Cancel Api all _deviceList: ');
-      // Keep method abort signals observable until every active task is rejected.
-      requestQueue.abortAllRequests();
       const canceledDevices: Device[] = [];
       const interruptDevice = (device?: Device) => {
         if (!device || canceledDevices.includes(device)) {
@@ -1403,8 +1421,10 @@ export const cancel = (context: CoreContext, connectId?: string) => {
     }
   }
 
-  cleanup();
-  closePopup();
+  cleanup(connectId);
+  if (!connectId || _uiPromises.length === 0) {
+    closePopup();
+  }
 };
 
 const checkPassphraseEnableState = (method: BaseMethod, features?: Features) => {
@@ -1442,9 +1462,16 @@ const shouldCheckPassphraseState = (method: BaseMethod, device: Device) => {
   return device.hasUsePassphrase();
 };
 
-const cleanup = () => {
-  const pendingUiPromises = _uiPromises;
-  _uiPromises = [];
+const cleanup = (connectId?: string) => {
+  const pendingUiPromises = connectId
+    ? _uiPromises.filter(
+        uiPromise =>
+          uiPromise.data?.mainId === connectId || uiPromise.data?.getConnectId() === connectId
+      )
+    : _uiPromises;
+  _uiPromises = connectId
+    ? _uiPromises.filter(uiPromise => !pendingUiPromises.includes(uiPromise))
+    : [];
   rejectUiPromises(
     pendingUiPromises,
     ERRORS.TypedError(HardwareErrorCode.ActionCancelled, 'UI request was cancelled')