@onekeyfe/hd-core 1.2.0-alpha.56 → 1.2.0-alpha.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.0-alpha.56",
+  "version": "1.2.0-alpha.58",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.0-alpha.56",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.56",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.58",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.58",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "bytebuffer": "^5.0.1",
@@ -44,5 +44,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "2c472748d67072307c21f8d33bc021cf18fe2ad7"
+  "gitHead": "43c11efeb7001741d4258c855b287993bc0a798e"
 }

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,
@@ -53,7 +54,6 @@ import type {
 
 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;
@@ -974,15 +974,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) {
@@ -1631,7 +1632,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 +1639,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 +1695,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/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/firmware/FirmwareUpdateBaseMethod.ts

@@ -15,6 +15,7 @@ import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
 
 import type {
+  FirmwareProgress,
   IFirmwareUpdateProgressType,
   IFirmwareUpdateTipMessage,
 } from '../../events/ui-request';
@@ -28,6 +29,11 @@ const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
 
+type FirmwareTransferMetrics = Pick<
+  FirmwareProgress['payload'],
+  'transferredBytes' | 'totalBytes' | 'rateBytesPerSecond' | 'elapsedMs'
+>;
+
 const isDeviceDisconnectedError = (error: unknown) => {
   const message = error instanceof Error ? error.message : String(error ?? '');
   return (
@@ -82,12 +88,17 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
    * @description Post the progress message
    * @param progress Post the percentage of the progress
    */
-  postProgressMessage = (progress: number, progressType: IFirmwareUpdateProgressType) => {
+  postProgressMessage = (
+    progress: number,
+    progressType: IFirmwareUpdateProgressType,
+    metrics?: FirmwareTransferMetrics
+  ) => {
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
         device: this.device.toMessageObject() as KnownDevice,
         progress,
         progressType,
+        ...metrics,
       })
     );
   };

package/src/api/helpers/protocolV2FileWrite.ts

@@ -5,9 +5,12 @@ import {
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { DataManager } from '../../data-manager';
+import { LoggerNames, getLogger } from '../../utils/logger';
 
 import type { DeviceCommands } from '../../device/DeviceCommands';
 
+const Log = getLogger(LoggerNames.Method);
+
 export type ProtocolV2FileWriteData = ArrayBuffer | Uint8Array | Blob | string;
 
 export type ProtocolV2FileWriteProgress = {
@@ -18,6 +21,12 @@ export type ProtocolV2FileWriteProgress = {
   elapsedMs: number;
 };
 
+export type ProtocolV2FileWriteChunkContext = {
+  offset: number;
+  chunkLength: number;
+  totalSize: number;
+};
+
 export type ProtocolV2FileWriteOptions = {
   commands: Pick<DeviceCommands, 'typedCall'>;
   path: string;
@@ -30,14 +39,54 @@ export type ProtocolV2FileWriteOptions = {
   append?: boolean;
   uiPercentage?: number;
   timeoutMs?: number;
+  writeWithResponse?: boolean;
   maxChunkRetries?: number;
   paceMs?: number;
   throwIfAborted?: () => void;
+  getUiPercentage?: (context: ProtocolV2FileWriteChunkContext) => number | undefined;
   onProgress?: (progress: ProtocolV2FileWriteProgress) => void;
 };
 
 const MIN_FILE_CHUNK_SIZE = 64;
 const FILE_TRANSFER_RATE_WINDOW_MS = 1000;
+const FILE_TRANSFER_LOG_INTERVAL_MS = 10_000;
+const SESSION_ERROR = 'session not found';
+
+function formatFileTransferRate(bytesPerSecond: number) {
+  return (Math.max(bytesPerSecond, 0) / 1024).toFixed(2);
+}
+
+function getAverageFileTransferRate(transferredBytes: number, elapsedMs: number) {
+  if (elapsedMs <= 0) return 0;
+  return Math.round((Math.max(transferredBytes, 0) / elapsedMs) * 1000);
+}
+
+function getFileTransferTransport() {
+  const env = DataManager.getSettings('env');
+  return env && DataManager.isBleConnect(env) ? 'BLE' : String(env ?? 'unknown');
+}
+
+function logFileTransferMetrics({
+  transport,
+  status,
+  transferredBytes,
+  totalBytes,
+  elapsedMs,
+  rateBytesPerSecond,
+}: {
+  transport: string;
+  status: 'progress' | 'completed' | 'failed';
+  transferredBytes: number;
+  totalBytes: number;
+  elapsedMs: number;
+  rateBytesPerSecond: number;
+}) {
+  Log.log(
+    `[FileWrite] metrics transport=${transport} status=${status} bytes=${transferredBytes}/${totalBytes} elapsed=${(
+      elapsedMs / 1000
+    ).toFixed(2)}s speed=${formatFileTransferRate(rateBytesPerSecond)} KiB/s`
+  );
+}
 
 export function isProtocolV2ResponseTimeout(error: unknown) {
   if (!error || typeof error !== 'object') return false;
@@ -125,89 +174,159 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
   let rateWindowStartedAt = startTime;
   let rateWindowStartedBytes = 0;
   let rateBytesPerSecond: number | undefined;
+  let lastConfirmedAt = startTime;
+  let logWindowStartedAt = startTime;
+  let logWindowStartedBytes = 0;
+  const transport = getFileTransferTransport();
 
-  while (written < dataLength) {
-    options.throwIfAborted?.();
-    const chunk = data.slice(written, Math.min(written + chunkSize, dataLength));
-    const offset = startOffset + written;
-    const progress =
-      options.uiPercentage ??
-      getDeviceTransferProgress(offset, offset + chunk.byteLength, totalSize);
-    const request = {
-      file: { path: options.path, offset, total_size: totalSize, data: chunk },
-      overwrite: chunks === 0 ? options.overwrite ?? false : false,
-      append: options.append ?? false,
-      ui_percentage: progress,
-    };
-    const maxChunkRetries = Math.max(Math.floor(options.maxChunkRetries ?? 0), 0);
-    let retryCount = 0;
-    let response;
-    let isWritePending = true;
-    while (isWritePending) {
-      try {
-        response = await options.commands.typedCall(
-          'FilesystemFileWrite',
-          'FilesystemFile',
-          request,
-          { timeoutMs: options.timeoutMs }
+  try {
+    while (written < dataLength) {
+      options.throwIfAborted?.();
+      const chunk = data.slice(written, Math.min(written + chunkSize, dataLength));
+      const offset = startOffset + written;
+      const progress =
+        options.uiPercentage ??
+        options.getUiPercentage?.({
+          offset,
+          chunkLength: chunk.byteLength,
+          totalSize,
+        }) ??
+        getDeviceTransferProgress(offset, offset + chunk.byteLength, totalSize);
+      const request = {
+        file: { path: options.path, offset, total_size: totalSize, data: chunk },
+        overwrite: chunks === 0 ? options.overwrite ?? false : false,
+        append: options.append ?? false,
+        ui_percentage: progress,
+      };
+      const maxChunkRetries = Math.max(Math.floor(options.maxChunkRetries ?? 0), 0);
+      let retryCount = 0;
+      let response;
+      let isWritePending = true;
+      while (isWritePending) {
+        try {
+          const callOptions =
+            options.writeWithResponse === undefined
+              ? { timeoutMs: options.timeoutMs }
+              : {
+                  ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                  writeWithResponse: options.writeWithResponse,
+                };
+          response = await options.commands.typedCall(
+            'FilesystemFileWrite',
+            'FilesystemFile',
+            request,
+            callOptions
+          );
+          isWritePending = false;
+        } catch (error) {
+          if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error)) throw error;
+          retryCount += 1;
+          options.throwIfAborted?.();
+        }
+      }
+      if (!response) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'FilesystemFileWrite completed without a response'
         );
-        isWritePending = false;
-      } catch (error) {
-        if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error)) throw error;
-        retryCount += 1;
-        options.throwIfAborted?.();
+      }
+      const responseType = (response as { type?: string }).type;
+      if (responseType && responseType !== 'FilesystemFile') {
+        const responseError = (response as { message?: { error?: unknown } }).message?.error;
+        if (typeof responseError === 'string' && responseError.includes(SESSION_ERROR)) {
+          throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, SESSION_ERROR);
+        }
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `FilesystemFileWrite received unexpected response ${responseType}`
+        );
+      }
+      options.throwIfAborted?.();
+      lastMessage = response.message;
+      const rawProcessedByte = response.message?.processed_byte;
+      const processedByte = Number(rawProcessedByte);
+      if (
+        rawProcessedByte !== undefined &&
+        (!Number.isFinite(processedByte) ||
+          processedByte <= offset ||
+          processedByte > offset + chunk.byteLength)
+      ) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `FilesystemFileWrite invalid processed_byte ${processedByte}`
+        );
+      }
+      written =
+        rawProcessedByte === undefined ? written + chunk.byteLength : processedByte - startOffset;
+      chunks += 1;
+      const now = Date.now();
+      lastConfirmedAt = now;
+      const elapsedMs = now - startTime;
+      const transferredBytes = Math.min(written, dataLength);
+      const rateWindowElapsedMs = now - rateWindowStartedAt;
+      if (rateWindowElapsedMs >= FILE_TRANSFER_RATE_WINDOW_MS) {
+        const rateWindowBytes = Math.max(transferredBytes - rateWindowStartedBytes, 0);
+        rateBytesPerSecond = Math.round((rateWindowBytes / rateWindowElapsedMs) * 1000);
+        rateWindowStartedAt = now;
+        rateWindowStartedBytes = transferredBytes;
+      } else if (rateBytesPerSecond === undefined && elapsedMs > 0) {
+        rateBytesPerSecond = Math.round((transferredBytes / elapsedMs) * 1000);
+      }
+      options.onProgress?.({
+        progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
+        transferredBytes,
+        totalBytes: dataLength,
+        rateBytesPerSecond,
+        elapsedMs,
+      });
+      const logWindowElapsedMs = now - logWindowStartedAt;
+      if (logWindowElapsedMs >= FILE_TRANSFER_LOG_INTERVAL_MS && transferredBytes < dataLength) {
+        const logWindowBytes = Math.max(transferredBytes - logWindowStartedBytes, 0);
+        logFileTransferMetrics({
+          transport,
+          status: 'progress',
+          transferredBytes,
+          totalBytes: dataLength,
+          elapsedMs,
+          rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+        });
+        logWindowStartedAt = now;
+        logWindowStartedBytes = transferredBytes;
+      }
+      if (options.paceMs && options.paceMs > 0) {
+        await new Promise(resolve => {
+          setTimeout(resolve, options.paceMs);
+        });
       }
     }
