@onekeyfe/hd-core 1.2.0-alpha.68 → 1.2.0-alpha.69

package/src/api/helpers/protocolV2FileWrite.ts

@@ -9,7 +9,7 @@ import { LoggerNames, getLogger } from '../../utils/logger';
 
 import type { DeviceCommands } from '../../device/DeviceCommands';
 
-const Log = getLogger(LoggerNames.Method);
+const Log = getLogger(LoggerNames.Core);
 
 export type ProtocolV2FileWriteData = ArrayBuffer | Uint8Array | Blob | string;
 
@@ -69,22 +69,36 @@ function getFileTransferTransport() {
 function logFileTransferMetrics({
   transport,
   status,
+  path,
   transferredBytes,
   totalBytes,
   elapsedMs,
   rateBytesPerSecond,
+  hostWriteElapsedMs,
+  responseWaitElapsedMs,
+  measuredAttempts,
 }: {
   transport: string;
   status: 'progress' | 'completed' | 'failed';
+  path: string;
   transferredBytes: number;
   totalBytes: number;
   elapsedMs: number;
   rateBytesPerSecond: number;
+  hostWriteElapsedMs: number;
+  responseWaitElapsedMs: number;
+  measuredAttempts: number;
 }) {
+  const segmentedMetrics =
+    measuredAttempts > 0
+      ? ` hostWriteTotal=${(hostWriteElapsedMs / 1000).toFixed(2)}s responseWaitTotal=${(
+          responseWaitElapsedMs / 1000
+        ).toFixed(2)}s measuredAttempts=${measuredAttempts}`
+      : '';
   Log.log(
-    `[FileWrite] metrics transport=${transport} status=${status} bytes=${transferredBytes}/${totalBytes} elapsed=${(
+    `[FileWrite] metrics transport=${transport} status=${status} path=${path} bytes=${transferredBytes}/${totalBytes} elapsed=${(
       elapsedMs / 1000
-    ).toFixed(2)}s speed=${formatFileTransferRate(rateBytesPerSecond)} KiB/s`
+    ).toFixed(2)}s speed=${formatFileTransferRate(rateBytesPerSecond)} KiB/s${segmentedMetrics}`
   );
 }
 
@@ -177,7 +191,13 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
   let lastConfirmedAt = startTime;
   let logWindowStartedAt = startTime;
   let logWindowStartedBytes = 0;
+  let hostWriteElapsedMs = 0;
+  let responseWaitElapsedMs = 0;
+  let measuredAttempts = 0;
   const transport = getFileTransferTransport();
+  Log.log(
+    `[FileWrite] started transport=${transport} path=${options.path} bytes=${dataLength} offset=${startOffset} chunk=${chunkSize}`
+  );
 
   try {
     while (written < dataLength) {
@@ -203,13 +223,25 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
       let response;
       let isWritePending = true;
       while (isWritePending) {
+        let currentHostWriteElapsedMs: number | undefined;
+        let responseWaitStartedAt: number | undefined;
         try {
           const callOptions =
             options.writeWithResponse === undefined
-              ? { timeoutMs: options.timeoutMs }
+              ? {
+                  timeoutMs: options.timeoutMs,
+                  onWriteCompleted: ({ elapsedMs }: { elapsedMs: number }) => {
+                    currentHostWriteElapsedMs = elapsedMs;
+                    responseWaitStartedAt = Date.now();
+                  },
+                }
               : {
                   ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
                   writeWithResponse: options.writeWithResponse,
+                  onWriteCompleted: ({ elapsedMs }: { elapsedMs: number }) => {
+                    currentHostWriteElapsedMs = elapsedMs;
+                    responseWaitStartedAt = Date.now();
+                  },
                 };
           response = await options.commands.typedCall(
             'FilesystemFileWrite',
@@ -222,6 +254,12 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
           if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error)) throw error;
           retryCount += 1;
           options.throwIfAborted?.();
+        } finally {
+          if (currentHostWriteElapsedMs !== undefined && responseWaitStartedAt !== undefined) {
+            hostWriteElapsedMs += currentHostWriteElapsedMs;
+            responseWaitElapsedMs += Math.max(Date.now() - responseWaitStartedAt, 0);
+            measuredAttempts += 1;
+          }
         }
       }
       if (!response) {
@@ -285,10 +323,14 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
         logFileTransferMetrics({
           transport,
           status: 'progress',
+          path: options.path,
           transferredBytes,
           totalBytes: dataLength,
           elapsedMs,
           rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+          hostWriteElapsedMs,
+          responseWaitElapsedMs,
+          measuredAttempts,
         });
         logWindowStartedAt = now;
         logWindowStartedBytes = transferredBytes;
@@ -307,10 +349,14 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
     logFileTransferMetrics({
       transport,
       status: 'failed',
+      path: options.path,
       transferredBytes: written,
       totalBytes: dataLength,
       elapsedMs,
       rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+      hostWriteElapsedMs,
+      responseWaitElapsedMs,
+      measuredAttempts,
     });
     throw error;
   }
@@ -321,10 +367,14 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
   logFileTransferMetrics({
     transport,
     status: 'completed',
+    path: options.path,
     transferredBytes: written,
     totalBytes: dataLength,
     elapsedMs,
     rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+    hostWriteElapsedMs,
+    responseWaitElapsedMs,
+    measuredAttempts,
   });
 
   return {

package/src/data-manager/DataManager.ts

@@ -408,17 +408,7 @@ export default class DataManager {
   static async load(settings: ConnectSettings): Promise<boolean> {
     this.settings = settings;
     this.protocolV2ResourcesConfigError = undefined;
-    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') {
-      throw new Error('External firmware config snapshot is required');
-    }
-    if (manifestMode !== 'sdk-managed') {
+    if (!settings.fetchConfig) {
       return false;
     }
 
@@ -429,19 +419,26 @@ 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 client configFetcher...');
+      Log.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
       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] Client configFetcher failed:', e);
+        Log.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
       }
     }
+
+    // 2. Fallback to default axios request
     if (!data) {
-      Log.debug('[DataConfig] Trying SDK-managed config request...');
+      Log.debug('[DataConfig] Trying axios (SDK default fetcher)...');
       try {
         const response = await axios.get<RemoteConfigResponse>(urlWithCache, {
           // because of iframe timeout is 10000
@@ -449,63 +446,61 @@ export default class DataManager {
         });
         data = response.data;
         fetchMethod = 'axios';
-        Log.log('[DataConfig] SDK-managed config request succeeded');
+        Log.log('[DataConfig] Axios fetch success');
       } catch (e) {
-        Log.warn('[DataConfig] SDK-managed config request failed:', e);
+        Log.warn('[DataConfig] Axios fetch error:', e);
       }
     }
 
+    // 3. Apply config if available
     if (data) {
-      this.applyRemoteConfig(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;
       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,21 +115,10 @@ 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,11 +99,6 @@ 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 = {
@@ -913,7 +908,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: options?.timeoutMs ?? 25 * 1000,
+          timeoutMs: 25 * 1000,
         });
         this.setLastInitializeDuration(Date.now() - initStartAt);
         this._updateFeatures(message, initSession);

package/src/index.ts

@@ -19,11 +19,6 @@ 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,18 +1,7 @@
-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';
 
@@ -127,10 +116,7 @@ export const inject = ({
 
     setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
 
-    dispose: async () => {
-      unregisterFirmwareUpdateHostBinding();
-      await dispose();
-    },
+    dispose,
 
     uiResponse,
 
@@ -162,12 +148,6 @@ 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,5 +1,4 @@
 import { createCoreApi, createProtocolAwareCall } from './inject';
-import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
 
 import type { EventEmitter } from 'events';
 import type { CallMethod, CoreMessage } from './events';
@@ -47,10 +46,7 @@ export const lowLevelInject = ({
 
     setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
 
-    dispose: async () => {
-      unregisterFirmwareUpdateHostBinding();
-      await dispose();
-    },
+    dispose,
 
     uiResponse,
 

package/src/protocols/protocol-v2/resources.ts

@@ -17,6 +17,7 @@ export const PROTOCOL_V2_RESOURCE_TYPES = [
   'translations',
   'roobert',
   'noto',
+  'firmware_logo',
 ] as const satisfies readonly IProtocolV2ResourceType[];
 
 export const PROTOCOL_V2_RESOURCE_DEVICE_PATHS: Readonly<Record<IProtocolV2ResourceType, string>> =
@@ -27,6 +28,7 @@ export const PROTOCOL_V2_RESOURCE_DEVICE_PATHS: Readonly<Record<IProtocolV2Resou
     translations: 'vol0:/bundles/translations/translations.okpkg',
     roobert: 'vol0:/bundles/font/roobert.okpkg',
     noto: 'vol0:/bundles/font/noto.okpkg',
+    firmware_logo: 'vol0:/bundles/firmware_logo.okpkg',
   };
 
 const RESOURCE_TYPE_SET = new Set<string>(PROTOCOL_V2_RESOURCE_TYPES);
@@ -313,7 +315,9 @@ export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources |
   const stable = config.stable.map(validateResource);
   const types = new Set(stable.map(resource => resource.type));
   if (stable.length !== PROTOCOL_V2_RESOURCE_TYPES.length || types.size !== stable.length) {
-    throw new Error('Invalid Pro2 resources config: stable must contain six unique resource types');
+    throw new Error(
+      `Invalid Pro2 resources config: stable must contain ${PROTOCOL_V2_RESOURCE_TYPES.length} unique resource types`
+    );
   }
   for (const type of PROTOCOL_V2_RESOURCE_TYPES) {
     if (!types.has(type)) {

package/src/topLevelInject.ts

@@ -1,7 +1,6 @@
 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';
@@ -50,10 +49,7 @@ export const topLevelInject = () => {
       lowLevelApi?.removeAllListeners(type);
     },
 
-    dispose: async () => {
-      unregisterFirmwareUpdateHostBinding();
-      await lowLevelApi?.dispose();
-    },
+    dispose: () => lowLevelApi?.dispose(),
 
     uiResponse: response => lowLevelApi?.uiResponse(response),
 

package/src/types/api/checkAllFirmwareRelease.ts

@@ -12,7 +12,6 @@ import type {
   IProtocolV2FirmwareComponentTarget,
 } from '../settings';
 import type { FirmwareUpdateV4Target } from './firmwareUpdate';
-import type { FirmwareUpdatePlan, FirmwareUpdatePlanForceTarget } from './firmwareUpdatePlan';
 
 export type FirmwareRelease = {
   shouldUpdate?: boolean;
@@ -65,15 +64,12 @@ 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,15 +1,9 @@
 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,30 +26,12 @@ 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,

package/src/types/api/firmwareUpdate.ts

@@ -1,52 +1,14 @@
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { PROTO } from '../../constants';
 import type { Params, Response } from '../params';
-import type { FirmwareUpdatePreparedPlan } from './firmwareUpdatePreparedPlan';
 
 type IUpdateType = 'firmware' | 'ble';
 
-export interface FirmwareArtifactReference {
-  artifactRef: string;
-  size: number;
-  sha256: string;
-}
-
-export interface FirmwareArtifactReader {
-  open(input: { artifactRef: string }): Promise<{
-    readerId: string;
-    size: number;
-  }>;
-  read(input: { readerId: string; offset: number; length: number }): Promise<{
-    data: ArrayBuffer;
-    bytesRead: number;
-    eof: boolean;
-  }>;
-  close(input: { readerId: string }): Promise<void>;
-}
-
-export interface FirmwareUpdateHostBinding {
-  artifactReader: FirmwareArtifactReader;
-}
-
 export interface FirmwareUpdateBinaryParams {
   binary: ArrayBuffer;
   updateType: IUpdateType;
 }
 
-export interface FirmwareUpdateArtifactParams {
-  preparedPlan: FirmwareUpdatePreparedPlan;
-  hostBindingGeneration: number;
-  artifact: FirmwareArtifactReference;
-  resourceEntries?: Array<{
-    entryName: string;
-    artifact: FirmwareArtifactReference;
-  }>;
-  updateType: IUpdateType;
-  forcedUpdateRes?: boolean;
-  isUpdateBootloader?: boolean;
-  firmwareType?: EFirmwareType;
-}
-
 export interface FirmwareUpdateParams {
   version?: number[];
   updateType: IUpdateType;
@@ -75,14 +37,8 @@ export declare function firmwareUpdateV2(
   connectId: string | undefined,
   params: Params<FirmwareUpdateBinaryParams & Platform>
 ): Response<PROTO.Success>;
-export declare function firmwareUpdateV2(
-  connectId: string | undefined,
-  params: Params<FirmwareUpdateArtifactParams & Platform>
-): Response<PROTO.Success>;
 
 export interface FirmwareUpdateV3Params {
-  preparedPlan?: FirmwareUpdatePreparedPlan;
-  hostBindingGeneration?: number;
   bleVersion?: number[];
   bleBinary?: ArrayBuffer;
   chunkSize?: number;
@@ -99,17 +55,6 @@ export interface FirmwareUpdateV3Params {
   firmwareType?: EFirmwareType;
 
   platform: IPlatform;
-
-  artifactReader?: FirmwareArtifactReader;
-  artifacts?: {
-    ble?: FirmwareArtifactReference;
-    firmware?: FirmwareArtifactReference;
-    bootloader?: FirmwareArtifactReference;
-    resourceEntries?: Array<{
-      entryName: string;
-      artifact: FirmwareArtifactReference;
-    }>;
-  };
 }
 
 /**
@@ -129,14 +74,10 @@ export type FirmwareUpdateV4Target =
   | 'se04';
 
 export interface FirmwareUpdateV4Params {
-  preparedPlan?: FirmwareUpdatePreparedPlan;
-  hostBindingGeneration?: number;
   platform: IPlatform;
-  expectedDeviceId?: string;
   chunkSize?: number;
   firmwareType?: EFirmwareType;
   targetsToUpdate?: FirmwareUpdateV4Target[];
-  expectedTargetVersions?: Partial<Record<FirmwareUpdateV4Target, string>>;
 
   /** FW_MGMT_TARGET_ROMLOADER = 2; Pro2 cannot install it through firmwareUpdateV4. */
   romloaderBinary?: ArrayBuffer;
@@ -164,24 +105,8 @@ export interface FirmwareUpdateV4Params {
     size?: number;
     fileHash?: string;
   }>;
-  artifactReader?: FirmwareArtifactReader;
-  componentArtifacts?: Partial<
-    Record<Exclude<FirmwareUpdateV4Target, 'resource'>, FirmwareArtifactReference>
-  >;
-  resourceBundleArtifacts?: Array<{
-    name: string;
-    artifact: FirmwareArtifactReference;
-  }>;
 }
 
-export declare function registerFirmwareUpdateHostBinding(
-  binding: FirmwareUpdateHostBinding
-): number;
-
-export declare function unregisterFirmwareUpdateHostBinding(generation?: number): boolean;
-
-export declare function getFirmwareUpdateHostBindingGeneration(): number;
-
 export declare function firmwareUpdateV3(
   connectId: string | undefined,
   params: Params<FirmwareUpdateV3Params>