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

package/src/api/firmware/uploadFirmware.ts

@@ -10,6 +10,7 @@ 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';
@@ -17,6 +18,7 @@ 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';
@@ -88,17 +90,20 @@ export const waitBleInstall = async (updateType: string) => {
   }
 };
 
-export const uploadFirmware = async (
+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 (
   updateType: 'firmware' | 'ble',
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  {
-    payload,
-    rebootOnSuccess,
-  }: PROTO.FirmwareUpload & {
-    rebootOnSuccess?: boolean;
-  },
+  source: FirmwareByteSource,
+  rebootOnSuccess?: boolean,
   isUpdateBootloader?: boolean
 ) => {
   const deviceType = device.getCurrentDeviceType();
@@ -119,20 +124,20 @@ export const uploadFirmware = async (
       if (supportUpgradeFileHeader) {
         // Extract and validate firmware header (first 1KB)
         const HEADER_SIZE = 1024;
-        if (payload.byteLength < HEADER_SIZE) {
+        if (source.size < HEADER_SIZE) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            `firmware payload too small: ${payload.byteLength} bytes, expected at least ${HEADER_SIZE} bytes`
+            `firmware payload too small: ${source.size} bytes, expected at least ${HEADER_SIZE} bytes`
           );
         }
 
         Log.debug('Uploading firmware header:', {
           size: HEADER_SIZE,
-          totalSize: payload.byteLength,
+          totalSize: source.size,
         });
         postProgressTip(device, 'UploadingFirmwareHeader', postMessage);
 
-        const header = new Uint8Array(payload.slice(0, HEADER_SIZE));
+        const header = new Uint8Array(await source.readAt(0, HEADER_SIZE));
 
         try {
           const headerRes = await typedCall('UpgradeFileHeader', 'Success', {
@@ -169,6 +174,9 @@ export const uploadFirmware = 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,
       });
@@ -200,9 +208,7 @@ export const uploadFirmware = async (
           updateType,
           postMessage,
           device,
-          {
-            payload,
-          },
+          source,
           rebootOnSuccess
         );
         return response.message;
@@ -211,7 +217,7 @@ export const uploadFirmware = async (
 
     postConfirmationMessage(device);
     postProgressTip(device, 'ConfirmOnDevice', postMessage);
-    const length = payload.byteLength;
+    const length = source.size;
 
     let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
     postProgressTip(device, 'FirmwareEraseSuccess', postMessage);
@@ -220,7 +226,7 @@ export const uploadFirmware = 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 = payload.slice(start, end);
+      const chunk = await source.readAt(start, end - start);
 
       if (start > 0) {
         postProgressMessage(
@@ -249,11 +255,45 @@ export const uploadFirmware = 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,
-  { payload }: PROTO.FirmwareUpload,
+  source: FirmwareByteSource,
   rebootOnSuccess = true
 ) => {
   let typedCall = device.getCommands().typedCall.bind(device.getCommands());
@@ -263,13 +303,13 @@ const newTouchUpdateProcess = async (
   const env = DataManager.getSettings('env');
   const perPackageSize = DataManager.isBleConnect(env) ? 16 : 128;
   const chunkSize = 1024 * perPackageSize;
-  const totalChunks = Math.ceil(payload.byteLength / chunkSize);
+  const totalChunks = Math.ceil(source.size / chunkSize);
   let offset = 0;
   for (let i = 0; i < totalChunks; i++) {
     const chunkStart = i * chunkSize;
-    const chunkEnd = Math.min(chunkStart + chunkSize, payload.byteLength);
+    const chunkEnd = Math.min(chunkStart + chunkSize, source.size);
     const chunkLength = chunkEnd - chunkStart;
-    const chunk = payload.slice(chunkStart, chunkEnd);
+    const chunk = await source.readAt(chunkStart, chunkLength);
     const overwrite = i === 0;
     const progress = Math.round(((i + 1) / totalChunks) * 100);
     const writeRes = await emmcFileWriteWithRetry(
@@ -503,6 +543,67 @@ 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,
@@ -537,11 +638,28 @@ export const updateBootloader = async (
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  source: ArrayBuffer
+  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
 ) => {
   postProgressTip(device, 'UpdateBootloader', postMessage);
   postProgressMessage(device, Math.floor(0), 'installingFirmware', postMessage);
-  await updateResource(typedCall, 'bootloader.bin', source, () => {
+  await updateResourceFromSource(typedCall, 'bootloader.bin', source, () => {
     postProcessingMessage('resource', postMessage);
   });
   postProgressMessage(device, Math.floor(100), 'installingFirmware', postMessage);

package/src/data-manager/DataManager.ts

@@ -408,7 +408,20 @@ export default class DataManager {
   static async load(settings: ConnectSettings): Promise<boolean> {
     this.settings = settings;
     this.protocolV2ResourcesConfigError = undefined;
-    if (!settings.fetchConfig) {
+    const manifestMode =
+      settings.firmwareManifestMode ?? (settings.fetchConfig ? 'sdk-managed' : undefined);
+    if (settings.preloadedConfig) {
+      this.applyRemoteConfig(settings.preloadedConfig);
+      Log.log('[DataConfig] Preloaded firmware config loaded');
+      return true;
+    }
+    if (manifestMode === 'external-only') {
+      Log.warn(
+        '[DataConfig] External firmware config is unavailable; SDK-managed networking remains disabled'
+      );
+      return false;
+    }
+    if (manifestMode !== 'sdk-managed') {
       return false;
     }
 
@@ -419,26 +432,19 @@ export default class DataManager {
     const urlWithCache = `${url}?noCache=${getTimeStamp()}`;
     let data: RemoteConfigResponse | null = null;
     let fetchMethod: 'configFetcher' | 'axios' | 'none' = 'none';
-
-    // 1. Try custom configFetcher first (client-side IP direct connection support)
     if (settings.configFetcher) {
-      Log.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
+      Log.debug('[DataConfig] Trying client configFetcher...');
       try {
         data = await settings.configFetcher(urlWithCache);
         if (data) {
           fetchMethod = 'configFetcher';
-          Log.log('[DataConfig] ConfigFetcher success');
-        } else {
-          Log.debug('[DataConfig] ConfigFetcher returned null, will fallback to axios');
         }
       } catch (e) {
-        Log.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
+        Log.warn('[DataConfig] Client configFetcher failed:', e);
       }
     }
-
-    // 2. Fallback to default axios request
     if (!data) {
-      Log.debug('[DataConfig] Trying axios (SDK default fetcher)...');
+      Log.debug('[DataConfig] Trying SDK-managed config request...');
       try {
         const response = await axios.get<RemoteConfigResponse>(urlWithCache, {
           // because of iframe timeout is 10000
@@ -446,61 +452,63 @@ export default class DataManager {
         });
         data = response.data;
         fetchMethod = 'axios';
-        Log.log('[DataConfig] Axios fetch success');
+        Log.log('[DataConfig] SDK-managed config request succeeded');
       } catch (e) {
-        Log.warn('[DataConfig] Axios fetch error:', e);
+        Log.warn('[DataConfig] SDK-managed config request failed:', e);
       }
     }
 
-    // 3. Apply config if available
     if (data) {
-      let pro2Resources: IProtocolV2Resources | undefined;
-      let neoResources: IProtocolV2Resources | undefined;
-      this.protocolV2ResourcesConfigError = undefined;
-      try {
-        pro2Resources = parseProtocolV2Resources(
-          (data.pro2 as { resources?: unknown } | undefined)?.resources
-        );
-        neoResources = parseProtocolV2Resources(
-          (data.neo as { resources?: unknown } | undefined)?.resources
-        );
-      } catch (error) {
-        // Firmware resource metadata is not required for base communication. If the
-        // remote config is temporarily incomplete, disable this resource update only.
-        this.protocolV2ResourcesConfigError =
-          error instanceof Error ? error : new Error(String(error));
-        Log.warn('[DataConfig] Ignoring invalid Pro2 resources config:', error);
-      }
-      const enrichedPro2Config = this.enrichFirmwareReleaseInfo(data.pro2);
-      const enrichedNeoConfig = this.enrichFirmwareReleaseInfo(data.neo);
-      const { resources: _unvalidatedResources, ...pro2Config } = enrichedPro2Config;
-      const { resources: _unvalidatedNeoResources, ...neoConfig } = enrichedNeoConfig;
+      this.applyRemoteConfig(data);
       Log.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
-      this.deviceMap = {
-        [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
-        [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
-        [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
-        [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
-        [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
-        [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
-        [EDeviceType.Pro2]: {
-          ...pro2Config,
-          ...(pro2Resources ? { resources: pro2Resources } : undefined),
-        },
-        [EDeviceType.Neo]: {
-          ...neoConfig,
-          ...(neoResources ? { resources: neoResources } : undefined),
-        },
-      };
-      this.assets = {
-        bridge: data.bridge,
-      };
       return true;
     }
     Log.warn('[DataConfig] All fetch methods failed, using built-in default config');
     return false;
   }
 
+  private static applyRemoteConfig(data: RemoteConfigResponse) {
+    let pro2Resources: IProtocolV2Resources | undefined;
+    let neoResources: IProtocolV2Resources | undefined;
+    try {
+      pro2Resources = parseProtocolV2Resources(
+        (data.pro2 as { resources?: unknown } | undefined)?.resources
+      );
+      neoResources = parseProtocolV2Resources(
+        (data.neo as { resources?: unknown } | undefined)?.resources
+      );
+    } catch (error) {
+      // Firmware resource metadata is not required for base communication. If the
+      // remote config is temporarily incomplete, disable this resource update only.
+      this.protocolV2ResourcesConfigError =
+        error instanceof Error ? error : new Error(String(error));
+      Log.warn('[DataConfig] Ignoring invalid Protocol V2 resources config:', error);
+    }
+    const enrichedPro2Config = this.enrichFirmwareReleaseInfo(data.pro2);
+    const enrichedNeoConfig = this.enrichFirmwareReleaseInfo(data.neo);
+    const { resources: _unvalidatedResources, ...pro2Config } = enrichedPro2Config;
+    const { resources: _unvalidatedNeoResources, ...neoConfig } = enrichedNeoConfig;
+    this.deviceMap = {
+      [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
+      [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
+      [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
+      [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
+      [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
+      [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
+      [EDeviceType.Pro2]: {
+        ...pro2Config,
+        ...(pro2Resources ? { resources: pro2Resources } : undefined),
+      },
+      [EDeviceType.Neo]: {
+        ...neoConfig,
+        ...(neoResources ? { resources: neoResources } : undefined),
+      },
+    };
+    this.assets = {
+      bridge: data.bridge,
+    };
+  }
+
   static updateEnv(newEnv: ConnectSettings['env']) {
     if (this.settings) {
       const prevEnv = this.settings.env;

package/src/data-manager/connectSettings.ts

@@ -115,10 +115,21 @@ export const parseConnectSettings = (input: Partial<ConnectSettings> = {}) => {
     settings.fetchConfig = input.fetchConfig;
   }
 
+  if (
+    input.firmwareManifestMode === 'sdk-managed' ||
+    input.firmwareManifestMode === 'external-only'
+  ) {
+    settings.firmwareManifestMode = input.firmwareManifestMode;
+  }
+
   if (input.configFetcher) {
     settings.configFetcher = input.configFetcher;
   }
 
+  if (input.preloadedConfig) {
+    settings.preloadedConfig = input.preloadedConfig;
+  }
+
   return settings;
 };
 

package/src/device/Device.ts

@@ -99,6 +99,11 @@ export type InitOptions = {
   protocolV2DeviceInfoTimeoutMs?: number;
   /** Refresh Protocol V2 runtime state before returning discovery results. */
   refreshRuntimeState?: boolean;
+  /**
+   * Protocol V1 Initialize response timeout override. Reboot-wait polling passes a
+   * short value so an unanswered probe settles before the next poll tick.
+   */
+  timeoutMs?: number;
 };
 
 export type RunOptions = {
@@ -909,7 +914,7 @@ export class Device extends EventEmitter {
         const initStartAt = Date.now();
         const { message } = await this.commands.typedCall('Initialize', 'Features', payload, {
           // iOS BLE bound devices can need close to 20 seconds.
-          timeoutMs: 25 * 1000,
+          timeoutMs: options?.timeoutMs ?? 25 * 1000,
         });
         this.setLastInitializeDuration(Date.now() - initStartAt);
         this._updateFeatures(message, initSession);

package/src/index.ts

@@ -19,6 +19,11 @@ export * from './types';
 export { whitelist, whitelistExtension } from './data/config';
 export { executeCallback, cleanupCallback };
 export { preloadSessionCache } from './device/Device';
+export {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from './api/firmware/FirmwareHostBinding';
 
 const HardwareSdk = ({
   init,

package/src/inject.ts

@@ -1,7 +1,18 @@
+import { getFirmwareUpdateCapabilities } from './api/firmware/FirmwareUpdateCapabilities';
+import {
+  prepareFirmwareUpdatePlan,
+  validateFirmwareUpdatePreparedPlan,
+} from './api/firmware/FirmwareUpdatePreparedPlan';
+import {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from './api/firmware/FirmwareHostBinding';
+
 import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
-import type { Unsuccessful } from './types';
 import type { EventEmitter } from 'events';
 import type { CallMethod } from './events';
+import type { Unsuccessful } from './types';
 import type { CoreApi } from './types/api';
 import type { AllNetworkAddress } from './types/api/allNetworkGetAddress';
 
@@ -116,7 +127,10 @@ export const inject = ({
 
     setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
 
-    dispose,
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await dispose();
+    },
 
     uiResponse,
 
@@ -148,6 +162,12 @@ export const createCoreApi = (
   | 'updateSettings'
   | 'switchTransport'
 > => ({
+  getFirmwareUpdateCapabilities,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+  getFirmwareUpdateHostBindingGeneration,
+  prepareFirmwareUpdatePlan,
+  validateFirmwareUpdatePreparedPlan,
   getLogs: () => call({ method: 'getLogs' }),
   clearSessionCache: params => call({ ...params, method: 'clearSessionCache' }),
   /**

package/src/lowLevelInject.ts

@@ -1,4 +1,5 @@
 import { createCoreApi, createProtocolAwareCall } from './inject';
+import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
 
 import type { EventEmitter } from 'events';
 import type { CallMethod, CoreMessage } from './events';
@@ -46,7 +47,10 @@ export const lowLevelInject = ({
 
     setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
 
-    dispose,
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await dispose();
+    },
 
     uiResponse,
 

package/src/topLevelInject.ts

@@ -1,6 +1,7 @@
 import EventEmitter from 'events';
 
 import { createCoreApi, createProtocolAwareCall } from './inject';
+import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
 
 import type { ConnectSettings } from './types/settings';
 import type { CoreApi } from './types/api';
@@ -49,7 +50,10 @@ export const topLevelInject = () => {
       lowLevelApi?.removeAllListeners(type);
     },
 
-    dispose: () => lowLevelApi?.dispose(),
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await lowLevelApi?.dispose();
+    },
 
     uiResponse: response => lowLevelApi?.uiResponse(response),
 

package/src/types/api/checkAllFirmwareRelease.ts

@@ -12,6 +12,7 @@ import type {
   IProtocolV2FirmwareComponentTarget,
 } from '../settings';
 import type { FirmwareUpdateV4Target } from './firmwareUpdate';
+import type { FirmwareUpdatePlan, FirmwareUpdatePlanForceTarget } from './firmwareUpdatePlan';
 
 export type FirmwareRelease = {
   shouldUpdate?: boolean;
@@ -64,12 +65,15 @@ export type AllFirmwareRelease = {
   components?: ProtocolV2FirmwareComponentRelease[];
   targetsToUpdate?: FirmwareUpdateV4Target[];
   release?: IFirmwareReleaseInfo;
+  firmwareUpdatePlan?: FirmwareUpdatePlan;
 };
 
 export type CheckAllFirmwareReleaseParams = {
   checkBridgeRelease?: boolean;
   checkFirmwareHash?: boolean;
   firmwareType?: EFirmwareType;
+  platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
+  forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
 };
 
 export declare function checkAllFirmwareRelease(

package/src/types/api/deviceUpdateBootloader.ts

@@ -1,9 +1,15 @@
 import type { Success } from '@onekeyfe/hd-transport';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
+import type { FirmwareArtifactReader, FirmwareArtifactReference } from './firmwareUpdate';
+import type { FirmwareUpdatePreparedPlan } from './firmwareUpdatePreparedPlan';
 import type { Response } from '../params';
 
 export type DeviceUpdateBootloaderParams = {
+  preparedPlan?: FirmwareUpdatePreparedPlan;
+  hostBindingGeneration?: number;
   binary?: ArrayBuffer;
+  artifact?: FirmwareArtifactReference;
+  artifactReader?: FirmwareArtifactReader;
   firmwareType?: EFirmwareType;
 };
 

package/src/types/api/export.ts

@@ -26,12 +26,30 @@ export type {
   DeviceUploadResourceResponse,
 } from './deviceUploadResource';
 export type {
+  FirmwareArtifactReader,
+  FirmwareArtifactReference,
+  FirmwareUpdateHostBinding,
+  FirmwareUpdateArtifactParams,
   FirmwareUpdateParams,
   FirmwareUpdateBinaryParams,
   FirmwareUpdateV3Params,
   FirmwareUpdateV4Params,
   FirmwareUpdateV4Target,
 } from './firmwareUpdate';
+export type {
+  FirmwareUpdatePlan,
+  FirmwareUpdatePlanArtifact,
+  FirmwareUpdatePlanArtifactRole,
+  FirmwareUpdatePlanForceTarget,
+  FirmwareUpdatePlanTarget,
+} from './firmwareUpdatePlan';
+export type {
+  FirmwareUpdatePreparedArtifact,
+  FirmwareUpdatePreparedArtifactInput,
+  FirmwareUpdatePreparedEntry,
+  FirmwareUpdatePreparedPlan,
+} from './firmwareUpdatePreparedPlan';
+export type { FirmwareUpdateCapabilities } from './firmwareUpdateCapabilities';
 export type { AllFirmwareRelease } from './checkAllFirmwareRelease';
 export type {
   ProtocolV2FirmwareComponentRelease,