@onekeyfe/hd-core 1.2.0-alpha.40 → 1.2.0-alpha.41

package/src/data-manager/DataManager.ts

@@ -399,7 +399,17 @@ export default class DataManager {
 
   static async load(settings: ConnectSettings) {
     this.settings = settings;
-    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;
+    }
+    if (manifestMode === 'external-only') {
+      throw new Error('External firmware config snapshot is required');
+    }
+    if (manifestMode !== 'sdk-managed') {
       return;
     }
 
@@ -409,60 +419,50 @@ 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
           timeout: 7000,
         });
         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) {
-      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]: this.enrichFirmwareReleaseInfo(data.pro2),
-      };
-      this.assets = {
-        bridge: data.bridge,
-      };
+      this.applyRemoteConfig(data);
     } else {
-      Log.warn('[DataConfig] All fetch methods failed, using built-in default config');
+      Log.warn('[DataConfig] SDK-managed config request failed, using built-in default config');
     }
   }
 
+  private static applyRemoteConfig(data: RemoteConfigResponse) {
+    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]: this.enrichFirmwareReleaseInfo(data.pro2),
+    };
+    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

@@ -74,9 +74,7 @@ import type { DeviceStateReadOptions } from '../types/api/getDeviceState';
 import type {
   DeviceButtonRequestPayload,
   DeviceFeaturesPayload,
-  HardwareUiInteractionMeta,
   PassphraseRequestPayload,
-  ProtocolV2UiEventMetadata,
 } from '../events';
 import type { PassphrasePromptResponse } from './DeviceCommands';
 import type { Deferred, HardwareConnectProtocol } from '@onekeyfe/hd-shared';
