@onekeyfe/hd-core 1.2.0-alpha.74 → 1.2.0-alpha.75

package/src/api/device/DeviceUpdateBootloader.ts

@@ -5,24 +5,15 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { FirmwareUpdateTipMessage } from '../../events/ui-request';
 import { FirmwareUpdateBaseMethod } from '../firmware/FirmwareUpdateBaseMethod';
 import { getSysResourceBinary } from '../firmware/getBinary';
-import { updateBootloader, updateBootloaderFromSource } from '../firmware/uploadFirmware';
+import { updateBootloader } from '../firmware/uploadFirmware';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
-import { checkBootloaderLength, checkBootloaderSourceLength } from '../firmware/updateBootloader';
-import { openFirmwareByteSource } from '../firmware/FirmwareArtifactSource';
-import { resolveFirmwareUpdateHostBinding } from '../firmware/FirmwareHostBinding';
-import {
-  assertFirmwareUpdatePreparedPlanBinding,
-  assertFirmwareUpdatePreparedPlanDeviceIdentity,
-} from '../firmware/FirmwareUpdatePreparedPlan';
-import { getDeviceType, getDeviceUUID } from '../../utils';
-import { resolveDeviceBootloaderMode } from '../../utils/deviceFeaturesCompat';
+import { checkBootloaderLength } from '../firmware/updateBootloader';
 
 import type { DeviceUpdateBootloaderParams } from '../../types/api/deviceUpdateBootloader';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Device } from '../../device/Device';
 import type { Features } from '../../types';
-import type { FirmwareByteSource } from '../firmware/FirmwareArtifactSource';
 
 export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any> {
   init() {
@@ -52,68 +43,17 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     return true;
   }
 
-  async updateBootloaderWithEmmcFileWriteFromSource(_device: Device, source: FirmwareByteSource) {
-    const filePath = '0:boot/bootloader.bin';
-
-    this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
-    await this.emmcCommonUpdateProcessFromSource({
-      source,
-      filePath,
-    });
-    this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
-    await this.reboot(RebootType.Normal);
-    this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloaderSuccess);
-    return true;
-  }
-
   async updateTouchBootloader({
     device,
     features,
     firmwareType,
-    binary: preparedBinary,
-    source: preparedSource,
   }: {
     device: Device;
     features?: Features;
     firmwareType: EFirmwareType;
-    binary?: ArrayBuffer;
-    source?: FirmwareByteSource;
   }) {
-    if (preparedSource) {
-      if (!(await checkBootloaderSourceLength(preparedSource))) {
-        throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
-      }
-      if (features && device.isBootloader()) {
-        this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-        const result = await this.updateBootloaderWithEmmcFileWriteFromSource(
-          device,
-          preparedSource
-        );
-        return result;
-      }
-      if (features && !device.isBootloader()) {
-        await updateBootloaderFromSource(
-          this.device.getCommands().typedCall.bind(this.device.getCommands()),
-          this.postMessage,
-          device,
-          preparedSource
-        );
-        return true;
-      }
-    }
-
-    let binary = preparedBinary;
+    let { binary } = this.payload;
     if (!binary) {
-      if (DataManager.getSettings('firmwareManifestMode') === 'external-only') {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Bootloader must be prepared by the external firmware host',
-          {
-            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-            artifactName: 'bootloader',
-          }
-        );
-      }
       this.postTipMessage(FirmwareUpdateTipMessage.CheckLatestUiResource);
       const resourceUrl = features
         ? DataManager.getBootloaderResource(features, firmwareType)
@@ -128,7 +68,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
       }
     }
 
-    if (!binary || !checkBootloaderLength(binary)) {
+    if (!checkBootloaderLength(binary)) {
       throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
     }
 
@@ -136,8 +76,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     if (features && device.isBootloader()) {
       // Use emmcFileWrite + reboot logic for bootloader mode
       this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-      const result = await this.updateBootloaderWithEmmcFileWrite(device, binary);
-      return result;
+      return this.updateBootloaderWithEmmcFileWrite(device, binary);
     }
 
     if (features && !device.isBootloader()) {
@@ -157,71 +96,13 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     const { features } = device;
 
     const payload = this.payload as DeviceUpdateBootloaderParams;
-    const hostBinding = payload.artifact
-      ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
-      : undefined;
-    const executionParams = {
-      ...payload,
-      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
-    };
-    if (payload.artifact) {
-      assertFirmwareUpdatePreparedPlanDeviceIdentity({
-        preparedPlan: payload.preparedPlan,
-        deviceIdentity: getDeviceUUID(features) || undefined,
-        bootloaderMode: resolveDeviceBootloaderMode(features),
-        deviceModel: String(getDeviceType(features)),
-      });
-      assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan: payload.preparedPlan,
-        executor: 'v2',
-        scopeTargets: ['bootloader'],
-        bindings: [
-          {
-            target: 'bootloader',
-            artifact: payload.artifact,
-          },
-        ],
-      });
-      const source = await openFirmwareByteSource({
-        artifact: payload.artifact,
-        reader: executionParams.artifactReader,
-      });
-      if (!source) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Bootloader artifact is not prepared'
-        );
-      }
-      try {
-        const deviceType = device.getCurrentDeviceType();
-        const deviceFirmwareType = device.getCurrentFirmwareType();
-        const firmwareType = payload.firmwareType ?? deviceFirmwareType;
-        if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-          return await this.updateTouchBootloader({
-            device,
-            features,
-            firmwareType,
-            source,
-          });
-        }
-        return true;
-      } finally {
-        await source.close().catch(() => undefined);
-      }
-    }
 