-    if (!response) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'FilesystemFileWrite completed without a response'
-      );
-    }
-    options.throwIfAborted?.();
-    lastMessage = response.message;
-    const rawProcessedByte = response.message?.processed_byte;
-    const processedByte = Number(rawProcessedByte);
-    if (
-      rawProcessedByte !== undefined &&
-      (!Number.isFinite(processedByte) ||
-        processedByte <= offset ||
-        processedByte > offset + chunk.byteLength)
-    ) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `FilesystemFileWrite invalid processed_byte ${processedByte}`
-      );
-    }
-    written =
-      rawProcessedByte === undefined ? written + chunk.byteLength : processedByte - startOffset;
-    chunks += 1;
+  } catch (error) {
     const now = Date.now();
-    const elapsedMs = now - startTime;
-    const transferredBytes = Math.min(written, dataLength);
-    const rateWindowElapsedMs = now - rateWindowStartedAt;
-    if (rateWindowElapsedMs >= FILE_TRANSFER_RATE_WINDOW_MS) {
-      const rateWindowBytes = Math.max(transferredBytes - rateWindowStartedBytes, 0);
-      rateBytesPerSecond = Math.round((rateWindowBytes / rateWindowElapsedMs) * 1000);
-      rateWindowStartedAt = now;
-      rateWindowStartedBytes = transferredBytes;
-    } else if (rateBytesPerSecond === undefined && elapsedMs > 0) {
-      rateBytesPerSecond = Math.round((transferredBytes / elapsedMs) * 1000);
-    }
-    options.onProgress?.({
-      progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
-      transferredBytes,
+    const elapsedMs = Math.max(now - startTime, 0);
+    const logWindowElapsedMs = Math.max(now - logWindowStartedAt, 0);
+    const logWindowBytes = Math.max(written - logWindowStartedBytes, 0);
+    logFileTransferMetrics({
+      transport,
+      status: 'failed',
+      transferredBytes: written,
       totalBytes: dataLength,
-      rateBytesPerSecond,
       elapsedMs,
+      rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
     });
-    if (options.paceMs && options.paceMs > 0) {
-      await new Promise(resolve => {
-        setTimeout(resolve, options.paceMs);
-      });
-    }
+    throw error;
   }
 
+  const elapsedMs = Math.max(lastConfirmedAt - startTime, 0);
+  const logWindowElapsedMs = Math.max(lastConfirmedAt - logWindowStartedAt, 0);
+  const logWindowBytes = Math.max(written - logWindowStartedBytes, 0);
+  logFileTransferMetrics({
+    transport,
+    status: 'completed',
+    transferredBytes: written,
+    totalBytes: dataLength,
+    elapsedMs,
+    rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+  });
+
   return {
     ...lastMessage,
     path: options.path,

package/src/core/index.ts

@@ -652,6 +652,12 @@ const onCallDevice = async (
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
       } catch (error) {
+        // Device.run may release the request before transport callbacks finish after a timeout.
+        // Ignore the stale callback because the caller already received the connection error.
+        if (!requestQueue.getTask(method.responseID)) {
+          Log.debug(`Call API - Ignore late inner method result`, error);
+          return;
+        }
         Log.debug(`Call API - Inner Method Run Error`, error);
         messageResponse = createResponseMessage(method.responseID, false, { error });
         requestQueue.resolveRequest(method.responseID, messageResponse);
@@ -1647,12 +1653,8 @@ export const init = async (
   plugin?: LowlevelTransportSharedPlugin
 ) => {
   try {
-    try {
-      await DataManager.load(settings);
-      initTransport(Transport, plugin);
-    } catch {
-      Log.error('DataManager.load error');
-    }
+    await DataManager.load(settings);
+    initTransport(Transport, plugin);
     enableLog(DataManager.getSettings('debug'));
     if (DataManager.getSettings('env') !== 'react-native') {
       setLoggerPostMessage(postMessage);
@@ -1663,6 +1665,7 @@ export const init = async (
     return _core;
   } catch (error) {
     Log.error('core init', error);
+    throw error;
   }
 };