@onekeyfe/hd-core 1.2.0-alpha.1 → 1.2.0-alpha.11

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

@@ -0,0 +1,59 @@
+import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+
+export type SupportedDeviceSettingsPage = DeviceSettingsPage;
+
+export type DeviceSettingsPageShowParams = {
+  page?:
+    | SupportedDeviceSettingsPage
+    | 'DeviceReset'
+    | 'DevicePinChange'
+    | 'DevicePassphrase'
+    | 'DeviceAirgap';
+  fieldName?: string;
+  field_name?: string;
+};
+
+const SUPPORTED_PAGES = new Set<number>([
+  DeviceSettingsPage.DeviceReset,
+  DeviceSettingsPage.DevicePinChange,
+  DeviceSettingsPage.DevicePassphrase,
+  DeviceSettingsPage.DeviceAirgap,
+]);
+
+function normalizePage(value: DeviceSettingsPageShowParams['page']): SupportedDeviceSettingsPage {
+  const page = typeof value === 'string' ? DeviceSettingsPage[value] : value;
+  if (page !== undefined && SUPPORTED_PAGES.has(page)) {
+    return page as SupportedDeviceSettingsPage;
+  }
+  throw invalidParameter(
+    'Parameter [page] must be DeviceReset, DevicePinChange, DevicePassphrase, or DeviceAirgap.'
+  );
+}
+
+export default class DeviceSettingsPageShow extends BaseMethod<{
+  page: SupportedDeviceSettingsPage;
+  field_name?: string;
+}> {
+  init() {
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      page: normalizePage(this.payload.page),
+      field_name: this.payload.field_name ?? this.payload.fieldName,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DeviceSettingsPageShow',
+      'Success',
+      this.params
+    );
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,39 @@
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+
+import type { DeviceSettings } from '@onekeyfe/hd-transport';
+
+export type DeviceSettingsSetParams = {
+  settings?: Omit<DeviceSettings, 'passphrase_enable' | 'airgap_mode'>;
+};
+
+export default class DeviceSettingsSet extends BaseMethod<{
+  settings: Omit<DeviceSettings, 'passphrase_enable' | 'airgap_mode'>;
+}> {
+  init() {
+    const settings = this.payload.settings;
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+      throw invalidParameter('Parameter [settings] must be an object.');
+    }
+
+    const {
+      passphrase_enable: _passphraseEnable,
+      airgap_mode: _airgapMode,
+      ...supported
+    } = settings as DeviceSettings;
+    if (Object.keys(supported).length === 0) {
+      throw invalidParameter('Parameter [settings] must contain at least one supported setting.');
+    }
+
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { settings: supported };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', this.params);
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,14 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceStatusGet extends BaseMethod {
+  init() {
+    this.requireProtocolV2 = true;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall('DeviceStatusGet', 'DeviceStatus', {});
+    return message;
+  }
+}

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

@@ -0,0 +1,160 @@
+import { blake2s } from '@noble/hashes/blake2s';
+import { bytesToHex } from '@noble/hashes/utils';
+import {
+  PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
+  PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
+  WallpaperTarget,
+} from '@onekeyfe/hd-transport';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+import { DataManager } from '../../data-manager';
+import {
+  encodePro2Wallpaper,
+  PRO2_WALLPAPER_HEIGHT,
+  PRO2_WALLPAPER_WIDTH,
+  type Pro2WallpaperColorFormat,
+} from '../../utils/pro2Wallpaper';
+
+export type DeviceUploadWallpaperParams = {
+  width: number;
+  height: number;
+  rgba: Uint8Array | ArrayBuffer;
+  fileName?: string;
+  chunkSize?: number;
+};
+
+export type DeviceUploadWallpaperResponse = {
+  path: string;
+  size: number;
+  colorFormat: Pro2WallpaperColorFormat;
+  message?: string;
+};
+
+const WALLPAPER_DIRECTORY = 'vol0:/wallpapers/user';
+const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
+
+function getDefaultChunkSize(): number {
+  const env = DataManager.getSettings('env');
+  return env && DataManager.isBleConnect(env)
+    ? PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
+    : PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+}
+
+function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
+  if (fileName !== undefined && (!fileName || !SAFE_FILE_NAME.test(fileName))) {
+    throw invalidParameter(
+      'Parameter [fileName] may only contain letters, numbers, underscores, hyphens and an optional .bin suffix.'
+    );
+  }
+  const baseName = fileName ?? `wallpaper-${bytesToHex(blake2s(data)).slice(0, 12)}`;
+  return baseName.endsWith('.bin') ? baseName : `${baseName}.bin`;
+}
+
+export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpaperParams> {
+  private encoded?: { data: Uint8Array; colorFormat: Pro2WallpaperColorFormat };
+
+  private directoryReady = false;
+
+  private uploaded = false;
+
+  private path = '';
+
+  init() {
+    const { width, height, rgba, fileName, chunkSize } = this.payload;
+    if (width !== PRO2_WALLPAPER_WIDTH || height !== PRO2_WALLPAPER_HEIGHT) {
+      throw invalidParameter(
+        `Pro2 wallpaper dimensions must be ${PRO2_WALLPAPER_WIDTH}x${PRO2_WALLPAPER_HEIGHT}.`
+      );
+    }
+    if (!(rgba instanceof ArrayBuffer) && !ArrayBuffer.isView(rgba)) {
+      throw invalidParameter('Parameter [rgba] must be an ArrayBuffer or Uint8Array.');
+    }
+    if (chunkSize !== undefined && (!Number.isInteger(chunkSize) || chunkSize <= 0)) {
+      throw invalidParameter('Parameter [chunkSize] must be a positive integer.');
+    }
+
+    const rgbaBytes =
+      rgba instanceof ArrayBuffer
+        ? rgba
+        : new Uint8Array(rgba.buffer, rgba.byteOffset, rgba.byteLength);
+    this.encoded = encodePro2Wallpaper({ width, height, rgba: rgbaBytes });
+    this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
+    this.params = { width, height, rgba: rgbaBytes, fileName, chunkSize };
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+  }
+
+  private async ensureDirectory() {
+    if (this.directoryReady) return;
+    try {
+      await this.device.commands.typedCall('FilesystemDirMake', 'Success', {
+        path: WALLPAPER_DIRECTORY,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!/exist/i.test(message)) throw error;
+    }
+    this.directoryReady = true;
+  }
+
+  private async upload() {
+    if (this.uploaded) return;
+    const encoded = this.encoded;
+    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
+
+    const maxChunkSize = getDefaultChunkSize();
+    const requestedChunkSize = this.params.chunkSize ?? maxChunkSize;
+    const chunkSize = Math.min(Math.max(64, Math.floor(requestedChunkSize)), maxChunkSize);
+    let offset = 0;
+    while (offset < encoded.data.byteLength) {
+      const chunk = encoded.data.slice(offset, Math.min(offset + chunkSize, encoded.data.byteLength));
+      const response = await this.device.commands.typedCall(
+        'FilesystemFileWrite',
+        'FilesystemFile',
+        {
+          file: {
+            path: this.path,
+            offset,
+            total_size: encoded.data.byteLength,
+            data: chunk,
+          },
+          overwrite: offset === 0,
+          append: false,
+          ui_percentage: Math.min(
+            Math.ceil(((offset + chunk.byteLength) / encoded.data.byteLength) * 100),
+            100
+          ),
+        },
+        { timeoutMs: undefined }
+      );
+      const processedByte = Number(response.message?.processed_byte);
+      offset = Number.isFinite(processedByte) && processedByte > offset
+        ? processedByte
+        : offset + chunk.byteLength;
+      if (offset > encoded.data.byteLength) {
+        throw invalidParameter(`Invalid processed_byte returned by device: ${processedByte}.`);
+      }
+    }
+    this.uploaded = true;
+  }
+
+  async run(): Promise<DeviceUploadWallpaperResponse> {
+    const encoded = this.encoded;
+    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
+    await this.ensureDirectory();
+    await this.upload();
+    const response = await this.device.commands.typedCall('SetWallpaper', 'Success', {
+      target: WallpaperTarget.Lock,
+      path: this.path,
+    });
+    return {
+      path: this.path,
+      size: encoded.data.byteLength,
+      colorFormat: encoded.colorFormat,
+      message: response.message?.message,
+    };
+  }
+}

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

@@ -10,7 +10,10 @@ export default class FilesystemFormat extends BaseMethod {
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('FilesystemFormat', 'Success', {});
+    const res = await this.device.commands.typedCall('FilesystemFormat', 'Success', {
+      data: true,
+      user: true,
+    });
     return Promise.resolve(res.message);
   }
 }

package/src/api/protocol-v2/{FilesystemFixPermission.ts → FilesystemPermissionFix.ts}

@@ -1,6 +1,6 @@
 import { BaseMethod } from '../BaseMethod';
 
-export default class FilesystemFixPermission extends BaseMethod {
+export default class FilesystemPermissionFix extends BaseMethod {
   init() {
     // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
     this.requireProtocolV2 = true;
@@ -10,7 +10,7 @@ export default class FilesystemFixPermission extends BaseMethod {
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('FilesystemFixPermission', 'Success', {});
+    const res = await this.device.commands.typedCall('FilesystemPermissionFix', 'Success', {});
     return Promise.resolve(res.message);
   }
 }

package/src/api/protocol-v2/{GetProtoVersion.ts → ProtocolInfoRequest.ts}

@@ -1,6 +1,6 @@
 import { BaseMethod } from '../BaseMethod';
 
-export default class GetProtoVersion extends BaseMethod {
+export default class ProtocolInfoRequest extends BaseMethod {
   init() {
     // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
     this.requireProtocolV2 = true;
@@ -10,7 +10,7 @@ export default class GetProtoVersion extends BaseMethod {
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('GetProtoVersion', 'ProtoVersion', {});
+    const res = await this.device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {});
     return Promise.resolve(res.message);
   }
 }

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

@@ -1,18 +1,16 @@
-import { DevRebootType } from '@onekeyfe/hd-transport';
+import { DeviceRebootType } from '@onekeyfe/hd-transport';
 
 import { invalidParameter, validateNonEmptyString } from '../helpers/filesystemValidation';
+import { ProtocolV2FirmwareTargetType } from '../../protocols/protocol-v2/firmware';
 
 import type {
-  DevFirmwareTarget,
-  DevFirmwareTargetType,
+  DeviceFirmwareTarget,
+  DeviceFirmwareTargetType,
+  DeviceFirmwareUpdateRecordFields,
   TransportCallOptions,
 } from '@onekeyfe/hd-transport';
 
-export type RebootTypeInput =
-  | DevRebootType
-  | keyof typeof DevRebootType
-  | string
-  | number;
+export type RebootTypeInput = DeviceRebootType | keyof typeof DeviceRebootType | string | number;
 
 export type DeviceRebootParams = {
   rebootType?: RebootTypeInput;
@@ -20,48 +18,58 @@ export type DeviceRebootParams = {
 };
 
 export type DeviceFirmwareTargetInput =
-  | DevFirmwareTarget
+  | DeviceFirmwareTarget
   | {
-      targetId?: DevFirmwareTargetType | string | number;
-      target_id?: DevFirmwareTargetType | string | number;
+      targetId?: DeviceFirmwareTargetType | string | number;
+      target_id?: DeviceFirmwareTargetType | string | number;
       path: string;
     };
 
 export type DeviceFirmwareUpdateParams = {
   targets?: DeviceFirmwareTargetInput[];
-  targetId?: DevFirmwareTargetType | string | number;
-  target_id?: DevFirmwareTargetType | string | number;
+  targetId?: DeviceFirmwareTargetType | string | number;
+  target_id?: DeviceFirmwareTargetType | string | number;
   path?: string;
 };
 
-export type FactoryDeviceInfoSettingsParams = {
-  serial_no?: string;
-  serialNo?: string;
-  cpu_info?: string;
-  cpuInfo?: string;
-  pre_firmware?: string;
-  preFirmware?: string;
+export type DeviceFirmwareUpdateStatusGetParams = {
+  fields?: DeviceFirmwareUpdateRecordFields;
 };
 
-const DEV_REBOOT_TYPES: Record<string, DevRebootType> = {
-  Normal: DevRebootType.Normal,
-  normal: DevRebootType.Normal,
-  Romloader: DevRebootType.Boardloader,
-  romloader: DevRebootType.Boardloader,
-  Boardloader: DevRebootType.Boardloader,
-  boardloader: DevRebootType.Boardloader,
-  Bootloader: DevRebootType.Bootloader,
-  bootloader: DevRebootType.Bootloader,
+export type DeviceFactoryInfoSetParams = {
+  version?: number;
+  serial_number?: string;
+  burn_in_completed?: boolean;
+  factory_test_completed?: boolean;
+  manufacture_time?: {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+  };
+};
+
+const DEVICE_REBOOT_TYPES: Record<string, DeviceRebootType> = {
+  Normal: DeviceRebootType.Normal,
+  normal: DeviceRebootType.Normal,
+  Romloader: DeviceRebootType.Romloader,
+  romloader: DeviceRebootType.Romloader,
+  Boardloader: DeviceRebootType.Romloader,
+  boardloader: DeviceRebootType.Romloader,
+  Bootloader: DeviceRebootType.Bootloader,
+  bootloader: DeviceRebootType.Bootloader,
 };
 
 export const PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS: TransportCallOptions = {
-  intermediateTypes: ['DevFirmwareInstallProgress'],
+  intermediateTypes: ['DeviceFirmwareUpdateStatus'],
 };
 
 export const PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES: (
   | 'Success'
-  | 'DevFirmwareUpdateStatus'
-)[] = ['Success', 'DevFirmwareUpdateStatus'];
+  | 'DeviceFirmwareUpdateStatus'
+)[] = ['Success', 'DeviceFirmwareUpdateStatus'];
 
 export const getProtocolV2UnknownErrorText = (error: unknown) => {
   if (!error) {
@@ -120,40 +128,56 @@ export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
   );
 };
 
-export function normalizeRebootType(value: RebootTypeInput | undefined): DevRebootType {
+export function normalizeRebootType(value: RebootTypeInput | undefined): DeviceRebootType {
   if (typeof value === 'number') return value;
   if (typeof value === 'string') {
     const numeric = Number(value);
     if (Number.isFinite(numeric)) return numeric;
-    if (value in DEV_REBOOT_TYPES) return DEV_REBOOT_TYPES[value];
+    if (value in DEVICE_REBOOT_TYPES) return DEVICE_REBOOT_TYPES[value];
   }
-  return DevRebootType.Normal;
+  return DeviceRebootType.Normal;
 }
 
-// 当前 firmware-pro2 子模块的 DevFirmwareTargetType 合法值。
-const VALID_FIRMWARE_TARGET_IDS = new Set<number>([0, 1, 2, 3, 4, 5, 6, 10]);
+// 与 firmware-pro2 的 proto_target_to_firmware_target 安装白名单保持一致。
+const INSTALLABLE_FIRMWARE_TARGET_IDS = new Set<number>([
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04,
+]);
+const FIRMWARE_TARGET_ID_BY_NAME = new Map<string, DeviceFirmwareTargetType>(
+  Object.entries(ProtocolV2FirmwareTargetType).flatMap(([key, value]) =>
+    INSTALLABLE_FIRMWARE_TARGET_IDS.has(value) ? [[key, value as DeviceFirmwareTargetType]] : []
+  )
+);
 
 function normalizeTargetId(
-  value: DevFirmwareTargetType | string | number | undefined,
+  value: DeviceFirmwareTargetType | string | number | undefined,
   name: string
-): DevFirmwareTargetType {
+): DeviceFirmwareTargetType {
   if (value === undefined || value === null) {
     throw invalidParameter(`Missing required parameter: ${name}`);
   }
-  const numeric = typeof value === 'number' ? value : Number(value);
-  // 校验值域：仅接受 DevFirmwareTargetType 中定义的 target id，
-  // 不再放行任意非负整数。
-  if (Number.isSafeInteger(numeric) && VALID_FIRMWARE_TARGET_IDS.has(numeric)) {
-    return numeric as DevFirmwareTargetType;
+  const named = typeof value === 'string' ? FIRMWARE_TARGET_ID_BY_NAME.get(value) : undefined;
+  const numeric = named ?? (typeof value === 'number' ? value : Number(value));
+  if (Number.isSafeInteger(numeric) && INSTALLABLE_FIRMWARE_TARGET_IDS.has(numeric)) {
+    return numeric as DeviceFirmwareTargetType;
   }
   throw invalidParameter(
-    `Parameter [${name}] must be a valid firmware target id (one of ${[
-      ...VALID_FIRMWARE_TARGET_IDS,
+    `Parameter [${name}] must be an installable firmware target id (one of ${[
+      ...INSTALLABLE_FIRMWARE_TARGET_IDS,
     ].join(', ')}).`
   );
 }
 
-export function normalizeFirmwareTargets(params: DeviceFirmwareUpdateParams): DevFirmwareTarget[] {
+export function normalizeFirmwareTargets(
+  params: DeviceFirmwareUpdateParams
+): DeviceFirmwareTarget[] {
   const targets =
     params.targets ??
     (params.path

package/src/api/ton/TonSignData.ts

@@ -51,11 +51,7 @@ export default class TonSignData extends BaseMethod<HardwareTonSignData> {
   }
 
   getVersionRange() {
-    return {
-      pro2: {
-        min: '0.0.0',
-      },
-    };
+    return {};
   }
 
   async run() {

package/src/api/tron/TronSignMessage.ts

@@ -47,7 +47,6 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
     return {
       pro2: {
         min: '0.0.0',
-        unsupported: true,
       },
       model_mini: {
         min: '2.5.0',

package/src/api/tron/TronSignTransaction.ts

@@ -150,7 +150,6 @@ export default class TronSignTransaction extends BaseMethod<TronSignTx> {
     return {
       pro2: {
         min: '0.0.0',
-        unsupported: true,
       },
       model_mini: {
         min: '2.5.0',

package/src/core/RequestQueue.ts

@@ -14,6 +14,8 @@ export type RequestTask = {
 export default class RequestQueue {
   private requestQueue = new Map<number, RequestTask>();
 
+  private operationRequestIds = new Map<string, number>();
+
   private pendingCallbackTasks = new Map<string, Deferred<void>>();
 
   // 生成唯一请求ID
@@ -30,11 +32,21 @@ export default class RequestQueue {
       method.responseID = requestId;
     }
     const abortController = new AbortController();
+    method.abortSignal = abortController.signal;
     const task = { id: requestId, method, abortController };
     this.requestQueue.set(requestId, task);
+    const operationId = method.payload?.operationId;
+    if (typeof operationId === 'string' && operationId) {
+      this.operationRequestIds.set(operationId, requestId);
+    }
     return task;
   }
 
+  public abortOperation(operationId: string) {
+    const requestId = this.operationRequestIds.get(operationId);
+    return requestId === undefined ? false : this.abortRequest(requestId);
+  }
+
   public getTask(requestId: number): RequestTask | undefined {
     return this.requestQueue.get(requestId);
   }
@@ -105,6 +117,13 @@ export default class RequestQueue {
 
   // 删除请求
   public releaseTask(requestId: number) {
+    const operationId = this.requestQueue.get(requestId)?.method.payload?.operationId;
+    if (
+      typeof operationId === 'string' &&
+      this.operationRequestIds.get(operationId) === requestId
+    ) {
+      this.operationRequestIds.delete(operationId);
+    }
     this.requestQueue.delete(requestId);
   }
 

package/src/core/index.ts

@@ -56,7 +56,7 @@ import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
 import RequestQueue from './RequestQueue';
 import { getSynchronize } from '../utils/getSynchronize';
-import { setProtocolV2DeviceInfoMock } from '../protocols/protocol-v2/features';
+import { runMethodWithUnlockRetry } from '../protocols/protocol-v2/unlockRetry';
 
 import type { ConnectSettings, Features, KnownDevice } from '../types';
 import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
@@ -96,6 +96,7 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   deviceId: method?.payload.deviceId,
   deriveCardano: method && hasDeriveCardano(method),
   connectProtocol: method?.payload.connectProtocol,
+  protocolV2DeviceInfoTimeoutMs: method?.payload.protocolV2DeviceInfoTimeoutMs,
 });
 
 let _core: Core;
@@ -223,9 +224,15 @@ const handlePreWarmSignal = async (
   message: CoreMessage,
   method: BaseMethod
 ): Promise<any> => {
+  const createAckResponse = () => {
+    completeMethodRequestContext(method);
+    method.dispose();
+    return createResponseMessage(method.responseID, true, true);
+  };
+
   // no connectId: can't target a device safely, skip pre-warm (ack only)
   if (!method.connectId) {
-    return createResponseMessage(method.responseID, true, true);
+    return createAckResponse();
   }
 
   const key = method.getPreWarmKey();
@@ -238,12 +245,12 @@ const handlePreWarmSignal = async (
     } catch {
       // pre-warm is best-effort; ignore its failure for the coalesced caller
     }
-    return createResponseMessage(method.responseID, true, true);
+    return createAckResponse();
   }
 
   const doneAt = preWarmDoneAt.get(key);
   if (typeof doneAt === 'number' && Date.now() - doneAt <= method.preWarmTtl) {
-    return createResponseMessage(method.responseID, true, true);
+    return createAckResponse();
   }
 
   const run = onCallDevice(context, message, method);
@@ -610,7 +617,7 @@ const onCallDevice = async (
       method.device?.commands?.checkDisposed();
 
       try {
-        const response: object = await method.run();
+        const response: object = await runMethodWithUnlockRetry(method, device);
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
@@ -732,6 +739,15 @@ function initDevice(method: BaseMethod) {
 
   if (method.connectId) {
     device = _deviceList.getDevice(method.connectId);
+    if (!device && method.name === 'firmwareUpdateV4' && allDevices.length === 1) {
+      const [singleDevice] = allDevices;
+      if (singleDevice.isBootloader()) {
+        Log.debug(
+          'firmwareUpdateV4 uses the only bootloader device when connectId changed after reboot'
+        );
+        device = singleDevice;
+      }
+    }
   } else if (allDevices.length === 1) {
     [device] = allDevices;
   } else if (allDevices.length > 1) {
@@ -1326,6 +1342,10 @@ export default class Core extends EventEmitter {
     Log.debug(`[Core] Created SDK instance: ${this.sdkInstanceId}`);
   }
 
+  cancelOperation(operationId: string) {
+    this.requestQueue.abortOperation(operationId);
+  }
+
   private getCoreContext() {
     return {
       sdkInstanceId: this.sdkInstanceId,
@@ -1394,6 +1414,10 @@ export default class Core extends EventEmitter {
         cancel(this.getCoreContext(), message.payload.connectId);
         break;
       }
+      case IFRAME.CANCEL_OPERATION: {
+        this.cancelOperation(message.payload.operationId);
+        break;
+      }
       case IFRAME.CALLBACK: {
         Log.log('callback message: ', message);
         postMessage(message);
@@ -1439,7 +1463,6 @@ export const init = async (
   try {
     try {
       await DataManager.load(settings);
-      setProtocolV2DeviceInfoMock(settings.protocolV2DeviceInfoMockEnabled ?? false);
       initTransport(Transport, plugin);
     } catch {
       Log.error('DataManager.load error');