@onekeyfe/hd-core 1.2.0-alpha.136 → 1.2.0-alpha.140

package/src/api/FirmwareUpdateV4.ts

@@ -2,6 +2,7 @@ import { EDeviceType, ERRORS, HardwareError, HardwareErrorCode, wait } from '@on
 import JSZip from 'jszip';
 import {
   DeviceRebootType,
+  DeviceSessionPinType,
   PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
   PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE,
   PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE,
@@ -90,9 +91,8 @@ const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
 const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
 const PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT = 15 * 1000;
-const PROTOCOL_V2_INSTALL_TIMEOUT = 8 * 60 * 1000;
+const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
 const PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY = 1000;
-const PROTOCOL_V2_MISSING_TARGET_STATUS_GRACE_TIMEOUT = 30 * 1000;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
 const PROTOCOL_V2_TARGET_STATUS_FINISHED = 2;
@@ -106,6 +106,8 @@ const PROTOCOL_V2_CONNECT_SINGLE_TIMEOUT = 75 * 1000;
 const PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT = 30 * 1000;
 const PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT = 3;
 const PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE = 'FirmwareInstallStatusConflict';
+const PROTOCOL_V2_INSTALL_FAILED_CODE = 'FirmwareInstallFailed';
+const PROTOCOL_V2_INSTALL_TIMEOUT_CODE = 'FirmwareInstallTimeout';
 const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
 const PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET = 0x200;
 const PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET = 0x240;
@@ -391,7 +393,8 @@ const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
 
 const isProtocolV2TerminalInstallStatusError = (error: unknown) =>
   error instanceof HardwareError &&
-  (error.errorCode === HardwareErrorCode.FirmwareError ||
+  (error.errorCode === HardwareErrorCode.ActionCancelled ||
+    error.errorCode === HardwareErrorCode.FirmwareError ||
     error.errorCode === HardwareErrorCode.FirmwareVerificationFailed ||
     error.params?.firmwareUpdateCode === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE);
 
@@ -587,9 +590,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2CompletedTargetVersions = new Map<number, number>();
 
-  private protocolV2LatestFinalFeatures?: Features;
+  private protocolV2CompletedTargetIds = new Set<number>();
 
-  private protocolV2FinalStatusVerified = false;
+  private protocolV2LatestFinalFeatures?: Features;
 
   private protocolV2InstallBaselineVersions = new Map<number, string>();
 
@@ -599,6 +602,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
     this.requireDeviceMode = [];
     this.unlockPolicy = 'unlock-before-run';
+    // Protocol V2 device-management actions are not wallet-scoped, so either
+    // the main PIN or an Attach PIN may authorize them.
+    this.protocolV2PreUnlockPinType = DeviceSessionPinType.Any;
     this.useDevicePassphraseState = false;
     this.skipForceUpdateCheck = true;
 
@@ -1623,9 +1629,17 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               Math.floor(statusVersion / 0x100) % 0x100
             }.${statusVersion % 0x100}`;
       if (!observedVersion) {
-        if (this.protocolV2FinalStatusVerified) {
+        const requestedTargetIds = requestedTargets.flatMap(requestedTarget => {
+          if (requestedTarget === 'resource' || requestedTarget === 'boot_resources') return [];
+          const installTarget = PROTOCOL_V2_INSTALL_TARGET_BY_UPDATE_TARGET.get(requestedTarget);
+          return installTarget ? [installTarget.targetId] : [];
+        });
+        const hasCompleteTargetEvidence =
+          requestedTargetIds.length > 0 &&
+          requestedTargetIds.every(targetId => this.protocolV2CompletedTargetIds.has(targetId));
+        if (hasCompleteTargetEvidence) {
           Log.warn(
-            `Protocol V2 target ${target} has no observable final version; completed target status is authoritative`
+            `Protocol V2 target ${target} has no observable final version; install completion is authoritative`
           );
         } else {
           throw ERRORS.TypedError(
@@ -1665,14 +1679,22 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   private async getProtocolV2DeviceFeatures(): Promise<Features> {
-    if (this.device.features) {
-      return this.device.features;
-    }
+    let { features } = this.device;
     if (typeof this.device.getFeatures === 'function') {
-      const features = await this.device.getFeatures();
-      if (features) return features;
+      features ??= await this.device.getFeatures();
     }
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device features not available');
+    if (!features) {
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device features not available');
+    }
+    const deviceType = this.device.getCurrentDeviceType();
+    if (deviceType !== EDeviceType.Pro2 && deviceType !== EDeviceType.Neo) {
+      return features;
+    }
+    return {
+      ...features,
+      deviceType,
+      firmwareType: this.device.getCurrentFirmwareType(),
+    };
   }
 
   private getProtocolV2SerialNumber(deviceInfo: ProtocolV2DeviceInfo) {
@@ -1965,6 +1987,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         ? PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId)
         : undefined;
       if (updateTarget && targetsToUpdate.has(updateTarget)) {
+        if (component.version) {
+          this.params.expectedTargetVersions ??= {};
+          this.params.expectedTargetVersions[updateTarget] = component.version.join('.');
+        }
         const explicitInstallItem = explicitInstallItemByTargetId.get(target.targetId);
         const installItem =
           explicitInstallItem ?? (await this.downloadRemoteProtocolV2Component(key, component));
@@ -2499,14 +2525,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         path: failedTarget.path,
       });
       Log.error(`[FirmwareUpdateV4] firmware install failed target=${failedTargetDetails}`);
-      throw ERRORS.TypedError(
-        HardwareErrorCode.FirmwareError,
-        `Protocol V2 firmware target failed: target=${failedTarget.target_id} status=${
-          failedTarget.status ?? 'unknown'
-        } payloadVersion=${failedTarget.payload_version ?? 'unknown'} path=${
-          failedTarget.path ?? 'unknown'
-        }`
-      );
+      throw ERRORS.TypedError(HardwareErrorCode.FirmwareError, undefined, {
+        firmwareUpdateCode: PROTOCOL_V2_INSTALL_FAILED_CODE,
+      });
     }
 
     const matchingTargets = statusTargets.filter(target =>
@@ -2520,13 +2541,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         seenTargetIds.has(targetId) ||
         (target.path && expectedPaths.get(targetId) && target.path !== expectedPaths.get(targetId))
       ) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `Protocol V2 install status conflicts with target ${target.target_id}`,
-          {
-            firmwareUpdateCode: PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE,
-          }
-        );
+        Log.error(`[FirmwareUpdateV4] install status conflicts with target=${target.target_id}`);
+        throw ERRORS.TypedError(HardwareErrorCode.FirmwareError, undefined, {
+          firmwareUpdateCode: PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE,
+        });
       }
       seenTargetIds.add(targetId);
     }
@@ -2538,6 +2556,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       const targetId = normalizeProtocolV2TargetId(target.target_id);
       if (targetId !== undefined) {
         completedTargetIds.add(targetId);
+        this.protocolV2CompletedTargetIds.add(targetId);
       }
     });
     if (completedTargetIds.size === expectedTargetIds.size && expectedTargetIds.size > 0) {
@@ -2642,7 +2661,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     targets: Array<{ target_id: number; path: string }>,
     requireCurrentInstallStatus = false
   ) {
-    this.protocolV2FinalStatusVerified = false;
     const expectedTargetIds = new Set(targets.map(target => target.target_id));
     const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
     const startTime = Date.now();
@@ -2651,15 +2669,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     // Reconnecting here probes DeviceInfo, which loaders reject while installation is active.
     let shouldReconnect = false;
     let deviceInfo: ProtocolV2DeviceInfo | undefined;
-    let missingTargetStatusSince: number | undefined;
-    let missingTargetStatusKey: string | undefined;
-    let normalModeWithoutInstallEvidenceSince: number | undefined;
     let installEvidenceObserved = false;
     let currentInstallStatusObserved = false;
-    const resetMissingTargetStatusGrace = () => {
-      missingTargetStatusSince = undefined;
-      missingTargetStatusKey = undefined;
-    };
 
     while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
       // A transport release caused by an explicit workflow cancellation must not
@@ -2687,7 +2698,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           );
           if (statusResponse.type === 'Success') {
             installEvidenceObserved = true;
-            resetMissingTargetStatusGrace();
             lastError = new Error(
               'Protocol V2 firmware install acknowledged; waiting for target status'
             );
@@ -2716,7 +2726,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             (!requireCurrentInstallStatus || currentInstallStatusObserved)
           ) {
             installEvidenceObserved = true;
-            normalModeWithoutInstallEvidenceSince = undefined;
           }
           const matchingStatusTargets = statusTargets.filter(target => {
             const targetId = normalizeProtocolV2TargetId(target.target_id);
@@ -2728,7 +2737,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             shouldVerifyTargetCompletion &&
             this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths)
           ) {
-            this.protocolV2FinalStatusVerified = true;
             return;
           }
 
@@ -2758,7 +2766,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           }
 
           if (statusTargets.length === 0) {
-            resetMissingTargetStatusGrace();
             if (statusResponse.type !== 'Success') {
               lastError = new Error(
                 'Protocol V2 firmware update is waiting for user confirmation or target status'
@@ -2770,30 +2777,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               expectedTargetIds
             );
             if (missingTargetIds.length > 0) {
-              const now = Date.now();
               const missingKey = missingTargetIds.join(',');
-              if (missingTargetStatusSince === undefined || missingTargetStatusKey !== missingKey) {
-                missingTargetStatusSince = now;
-                missingTargetStatusKey = missingKey;
-              } else if (
-                now - missingTargetStatusSince >=
-                PROTOCOL_V2_MISSING_TARGET_STATUS_GRACE_TIMEOUT
-              ) {
-                const reportedTargetIds = statusTargets
-                  .map(target => normalizeProtocolV2TargetId(target.target_id))
-                  .filter((targetId): targetId is number => targetId !== undefined);
-                throw ERRORS.TypedError(
-                  HardwareErrorCode.FirmwareError,
-                  `Protocol V2 firmware status is missing requested records: targetIds=${missingKey} reportedTargetIds=${reportedTargetIds.join(
-                    ','
-                  )}`
-                );
-              }
               lastError = new Error(
                 `Protocol V2 firmware status is temporarily missing targetIds=${missingKey}`
               );
             } else {
-              resetMissingTargetStatusGrace();
               lastError = new Error('Protocol V2 firmware targets are still installing');
             }
           }
@@ -2801,9 +2789,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           if (isProtocolV2TerminalInstallStatusError(error)) {
             throw error;
           }
-          // Only consecutive full status dumps can prove that a record is absent.
-          // A reboot or transport interruption starts a fresh grace window.
-          resetMissingTargetStatusGrace();
           // App firmware does not register DeviceFirmwareUpdateStatusGet. Treat the
           // missing endpoint as completion only after the runtime probe confirms App mode.
           if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
@@ -2826,22 +2811,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               return;
             }
             if (isNormalMode) {
-              const now = Date.now();
-              normalModeWithoutInstallEvidenceSince ??= now;
-              if (
-                now - normalModeWithoutInstallEvidenceSince >=
-                PROTOCOL_V2_MISSING_TARGET_STATUS_GRACE_TIMEOUT
-              ) {
-                throw ERRORS.TypedError(
-                  HardwareErrorCode.FirmwareError,
-                  'Protocol V2 device returned to normal mode without install ACK, target status, or version change'
-                );
-              }
               lastError = new Error(
                 'Protocol V2 device is in normal mode but installation is not yet confirmed'
               );
             } else {
-              normalModeWithoutInstallEvidenceSince = undefined;
               lastError = new Error(
                 'Protocol V2 firmware status endpoint is unavailable while the device remains in loader mode'
               );
@@ -2872,18 +2845,19 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         }
         shouldReconnect = true;
         deviceInfo = undefined;
-        resetMissingTargetStatusGrace();
         Log.log('Protocol V2 firmware install device readiness probe failed: ', error);
       }
       await wait(1000);
     }
 
-    throw ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      `Protocol V2 firmware update status not complete within ${
+    Log.error(
+      `[FirmwareUpdateV4] install timed out after ${
         PROTOCOL_V2_INSTALL_TIMEOUT / 1000
       }s: ${this.normalizeErrorMessage(lastError)}`
     );
+    throw ERRORS.TypedError(HardwareErrorCode.FirmwareError, undefined, {
+      firmwareUpdateCode: PROTOCOL_V2_INSTALL_TIMEOUT_CODE,
+    });
   }
 
   private async exitProtocolV2BootloaderToNormal() {

package/src/api/device/DeviceChangePin.ts

@@ -1,4 +1,4 @@
-import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
+import { DeviceSessionPinType, DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
@@ -13,6 +13,9 @@ export default class DeviceChangePin extends BaseMethod<ChangePin> {
 
   init() {
     this.unlockPolicy = 'unlock-before-run';
+    // Protocol V2 device-management actions are not wallet-scoped, so either
+    // the main PIN or an Attach PIN may authorize them.
+    this.protocolV2PreUnlockPinType = DeviceSessionPinType.Any;
     this.useDevicePassphraseState = false;
 
     // check payload

package/src/api/device/DeviceSettings.ts

@@ -200,6 +200,19 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
           const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
             page: DeviceSettingsPage.DevicePassphrase,
           });
+          // A successful page response confirms the device-side toggle. When an Attach PIN
+          // session disables passphrase protection, the firmware locks immediately and omits
+          // private passphrase fields from subsequent reads, so persist the confirmed value
+          // before refreshing the remaining device state.
+          this.device.updateState(
+            {
+              status: {
+                passphraseProtection: requestedPassphrase,
+                ...(requestedPassphrase === false ? { unlockedAttachPin: false } : undefined),
+              },
+            },
+            'settings-write'
+          );
           await refreshStatusAndSettings();
           return res.message;
         }

package/src/api/device/DeviceVerify.ts

@@ -1,5 +1,6 @@
 import { sha256 } from '@noble/hashes/sha256';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 import { bytesToHex } from '@noble/hashes/utils';
 
 import { formatAnyHex } from '../helpers/hexUtils';
@@ -11,7 +12,15 @@ import type { BixinVerifyDeviceRequest } from '@onekeyfe/hd-transport';
 import type { DeviceVerifySignature } from '../../types';
 
 export default class DeviceVerify extends BaseMethod<BixinVerifyDeviceRequest> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
+    this.unlockPolicy = 'unlock-before-run';
+    // Protocol V2 device-management actions are not wallet-scoped, so either
+    // the main PIN or an Attach PIN may authorize them.
+    this.protocolV2PreUnlockPinType = DeviceSessionPinType.Any;
     this.useDevicePassphraseState = false;
 
     // check payload
@@ -38,6 +47,22 @@ export default class DeviceVerify extends BaseMethod<BixinVerifyDeviceRequest> {
         }
       );
       response = res.message;
+    } else if (this.device.isProtocolV2()) {
+      const signatureRes = await this.device.commands.typedCall(
+        'DeviceCertificateSign',
+        'DeviceCertificateSignature',
+        {
+          data: this.params.data,
+        }
+      );
+      const certRes = await this.device.commands.typedCall(
+        'DeviceCertificateRead',
+        'DeviceCertificate'
+      );
+      response = {
+        cert: certRes.message.cert_and_pubkey,
+        signature: signatureRes.message.data,
+      };
     } else {
       const signatureRes = await this.device.commands.typedCall(
         'SESignMessage',

package/src/api/device/DeviceWipe.ts

@@ -1,4 +1,4 @@
-import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
+import { DeviceSessionPinType, DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import { BaseMethod } from '../BaseMethod';
 
@@ -11,6 +11,9 @@ export default class DeviceWipe extends BaseMethod<WipeDevice> {
 
   init() {
     this.unlockPolicy = 'unlock-before-run';
+    // Protocol V2 device-management actions are not wallet-scoped, so either
+    // the main PIN or an Attach PIN may authorize them.
+    this.protocolV2PreUnlockPinType = DeviceSessionPinType.Any;
     this.useDevicePassphraseState = false;
     this.protocolV2UiInteraction = {
       request: 'button',

package/src/api/firmware/protocolV2Release.ts

@@ -77,11 +77,16 @@ export async function loadProtocolV2FirmwareReleaseContext({
   }
 
   const firmwareType = firmwareTypeParam ?? state.identity.firmwareType ?? EFirmwareType.Universal;
+  const normalizedFeatures: Features = {
+    ...features,
+    deviceType: state.identity.deviceType,
+    firmwareType,
+  };
   return {
     state: state as ProtocolV2FirmwareReleaseContext['state'],
-    features,
+    features: normalizedFeatures,
     firmwareType,
-    release: DataManager.getFirmwareLatestRelease(features, firmwareType),
+    release: DataManager.getFirmwareLatestRelease(normalizedFeatures, firmwareType),
   };
 }
 

package/src/device/Device.ts

@@ -930,6 +930,17 @@ export class Device extends EventEmitter {
       };
 
       const expectedDeviceId = options?.deviceId;
+      if (expectedDeviceId) {
+        // 先只读校验物理设备身份；钱包上下文仍由下方携带完整参数的
+        // Initialize 选择，避免标准钱包请求复用此前的隐藏钱包上下文。
+        this.passphraseState = undefined;
+        const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
+        this._updateFeatures(message);
+        await TransportManager.reconfigure(this.features);
+        if (!this.checkDeviceId(expectedDeviceId)) {
+          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+        }
+      }
 
       this.passphraseState = options?.passphraseState;
 
@@ -949,46 +960,7 @@ export class Device extends EventEmitter {
         payload.derive_cardano = true;
       }
 
-      if (this.features) {
-        // Re-sync the V1 message schema for THIS device before encoding
-        // Initialize: the process-global schema may still reflect another
-        // device (e.g. legacy-firmware Touch/Mini) on multi-device setups, and
-        // a stale legacy schema would silently strip passphrase_state /
-        // is_contains_attach from the wire message. Local operation, no wire
-        // I/O; a no-op when the schema is unchanged.
-        await TransportManager.reconfigure(this.features);
-      }
-
-      // Initialize's own Features response carries device_id, so the physical
-      // device identity is validated on the same round trip instead of via a
-      // separate read-only GetFeatures preflight (which doubled the wire cost
-      // of every deviceId-carrying call). The method fn has not run yet, so a
-      // mismatch still fails before any wallet data can be derived, with the
-      // same DeviceCheckDeviceIdError. Wallet-context selection is unchanged:
-      // it is decided by the Initialize payload above either way.
-      const assertExpectedDeviceIdentity = () => {
-        if (expectedDeviceId && !this.checkDeviceId(expectedDeviceId)) {
-          // The mismatched Initialize may have cached a session under the wrong
-          // device's identity; drop it so no wallet context survives from it.
-          // (This also evicts any session the wrong device legitimately cached
-          // under the same passphraseState — a deliberate conservative purge
-          // after a physical-swap event, consistent with
-          // reconcileDeviceIdentity purging the previous device's sessions.)
-          this.clearInternalState();
-          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
-        }
-      };
-
-      try {
-        await callInitialize(payload, options?.initSession);
-      } catch (error) {
-        // callInitialize can fail AFTER the wire call cached the session (e.g.
-        // TransportManager.reconfigure rejecting); the identity check must
-        // still run so a wrong-device session never survives the error path.
-        assertExpectedDeviceIdentity();
-        throw error;
-      }
-      assertExpectedDeviceIdentity();
+      await callInitialize(payload, options?.initSession);
     } catch (error) {
       Log.error('Initialization failed:', error);
       throw error;
@@ -1558,15 +1530,18 @@ export class Device extends EventEmitter {
     const error = ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
     const cleanupPromise = this.runCleanupPromise;
     const { cancelableAction } = this;
+    const env = DataManager.getSettings('env');
     if (cancelableAction) {
       await cancelableAction(error);
     } else if (
       this.isProtocolV2() &&
-      DataManager.isBleConnect(DataManager.getSettings('env')) &&
+      (DataManager.isBleConnect(env) ||
+        DataManager.isBrowserWebUsb(env) ||
+        DataManager.isDesktopWebUsb(env)) &&
       this.hasDeviceAcquire()
     ) {
       await this.commands?.cancelDevice?.().catch(cancelError => {
-        Log.debug('Protocol V2 BLE fallback cancel error', cancelError);
+        Log.debug('Protocol V2 fallback cancel error', cancelError);
       });
     }
     await this.commands?.cancel();

package/src/device/DeviceCommands.ts

@@ -69,7 +69,7 @@ const DEVICE_CONTROL_CALLS = new Set([
 // Older Protocol V2 firmware may omit the cancellation subcode, so retain a
 // narrow message fallback for compatibility.
 const isProtocolV2ActionCancelledMessage = (message: string) =>
-  /^(?:cancel(?:led|ed)(?: on device)?|confirm dismissed|user cancel(?:led|ed)(?:\s+.*)?)$/i.test(
+  /^(?:cancel(?:led|ed)(?: on device)?|confirm dismissed|update cancel(?:led|ed)|user cancel(?:led|ed)(?:\s+.*)?)$/i.test(
     message
   );
 

package/src/device/DeviceStateMapper.ts

@@ -347,8 +347,10 @@ export const mapProtocolV2DeviceStatusToState = (status: DeviceStatus): DeviceSt
     unlocked: status.unlocked,
     passphraseProtection: status.unlocked === true ? status.passphrase_enabled ?? null : undefined,
     backupRequired: status.backup_required,
-    attachToPinEnabled: status.attach_to_pin_enabled,
-    unlockedAttachPin: status.unlocked_by_attach_to_pin,
+    attachToPinEnabled:
+      status.unlocked === true ? status.attach_to_pin_enabled ?? undefined : undefined,
+    unlockedAttachPin:
+      status.unlocked === true ? status.unlocked_by_attach_to_pin ?? null : undefined,
   }),
   raw: { protocolV2DeviceStatus: status },
 });
@@ -375,21 +377,23 @@ export const mapApplySettingsToState = (settings: ApplySettings): DeviceStatePat
 };
 
 export const mapDeviceSettingsToState = (settings: DeviceSettings): DeviceStatePatch => {
-  const identity = definedEntries({ label: settings.label });
-  const status = definedEntries({ passphraseProtection: settings.passphrase_enable });
+  const identity = definedEntries({ label: settings.label ?? undefined });
+  const status = definedEntries({
+    passphraseProtection: settings.passphrase_enable ?? undefined,
+  });
   const stateSettings = definedEntries({
     bleEnabled: settings.bt_enable,
     language: mapLanguageFromProtocolV2(settings.language),
     wallpaperPath: settings.wallpaper_path,
     brightness: settings.brightness,
-    autoLockDelayMs: settings.autolock_delay_ms,
-    autoShutdownDelayMs: settings.autoshutdown_delay_ms,
+    autoLockDelayMs: settings.autolock_delay_ms ?? undefined,
+    autoShutdownDelayMs: settings.autoshutdown_delay_ms ?? undefined,
     animationEnabled: settings.animation_enable,
     tapToWake: settings.tap_to_wake,
     hapticFeedback: settings.haptic_feedback,
     deviceNameDisplayEnabled: settings.device_name_display_enabled,
     airgapMode: settings.airgap_mode,
-    fidoEnabled: settings.fido_enabled,
+    fidoEnabled: settings.fido_enabled ?? undefined,
     usbLockEnabled: settings.usb_lock_enable,
     randomKeypad: settings.random_keypad,
   });