-    const { binary } = payload;
     const deviceType = device.getCurrentDeviceType();
     const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-      return this.updateTouchBootloader({
-        device,
-        features,
-        firmwareType,
-        binary,
-      });
+      return this.updateTouchBootloader({ device, features, firmwareType });
     }
 
     return Promise.resolve(true);

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -13,7 +13,6 @@ import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
 import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
-import { writeFirmwareByteSource } from './FirmwareArtifactSource';
 
 import type {
   FirmwareProgress,
@@ -25,22 +24,11 @@ import type { RebootType } from '@onekeyfe/hd-transport';
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { KnownDevice } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
 
-/**
- * Response timeout for each Initialize probe while polling a rebooting device over BLE.
- * Overlap safety comes from the poll's in-flight guard, not from this value. Keep it
- * well below the 30s reboot budget so several attempts fit: a probe written into the
- * dying pre-reboot connection is never answered, and its timeout tears that stale link
- * down so the next tick reconnects fresh. Raise it only if a device model is proven to
- * answer bootloader Initialize slower than this on a fresh connection.
- */
-export const BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS = 5000;
-
 type FirmwareTransferMetrics = Pick<
   FirmwareProgress['payload'],
   'transferredBytes' | 'totalBytes' | 'rateBytesPerSecond' | 'elapsedMs'
@@ -155,10 +143,6 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     this.checkPromise = createDeferred();
     const env = DataManager.getSettings('env');
     const isBleReconnect = connectId && DataManager.isBleConnect(env);
-    // Tracks the in-flight BLE probe so interval ticks never overlap: a superseded
-    // Initialize left pending on the V1 transport is exactly what later times out
-    // and used to tear down the connection mid-firmware-upload.
-    let bleProbeInFlight = false;
 
     Log.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
 
@@ -214,8 +198,6 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
         }
 
         if (isBleReconnect) {
-          if (bleProbeInFlight) return;
-          bleProbeInFlight = true;
           try {
             await this.device.deviceConnector?.acquire(
               this.device.originalDescriptor.id,
@@ -223,10 +205,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
               true,
               this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
             );
-            // Bound each probe so a request the rebooting device never received
-            // frees the slot for the next tick instead of hanging into the
-            // 30s reboot budget.
-            await this.device.initialize({ timeoutMs: BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS });
+            await this.device.initialize();
             if (this.device.isBootloader()) {
               clearInterval(intervalTimer);
               this.checkPromise?.resolve(true);
@@ -234,8 +213,6 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
           } catch (e) {
             // ignore error because of device is not connected
             Log.log('catch Bluetooth error when device is restarting: ', e);
-          } finally {
-            bleProbeInFlight = false;
           }
         } else {
           await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
@@ -417,54 +394,6 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
   }
 
-  async emmcCommonUpdateProcessFromSource({
-    source,
-    filePath,
-    processedSize,
-    totalSize,
-  }: {
-    source: FirmwareByteSource;
-    filePath: string;
-    processedSize?: number;
-    totalSize?: number;
-  }) {
-    if (!filePath.startsWith('0:')) {
-      throw new Error('filePath must start with 0:');
-    }
-    const env = DataManager.getSettings('env');
-    const chunkSize = 1024 * (DataManager.isBleConnect(env) ? 16 : 128);
-
-    await writeFirmwareByteSource({
-      source,
-      chunkSize,
-      write: async ({ data, sourceOffset, length, first }) => {
-        const progress =
-          totalSize !== undefined && processedSize !== undefined
-            ? Math.min(Math.ceil(((processedSize + sourceOffset + length) / totalSize) * 100), 99)
-            : Math.min(Math.ceil(((sourceOffset + length) / source.size) * 100), 99);
-        const writeRes = await this.emmcFileWriteWithRetry(
-          filePath,
-          length,
-          sourceOffset,
-          data,
-          first,
-          progress
-        );
-        if (!writeRes) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.EmmcFileWriteFirmwareError,
-            'transfer data error'
-          );
-        }
-        const processedBytes = Number(writeRes.message.processed_byte);
-        this.postProgressMessage(progress, 'transferData');
-        return Number.isFinite(processedBytes) ? processedBytes : length;
-      },
-    });
-
-    return totalSize !== undefined ? (processedSize ?? 0) + source.size : 0;
-  }
-
   async emmcFileWriteWithRetry(
     filePath: string,
     chunkLength: number,

package/src/api/firmware/updateBootloader.ts

@@ -8,7 +8,6 @@ import { shouldUpdateBootloaderForClassicAndMini } from './bootloaderHelper';
 
 import type { Features } from '../../types';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 export function checkNeedUpdateBootForTouch(features: Features, firmwareType: EFirmwareType) {
   const deviceType = getDeviceType(features);
@@ -63,7 +62,8 @@ export function checkNeedUpdateBootForClassicAndMini({
 }
 
 const INIT_DATA_CHUNK_SIZE = 16 * 1024;
-const readBootloaderLength = (chunk: Uint8Array) => {
+export function checkBootloaderLength(data: ArrayBuffer) {
+  const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE, data.byteLength)));
   const buffer = ByteBuffer.wrap(chunk, undefined, undefined, true);
   buffer.LE();
   // byte 'O', 'K', 'T', 'B'
@@ -77,21 +77,6 @@ const readBootloaderLength = (chunk: Uint8Array) => {
   buffer.readUint32();
   // codelen
   const codelen = buffer.readUint32();
-  return hdrlen + codelen;
-};
-
-export function checkBootloaderLength(data: ArrayBuffer) {
-  if (data.byteLength < 16) {
-    return false;
-  }
-  const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE, data.byteLength)));
-  return readBootloaderLength(chunk) === data.byteLength;
+  const bootloaderLength = hdrlen + codelen;
+  return bootloaderLength === data.byteLength;
 }
