@onekeyfe/hd-core 1.2.0-alpha.2 → 1.2.0-alpha.21

package/src/api/device/DeviceCancel.ts

@@ -5,6 +5,7 @@ import type { Cancel } from '@onekeyfe/hd-transport';
 export default class DeviceCancel extends BaseMethod<Cancel> {
   init() {
     this.useDevicePassphraseState = false;
+    this.unlockPolicy = 'none';
   }
 
   async run() {

package/src/api/device/DeviceChangePin.ts

@@ -1,10 +1,14 @@
+import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
+
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
+import { invalidParameter } from '../helpers/filesystemValidation';
 
 import type { ChangePin } from '@onekeyfe/hd-transport';
 
 export default class DeviceChangePin extends BaseMethod<ChangePin> {
   init() {
+    this.unlockPolicy = 'retry-on-locked';
     this.useDevicePassphraseState = false;
 
     // check payload
@@ -13,9 +17,29 @@ export default class DeviceChangePin extends BaseMethod<ChangePin> {
     this.params = {
       remove: this.payload.remove,
     };
+    this.protocolV2UiInteraction = {
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'change-pin',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      page: DeviceSettingsPage.DevicePinChange,
+    };
   }
 
   async run() {
+    if (this.device.isProtocolV2()) {
+      if (this.params.remove) {
+        throw invalidParameter(
+          'Parameter [remove=true] is not supported by the Pro2 device PIN page.'
+        );
+      }
+      const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
+        page: DeviceSettingsPage.DevicePinChange,
+      });
+      return Promise.resolve(res.message);
+    }
+
     const res = await this.device.commands.typedCall('ChangePin', 'Success', {
       ...this.params,
     });

package/src/api/device/DeviceFullyUploadResource.ts

@@ -5,12 +5,11 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { BaseMethod } from '../BaseMethod';
 import { getSysResourceBinary } from '../firmware/getBinary';
 import { updateResources } from '../firmware/uploadFirmware';
-import { getDeviceFirmwareVersion, getFirmwareType } from '../../utils';
 import { createUiMessage } from '../../events/ui-request';
 import { DataManager } from '../../data-manager';
 
 import type { Deferred } from '@onekeyfe/hd-shared';
-import type { Features, KnownDevice } from '../../types';
+import type { KnownDevice } from '../../types';
 import type { DeviceFullyUploadResourceParams } from '../../types/api/deviceFullyUploadResource';
 
 export default class DeviceFullyUploadResource extends BaseMethod {
@@ -33,12 +32,12 @@ export default class DeviceFullyUploadResource extends BaseMethod {
     );
   };
 
-  isSupportResourceUpdate(features: Features, updateType: string) {
+  isSupportResourceUpdate(updateType: string) {
     if (updateType !== 'firmware') return false;
 
     const deviceType = this.device.getCurrentDeviceType();
     const isTouchMode = deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro;
-    const currentVersion = getDeviceFirmwareVersion(features).join('.');
+    const currentVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
 
     return isTouchMode && semver.gte(currentVersion, '3.4.0');
   }
@@ -49,7 +48,7 @@ export default class DeviceFullyUploadResource extends BaseMethod {
 
     const payload = this.payload as DeviceFullyUploadResourceParams;
 
-    const deviceFirmwareType = getFirmwareType(features);
+    const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     if (!device.isBootloader() && features) {

package/src/api/device/DeviceLock.ts

@@ -5,6 +5,7 @@ import type { LockDevice } from '@onekeyfe/hd-transport';
 export default class DeviceLock extends BaseMethod<LockDevice> {
   init() {
     this.useDevicePassphraseState = false;
+    this.unlockPolicy = 'none';
   }
 
   async run() {

package/src/api/device/DeviceRebootToBoardloader.ts

@@ -1,4 +1,4 @@
-import { DevRebootType } from '@onekeyfe/hd-transport';
+import { DeviceRebootType } from '@onekeyfe/hd-transport';
 
 import { BaseMethod } from '../BaseMethod';
 
@@ -23,11 +23,12 @@ export default class DeviceRebootToBoardloader extends BaseMethod<RebootToBoardl
   }
 
   async run() {
-    // Protocol V2 submodule firmware uses DevReboot with reboot_type enum.
+    // Protocol V2 submodule firmware uses DeviceReboot with reboot_type enum.
     if (this.device.isProtocolV2()) {
-      const res = await this.device.commands.typedCall('DevReboot', 'Success', {
-        reboot_type: DevRebootType.Boardloader,
+      const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
+        reboot_type: DeviceRebootType.Romloader,
       });
+      this.device.markProtocolV2Reboot(DeviceRebootType.Romloader);
       return Promise.resolve(res.message);
     }
 

package/src/api/device/DeviceRebootToBootloader.ts

@@ -1,4 +1,4 @@
-import { DevRebootType } from '@onekeyfe/hd-transport';
+import { DeviceRebootType } from '@onekeyfe/hd-transport';
 
 import { BaseMethod } from '../BaseMethod';
 
@@ -23,11 +23,12 @@ export default class DeviceRebootToBootloader extends BaseMethod<RebootToBootloa
   }
 
   async run() {
-    // Protocol V2 submodule firmware uses DevReboot with reboot_type enum.
+    // Protocol V2 submodule firmware uses DeviceReboot with reboot_type enum.
     if (this.device.isProtocolV2()) {
-      const res = await this.device.commands.typedCall('DevReboot', 'Success', {
-        reboot_type: DevRebootType.Bootloader,
+      const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
+        reboot_type: DeviceRebootType.Bootloader,
       });
+      this.device.markProtocolV2Reboot(DeviceRebootType.Bootloader);
       return Promise.resolve(res.message);
     }
 

package/src/api/device/DeviceSettings.ts

@@ -1,10 +1,76 @@
 import { HardwareErrorCode, TypedError } from '@onekeyfe/hd-shared';
+import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
 import { validateParams } from '../helpers/paramsValidator';
-import { LANGUAGE_LABELS } from '../../utils/deviceSettings';
+import {
+  mapApplySettingsToState,
+  mapCommonSettingsToProtocolV2,
+  mapDeviceSettingsToState,
+} from '../../device/DeviceStateMapper';
+import { getProtocolV2SettingsBehavior } from '../../protocols/protocol-v2/settingsUnlockPolicy';
+import {
+  DEVICE_SETTINGS_V1_ONLY_FIELDS,
+  DEVICE_SETTINGS_V2_ONLY_FIELDS,
+  LANGUAGE_LABELS,
+  getDeviceSettingsCapabilities,
+} from '../../utils/deviceSettings';
 
 import type { ApplySettings } from '@onekeyfe/hd-transport';
+import type { DeviceSettingsParams } from '../../types/api/deviceSettings';
+
+const assertSettingsSupported = (
+  payload: DeviceSettingsParams,
+  unsupported: readonly (keyof DeviceSettingsParams)[],
+  protocol: 'Protocol V1' | 'Protocol V2'
+) => {
+  const provided = unsupported.filter(key => payload[key] !== undefined);
+  if (provided.length > 0) {
+    throw invalidParameter(`${protocol} does not support settings: ${provided.join(', ')}.`);
+  }
+};
+
+const assertProtocolV2SettingValues = (
+  payload: DeviceSettingsParams,
+  capabilities: ReturnType<typeof getDeviceSettingsCapabilities>
+) => {
+  const brightnessRange = capabilities.ranges.brightness;
+  if (
+    payload.brightness !== undefined &&
+    brightnessRange &&
+    (payload.brightness < brightnessRange.min || payload.brightness > brightnessRange.max)
+  ) {
+    throw invalidParameter(
+      `Protocol V2 brightness must be between ${brightnessRange.min} and ${brightnessRange.max}.`
+    );
+  }
+
+  const delayFields = [
+    ['autoLockDelayMs', capabilities.autoLockDelayOptions],
+    ['autoShutdownDelayMs', capabilities.autoShutdownDelayOptions],
+  ] as const;
+  delayFields.forEach(([field, options]) => {
+    const value = payload[field];
+    if (value !== undefined && !options.some(option => option.valueMs === value)) {
+      throw invalidParameter(
+        `Protocol V2 ${field} must be one of: ${options.map(option => option.valueMs).join(', ')}.`
+      );
+    }
+  });
+};
+
+const settingsPageForPayload = (
+  payload: DeviceSettingsParams
+): DeviceSettingsPage.DevicePassphrase | DeviceSettingsPage.DeviceAirgap | undefined => {
+  if (payload.usePassphrase !== undefined) {
+    return DeviceSettingsPage.DevicePassphrase;
+  }
+  if (payload.airgapMode !== undefined) {
+    return DeviceSettingsPage.DeviceAirgap;
+  }
+  return undefined;
+};
 
 export default class DeviceSettings extends BaseMethod<ApplySettings> {
   init() {
@@ -24,7 +90,16 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
       { name: 'experimentalFeatures', type: 'boolean' },
       { name: 'autoShutdownDelayMs', type: 'number' },
       { name: 'changeBrightness', type: 'boolean' },
+      { name: 'brightness', type: 'number' },
       { name: 'hapticFeedback', type: 'boolean' },
+      { name: 'bluetoothEnabled', type: 'boolean' },
+      { name: 'airgapMode', type: 'boolean' },
+      { name: 'animationEnabled', type: 'boolean' },
+      { name: 'tapToWake', type: 'boolean' },
+      { name: 'deviceNameDisplayEnabled', type: 'boolean' },
+      { name: 'fidoEnabled', type: 'boolean' },
+      { name: 'usbLockEnabled', type: 'boolean' },
+      { name: 'randomKeypad', type: 'boolean' },
     ]);
 
     // init params
@@ -40,11 +115,34 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
       safety_checks: this.payload.safetyChecks,
       experimental_features: this.payload.experimentalFeatures,
       auto_shutdown_delay_ms: this.payload.autoShutdownDelayMs,
+      use_ble: this.payload.bluetoothEnabled,
       ...(this.payload.changeBrightness
         ? { change_brightness: this.payload.changeBrightness }
         : undefined),
       haptic_feedback: this.payload.hapticFeedback,
     };
+    const page = settingsPageForPayload(this.payload);
+    const directSettings = mapCommonSettingsToProtocolV2(this.payload);
+    const hasConflictingPages =
+      this.payload.usePassphrase !== undefined && this.payload.airgapMode !== undefined;
+    const combinesPageWithDirectSettings =
+      page !== undefined && Object.keys(directSettings).length > 0;
+    if (hasConflictingPages || combinesPageWithDirectSettings) {
+      // V1 may still accept passphrase plus direct settings. Suppress only the
+      // Protocol V2 pre-run interaction; run() returns the protocol-specific error.
+      this.unlockPolicy = 'none';
+      this.protocolV2UiInteraction = undefined;
+      return;
+    }
+    const behavior =
+      page === undefined
+        ? getProtocolV2SettingsBehavior({
+            kind: 'direct',
+            settings: directSettings,
+          })
+        : getProtocolV2SettingsBehavior({ kind: 'page', page });
+    this.unlockPolicy = behavior.unlockPolicy;
+    this.protocolV2UiInteraction = behavior.uiInteraction;
   }
 
   getVersionRange() {
@@ -60,9 +158,93 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
 
   async run() {
     try {
+      if (this.device.isProtocolV2()) {
+        assertSettingsSupported(this.payload, DEVICE_SETTINGS_V1_ONLY_FIELDS, 'Protocol V2');
+        const capabilities = getDeviceSettingsCapabilities(
+          this.device.getCurrentDeviceType(),
+          'V2'
+        );
+        assertProtocolV2SettingValues(this.payload, capabilities);
+        const settings = mapCommonSettingsToProtocolV2(this.payload);
+        const requestedPassphrase = this.payload.usePassphrase;
+        const requestedAirgap = this.payload.airgapMode;
+        const hasPassphrasePage = requestedPassphrase !== undefined;
+        const hasAirgapPage = requestedAirgap !== undefined;
+
+        if (hasPassphrasePage && hasAirgapPage) {
+          throw invalidParameter(
+            'Protocol V2 passphrase and air-gap settings must be changed in separate calls.'
+          );
+        }
+        if ((hasPassphrasePage || hasAirgapPage) && Object.keys(settings).length > 0) {
+          throw invalidParameter(
+            'Protocol V2 on-device settings must not be combined with direct settings.'
+          );
+        }
+        if (requestedPassphrase !== undefined) {
+          const current = await this.device.getDeviceState({ refreshSections: ['status'] });
+          if (current.status.passphraseProtection === requestedPassphrase) {
+            return { message: 'Settings already match requested value.' };
+          }
+
+          const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
+            page: DeviceSettingsPage.DevicePassphrase,
+          });
+          const updated = await this.device.getDeviceState({ refreshSections: ['status'] });
+          if (updated.status.passphraseProtection !== requestedPassphrase) {
+            throw TypedError(
+              HardwareErrorCode.RuntimeError,
+              'Protocol V2 passphrase setting did not reach the requested value.'
+            );
+          }
+          return res.message;
+        }
+        if (requestedAirgap !== undefined) {
+          const current = await this.device.getDeviceState({ refreshSections: ['settings'] });
+          if (current.settings.airgapMode === requestedAirgap) {
+            return { message: 'Settings already match requested value.' };
+          }
+
+          const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
+            page: DeviceSettingsPage.DeviceAirgap,
+          });
+          const updated = await this.device.getDeviceState({ refreshSections: ['settings'] });
+          if (updated.settings.airgapMode !== requestedAirgap) {
+            throw TypedError(
+              HardwareErrorCode.RuntimeError,
+              'Protocol V2 air-gap setting did not reach the requested value.'
+            );
+          }
+          return res.message;
+        }
+        if (Object.keys(settings).length === 0) {
+          throw invalidParameter('No Protocol V2 compatible setting provided.');
+        }
+
+        const res = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
+          settings,
+        });
+        this.device.updateState(mapDeviceSettingsToState(settings), 'settings-write');
+        return res.message;
+      }
+
+      assertSettingsSupported(this.payload, DEVICE_SETTINGS_V2_ONLY_FIELDS, 'Protocol V1');
+      const capabilities = getDeviceSettingsCapabilities(this.device.getCurrentDeviceType(), 'V1');
+      if (
+        this.payload.safetyChecks !== undefined &&
+        !capabilities.safetyCheckOptions.some(option => option.value === this.payload.safetyChecks)
+      ) {
+        throw invalidParameter(
+          `Protocol V1 safetyChecks must be one of: ${capabilities.safetyCheckOptions
+            .map(option => option.value)
+            .join(', ')}.`
+        );
+      }
+
       const res = await this.device.commands.typedCall('ApplySettings', 'Success', {
         ...this.params,
       });
+      this.device.updateState(mapApplySettingsToState(this.params), 'settings-write');
       return res.message;
     } catch (error) {
       if (error.message?.toLowerCase().includes('no setting provided')) {

package/src/api/device/DeviceUnlock.ts

@@ -5,9 +5,19 @@ import type { LockDevice } from '@onekeyfe/hd-transport';
 export default class DeviceUnlock extends BaseMethod<LockDevice> {
   init() {
     this.useDevicePassphraseState = false;
+    this.unlockPolicy = 'none';
+    this.protocolV2UiInteraction = {
+      request: 'pin',
+      source: 'method-lifecycle',
+      reason: 'device-unlock',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      operation: 'unlock-device',
+    };
   }
 
   async run() {
-    return this.device.unlockDevice();
+    await this.device.unlockDevice();
+    return this.device.getDeviceState();
   }
 }

package/src/api/device/DeviceUpdateBootloader.ts

@@ -9,7 +9,6 @@ import { updateBootloader } from '../firmware/uploadFirmware';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
 import { checkBootloaderLength } from '../firmware/updateBootloader';
-import { getFirmwareType } from '../../utils';
 
 import type { DeviceUpdateBootloaderParams } from '../../types/api/deviceUpdateBootloader';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
@@ -99,7 +98,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     const payload = this.payload as DeviceUpdateBootloaderParams;
 
     const deviceType = device.getCurrentDeviceType();
-    const deviceFirmwareType = getFirmwareType(features);
+    const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     if (DeviceModelToTypes.model_touch.includes(deviceType)) {

package/src/api/device/DeviceWipe.ts

@@ -1,13 +1,32 @@
+import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
+
 import { BaseMethod } from '../BaseMethod';
 
 import type { WipeDevice } from '@onekeyfe/hd-transport';
 
 export default class DeviceWipe extends BaseMethod<WipeDevice> {
   init() {
+    this.unlockPolicy = 'retry-on-locked';
     this.useDevicePassphraseState = false;
+    this.protocolV2UiInteraction = {
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'device-management',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      page: DeviceSettingsPage.DeviceReset,
+      operation: 'wipe-device',
+    };
   }
 
   async run() {
+    if (this.device.isProtocolV2()) {
+      const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
+        page: DeviceSettingsPage.DeviceReset,
+      });
+      return Promise.resolve(res.message);
+    }
+
     const res = await this.device.commands.typedCall('WipeDevice', 'Success');
 
     return Promise.resolve(res.message);

package/src/api/evm/EVMSignTypedData.ts

@@ -32,9 +32,8 @@ import type {
 } from '@onekeyfe/hd-transport';
 
 /**
- * EthereumTypedDataStructAckOneKey 与 EthereumTypedDataStructAck 的字段结构与
- * 枚举数值完全一致（生成产物的 OneKey/Trezor 双份消息），仅枚举名义类型不同；
- * 这里做无运行时成本的名义转换，避免在调用点散落 any。
+ * EthereumTypedDataStructAckOneKey and EthereumTypedDataStructAck have identical
+ * fields and enum values. This zero-cost nominal conversion avoids scattered `any`.
  */
 const toOneKeyStructAck = (ack: EthereumTypedDataStructAck): EthereumTypedDataStructAckOneKey =>
   ack as unknown as EthereumTypedDataStructAckOneKey;
@@ -227,8 +226,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
     if (response.type === 'EthereumGnosisSafeTxRequest') {
       const { data } = this.params;
       const verifyingContract = data.domain?.verifyingContract;
-      // EthereumGnosisSafeTxAck.verifyingContract 在 proto 中是 required 字段，
-      // Gnosis Safe 签名缺少 verifyingContract 没有意义，这里给出明确的参数错误。
+      // verifyingContract is required by proto and essential to a Gnosis Safe signature.
       if (!verifyingContract) {
         throw ERRORS.TypedError(
           HardwareErrorCode.CallMethodInvalidParameter,

package/src/api/evm/legacyV1/getAddress.ts

@@ -7,8 +7,8 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetAddressOneKey;
 }): Promise<MessageResponse<'EthereumAddress'>> {
-  // legacy EthereumGetAddress 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: param.address_n,
     show_display: param.show_display,

package/src/api/evm/legacyV1/getPublicKey.ts

@@ -11,8 +11,8 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetPublicKeyOneKey;
 }): Promise<MessageResponse<'EthereumPublicKey'>> {
-  // legacy EthereumGetPublicKey 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: param.address_n,
     show_display: param.show_display,

package/src/api/evm/legacyV1/signMessage.ts

@@ -11,8 +11,8 @@ export default async function ({
   typedCall: TypedCall;
   params: EthereumSignMessageOneKey;
 }): Promise<EthereumMessageSignature> {
-  // legacy EthereumSignMessage 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: params.address_n,
     message: params.message,

package/src/api/evm/legacyV1/signTypedData.ts

@@ -16,8 +16,8 @@ export const signTypedData = async ({
 }) => {
   const { primaryType }: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> = data;
 
-  // legacy EthereumSignTypedData 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: addressN,
     primary_type: primaryType as string,

package/src/api/evm/legacyV1/signTypedHash.ts

@@ -38,8 +38,8 @@ export const signTypedHash = async ({
     }
   }
 
-  // legacy EthereumSignTypedHash 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: addressN,
     domain_separator_hash: domainHash ?? '',

package/src/api/evm/legacyV1/verifyMessage.ts

@@ -7,8 +7,8 @@ export default async function ({
   typedCall: TypedCall;
   params: EthereumVerifyMessageOneKey;
 }): Promise<Success> {
-  // legacy EthereumVerifyMessage 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     signature: params.signature,
     message: params.message,

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -8,11 +8,12 @@ import {
 
 import { FirmwareUpdateTipMessage, UI_REQUEST, createUiMessage } from '../../events/ui-request';
 import { DevicePool } from '../../device/DevicePool';
-import { LoggerNames, getDeviceUUID, getLogger, wait } from '../../utils';
+import { LoggerNames, getLogger, wait } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
 import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
+import { createFirmwareProgressThrottle } from './progressThrottle';
 
 import type {
   IFirmwareUpdateProgressType,
@@ -40,6 +41,8 @@ const isDeviceDisconnectedError = (error: unknown) => {
 export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
   checkPromise: Deferred<any> | null = null;
 
+  private shouldPostFirmwareProgress = createFirmwareProgressThrottle();
+
   init(): void {}
 
   run(): Promise<any> {
@@ -83,6 +86,10 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
    * @param progress Post the percentage of the progress
    */
   postProgressMessage = (progress: number, progressType: IFirmwareUpdateProgressType) => {
+    if (!this.shouldPostFirmwareProgress(progress, progressType)) {
+      return;
+    }
+
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
         device: this.device.toMessageObject() as KnownDevice,
@@ -138,6 +145,8 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     // check device goto bootloader mode
     let isFirstCheck = true;
     let checkCount = 0;
+    let hasPromptedWebDevice = false;
+    let isPromptingWebDevice = false;
     // eslint-disable-next-line prefer-const
     let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
 
@@ -158,23 +167,28 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
         if (
           checkCount > 4 &&
           DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
-          !this.payload.skipWebDevicePrompt
+          !this.payload.skipWebDevicePrompt &&
+          !hasPromptedWebDevice &&
+          !isPromptingWebDevice
         ) {
-          clearInterval(intervalTimer);
-          clearTimeout(timeoutTimer);
-
+          isPromptingWebDevice = true;
           try {
             this.postTipMessage(FirmwareUpdateTipMessage.SelectDeviceInBootloaderForWebDevice);
             const confirmed = await this._promptDeviceInBootloaderForWebDevice();
+            hasPromptedWebDevice = true;
             if (confirmed) {
               await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
             }
           } catch (e) {
+            clearInterval(intervalTimer);
+            clearTimeout(timeoutTimer);
             Log.log(
               'FirmwareUpdateBaseMethod [checkDeviceToBootloader] _promptDeviceInBootloaderForWebDevice failed: ',
               e
             );
             this.checkPromise?.reject(e);
+          } finally {
+            isPromptingWebDevice = false;
           }
           return;
         }
@@ -237,7 +251,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
   async enterBootloaderMode() {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
     if (this.device.features && !this.device.isBootloader()) {
-      const uuid = getDeviceUUID(this.device.features);
+      const serialNo = this.device.getCurrentSerialNo();
       const deviceType = this.device.getCurrentDeviceType();
       // auto go to bootloader mode
       try {
@@ -252,7 +266,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
 
         // force clean classic device cache so that the device can initialize again
         if (DeviceModelToTypes.model_classic.includes(deviceType)) {
-          DevicePool.clearDeviceCache(uuid);
+          DevicePool.clearDeviceCache(serialNo);
         }
         delete DevicePool.devicesCache[''];
         await this.checkPromise?.promise;