@onekeyfe/hd-core 1.2.2-alpha.100 → 1.2.2-alpha.3

package/src/api/OpenWalletSession.ts

@@ -29,6 +29,12 @@ const wasResumed = (session: unknown) =>
   'resumed' in session &&
   (session as { resumed?: unknown }).resumed === true;
 
+const wasWalletStatusRefreshed = (session: unknown) =>
+  !!session &&
+  typeof session === 'object' &&
+  'walletStatusRefreshed' in session &&
+  (session as { walletStatusRefreshed?: unknown }).walletStatusRefreshed === true;
+
 const requireHiddenWalletResponse = (session: { passphraseState?: string }) => {
   if (!session.passphraseState) {
     throw ERRORS.TypedError(
@@ -87,12 +93,20 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     this.unlockPolicy = 'unlock-before-run';
     this.skipForceUpdateCheck = true;
     this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
+    this.protocolV2PreUnlockPinType =
+      this.params.mode === OpenWalletSessionMode.SelectHidden
+        ? DeviceSessionPinType.Any
+        : DeviceSessionPinType.Main;
     this.payload.useEmptyPassphrase = this.params.mode === OpenWalletSessionMode.Standard;
   }
 
   async run(): Promise<OpenWalletSessionPayload> {
     const isProtocolV2 = this.device.isProtocolV2();
-    let state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    const reusePreflightStatus =
+      isProtocolV2 && this.protocolV2UnlockContext?.preflightStatusRefreshed === true;
+    let state = reusePreflightStatus
+      ? await this.device.getDeviceState()
+      : await this.device.getDeviceState({ refreshSections: ['status'] });
     let currentDeviceId = state.identity.deviceId;
     const hasAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) =>
       candidate.status.unlocked === true &&
@@ -115,14 +129,25 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       currentDeviceId = state.identity.deviceId;
       return state;
     };
+    const resolveProtocolV2DeviceStateAfterSession = async (session: unknown) => {
+      if (!wasWalletStatusRefreshed(session)) {
+        return refreshProtocolV2DeviceState();
+      }
+      state = await this.device.getDeviceState();
+      currentDeviceId = state.identity.deviceId;
+      return state;
+    };
     const ensureProtocolV2WalletStatus = async () => {
       if (isProtocolV2 && !hasAuthoritativeProtocolV2WalletStatus(state)) {
-        await this.device.unlockDevice(DeviceSessionPinType.Main, {
-          source: 'unlock-coordinator',
-          reason: 'device-locked',
-          deviceOnly: true,
-          method: 'openWalletSession',
-        });
+        await this.device.unlockDevice(
+          this.protocolV2PreUnlockPinType ?? DeviceSessionPinType.Main,
+          {
+            source: 'unlock-coordinator',
+            reason: 'device-locked',
+            deviceOnly: true,
+            method: 'openWalletSession',
+          }
+        );
         requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState());
       }
       return state;
@@ -139,13 +164,16 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
             selectMainWalletBeforeRestore:
               !hasAuthoritativeProtocolV2WalletStatus(state) ||
               state.status.unlockedAttachPin === true,
+            mainPinSelected: this.protocolV2UnlockContext?.preflightMainPinSelected,
           })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             onlyMainPin: true,
             initSession: this.payload.initSession,
           });
       const refreshedState = isProtocolV2
-        ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+        ? requireAuthoritativeProtocolV2WalletStatus(
+            await resolveProtocolV2DeviceStateAfterSession(session)
+          )
         : state;
       const deviceId = requireDeviceId();
       if (
@@ -233,7 +261,9 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
         })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
     const refreshedState = isProtocolV2