-
-export const checkBootloaderSourceLength = async (source: FirmwareByteSource) => {
-  if (source.size < 16) {
-    return false;
-  }
-  const chunk = new Uint8Array(await source.readAt(0, Math.min(INIT_DATA_CHUNK_SIZE, source.size)));
-  return readBootloaderLength(chunk) === source.size;
-};

package/src/api/firmware/uploadFirmware.ts

@@ -10,7 +10,6 @@ import { bytesToHex } from '../helpers/hexUtils';
 import { DataManager } from '../../data-manager';
 import { DevicePool } from '../../device/DevicePool';
 import { buildProtocolV1FeaturesPayload } from '../../deviceProfile';
-import { openFirmwareByteSource, readFirmwareByteSourceFully } from './FirmwareArtifactSource';
 
 import type { KnownDevice } from '../../types';
 import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
@@ -18,7 +17,6 @@ import type { PROTO } from '../../constants';
 import type { CoreMessage, IFirmwareUpdateProgressType } from '../../events';
 import type { Success } from '@onekeyfe/hd-transport';
 import type { Device } from '../../device/Device';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const NEW_BOOT_UPRATE_FIRMWARE_VERSION = '2.4.5';
 const SESSION_ERROR = 'session not found';
@@ -90,20 +88,17 @@ export const waitBleInstall = async (updateType: string) => {
   }
 };
 