@@ -134,8 +132,6 @@ const isProtocolV2DeviceStatusUnsupportedError = (error: unknown) => {
 
 export interface DeviceEvents {
   [DEVICE.PIN]: [Device, PROTO.PinMatrixRequestType | undefined, (err: any, pin: string) => void];
-  [DEVICE.PIN_ON_DEVICE]: [Device, DeviceSessionPinType, ProtocolV2UiEventMetadata?];
-  [DEVICE.PIN_ON_DEVICE_COMPLETE]: [Device, HardwareUiInteractionMeta];
   [DEVICE.PASSPHRASE_ON_DEVICE]: [Device, PassphraseRequestPayload?];
   [DEVICE.ATTACH_PIN_ON_DEVICE]: [Device, PassphraseRequestPayload?];
   [DEVICE.BUTTON]: [Device, DeviceButtonRequestPayload];
@@ -234,24 +230,6 @@ export class Device extends EventEmitter {
   /** Force the next initialization to reload DeviceInfo after reconnect or reboot. */
   private protocolV2StateNeedsReload = false;
 
-  /** Runtime context negotiated once per active Protocol V2 link. */
-  private protocolV2RuntimeContext?: ProtocolInfo;
-
-  /** Coalesces concurrent first-use runtime negotiation on the same active link. */
-  private protocolV2RuntimeContextPromise?: Promise<ProtocolInfo>;
-
-  /** Invalidates an in-flight runtime-context response without adding a transport epoch. */
-  private protocolV2RuntimeContextRequestToken?: object;
-
-  private protocolV2UiInteraction?: {
-    interactionId: string;
-    phaseCounter: number;
-    sequence: number;
-    opened: boolean;
-  };
-
-  private protocolV2UiInteractionCounter = 0;
-
   get state() {
     return this.stateStore.getState();
   }
@@ -986,10 +964,7 @@ export class Device extends EventEmitter {
       await this.getFeatures();
     }
 
-    const supportsProtocolV1OnekeyFeatures =
-      this.getCurrentDeviceType() === EDeviceType.Touch ||
-      this.getCurrentDeviceType() === EDeviceType.Pro;
-    if (!this.isProtocolV2() && refresh.has('verification') && supportsProtocolV1OnekeyFeatures) {
+    if (!this.isProtocolV2() && refresh.has('verification')) {
       const { message } = await this.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
       this.updateState(mapProtocolV1OnekeyFeaturesToState(message), 'device-info');
     }
@@ -1012,7 +987,13 @@ export class Device extends EventEmitter {
       }
 
       if (refresh.has('status') && !initializedWithDeviceInfo) {
-        await this.probeProtocolV2RuntimeState(refreshedDeviceInfo);
+        const deviceInfo =
+          refreshedDeviceInfo ??
+          (await requestProtocolV2DeviceInfo({
+            commands: this.commands,
+            request: getProtocolV2DeviceInfoRequest(),
+          }));
+        await this.probeProtocolV2RuntimeState(deviceInfo);
       }
 
       if (refresh.has('settings') && this.state?.status.mode === 'normal') {
@@ -1083,58 +1064,15 @@ export class Device extends EventEmitter {
     return this.features;
   }
 
-  async ensureProtocolV2RuntimeContext(timeoutMs?: number): Promise<ProtocolInfo> {
-    const cachedProtocolInfo =
-      this.protocolV2RuntimeContext ??
-      (!this.protocolV2StateNeedsReload
-        ? this.state?.raw?.protocolV2ProtocolInfo ?? undefined
-        : undefined);
-    if (cachedProtocolInfo) {
-      this.protocolV2RuntimeContext = cachedProtocolInfo;
-      return cachedProtocolInfo;
-    }
-
-    if (this.protocolV2RuntimeContextPromise) {
-      return this.protocolV2RuntimeContextPromise;
-    }
-
-    const requestToken = {};
-    const pendingRequest = (async () => {
-      const protocolInfo = await requestProtocolV2ProtocolInfo({
-        commands: this.commands,
-        timeoutMs,
-      });
-      if (this.protocolV2RuntimeContextRequestToken !== requestToken) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.DeviceInitializeFailed,
-          'Protocol V2 runtime context was invalidated while loading.'
-        );
-      }
-      this.protocolV2RuntimeContext = protocolInfo;
-      return protocolInfo;
-    })();
-    this.protocolV2RuntimeContextRequestToken = requestToken;
-    this.protocolV2RuntimeContextPromise = pendingRequest;
-
-    try {
-      return await pendingRequest;
-    } finally {
-      if (this.protocolV2RuntimeContextPromise === pendingRequest) {
-        this.protocolV2RuntimeContextPromise = undefined;
-      }
-      if (this.protocolV2RuntimeContextRequestToken === requestToken) {
-        this.protocolV2RuntimeContextRequestToken = undefined;
-      }
-    }
-  }
-
-  async probeProtocolV2RuntimeState(deviceInfo?: ProtocolV2DeviceInfo, timeoutMs?: number) {
-    const protocolInfo = await this.ensureProtocolV2RuntimeContext(timeoutMs);
+  async probeProtocolV2RuntimeState(deviceInfo: ProtocolV2DeviceInfo, timeoutMs?: number) {
+    const protocolInfo = await requestProtocolV2ProtocolInfo({
+      commands: this.commands,
+      timeoutMs,
+    });
     const runtimeMode = getProtocolV2RuntimeMode(protocolInfo);
-    const runtimeDeviceInfo = deviceInfo ?? this.state?.raw?.protocolV2DeviceInfo;
-    const protocolV2DeviceType = runtimeDeviceInfo
-      ? resolveProtocolV2DeviceIdentity(runtimeDeviceInfo.hw?.Device_type).deviceType
-      : this.getCurrentDeviceType();
+    const protocolV2DeviceType = resolveProtocolV2DeviceIdentity(
+      deviceInfo.hw?.Device_type
+    ).deviceType;
     if (runtimeMode === 'romloader' && protocolV2DeviceType !== EDeviceType.Pro2) {
       throw ERRORS.TypedError(
         HardwareErrorCode.DeviceInitializeFailed,
@@ -1209,9 +1147,6 @@ export class Device extends EventEmitter {
     this.deviceAcquired = false;
     if (!this.isProtocolV2()) return;
     this.protocolV2StateNeedsReload = true;
-    this.protocolV2RuntimeContext = undefined;
-    this.protocolV2RuntimeContextPromise = undefined;
-    this.protocolV2RuntimeContextRequestToken = undefined;
     this.clearPreInitialized();
   }
 
@@ -1220,14 +1155,9 @@ export class Device extends EventEmitter {
     if (deviceId) {
       deviceWalletSessionStore.deleteDevice(deviceId);
     }
-    if (this.isProtocolV2()) {
-      if (this.originalDescriptor.path !== deviceId) {
-        deviceWalletSessionStore.deleteDevice(this.originalDescriptor.path);
-      }
+    if (this.isProtocolV2() && this.originalDescriptor.path !== deviceId) {
+      deviceWalletSessionStore.deleteDevice(this.originalDescriptor.path);
       this.protocolV2StateNeedsReload = true;
-      this.protocolV2RuntimeContext = undefined;
-      this.protocolV2RuntimeContextPromise = undefined;
-      this.protocolV2RuntimeContextRequestToken = undefined;
     }
 
     this.passphraseState = undefined;
@@ -1240,9 +1170,6 @@ export class Device extends EventEmitter {
     if (!this.isProtocolV2()) return;
 
     this.protocolV2StateNeedsReload = true;
-    this.protocolV2RuntimeContext = undefined;
-    this.protocolV2RuntimeContextPromise = undefined;
-    this.protocolV2RuntimeContextRequestToken = undefined;
     this.clearPreInitialized();
     let loaderMode: 'bootloader' | 'romloader' | undefined;
     if (rebootType === DeviceRebootType.Bootloader) {
@@ -1595,75 +1522,6 @@ export class Device extends EventEmitter {
     return res.message;
   }
 
-  beginProtocolV2UiInteraction() {
-    if (!this.isProtocolV2()) return;
-    this.protocolV2UiInteraction = {
-      interactionId: `${this.instanceId}:${Date.now()}:${++this.protocolV2UiInteractionCounter}`,
-      phaseCounter: 0,
-      sequence: 0,
-      opened: false,
-    };
-  }
-
-  createProtocolV2UiPhaseMetadata(
-    phase: HardwareUiInteractionMeta['phase'],
-    transition: HardwareUiInteractionMeta['transition'],
-    options?: {
-      phaseId?: string;
-      outcome?: HardwareUiInteractionMeta['outcome'];
-    }
-  ): HardwareUiInteractionMeta | undefined {
-    if (!this.isProtocolV2()) return undefined;
-    if (!this.protocolV2UiInteraction) this.beginProtocolV2UiInteraction();
-
-    const interaction = this.protocolV2UiInteraction;
-    if (!interaction) return undefined;
-    const phaseId =
-      options?.phaseId ?? `${interaction.interactionId}:phase-${++interaction.phaseCounter}`;
-    interaction.opened = true;
-    interaction.sequence += 1;
-
-    return {
-      interactionId: interaction.interactionId,
-      phaseId,
-      sequence: interaction.sequence,
-      phase,
-      transition,
-      ...(options?.outcome ? { outcome: options.outcome } : {}),
-      protocol: 'V2',
-    };
-  }
-
-  completeProtocolV2UiPhase(
-    phase: HardwareUiInteractionMeta,
-    outcome: HardwareUiInteractionMeta['outcome'] = 'succeeded'
-  ) {
-    return this.createProtocolV2UiPhaseMetadata(phase.phase, 'complete', {
-      phaseId: phase.phaseId,
-      outcome,
-    });
-  }
-
-  finishProtocolV2UiInteraction(outcome: HardwareUiInteractionMeta['outcome'] = 'succeeded') {
-    const interaction = this.protocolV2UiInteraction;
-    if (!interaction?.opened) {
-      this.protocolV2UiInteraction = undefined;
-      return undefined;
-    }
-
-    const phaseId = `${interaction.interactionId}:phase-${Math.max(interaction.phaseCounter, 1)}`;
-    const metadata = this.createProtocolV2UiPhaseMetadata('processing', 'finish', {
-      phaseId,
-      outcome,
-    });
-    this.protocolV2UiInteraction = undefined;
-    return metadata;
-  }
-
-  hasOpenProtocolV2UiInteraction() {
-    return this.protocolV2UiInteraction?.opened === true;
-  }
-
   supportUnlockVersionRange(): DeviceFirmwareRange {
     // This range applies to Protocol V1 Pro devices; Pro2 has a dedicated unlock flow.
     return {
@@ -1673,33 +1531,10 @@ export class Device extends EventEmitter {
     };
   }
 
-  async unlockDevice(
-    pinType?: DeviceSessionPinType,
-    options?: ProtocolV2UiEventMetadata & { emitUiEvent?: boolean }
-  ) {
+  async unlockDevice(pinType: DeviceSessionPinType = DeviceSessionPinType.Main) {
     if (this.isProtocolV2()) {
-      const requestedPinType = pinType ?? DeviceSessionPinType.Main;
-      const interaction =
-        options?.interaction ??
-        (options?.emitUiEvent === false
-          ? undefined
-          : this.createProtocolV2UiPhaseMetadata('pin', 'start'));
-      if (options?.emitUiEvent !== false) {
-        this.emit(DEVICE.PIN_ON_DEVICE, this, requestedPinType, {
-          source: options?.source ?? 'unlock-coordinator',
-          reason: options?.reason ?? 'device-unlock',
-          deviceOnly: options?.deviceOnly ?? true,
-          completion: options?.completion,
-          method: options?.method,
-          page: options?.page,
-          operation: options?.operation,
-          interaction: options?.interaction ?? interaction,
-        });
-      }
       try {
-        await this.commands.typedCall('DeviceSessionAskPin', 'Success', {
-          type: requestedPinType,
-        });
+        await this.commands.typedCall('DeviceSessionAskPin', 'Success', { type: pinType });
       } catch (error) {
         const errorText =
           error instanceof Error
@@ -1711,11 +1546,6 @@ export class Device extends EventEmitter {
         throw error;
       }
 
-      const completion = interaction ? this.completeProtocolV2UiPhase(interaction) : undefined;
-      if (completion) {
-        this.emit(DEVICE.PIN_ON_DEVICE_COMPLETE, this, completion);
-      }
-
       const status = await requestProtocolV2DeviceStatus({ commands: this.commands });
       return this.updateProtocolV2Status(status);
     }
@@ -1777,8 +1607,7 @@ export class Device extends EventEmitter {
   async checkPassphraseStateSafety(
     passphraseState?: string,
     useEmptyPassphrase?: boolean,
-    skipPassphraseCheck?: boolean,
-    deriveCardano?: boolean
+    skipPassphraseCheck?: boolean
   ) {
     if (this.isUnacquired()) return false;
 
@@ -1787,7 +1616,6 @@ export class Device extends EventEmitter {
       await getPassphraseStateWithRefreshDeviceInfo(this, {
         expectPassphraseState: expectedPassphraseState,
         onlyMainPin: useEmptyPassphrase,
-        deriveCardano,
       });
 
     // Main wallet and unlock Attach Pin, throw safe error

package/src/events/device.ts

@@ -1,5 +1,4 @@
 import type { MessageFactoryFn } from './utils';
-import type { HardwareUiInteractionMeta } from './ui-request';
 import type { PROTO } from '../constants';
 import type {
   KnownDevice as Device,
@@ -27,8 +26,6 @@ export const DEVICE = {
   // onekey-transport events in protobuf format
   BUTTON: 'button',
   PIN: 'pin',
-  PIN_ON_DEVICE: 'pin_on_device',
-  PIN_ON_DEVICE_COMPLETE: 'pin_on_device_complete',
   PASSPHRASE: 'passphrase',
   PASSPHRASE_ON_DEVICE: 'passphrase_on_device',
   ATTACH_PIN_ON_DEVICE: 'attach_pin_on_device',
@@ -61,7 +58,6 @@ export type PassphraseRequestPayload = {
   source?: 'wallet-session-coordinator';
   reason?: 'open-wallet' | 'session-recovery';
   expectedPassphraseState?: string;
-  interaction?: HardwareUiInteractionMeta;
 };
 
 export interface DeviceButtonRequest {

package/src/events/logBlockEvent.ts

@@ -10,7 +10,6 @@ export const LogBlockEvent: Set<string> = new Set([
 
 const LogLabelMethod: Set<string> = new Set([
   'openWalletSession',
-  'deviceUploadNft',
   'deviceUploadWallpaper',
   'uploadPortfolio',
   'fileWrite',

package/src/events/ui-request.ts

@@ -56,16 +56,6 @@ export type ProtocolV2UiEventSource =
 
 export type ProtocolV2UiCompletion = 'page-accepted' | 'operation-completed';
 
-export type HardwareUiInteractionMeta = {
-  interactionId: string;
-  phaseId: string;
-  sequence: number;
-  phase: 'pin' | 'passphrase' | 'passphrase-on-device' | 'button' | 'processing';
-  transition: 'start' | 'complete' | 'finish';
-  outcome?: 'submitted' | 'succeeded' | 'failed' | 'cancelled' | 'disconnected';
-  protocol: 'V2';
-};
-
 export type ProtocolV2UiEventMetadata = {
   source?: ProtocolV2UiEventSource;
   reason?: string;
@@ -74,29 +64,12 @@ export type ProtocolV2UiEventMetadata = {
   method?: string;
   page?: string | number;
   operation?: string;
-  interaction?: HardwareUiInteractionMeta;
 };
 
-export type UiRequestWindowClose =
-  | {
-      type: typeof UI_REQUEST.CLOSE_UI_WINDOW;
-      payload: HardwareUiInteractionMeta;
-    }
-  | {
-      type: typeof UI_REQUEST.CLOSE_UI_PIN_WINDOW;
-      payload: HardwareUiInteractionMeta;
-    }
-  | {
-      type: typeof UI_REQUEST.CLOSE_UI_WINDOW;
-      payload?: undefined;
-    }
-  | {
-      type: typeof UI_REQUEST.CLOSE_UI_PIN_WINDOW;
-      payload?: undefined;
-    };
-
 export interface UiRequestWithoutPayload {
   type:
+    | typeof UI_REQUEST.CLOSE_UI_WINDOW
+    | typeof UI_REQUEST.CLOSE_UI_PIN_WINDOW
     | typeof UI_REQUEST.BLUETOOTH_PERMISSION
     | typeof UI_REQUEST.BLUETOOTH_UNSUPPORTED
     | typeof UI_REQUEST.BLUETOOTH_POWERED_OFF
@@ -138,7 +111,6 @@ export interface UiRequestPassphrase {
     source?: 'wallet-session-coordinator';
     reason?: 'open-wallet' | 'session-recovery';
     expectedPassphraseState?: string;
-    interaction?: HardwareUiInteractionMeta;
   };
 }
 
@@ -149,7 +121,6 @@ export interface UiRequestPassphraseOnDevice {
     passphraseState?: string;
     source?: 'wallet-session-coordinator';
     reason?: 'open-wallet' | 'session-recovery';
-    interaction?: HardwareUiInteractionMeta;
   };
 }
 
@@ -220,7 +191,6 @@ export interface PreviousAddressResult {
 
 export type UiEvent =
   | UiRequestWithoutPayload
-  | UiRequestWindowClose
   | UiRequestDeviceAction
   | UiRequestButton
   | UiRequestPassphraseOnDevice

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,6 +1,17 @@
-import type { Unsuccessful } from './types';
+import { getFirmwareUpdateCapabilities } from './api/firmware/FirmwareUpdateCapabilities';
+import {
+  prepareFirmwareUpdatePlan,
+  validateFirmwareUpdatePreparedPlan,
+} from './api/firmware/FirmwareUpdatePreparedPlan';
+import {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from './api/firmware/FirmwareHostBinding';
+
 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';
 
@@ -68,7 +79,10 @@ export const inject = ({
 
     call,
 
-    dispose,
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await dispose();
+    },
 
     uiResponse,
 
@@ -99,6 +113,12 @@ export const createCoreApi = (
   | 'updateSettings'
   | 'switchTransport'
 > => ({
+  getFirmwareUpdateCapabilities,
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+  getFirmwareUpdateHostBindingGeneration,
+  prepareFirmwareUpdatePlan,
+  validateFirmwareUpdatePreparedPlan,
   getLogs: () => call({ method: 'getLogs' }),
   clearSessionCache: params => call({ ...params, method: 'clearSessionCache' }),
   /**
@@ -162,7 +182,6 @@ export const createCoreApi = (
     call({ ...params, connectId, method: 'deviceGetOnboardingStatus' }),
   deviceUploadWallpaper: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceUploadWallpaper' }),
-  deviceUploadNft: (connectId, params) => call({ ...params, connectId, method: 'deviceUploadNft' }),
   uploadPortfolio: (connectId, params) => call({ ...params, connectId, method: 'uploadPortfolio' }),
   deviceRecovery: (connectId, params) => call({ ...params, connectId, method: 'deviceRecovery' }),
   deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),

package/src/lowLevelInject.ts

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

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

@@ -168,15 +168,8 @@ export async function requestProtocolV2ProtocolInfo({
 }): Promise<ProtocolInfo> {
   const response =
     timeoutMs === undefined
-      ? await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
-          eventless_wallet_session: true,
-        })
-      : await commands.typedCall(
-          'ProtocolInfoRequest',
-          'ProtocolInfo',
-          { eventless_wallet_session: true },
-          { timeoutMs }
-        );
+      ? await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {})
+      : await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {}, { timeoutMs });
   return response.message;
 }
 

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

@@ -0,0 +1,10 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+export function isDeviceLockedError(error: unknown): boolean {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'errorCode' in error &&
+    error.errorCode === HardwareErrorCode.DeviceLocked
+  );
+}