-      ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+      ? requireAuthoritativeProtocolV2WalletStatus(
+          await resolveProtocolV2DeviceStateAfterSession(session)
+        )
       : state;
     const deviceId = requireDeviceId();
     if (isProtocolV2 && refreshedState.status.passphraseProtection !== true) {

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -393,14 +393,17 @@ 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');
+          // false would AskPassphrase with [Standard] only and permanently drop Cardano
+          // from a reused session. Omit the flag for non-Cardano nested methods.
+          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(
               this.payload.passphraseState,
               useEmptyPassphrase,
               this.payload.skipPassphraseCheck,
-              deriveCardano
+              deriveCardano,
+              this.protocolV2UnlockContext?.preflightMainPinSelected
             );
             if (!passphraseStateSafety) {
               throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);

package/src/api/evm/EVMSignTypedData.ts

@@ -360,6 +360,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     const supportBiggerData =
       DeviceModelToTypes.model_classic1s.includes(currentDeviceType) ||
+      DeviceModelToTypes.model_pro2.includes(currentDeviceType) ||
       (DeviceModelToTypes.model_touch.includes(currentDeviceType) &&
         semver.gte(currentVersion, supportBiggerDataVersion));
 

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -41,9 +41,15 @@ const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
  */
 export const BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS = 5000;
 
-type FirmwareTransferMetrics = Pick<
+type FirmwareProgressMetadata = Pick<
   FirmwareProgress['payload'],
-  'transferredBytes' | 'totalBytes' | 'rateBytesPerSecond' | 'elapsedMs'
+  | 'transferredBytes'
+  | 'totalBytes'
+  | 'rateBytesPerSecond'
+  | 'elapsedMs'
+  | 'installTargetId'
+  | 'installPhase'
+  | 'installPhaseProgress'
 >;
 
 const isDeviceDisconnectedError = (error: unknown) => {
@@ -103,7 +109,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
   postProgressMessage = (
     progress: number,
     progressType: IFirmwareUpdateProgressType,
-    metrics?: FirmwareTransferMetrics
+    metrics?: FirmwareProgressMetadata
   ) => {
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {

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

@@ -4,7 +4,13 @@ import { invalidParameter } from '../helpers/filesystemValidation';
 import type { DeviceFirmwareUpdateStatusGetParams } from './helpers';
 import type { DeviceFirmwareUpdateRecordFields } from '@onekeyfe/hd-transport';
 
-const DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS = ['status', 'payload_version', 'path'] as const;
+const DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS = [
+  'status',
+  'progress_percent',
+  'phase_info',
+  'payload_version',
+  'path',
+] as const;
 
 function normalizeStatusFields(
   fields: DeviceFirmwareUpdateStatusGetParams['fields']

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

@@ -20,6 +20,10 @@ import {
   getCompletePro2NftBasenames,
 } from '../../utils/pro2Nft';
 import { encodePro2Image } from '../../utils/pro2Wallpaper';
+import {
+  buildPro2HostAssetPackage,
+  supportsPro2HostAssetPackage,
+} from '../../utils/pro2HostAssetPackage';
 import { BaseMethod } from '../BaseMethod';
 import { decodeJpegBase64ToRgba } from '../helpers/base64Data';
 import { invalidParameter } from '../helpers/filesystemValidation';
@@ -38,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;
@@ -138,7 +145,7 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     this.useDevicePassphraseState = false;
   }
 
-  private async assertCapabilities() {
+  private async assertCapabilities(useHostAssetPackage: boolean) {
     const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
     const hasFileWrite = supportsProtocolV2Message(
       protocolInfo,
@@ -150,7 +157,7 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     );
     const hasDirList = supportsProtocolV2Message(protocolInfo, FILESYSTEM_DIR_LIST_MESSAGE_TYPE);
     const hasNftUpdate = supportsProtocolV2Message(protocolInfo, NFT_UPDATE_MESSAGE_TYPE);
-    if (!hasFileWrite || !hasPathInfo || !hasDirList || !hasNftUpdate) {
+    if (!hasFileWrite || !hasNftUpdate || (!useHostAssetPackage && (!hasPathInfo || !hasDirList))) {
       throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
     }
   }
@@ -192,16 +199,32 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     const { bundle } = this;
     if (!bundle) throw invalidParameter('NFT data has not been initialized.');
 
-    await this.assertCapabilities();
+    const useHostAssetPackage = supportsPro2HostAssetPackage(
+      this.device.state?.versions.firmware ?? undefined
+    );
+    await this.assertCapabilities(useHostAssetPackage);
     this.throwIfAborted();
-    await this.assertStorageCapacity(bundle.basename);
+    if (!useHostAssetPackage) await this.assertStorageCapacity(bundle.basename);
     this.throwIfAborted();
 
-    const files = [
+    const extractedFiles = [
       { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.bin`, data: bundle.image },
       { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}_m.bin`, data: bundle.thumbnail },
       { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.json`, data: bundle.metadata },
     ];
+    const files = useHostAssetPackage
+      ? [
+          {
+            path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.okpkg`,
+            data: buildPro2HostAssetPackage(
+              extractedFiles.map(file => ({
+                name: file.path.slice(`${PRO2_NFT_DIRECTORY}/`.length),
+                data: file.data,
+              }))
+            ),
+          },
+        ]
+      : extractedFiles;
     const totalSize = files.reduce((sum, file) => sum + file.data.byteLength, 0);
     let transferredBeforeFile = 0;
 
@@ -238,9 +261,9 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     const response = await this.updateNft(bundle.basename);
     return {
       basename: bundle.basename,
-      imagePath: files[0].path,
-      thumbnailPath: files[1].path,
-      metadataPath: files[2].path,
+      imagePath: extractedFiles[0].path,
+      thumbnailPath: extractedFiles[1].path,
+      metadataPath: extractedFiles[2].path,
       totalSize,
       nftUpdated: true,
       message: response.message?.message,

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

@@ -16,14 +16,26 @@ import {
   type Pro2WallpaperColorFormat,
   encodePro2Wallpaper,
 } from '../../utils/pro2Wallpaper';
+import {
+  buildPro2HostAssetPackage,
+  supportsPro2HostAssetPackage,
+} from '../../utils/pro2HostAssetPackage';
 
 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;
@@ -31,6 +43,8 @@ export type DeviceUploadWallpaperResponse = {
 };
 
 const WALLPAPER_DIRECTORY = 'vol1:/wallpapers';
+const WALLPAPER_PACKAGE_PATH = `${WALLPAPER_DIRECTORY}/wallpaper.okpkg`;
+const WALLPAPER_PACKAGE_ENTRY = 'wallpaper.bin';
 const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
 const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
@@ -116,16 +130,14 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     this.directoryReady = true;
   }
 
-  private async upload() {
+  private async upload(path: string, data: Uint8Array) {
     if (this.uploaded) return;
-    const { encoded } = this;
-    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
 
     await writeProtocolV2File({
       commands: this.device.commands,
-      path: this.path,
-      data: encoded.data,
-      totalSize: encoded.data.byteLength,
+      path,
+      data,
+      totalSize: data.byteLength,
       chunkSize: this.params.chunkSize,
       maxChunkRetries: 3,
       overwrite: true,
@@ -145,7 +157,14 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
     await this.assertCapabilities();
     await this.ensureDirectory();
-    await this.upload();
+    const useHostAssetPackage = supportsPro2HostAssetPackage(
+      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);
     const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
       settings: { wallpaper_path: this.path },
     });
@@ -160,7 +179,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     }
     return {
       path: this.path,
-      size: encoded.data.byteLength,
+      size: data.byteLength,
       colorFormat: encoded.colorFormat,
       message: response.message?.message,
     };

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

@@ -1,4 +1,5 @@
 import { DeviceRebootType } from '@onekeyfe/hd-transport';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { invalidParameter, validateNonEmptyString } from '../helpers/filesystemValidation';
 import { ProtocolV2FirmwareTargetType } from '../../protocols/protocol-v2/firmware';
@@ -103,6 +104,13 @@ export const getProtocolV2UnknownErrorText = (error: unknown) => {
 };
 
 export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
+  const errorCode =
+    error && typeof error === 'object'
+      ? (error as { errorCode?: number; code?: number }).errorCode ??
+        (error as { errorCode?: number; code?: number }).code
+      : undefined;
+  if (errorCode === HardwareErrorCode.BleDeviceDisconnected) return true;
+
   const message = getProtocolV2UnknownErrorText(error).toLowerCase();
   const compactMessage = message.replace(/\s+/g, '');
   return (

package/src/core/index.ts

@@ -92,7 +92,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 +102,20 @@ function hasDeriveCardano(method: BaseMethod): boolean {
   ) {
     return true;
   }
-
-  return method.name.startsWith('cardano') || method.payload?.deriveCardano;
+  if (method.name.startsWith('cardano')) {
+    return true;
+  }
+  if (typeof method.payload?.deriveCardano === 'boolean') {
+    return method.payload.deriveCardano;
+  }
+  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,
@@ -415,6 +420,13 @@ const onCallDevice = async (
   if (method.payload?.onlyConnectBleDevice) {
     preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
+    // This early return bypasses the normal-path bookkeeping at the end of the
+    // call. Without it the task leaks and haunts every later queue snapshot
+    // and cancel sweep (field log: a completed task lingered for 6 minutes),
+    // and the request stays in the active maps, so repeated preconnects pile
+    // up phantom work in diagnostics.
+    completeMethodRequestContext(method);
+    requestQueue.releaseTask(method.responseID);
     return createResponseMessage(method.responseID, true, null);
   }
 
@@ -644,7 +656,8 @@ const onCallDevice = async (
                 method.payload?.passphraseState,
                 method.payload?.useEmptyPassphrase,
                 method.payload?.skipPassphraseCheck,
-                hasDeriveCardano(method)
+                resolveDeriveCardano(method),
+                method.protocolV2UnlockContext?.preflightMainPinSelected
               );
 
               // Double check, handles the special case of Touch/Pro
@@ -950,11 +963,72 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
   );
 }
 
+export function isProtocolV2PeerRemovedPairingError(method: BaseMethod, error: unknown) {
+  return (
+    method.payload.connectProtocol === 'V2' &&
+    (error as { errorCode?: unknown })?.errorCode ===
+      HardwareErrorCode.BlePeerRemovedPairingInformation
+  );
+}
+
 /**
  * If the Bluetooth connection times out, retry up to 6 times
  * @param retryCount - Current retry count (default 0)
  */
-async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
+// device.acquire awaits a transport reply with no deadline of its own; a
+// transport that never settles (field case: Electron main lost an IPC reply,
+// "reply was never sent" after 5 minutes) hangs the call forever and cancel()
+// only takes effect at poll checkpoints. Race acquire against a deadline and
+// the caller's abort signal so the hang is bounded and cancel is immediate.
+const BLE_ACQUIRE_DEADLINE_MS = 60 * 1000;
+
+function raceBleAcquire<T>(acquirePromise: Promise<T>, abortSignal?: AbortSignal): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    let settled = false;
+    const settle = (fn: () => void) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      abortSignal?.removeEventListener('abort', onAbort);
+      fn();
+    };
+    const onAbort = () =>
+      settle(() => reject(ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)));
+    const deadline = setTimeout(
+      () =>
+        settle(() =>
+          reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.BleTimeoutError,
+              `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`
+            )
+          )
+        ),
+      BLE_ACQUIRE_DEADLINE_MS
+    );
+    // Attach before any early return so a late settlement of acquirePromise
+    // is always consumed — an abort or deadline must never leave the acquire
+    // rejection unhandled.
+    acquirePromise.then(
+      value => settle(() => resolve(value)),
+      error => settle(() => reject(error))
+    );
+    if (abortSignal) {
+      if (abortSignal.aborted) {
+        onAbort();
+        return;
+      }
+      abortSignal.addEventListener('abort', onAbort);
+    }
+  });
+}
+
+async function connectDeviceForBle(
+  method: BaseMethod,
+  device: Device,
+  abortSignal?: AbortSignal,
+  retryCount = 0
+) {
   try {
     if (device.wasInterruptedByUser()) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
@@ -968,9 +1042,43 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
       !device.commands ||
       device.commands.disposed;
     if (shouldAcquire) {
-      await device.acquire(method.payload.connectProtocol, {
-        forceProtocolDetection: method.payload.forceProtocolDetection,
-      });
+      // 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
+      // legitimately block on a user-driven system bonding prompt for longer
+      // than any sane deadline. Other envs keep the plain acquire unchanged.
+      const useAcquireGuards = DataManager.getSettings('env') === 'desktop-web-ble';
+      // A cancel landing during the retry backoff must not start a new acquire.
+      if (useAcquireGuards && abortSignal?.aborted) {
+        throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
+      }
+      if (!useAcquireGuards) {
+        await device.acquire(method.payload.connectProtocol, {
+          forceProtocolDetection: method.payload.forceProtocolDetection,
+        });
+      } else {
+        try {
+          await raceBleAcquire(
+            device.acquire(method.payload.connectProtocol, {
+              forceProtocolDetection: method.payload.forceProtocolDetection,
+            }),
+            abortSignal
+          );
+        } catch (err) {
+          // A deadline hit means the transport is wedged mid-acquire; drop the
+          // link before the retry so it cold-connects instead of stacking a
+          // second connect onto the half-open one.
+          if (
+            err.errorCode === HardwareErrorCode.BleTimeoutError &&
+            device.mainId &&
+            device.deviceConnector
+          ) {
+            await device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
+            device.markTransportDisconnected();
+          }
+          throw err;
+        }
+      }
     }
     if (method.payload?.onlyConnectBleDevice) {
       if (shouldAcquire) {
@@ -1010,7 +1118,7 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
       const nextRetry = retryCount + 1;
       Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
       await wait(3000);
-      await connectDeviceForBle(method, device, nextRetry);
+      await connectDeviceForBle(method, device, abortSignal, nextRetry);
     } else {
       throw err;
     }
@@ -1120,7 +1228,7 @@ const ensureConnected = async (
             if (tryCount === 1) {
               device.beginConnectionAttempt();
             }
-            await connectDeviceForBle(method, device);
+            await connectDeviceForBle(method, device, abortSignal);
           }
           resolve(device);
           return;
@@ -1164,7 +1272,8 @@ const ensureConnected = async (
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
-          ].includes(error.errorCode)
+          ].includes(error.errorCode) ||
+          isProtocolV2PeerRemovedPairingError(method, error)
         ) {
           reject(error);
           return;
@@ -1220,6 +1329,9 @@ 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.
+      requestQueue.abortRequestsByConnectId(connectId);
       const canceledDevices: Device[] = [];
       const interruptDevice = (device: Device | undefined, deviceConnectId: string) => {
         if (!device || canceledDevices.includes(device)) {
@@ -1244,7 +1356,6 @@ export const cancel = (context: CoreContext, connectId?: string) => {
         }
       }
       interruptDevice(deviceCacheMap.get(connectId), connectId);
-      requestQueue.abortRequestsByConnectId(connectId);
       pollingManager.stop(connectId);
     } catch (e) {
       Log.error('Cancel API Error: ', e);
@@ -1253,6 +1364,8 @@ export const cancel = (context: CoreContext, connectId?: string) => {
     const env = DataManager.getSettings('env');
     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)) {
@@ -1277,7 +1390,6 @@ export const cancel = (context: CoreContext, connectId?: string) => {
         }
       }
       deviceCacheMap.forEach(interruptDevice);
-      requestQueue.abortAllRequests();
       pollingManager.stopAll();
     } else {
       _deviceList?.allDevices().forEach(device => {
@@ -1328,6 +1440,10 @@ const checkPassphraseEnableState = (method: BaseMethod, features?: Features) =>
 const shouldCheckPassphraseState = (method: BaseMethod, device: Device) => {
   if (!method.useDevicePassphraseState) return false;
 
+  if (device.isProtocolV2() && method.payload?.useEmptyPassphrase === true) {
+    return true;
+  }
+
   return device.hasUsePassphrase();
 };