-const toArrayBuffer = (payload: ArrayBuffer | Buffer): ArrayBuffer => {
-  if (payload instanceof ArrayBuffer) {
-    return payload;
-  }
-  return new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength).slice().buffer;
-};
-
-export const uploadFirmwareFromSource = async (
+export const uploadFirmware = async (
   updateType: 'firmware' | 'ble',
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  source: FirmwareByteSource,
-  rebootOnSuccess?: boolean,
+  {
+    payload,
+    rebootOnSuccess,
+  }: PROTO.FirmwareUpload & {
+    rebootOnSuccess?: boolean;
+  },
   isUpdateBootloader?: boolean
 ) => {
   const deviceType = device.getCurrentDeviceType();
@@ -124,20 +119,20 @@ export const uploadFirmwareFromSource = async (
       if (supportUpgradeFileHeader) {
         // Extract and validate firmware header (first 1KB)
         const HEADER_SIZE = 1024;
-        if (source.size < HEADER_SIZE) {
+        if (payload.byteLength < HEADER_SIZE) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            `firmware payload too small: ${source.size} bytes, expected at least ${HEADER_SIZE} bytes`
+            `firmware payload too small: ${payload.byteLength} bytes, expected at least ${HEADER_SIZE} bytes`
           );
         }
 
         Log.debug('Uploading firmware header:', {
           size: HEADER_SIZE,
-          totalSize: source.size,
+          totalSize: payload.byteLength,
         });
         postProgressTip(device, 'UploadingFirmwareHeader', postMessage);
 
-        const header = new Uint8Array(await source.readAt(0, HEADER_SIZE));
+        const header = new Uint8Array(payload.slice(0, HEADER_SIZE));
 
         try {
           const headerRes = await typedCall('UpgradeFileHeader', 'Success', {
@@ -174,9 +169,6 @@ export const uploadFirmwareFromSource = async (
     postProgressMessage(device, 0, 'installingFirmware', postMessage);
     let updateResponse: TypedResponseMessage<'Success'>;
     try {
-      // Classic/Mini bootloaders accept one protobuf payload and do not expose
-      // a request-range protocol. Other device families remain fully streamed.
-      const payload = await readFirmwareByteSourceFully(source);
       updateResponse = await typedCall('FirmwareUpload', 'Success', {
         payload,
       });
@@ -208,7 +200,9 @@ export const uploadFirmwareFromSource = async (
           updateType,
           postMessage,
           device,
-          source,
+          {
+            payload,
+          },
           rebootOnSuccess
         );
         return response.message;
@@ -217,7 +211,7 @@ export const uploadFirmwareFromSource = async (
 
     postConfirmationMessage(device);
     postProgressTip(device, 'ConfirmOnDevice', postMessage);
-    const length = source.size;
+    const length = payload.byteLength;
 
     let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
     postProgressTip(device, 'FirmwareEraseSuccess', postMessage);
@@ -226,7 +220,7 @@ export const uploadFirmwareFromSource = async (
       const start = response.message.offset!;
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       const end = response.message.offset! + response.message.length!;
-      const chunk = await source.readAt(start, end - start);
+      const chunk = payload.slice(start, end);
 
       if (start > 0) {
         postProgressMessage(
@@ -255,45 +249,11 @@ export const uploadFirmwareFromSource = async (
   throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown device model');
 };
 
-export const uploadFirmware = async (
-  updateType: 'firmware' | 'ble',
-  typedCall: TypedCall,
-  postMessage: (message: CoreMessage) => void,
-  device: Device,
-  {
-    payload,
-    rebootOnSuccess,
-  }: PROTO.FirmwareUpload & {
-    rebootOnSuccess?: boolean;
-  },
-  isUpdateBootloader?: boolean
-) => {
-  const source = await openFirmwareByteSource({
-    binary: toArrayBuffer(payload),
-  });
-  if (!source) {
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'firmware payload is empty');
-  }
-  try {
-    return await uploadFirmwareFromSource(
-      updateType,
-      typedCall,
-      postMessage,
-      device,
-      source,
-      rebootOnSuccess,
-      isUpdateBootloader
-    );
-  } finally {
-    await source.close();
-  }
-};
-
 const newTouchUpdateProcess = async (
   updateType: 'firmware' | 'ble',
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  source: FirmwareByteSource,
+  { payload }: PROTO.FirmwareUpload,
   rebootOnSuccess = true
 ) => {
   let typedCall = device.getCommands().typedCall.bind(device.getCommands());
@@ -303,13 +263,13 @@ const newTouchUpdateProcess = async (
   const env = DataManager.getSettings('env');
   const perPackageSize = DataManager.isBleConnect(env) ? 16 : 128;
   const chunkSize = 1024 * perPackageSize;
-  const totalChunks = Math.ceil(source.size / chunkSize);
+  const totalChunks = Math.ceil(payload.byteLength / chunkSize);
   let offset = 0;
   for (let i = 0; i < totalChunks; i++) {
     const chunkStart = i * chunkSize;
-    const chunkEnd = Math.min(chunkStart + chunkSize, source.size);
+    const chunkEnd = Math.min(chunkStart + chunkSize, payload.byteLength);
     const chunkLength = chunkEnd - chunkStart;
-    const chunk = await source.readAt(chunkStart, chunkLength);
+    const chunk = payload.slice(chunkStart, chunkEnd);
     const overwrite = i === 0;
     const progress = Math.round(((i + 1) / totalChunks) * 100);
     const writeRes = await emmcFileWriteWithRetry(
@@ -543,67 +503,6 @@ export const updateResource = async (
   return processResourceRequest(typedCall, res, data);
 };
 
-export const updateResourceFromSource = async (
-  typedCall: TypedCall,
-  fileName: string,
-  source: FirmwareByteSource,
-  onConfirmAfter?: () => void
-) => {
-  const initialLength = Math.min(INIT_DATA_CHUNK_SIZE, source.size);
-  const initialChunk = new Uint8Array(await source.readAt(0, initialLength));
-  let response = await typedCall('ResourceUpdate', ['ResourceRequest', 'Success'], {
-    file_name: fileName,
-    data_length: source.size,
-    initial_data_chunk: bytesToHex(initialChunk),
-    hash: bytesToHex(blake2s(initialChunk)),
-  });
-  onConfirmAfter?.();
-
-  while (response.type !== 'Success') {
-    const { offset, data_length: dataLength } = response.message;
-    if (
-      !Number.isSafeInteger(offset) ||
-      offset === undefined ||
-      offset < 0 ||
-      !Number.isSafeInteger(dataLength) ||
-      dataLength === undefined ||
-      dataLength <= 0 ||
-      offset + dataLength > source.size
-    ) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Device requested an invalid firmware resource range'
-      );
-    }
-    const chunk = new Uint8Array(await source.readAt(offset, dataLength));
-    response = await typedCall('ResourceAck', ['ResourceRequest', 'Success'], {
-      data_chunk: bytesToHex(chunk),
-      hash: bytesToHex(blake2s(chunk)),
-    });
-  }
-  return response.message;
-};
-
-export const updateResourcesFromSources = async (
-  typedCall: TypedCall,
-  postMessage: (message: CoreMessage) => void,
-  device: Device,
-  entries: ReadonlyArray<{ entryName: string; source: FirmwareByteSource }>
-) => {
-  postProgressTip(device, 'UpdateSysResource', postMessage);
-  for (const [index, entry] of entries.entries()) {
-    await updateResourceFromSource(typedCall, entry.entryName, entry.source);
-    postProgressMessage(
-      device,
-      Math.floor(((index + 1) / entries.length) * 100),
-      'installingFirmware',
-      postMessage
-    );
-  }
-  postProgressTip(device, 'UpdateSysResourceSuccess', postMessage);
-  return true;
-};
-
 export const updateResources = async (
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
@@ -638,28 +537,11 @@ export const updateBootloader = async (
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  data: ArrayBuffer
-) => {
-  const source = await openFirmwareByteSource({ binary: data });
-  if (!source) {
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'bootloader payload is empty');
-  }
-  try {
-    return await updateBootloaderFromSource(typedCall, postMessage, device, source);
-  } finally {
-    await source.close();
-  }
-};
-
-export const updateBootloaderFromSource = async (
-  typedCall: TypedCall,
-  postMessage: (message: CoreMessage) => void,
-  device: Device,
-  source: FirmwareByteSource
+  source: ArrayBuffer
 ) => {
   postProgressTip(device, 'UpdateBootloader', postMessage);
   postProgressMessage(device, Math.floor(0), 'installingFirmware', postMessage);
-  await updateResourceFromSource(typedCall, 'bootloader.bin', source, () => {
+  await updateResource(typedCall, 'bootloader.bin', source, () => {
     postProcessingMessage('resource', postMessage);
   });
   postProgressMessage(device, Math.floor(100), 'installingFirmware', postMessage);

package/src/core/index.ts

@@ -3,6 +3,7 @@ import EventEmitter from 'events';
 import { DeviceSessionPinType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 import {
   ERRORS,
+  ERROR_CODES_REQUIRE_DISCONNECT,
   ERROR_CODES_REQUIRE_RELEASE,
   HardwareError,
   HardwareErrorCode,
@@ -933,6 +934,21 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
       DevicePool.emitter.emit(DEVICE.CONNECT, device);
     }
   } catch (err) {
+    // Device.run()'s REQUIRE_DISCONNECT handling never sees acquire/initialize
+    // failures, so with keep-alive a wedged link would be reused by every retry
+    // (field case: Initialize timing out at 25s per attempt, forever). Drop it
+    // here so the next retry cold-connects.
+    if (
+      ERROR_CODES_REQUIRE_DISCONNECT.includes(err.errorCode) &&
+      device.mainId &&
+      device.deviceConnector
+    ) {
+      await device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
+      // The connector only drops the link; `deviceAcquired` is reset by
+      // release()/markTransportDisconnected() alone. Leaving it set makes the
+      // next attempt skip acquire and initialize onto the link we just cut.
+      device.markTransportDisconnected();
+    }
     if (
       (err.errorCode === HardwareErrorCode.BleTimeoutError ||
         err.errorCode === HardwareErrorCode.BleConnectedError ||