@onekeyfe/hd-core 1.2.0-alpha.57 → 1.2.0-alpha.59

package/src/api/FirmwareUpdateV4.ts

@@ -8,6 +8,7 @@ import { sha256 } from '@noble/hashes/sha256';
 
 import { FirmwareUpdateTipMessage, UI_REQUEST } from '../events/ui-request';
 import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
+import { writeProtocolV2File } from './helpers/protocolV2FileWrite';
 import { validateParams } from './helpers/paramsValidator';
 import {
   LoggerNames,
@@ -45,15 +46,14 @@ import type { TypedResponseMessage } from '../device/DeviceCommands';
 import type {
   Features,
   IFirmwareReleaseInfo,
-  IProtocolV2BootResources,
   IProtocolV2FirmwareComponent,
   IProtocolV2Resource,
+  IProtocolV2ResourceFile,
   IVersionArray,
 } from '../types';
 
 const Log = getLogger(LoggerNames.Method);
 
-const SESSION_ERROR = 'session not found';
 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;
@@ -77,7 +77,6 @@ const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
 const PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET = 0x200;
 const PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET = 0x240;
 const PROTOCOL_V2_OKPP_HASH_SIZE = 64;
-const PROTOCOL_V2_BOOT_RESOURCES_FILE_NAME = 'boot_resources.crate.okpkg';
 
 const getProtocolV2DeviceTransferProgress = (
   bytesBeforeChunk: number,
@@ -112,7 +111,7 @@ type ProtocolV2FirmwareUpdateStartResponse = TypedResponseMessage<'Success'>;
 
 type ProtocolV2TargetBinary = { fileName: string; binary: ArrayBuffer; targetId: number };
 type ProtocolV2InstallItem = ProtocolV2TargetBinary & {
-  kind: ProtocolV2RemoteComponentTarget['kind'] | 'boot_resources';
+  kind: ProtocolV2RemoteComponentTarget['kind'];
 };
 type ProtocolV2InstallTarget = ProtocolV2InstallItem & {
   path: string;
@@ -125,7 +124,7 @@ type ProtocolV2FileTransferParams = PROTO.FirmwareUpload & {
   onTransferredBytes?: (transferredBytes: number) => void;
 };
 
-/** RESC bundle okpkg written independently to devicePath through FileWrite. */
+/** Protocol V2 resource file written independently to devicePath through FileWrite. */
 type ProtocolV2ResourceBundleBinary = {
   name: string;
   binary: ArrayBuffer;
@@ -371,19 +370,30 @@ export const isProtocolV2FirmwareFingerprintValid = (
 
 export const assertProtocolV2ReconnectIdentity = (
   expectedSerialNumber?: string,
-  actualSerialNumber?: string
+  actualSerialNumber?: string,
+  expectedPath?: string,
+  actualPath?: string
 ) => {
-  // Some Pro2 loader builds omit serial_no. Reconnect still uses the same BLE
-  // descriptor or requires a uniquely enumerated USB device before this check.
-  if (!expectedSerialNumber || !actualSerialNumber) {
+  if (expectedSerialNumber && actualSerialNumber) {
+    if (actualSerialNumber !== expectedSerialNumber) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceNotFound,
+        `Protocol V2 reconnect physical identity mismatch: expected ${expectedSerialNumber}, received ${actualSerialNumber}`
+      );
+    }
     return;
   }
-  if (actualSerialNumber !== expectedSerialNumber) {
-    throw ERRORS.TypedError(
-      HardwareErrorCode.DeviceNotFound,
-      `Protocol V2 reconnect physical identity mismatch: expected ${expectedSerialNumber}, received ${actualSerialNumber}`
-    );
+
+  if (expectedPath && actualPath && expectedPath === actualPath) {
+    return;
   }
+
+  throw ERRORS.TypedError(
+    HardwareErrorCode.DeviceNotFound,
+    `Protocol V2 reconnect physical identity unavailable: expected path ${
+      expectedPath ?? 'unknown'
+    }, received ${actualPath ?? 'unknown'}`
+  );
 };
 
 /**
@@ -397,6 +407,8 @@ export const assertProtocolV2ReconnectIdentity = (
 export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareUpdateV4Params> {
   private protocolV2ExpectedSerialNumber?: string;
 
+  private protocolV2ExpectedPath?: string;
+
   getSupportedProtocols() {
     return ['V2'] as const;
   }
@@ -427,7 +439,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       { name: 'chunkSize', type: 'number' },
       { name: 'forcedUpdateRes', type: 'boolean' },
       { name: 'bootloaderBinary', type: 'buffer' },
-      { name: 'bootResourcesBinary', type: 'buffer' },
       { name: 'romloaderBinary', type: 'buffer' },
       { name: 'applicationP1Binary', type: 'buffer' },
       { name: 'applicationP2Binary', type: 'buffer' },
@@ -439,14 +450,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       { name: 'firmwareType', type: 'string' },
       { name: 'targetsToUpdate', type: 'array', allowEmpty: true },
       { name: 'platform', type: 'string' },
-      { name: 'resourceBundleFiles', type: 'array', allowEmpty: true },
+      { name: 'resourceFiles', type: 'array', allowEmpty: true },
     ]);
 
     this.params = {
       chunkSize: payload.chunkSize,
       forcedUpdateRes: payload.forcedUpdateRes,
       bootloaderBinary: payload.bootloaderBinary,
-      bootResourcesBinary: payload.bootResourcesBinary,
       romloaderBinary: payload.romloaderBinary,
       applicationP1Binary: payload.applicationP1Binary,
       applicationP2Binary: payload.applicationP2Binary,
@@ -455,7 +465,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       se02Binary: payload.se02Binary,
       se03Binary: payload.se03Binary,
       se04Binary: payload.se04Binary,
-      resourceBundleFiles: payload.resourceBundleFiles,
+      resourceFiles: payload.resourceFiles,
       firmwareType: payload.firmwareType,
       targetsToUpdate: payload.targetsToUpdate,
       platform: payload.platform,
@@ -490,26 +500,24 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const deviceFirmwareType = getFirmwareType(deviceFeatures);
     const firmwareType = this.params.firmwareType ?? deviceFirmwareType;
     const needsRemoteResources =
-      !this.params.resourceBundleFiles?.length &&
-      !!this.params.targetsToUpdate?.includes('resource');
+      !this.params.resourceFiles?.length && !!this.params.targetsToUpdate?.includes('resource');
 
     let fwBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
-    let bootResourcesInstallItem: ProtocolV2InstallItem | undefined;
     let installItems: ProtocolV2InstallItem[] | undefined;
     let resourceBundles: ProtocolV2ResourceBundleBinary[] | undefined;
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
-      resourceBundles = this.prepareExplicitProtocolV2ResourceBundles();
+      resourceBundles = this.prepareExplicitProtocolV2ResourceFiles();
       fwBinaryMap = this.collectExplicitTargetBinaries();
       bootloaderBinary = this.prepareBootloaderBinary();
       const needsRemoteFirmware = !this.hasExplicitProtocolV2Payload(fwBinaryMap);
-      const needsRemoteBootResources =
-        !this.params.bootResourcesBinary &&
-        !!this.params.targetsToUpdate?.includes('boot_resources');
+      const needsRemoteBootResources = !!this.params.targetsToUpdate?.includes('boot_resources');
       if (needsRemoteFirmware || needsRemoteResources || needsRemoteBootResources) {
         // Remote updates must use a freshly fetched config before any reboot or file write.
-        await DataManager.forceReloadData();
+        await DataManager.forceReloadData({
+          requireResources: needsRemoteResources || needsRemoteBootResources,
+        });
       }
       if (needsRemoteFirmware) {
         const remoteBinaries = await this.prepareRemoteProtocolV2Binaries(
@@ -520,12 +528,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         fwBinaryMap = remoteBinaries.fwBinaryMap;
         installItems = remoteBinaries.installItems;
       }
-      bootResourcesInstallItem = await this.prepareProtocolV2BootResources();
-      if (bootResourcesInstallItem) {
-        installItems = [
-          bootResourcesInstallItem,
-          ...(installItems ?? this.buildProtocolV2InstallItems({ bootloaderBinary, fwBinaryMap })),
-        ];
+      const bootResourceFiles = await this.prepareProtocolV2BootResources();
+      if (bootResourceFiles?.length) {
+        resourceBundles = [...(resourceBundles ?? []), ...bootResourceFiles];
       }
       if (!needsRemoteResources) {
         this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
@@ -554,7 +559,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     if (needsRemoteResources) {
       try {
-        resourceBundles = await this.prepareProtocolV2ResourceBundles();
+        const stableResources = await this.prepareProtocolV2ResourceBundles();
+        resourceBundles = [...(resourceBundles ?? []), ...(stableResources ?? [])];
         this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
       } catch (err) {
         if (enteredBootloader) {
@@ -607,7 +613,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private assertProtocolV2DeviceInfoIdentity(deviceInfo: ProtocolV2DeviceInfo) {
     assertProtocolV2ReconnectIdentity(
       this.protocolV2ExpectedSerialNumber,
-      this.getProtocolV2SerialNumber(deviceInfo)
+      this.getProtocolV2SerialNumber(deviceInfo),
+      this.protocolV2ExpectedPath,
+      this.device.originalDescriptor.path
     );
   }
 
@@ -627,8 +635,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private async captureProtocolV2PhysicalIdentity() {
     const deviceInfo = await this.requestProtocolV2PhysicalIdentity();
     const serialNumber = this.getProtocolV2SerialNumber(deviceInfo);
-    assertProtocolV2ReconnectIdentity(serialNumber, serialNumber);
+    const path = this.device.originalDescriptor.path?.trim() || undefined;
+    assertProtocolV2ReconnectIdentity(serialNumber, serialNumber, path, path);
     this.protocolV2ExpectedSerialNumber = serialNumber;
+    this.protocolV2ExpectedPath = path;
   }
 
   private async verifyProtocolV2ReconnectIdentity() {
@@ -643,9 +653,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private hasExplicitProtocolV2Payload(fwBinaryMap: ProtocolV2TargetBinary[]) {
     return (
-      !!this.params.resourceBundleFiles?.length ||
+      !!this.params.resourceFiles?.length ||
       !!this.params.bootloaderBinary ||
-      !!this.params.bootResourcesBinary ||
       fwBinaryMap.length > 0
     );
   }
@@ -795,68 +804,68 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     };
   }
 
-  private validateProtocolV2BootResourcesBinary(
-    binary: ArrayBuffer,
-    resource?: IProtocolV2BootResources
-  ) {
-    if (resource && !isProtocolV2ResourceFileValid(binary, resource)) {
-      throw new Error('Pro2 boot resources file verification failed');
-    }
-    const header = parseProtocolV2OkppHeader(toProtocolV2Bytes(binary));
-    if (!header || header.type !== 'CRAT') {
-      throw new Error('Invalid Pro2 boot resources CRATE header');
-    }
-    if (resource) {
-      const expectedPayloadHash = normalizeProtocolV2Hex(resource.payloadHash);
-      const expectedHeaderHash = normalizeProtocolV2Hex(resource.headerHash);
-      if (header.payloadHash !== expectedPayloadHash) {
-        throw new Error('Pro2 boot resources payload hash mismatch');
-      }
-      if (header.headerHash !== expectedHeaderHash) {
-        throw new Error('Pro2 boot resources header hash mismatch');
-      }
-    }
+  private getProtocolV2DeviceType(): EDeviceType.Pro2 | EDeviceType.Neo {
+    const deviceType = this.device.getCurrentDeviceType();
+    if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) return deviceType;
+    throw new Error(`Unsupported Protocol V2 device type: ${deviceType}`);
   }
 
-  private async prepareProtocolV2BootResources(): Promise<ProtocolV2InstallItem | undefined> {
-    let binary = this.params.bootResourcesBinary;
-    let resource: IProtocolV2BootResources | undefined;
-
-    if (!binary) {
-      if (!this.params.targetsToUpdate?.includes('boot_resources')) {
-        return undefined;
-      }
-      resource = DataManager.getProtocolV2BootResources();
-      if (!resource) {
-        throw new Error('Missing Pro2 boot resources configuration');
+  private async prepareProtocolV2BootResources(): Promise<
+    ProtocolV2ResourceBundleBinary[] | undefined
+  > {
+    if (!this.params.targetsToUpdate?.includes('boot_resources')) return undefined;
+    const resource = DataManager.getProtocolV2BootResources(this.getProtocolV2DeviceType());
+    if (!resource) throw new Error('Missing Protocol V2 boot resources configuration');
+
+    const files: ProtocolV2ResourceBundleBinary[] = [];
+    for (const file of resource.files) {
+      Log.log(`[FirmwareUpdateV4] downloading boot resource ${file.devicePath}`);
+      const { binary } = await getSysResourceBinary(file.url);
+      if (!isProtocolV2ResourceFileValid(binary, file)) {
+        throw new Error(`Boot resource file verification failed: ${file.devicePath}`);
       }
-      Log.log('[FirmwareUpdateV4] downloading Pro2 boot resources CRATE');
-      ({ binary } = await getSysResourceBinary(resource.url));
+      files.push({
+        name: file.name ?? file.devicePath.split('/').pop() ?? file.devicePath,
+        binary,
+        devicePath: file.devicePath,
+      });
     }
-
-    this.validateProtocolV2BootResourcesBinary(binary, resource);
-    return {
-      fileName: PROTOCOL_V2_BOOT_RESOURCES_FILE_NAME,
-      binary,
-      targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
-      kind: 'boot_resources',
-    };
+    return files;
   }
 
-  private prepareExplicitProtocolV2ResourceBundles(): ProtocolV2ResourceBundleBinary[] | undefined {
-    if (!this.params.resourceBundleFiles?.length) return undefined;
+  private prepareExplicitProtocolV2ResourceFiles(): ProtocolV2ResourceBundleBinary[] | undefined {
+    const files = this.params.resourceFiles ?? [];
+    if (!files?.length) return undefined;
 
-    return this.params.resourceBundleFiles.map((file, index) => {
+    const prepared = files.map((file, index) => {
       const devicePath = validateProtocolV2FilesystemPath(
         file.devicePath,
-        `resourceBundleFiles[${index}].devicePath`
+        `resourceFiles[${index}].devicePath`
       );
+      const descriptor = file as typeof file &
+        Pick<Partial<IProtocolV2ResourceFile>, 'size' | 'fileHash'>;
+      if (descriptor.size !== undefined && descriptor.size !== file.binary.byteLength) {
+        throw new Error(`resourceFiles[${index}] size mismatch`);
+      }
+      if (
+        descriptor.fileHash &&
+        !isProtocolV2ResourceFileValid(file.binary, {
+          size: file.binary.byteLength,
+          fileHash: descriptor.fileHash,
+        })
+      ) {
+        throw new Error(`resourceFiles[${index}] SHA-256 mismatch`);
+      }
       return {
         name: devicePath.split('/').pop() ?? devicePath,
         binary: file.binary,
         devicePath,
       };
     });
+    if (new Set(prepared.map(file => file.devicePath)).size !== prepared.length) {
+      throw new Error('resourceFiles contain duplicate devicePath values');
+    }
+    return prepared;
   }
 
   private async prepareProtocolV2ResourceBundles(): Promise<
@@ -866,7 +875,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       return undefined;
     }
 
-    const resources = DataManager.getProtocolV2Resources();
+    const resources = DataManager.getProtocolV2Resources(this.getProtocolV2DeviceType());
     if (!resources?.length) {
       throw new Error('Missing Pro2 stable resource configuration');
     }
@@ -886,7 +895,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       forced: this.params.forcedUpdateRes,
     });
     Log.log(
-      `[FirmwareUpdateV4] Pro2 resource plan mode=bootloader-recovery status=${plan.status} count=${plan.resources.length}`
+      `[FirmwareUpdateV4] Protocol V2 resource plan mode=bootloader-recovery status=${plan.status} count=${plan.resources.length}`
     );
 
     const bundles: ProtocolV2ResourceBundleBinary[] = [];
@@ -926,7 +935,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     let processedSize = 0;
     for (const bundle of bundles) {
       Log.log(
-        `[FirmwareUpdateV4] syncing RESC bundle ${bundle.name} -> ${bundle.devicePath} bytes=${bundle.binary.byteLength}`
+        `[FirmwareUpdateV4] syncing resource ${bundle.name} -> ${bundle.devicePath} bytes=${bundle.binary.byteLength}`
       );
       processedSize = await this.protocolV2CommonUpdateProcess({
         payload: bundle.binary,
@@ -938,7 +947,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     const elapsedMs = Date.now() - transferStartTime;
     Log.log(
-      `[FirmwareUpdateV4] RESC bundle sync finished transport=${transferTransport} bytes=${totalSize} elapsed=${(
+      `[FirmwareUpdateV4] resource sync finished transport=${transferTransport} bytes=${totalSize} elapsed=${(
         elapsedMs / 1000
       ).toFixed(2)}s speed=${formatProtocolV2TransferSpeed(totalSize, elapsedMs)} KB/s`
     );
@@ -956,7 +965,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   private isProtocolV2RomloaderMode() {
-    if (!this.device.isProtocolV2() || this.device.getCurrentDeviceType() !== EDeviceType.Pro2) {
+    const deviceType = this.device.getCurrentDeviceType();
+    if (
+      !this.device.isProtocolV2() ||
+      (deviceType !== EDeviceType.Pro2 && deviceType !== EDeviceType.Neo)
+    ) {
       return false;
     }
     if (typeof this.device.isRomloader === 'function') {
@@ -974,15 +987,16 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
     if (this.isProtocolV2BootloaderMode()) {
       Log.debug('Protocol V2 device is already in bootloader mode, skip reboot');
+      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
       return false;
     }
 
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.AutoRebootToBootloader);
       await this.protocolV2Reboot(DeviceRebootType.Bootloader);
-      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
       await wait(1000);
       await this.waitForProtocolV2BootloaderMode();
+      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
       return true;
     } catch (error) {
       if (error instanceof HardwareError) {
@@ -1111,9 +1125,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       totalSize = resourceTransfer.totalSize;
     }
 
-    // Skip staging and installation when the update contains RESC bundles only.
+    // Skip staging and installation when the update contains resource files only.
     if (orderedInstallItems.length === 0) {
-      Log.log('[FirmwareUpdateV4] no firmware targets to install (RESC bundles only)');
+      Log.log('[FirmwareUpdateV4] no firmware targets to install (resource files only)');
       if (totalSize > 0) {
         this.postProgressMessage(100, 'transferData');
       }
@@ -1536,9 +1550,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
       devicesDescriptor.length === 1
     ) {
+      const descriptor = devicesDescriptor[0];
+      if (!this.protocolV2ExpectedSerialNumber && descriptor.path !== this.protocolV2ExpectedPath) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
+      }
       this.device.updateDescriptor(
         {
-          ...devicesDescriptor[0],
+          ...descriptor,
           protocolType: PROTOCOL_V2_CONNECT_PROTOCOL,
         },
         true
@@ -1555,18 +1573,14 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       connectProtocol: PROTOCOL_V2_CONNECT_PROTOCOL,
     });
     const expectedSerialNumber = this.protocolV2ExpectedSerialNumber?.trim();
-    const identityMatch = expectedSerialNumber
-      ? deviceList.find(
-          candidate => candidate.getCurrentSerialNo?.().trim() === expectedSerialNumber
-        )
-      : undefined;
-    const singleCandidate = deviceList.length === 1 ? deviceList.at(0) : undefined;
-    const singleCandidateSerialNumber = singleCandidate?.getCurrentSerialNo?.().trim();
-    const reconnectDevice =
-      identityMatch ??
-      (singleCandidate && (!expectedSerialNumber || !singleCandidateSerialNumber)
-        ? singleCandidate
-        : undefined);
+    const expectedPath = this.protocolV2ExpectedPath?.trim();
+    const reconnectDevice = deviceList.find(candidate => {
+      const candidateSerialNumber = candidate.getCurrentSerialNo?.().trim();
+      if (expectedSerialNumber && candidateSerialNumber) {
+        return candidateSerialNumber === expectedSerialNumber;
+      }
+      return !!expectedPath && candidate.getConnectId() === expectedPath;
+    });
     if (!reconnectDevice) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
     }
@@ -1631,7 +1645,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     onTransferredBytes,
   }: ProtocolV2FileTransferParams) {
     const chunkSize = this.getProtocolV2FirmwareChunkSize();
-    let offset = 0;
     const getUploadProgress = (fileOffset: number) => {
       if (totalSize !== undefined && processedSize !== undefined) {
         return Math.min(Math.ceil(((processedSize + fileOffset) / totalSize) * 100), 99);
@@ -1639,37 +1652,43 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       return Math.min(Math.ceil((fileOffset / payload.byteLength) * 100), 99);
     };
 
-    while (offset < payload.byteLength) {
-      const chunkEnd = Math.min(offset + chunkSize, payload.byteLength);
-      const chunkLength = chunkEnd - offset;
-      const chunk = payload.slice(offset, chunkEnd);
-      const overwrite = offset === 0;
-      const progress = getProtocolV2DeviceTransferProgress(
-        (processedSize ?? 0) + offset,
-        (processedSize ?? 0) + chunkEnd,
-        totalSize ?? payload.byteLength
-      );
-
-      const writeRes = await this.fileWriteChunk(
-        filePath,
-        payload.byteLength,
-        offset,
-        chunk,
-        overwrite,
-        progress
-      );
-      const rawProcessedByte = writeRes.message.processed_byte;
-      const processedByte = Number(rawProcessedByte);
-      const nextOffset = rawProcessedByte === undefined ? offset + chunkLength : processedByte;
-      if (!Number.isFinite(nextOffset) || nextOffset <= offset || nextOffset > chunkEnd) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.EmmcFileWriteFirmwareError,
-          `invalid processed_byte ${writeRes.message.processed_byte} for offset ${offset}`
-        );
+    try {
+      await writeProtocolV2File({
+        commands: this.device.getCommands(),
+        path: filePath,
+        data: payload,
+        totalSize: payload.byteLength,
+        chunkSize,
+        overwrite: true,
+        append: false,
+        writeWithResponse: true,
+        maxChunkRetries: 0,
+        getUiPercentage: ({ offset, chunkLength }) =>
+          getProtocolV2DeviceTransferProgress(
+            (processedSize ?? 0) + offset,
+            (processedSize ?? 0) + offset + chunkLength,
+            totalSize ?? payload.byteLength
+          ),
+        onProgress: progress => {
+          const transferredBytes = (processedSize ?? 0) + progress.transferredBytes;
+          onTransferredBytes?.(transferredBytes);
+          this.postProgressMessage(getUploadProgress(progress.transferredBytes), 'transferData', {
+            transferredBytes,
+            totalBytes: totalSize ?? payload.byteLength,
+            rateBytesPerSecond: progress.rateBytesPerSecond,
+            elapsedMs: progress.elapsedMs,
+          });
+        },
+      });
+    } catch (error) {
+      if (
+        error instanceof HardwareError &&
+        error.errorCode === HardwareErrorCode.RuntimeError &&
+        error.message.includes('FilesystemFileWrite')
+      ) {
+        throw ERRORS.TypedError(HardwareErrorCode.EmmcFileWriteFirmwareError, error.message);
       }
-      offset = nextOffset;
-      onTransferredBytes?.((processedSize ?? 0) + offset);
-      this.postProgressMessage(getUploadProgress(offset), 'transferData');
+      throw error;
     }
 
     return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
@@ -1689,42 +1708,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return env ?? 'unknown';
   }
 
-  private async fileWriteChunk(
-    filePath: string,
-    totalFileSize: number,
-    offset: number,
-    chunk: ArrayBuffer | Buffer,
-    overwrite: boolean,
-    progress: number | null
-  ): Promise<TypedResponseMessage<'FilesystemFile'>> {
-    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    const writeRes = await typedCall(
-      'FilesystemFileWrite',
-      'FilesystemFile',
-      {
-        file: {
-          path: filePath,
-          offset,
-          total_size: totalFileSize,
-          data: chunk,
-        },
-        overwrite,
-        append: false,
-        ui_percentage: progress ?? undefined,
-      },
-      { writeWithResponse: true }
-    );
-    if (writeRes.type !== 'FilesystemFile') {
-      if ((writeRes as any).type === 'CallMethodError') {
-        if (((writeRes as any).message.error ?? '').indexOf(SESSION_ERROR) > -1) {
-          throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, SESSION_ERROR);
-        }
-      }
-      throw ERRORS.TypedError(HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
-    }
-    return writeRes;
-  }
-
   private async recoverProtocolV2FileTransfer() {
     const env = DataManager.getSettings('env');
     if (DataManager.isBleConnect(env)) {

package/src/api/OpenWalletSession.ts

@@ -84,6 +84,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
   init() {
     this.useDevicePassphraseState = false;
+    this.unlockPolicy = 'unlock-before-run';
     this.skipForceUpdateCheck = true;
     this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
     this.payload.useEmptyPassphrase = this.params.mode === OpenWalletSessionMode.Standard;

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -393,12 +393,14 @@ 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');
           const shouldResumeWalletSession = useEmptyPassphrase || !!this.payload.passphraseState;
           if (this.device.isProtocolV2() && shouldResumeWalletSession) {
             const passphraseStateSafety = await this.device.checkPassphraseStateSafety(
               this.payload.passphraseState,
               useEmptyPassphrase,
-              this.payload.skipPassphraseCheck
+              this.payload.skipPassphraseCheck,
+              deriveCardano
             );
             if (!passphraseStateSafety) {
               throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);

package/src/api/device/DeviceSettings.ts

@@ -7,7 +7,6 @@ import { validateParams } from '../helpers/paramsValidator';
 import {
   mapApplySettingsToState,
   mapCommonSettingsToProtocolV2,
-  mapDeviceSettingsToState,
 } from '../../device/DeviceStateMapper';
 import { getProtocolV2SettingsBehavior } from '../../protocols/protocol-v2/settingsUnlockPolicy';
 import {
@@ -163,6 +162,8 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
   async run() {
     try {
       if (this.device.isProtocolV2()) {
+        const refreshStatusAndSettings = () =>
+          this.device.getDeviceState({ refreshSections: ['status', 'settings'] });
         assertSettingsSupported(this.payload, DEVICE_SETTINGS_V1_ONLY_FIELDS, 'Protocol V2');
         const capabilities = getDeviceSettingsCapabilities(
           this.device.getCurrentDeviceType(),
@@ -194,7 +195,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
           const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
             page: DeviceSettingsPage.DevicePassphrase,
           });
-          const updated = await this.device.getDeviceState({ refreshSections: ['status'] });
+          const updated = await refreshStatusAndSettings();
           const lockedAfterDisabling =
             requestedPassphrase === false &&
             current.status.unlocked === true &&
@@ -219,7 +220,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
           const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
             page: DeviceSettingsPage.DeviceAirgap,
           });
-          const updated = await this.device.getDeviceState({ refreshSections: ['settings'] });
+          const updated = await refreshStatusAndSettings();
           if (updated.settings.airgapMode !== requestedAirgap) {
             throw TypedError(
               HardwareErrorCode.RuntimeError,
@@ -235,7 +236,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
         const res = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
           settings,
         });
-        this.device.updateState(mapDeviceSettingsToState(settings), 'settings-write');
+        await refreshStatusAndSettings();
         return res.message;
       }
 

package/src/api/device/DeviceVerify.ts

@@ -6,7 +6,6 @@ import { formatAnyHex } from '../helpers/hexUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 import { DeviceModelToTypes } from '../../types';
-import { UI_REQUEST } from '../../events';
 
 import type { BixinVerifyDeviceRequest } from '@onekeyfe/hd-transport';
 import type { DeviceVerifySignature } from '../../types';
@@ -14,7 +13,6 @@ import type { DeviceVerifySignature } from '../../types';
 export default class DeviceVerify extends BaseMethod<BixinVerifyDeviceRequest> {
   init() {
     this.useDevicePassphraseState = false;
-    this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
 
     // check payload
     validateParams(this.payload, [{ name: 'dataHex', type: 'hexString' }]);