@onekeyfe/hd-core 1.2.0-alpha.21 → 1.2.0-alpha.22

package/src/api/helpers/protocolV2FileWrite.ts

@@ -152,6 +152,12 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
         options.throwIfAborted?.();
       }
     }
+    if (!response) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'FilesystemFileWrite completed without a response'
+      );
+    }
     options.throwIfAborted?.();
     lastMessage = response.message;
     const rawProcessedByte = response.message?.processed_byte;

package/src/api/index.ts

@@ -48,24 +48,6 @@ export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
 export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
 export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
-// Protocol V2 development APIs. These remain public while Pro2 integration is in development.
-export { default as deviceInfoGet } from './protocol-v2/DeviceInfoGet';
-export { default as deviceStatusGet } from './protocol-v2/DeviceStatusGet';
-export { default as protocolInfoRequest } from './protocol-v2/ProtocolInfoRequest';
-export { default as ping } from './protocol-v2/Ping';
-export { default as deviceFirmwareUpdate } from './protocol-v2/DeviceFirmwareUpdate';
-export { default as deviceGetFirmwareUpdateStatus } from './protocol-v2/DeviceGetFirmwareUpdateStatus';
-export { default as deviceFactoryInfoSet } from './protocol-v2/DeviceFactoryInfoSet';
-export { default as deviceFactoryInfoGet } from './protocol-v2/DeviceFactoryInfoGet';
-export { default as filesystemPermissionFix } from './protocol-v2/FilesystemPermissionFix';
-export { default as filesystemFormat } from './protocol-v2/FilesystemFormat';
-export { default as fileRead } from './FileRead';
-export { default as fileWrite } from './FileWrite';
-export { default as fileDelete } from './FileDelete';
-export { default as dirList } from './DirList';
-export { default as dirMake } from './DirMake';
-export { default as dirRemove } from './DirRemove';
-export { default as pathInfo } from './PathInfo';
 export { default as uploadPortfolio } from './UploadPortfolio';
 
 export { default as cipherKeyValue } from './CipherKeyValue';

package/src/api/nexa/NexaSignTransaction.ts

@@ -9,6 +9,8 @@ import type { TypedCall } from '@onekeyfe/hd-transport';
 import type { DeviceFirmwareRange, NexaSignTransactionParams, NexaSignature } from '../../types';
 
 export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionParams> {
+  checkDeviceId = true;
+
   hasBundle = false;
 
   init() {

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -71,7 +71,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
     this.params = { width, height, rgba: rgbaBytes, fileName, chunkSize };
     this.requireProtocolV2 = true;
-    this.unlockPolicy = 'retry-on-locked';
+    this.unlockPolicy = 'unlock-before-run';
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
   }

package/src/data/messages/messages-protocol-v2.json

@@ -482,9 +482,9 @@
         "MessageType_DeviceStatus": 60603,
         "MessageType_DevGetOnboardingStatus": 60604,
         "MessageType_DevOnboardingStatus": 60605,
-        "MessageType_DeviceSessionGet": 60606,
         "MessageType_DeviceSession": 60607,
         "MessageType_DeviceSessionAskPin": 60608,
+        "MessageType_DeviceSessionOpen": 60609,
         "MessageType_FilesystemPermissionFix": 60800,
         "MessageType_FilesystemPathInfo": 60801,
         "MessageType_FilesystemPathInfoQuery": 60802,
@@ -506,7 +506,8 @@
         [90, 92],
         [114, 122],
         [300, 304],
-        [309, 312]
+        [309, 312],
+        [60606, 60606]
       ]
     },
     "AlephiumGetAddress": {
@@ -11744,7 +11745,15 @@
       }
     },
     "ProtocolInfoRequest": {
-      "fields": {}
+      "fields": {
+        "eventless_wallet_session": {
+          "type": "bool",
+          "id": 1,
+          "options": {
+            "default": false
+          }
+        }
+      }
     },
     "ProtocolInfo": {
       "fields": {
@@ -12427,14 +12436,78 @@
         }
       }
     },
-    "DeviceSessionGet": {
+    "DeviceSessionErrorCode": {
+      "values": {
+        "DeviceSessionError_None": 0,
+        "DeviceSessionError_UserCancelled": 1,
+        "DeviceSessionError_InvalidSession": 2,
+        "DeviceSessionError_AttachPinUnavailable": 3,
+        "DeviceSessionError_PassphraseDisabled": 4,
+        "DeviceSessionError_Busy": 5
+      }
+    },
+    "DeviceSessionResume": {
       "fields": {
         "session_id": {
+          "rule": "required",
           "type": "bytes",
           "id": 1
         }
       }
     },
+    "DeviceSessionHostPassphrase": {
+      "fields": {
+        "passphrase": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
+    "DeviceSessionPassphraseOnDevice": {
+      "fields": {}
+    },
+    "DeviceSessionAttachPinOnDevice": {
+      "fields": {}
+    },
+    "DeviceSessionSelect": {
+      "oneofs": {
+        "access": {
+          "oneof": ["host_passphrase", "passphrase_on_device", "attach_pin_on_device"]
+        }
+      },
+      "fields": {
+        "host_passphrase": {
+          "type": "DeviceSessionHostPassphrase",
+          "id": 1
+        },
+        "passphrase_on_device": {
+          "type": "DeviceSessionPassphraseOnDevice",
+          "id": 2
+        },
+        "attach_pin_on_device": {
+          "type": "DeviceSessionAttachPinOnDevice",
+          "id": 3
+        }
+      }
+    },
+    "DeviceSessionOpen": {
+      "oneofs": {
+        "mode": {
+          "oneof": ["resume", "select"]
+        }
+      },
+      "fields": {
+        "resume": {
+          "type": "DeviceSessionResume",
+          "id": 1
+        },
+        "select": {
+          "type": "DeviceSessionSelect",
+          "id": 2
+        }
+      }
+    },
     "DeviceSession": {
       "fields": {
         "session_id": {

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

@@ -153,7 +153,8 @@ export interface Device {
  * This allows short-lived processes (e.g. CLI) to restore a previously
  * obtained session, avoiding the need to re-enter passphrase on every
  * invocation. The session must have been obtained from a prior
- * getPassphraseState() call on the same device.
+ * wallet-session call on the same device. This compatibility hook is intended
+ * for a trusted CLI process restoring its own OS-keychain entry.
  *
  * @param deviceId - The device's device_id (from features)
  * @param passphraseState - The passphrase state token
@@ -222,24 +223,7 @@ export class Device extends EventEmitter {
 
   get features(): Features | undefined {
     if (!this.state) return undefined;
-    const features = projectFeatures(this.state);
-    const sessionCacheDeviceKey =
-      this.state.identity.deviceId ||
-      (this.isProtocolV2()
-        ? this.originalDescriptor.path || this.originalDescriptor.id
-        : undefined);
-    const sessionId =
-      sessionCacheDeviceKey && this.passphraseState
-        ? deviceWalletSessionStore.get(sessionCacheDeviceKey, this.passphraseState)
-        : undefined;
-    return sessionId
-      ? {
-          ...features,
-          sessionId,
-          session_id: sessionId,
-          passphraseState: this.passphraseState,
-        }
-      : features;
+    return projectFeatures(this.state);
   }
 
   set features(features: Features | undefined) {
@@ -334,7 +318,7 @@ export class Device extends EventEmitter {
       instanceId: this.instanceId,
       createdAt: this.createdAt,
       deviceType,
-      /** ID for current seeds, will clear after replace a new seed at device */
+      /** Wallet-lifecycle ID; changes after the device is wiped or reinitialized. */
       deviceId,
       path: this.originalDescriptor?.path,
       bleName,
@@ -691,16 +675,14 @@ export class Device extends EventEmitter {
     const deviceId = _deviceId || this.getCurrentDeviceId();
     if (deviceId) return deviceId;
     if (this.isProtocolV2()) {
-      return this.originalDescriptor.path || this.originalDescriptor.id;
+      return this.originalDescriptor.path;
     }
     return undefined;
   }
 
   private reconcileSessionCacheDeviceIdentity(previousDeviceId?: string) {
     deviceWalletSessionStore.reconcileDeviceIdentity({
-      temporaryKey: this.isProtocolV2()
-        ? this.originalDescriptor.path || this.originalDescriptor.id
-        : undefined,
+      temporaryKey: this.isProtocolV2() ? this.originalDescriptor.path : undefined,
       previousDeviceId,
       nextDeviceId: this.getCurrentDeviceId(),
     });
@@ -806,43 +788,55 @@ export class Device extends EventEmitter {
       return;
     }
 
-    // Log.debug('initialize param:', options);
+    try {
+      const callInitialize = async (payload: Record<string, unknown>, initSession?: boolean) => {
+        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,
+        });
+        this.setLastInitializeDuration(Date.now() - initStartAt);
+        this._updateFeatures(message, initSession);
+        await TransportManager.reconfigure(this.features);
+      };
 
-    this.passphraseState = options?.passphraseState;
+      const expectedDeviceId = options?.deviceId;
+      if (expectedDeviceId) {
+        // Establish the live physical identity before sending wallet-bound state.
+        this.passphraseState = undefined;
+        await callInitialize({ is_contains_attach: true });
+        if (!this.checkDeviceId(expectedDeviceId)) {
+          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+        }
+      }
 
-    if (options?.initSession) {
-      this.clearInternalState(options?.deviceId);
-    }
+      this.passphraseState = options?.passphraseState;
 
-    const internalState = this.getInternalState(options?.deviceId);
-    const payload: any = {};
-    if (internalState) {
-      payload.session_id = internalState;
-    }
+      if (options?.initSession) {
+        this.clearInternalState(options?.deviceId);
+      }
 
-    if (options?.deriveCardano) {
-      payload.derive_cardano = true;
-    }
-    payload.passphrase_state = options?.passphraseState;
-    payload.is_contains_attach = true;
+      const internalState = this.getInternalState(options?.deviceId);
+      const payload: Record<string, unknown> = {
+        passphrase_state: options?.passphraseState,
+        is_contains_attach: true,
+      };
+      if (internalState) {
+        payload.session_id = internalState;
+      }
+      if (options?.deriveCardano) {
+        payload.derive_cardano = true;
+      }
 
-    const initStartAt = Date.now();
-    try {
-      // @ts-expect-error
-      const { message } = await Promise.race([
-        this.commands.typedCall('Initialize', 'Features', payload),
-        new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed));
-            // iOS ble bound device timeout 20s
-          }, 25 * 1000);
-        }),
-      ]);
-
-      const initCostMs = Date.now() - initStartAt;
-      this.setLastInitializeDuration(initCostMs);
-      this._updateFeatures(message, options?.initSession);
-      await TransportManager.reconfigure(this.features);
+      const requiresWalletInitialize =
+        !expectedDeviceId ||
+        Boolean(internalState) ||
+        Boolean(options?.passphraseState) ||
+        options?.deriveCardano === true ||
+        options?.initSession === true;
+      if (requiresWalletInitialize) {
+        await callInitialize(payload, options?.initSession);
+      }
     } catch (error) {
       Log.error('Initialization failed:', error);
       throw error;
@@ -972,10 +966,6 @@ export class Device extends EventEmitter {
         ? protoFeatures
         : buildProtocolV1FeaturesPayload(protoFeatures, this.features);
 
-    // GetFeatures doesn't return 'session_id'
-    if (this.features?.sessionId && !feat.sessionId) {
-      feat.sessionId = this.features.sessionId;
-    }
     feat.unlocked = feat.unlocked ?? true;
 
     feat = fixFeaturesFirmwareVersion(feat);

package/src/device/DeviceCommands.ts

@@ -1,6 +1,7 @@
 import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import {
   DeviceErrorCode,
+  DeviceSessionErrorCode,
   type FailureType,
   type Messages,
   type Transport,
@@ -52,7 +53,7 @@ const HIGH_VOLUME_DEBUG_CALLS = new Set([
   'FirmwareUpload',
   'ResourceAck',
 ]);
-const SENSITIVE_DEBUG_CALLS = new Set(['DeviceSessionGet']);
+const SENSITIVE_DEBUG_CALLS = new Set(['DeviceSessionOpen']);
 
 function shouldReduceDebugForCall(type: string) {
   return HIGH_VOLUME_DEBUG_CALLS.has(type);
@@ -337,20 +338,27 @@ export class DeviceCommands {
     if (this.disposed) {
       return;
     }
-    this.dispose(true);
-    if (this.callPromise) {
-      try {
-        await Promise.all([
-          new Promise((_resolve, reject) =>
-            // eslint-disable-next-line no-promise-executor-return
-            setTimeout(() => reject(new Error('cancel timeout')), 10 * 1000)
-          ),
-          await this.callPromise,
-        ]);
-      } catch {
-        // device error
+    const activeCall = this.callPromise;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const cancellation = (async () => {
+      await this.dispose(true);
+      await activeCall?.catch(() => undefined);
+    })();
+
+    try {
+      await Promise.race([
+        cancellation,
+        new Promise<void>(resolve => {
+          timer = setTimeout(resolve, 10 * 1000);
+        }),
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+      if (this.callPromise === activeCall) {
         this.callPromise = undefined;
       }
+      // The cancellation work may finish after the bounded wait.
+      cancellation.catch(() => undefined);
     }
   }
 
@@ -451,7 +459,7 @@ export class DeviceCommands {
         'PinMatrixAck',
         'PassphraseAck',
         'Cancel',
-        'DeviceSessionGet',
+        'DeviceSessionOpen',
         'BixinPinInputOnDevice',
         'FilesystemFileRead',
         'FilesystemFileWrite',
@@ -599,6 +607,42 @@ export class DeviceCommands {
         const isLegacyProtocolV2LockedFailure =
           this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(normalizedMessage);
         if (
+          callType === 'DeviceSessionOpen' &&
+          subcode === DeviceSessionErrorCode.DeviceSessionError_InvalidSession
+        ) {
+          error = ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
+        } else if (
+          callType === 'DeviceSessionOpen' &&
+          subcode === DeviceSessionErrorCode.DeviceSessionError_UserCancelled
+        ) {
+          error = ERRORS.TypedError(HardwareErrorCode.ActionCancelled, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
+        } else if (
+          callType === 'DeviceSessionOpen' &&
+          subcode === DeviceSessionErrorCode.DeviceSessionError_AttachPinUnavailable
+        ) {
+          error = ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
+        } else if (
+          callType === 'DeviceSessionOpen' &&
+          subcode === DeviceSessionErrorCode.DeviceSessionError_PassphraseDisabled
+        ) {
+          error = ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
+        } else if (
           subcode === DeviceErrorCode.DeviceError_ActionCancelled ||
           isLegacyProtocolV2ActionCancelledFailure
         ) {

package/src/device/DeviceStateMapper.ts

@@ -29,6 +29,23 @@ const definedEntries = <T extends Record<string, unknown>>(value: T): T =>
     Object.entries(value).filter(([, fieldValue]) => fieldValue !== undefined)
   ) as T;
 
+const sanitizeRawFeatures = (features: Features): Features['raw'] => {
+  if (!features.raw) return undefined;
+
+  const raw = { ...features.raw };
+  if (raw.protocolV1Features) {
+    const { session_id: _sessionId, ...protocolV1Features } = raw.protocolV1Features;
+    const compatibilityFields = protocolV1Features as typeof protocolV1Features & {
+      sessionId?: string;
+      passphraseState?: string;
+    };
+    delete compatibilityFields.sessionId;
+    delete compatibilityFields.passphraseState;
+    raw.protocolV1Features = compatibilityFields as PROTO.Features;
+  }
+  return raw;
+};
+
 const imageVersion = (image?: DeviceFirmwareImageInfo | null) => image?.version ?? undefined;
 
 const bytesToHex = (value: unknown): string | undefined => {
@@ -127,7 +144,7 @@ export const mapFeaturesToState = (features: Features): DeviceStatePatch => ({
   },
   capabilities: features.capabilities,
   verification: definedEntries(features.verify ?? {}),
-  raw: features.raw,
+  raw: sanitizeRawFeatures(features),
 });
 
 export const mapProtocolV1FeaturesToState = (

package/src/device/DeviceStateProjector.ts

@@ -16,6 +16,12 @@ export const projectFeatures = (state: StoredDeviceState): Features => {
   delete publicRawFeatures.session_id;
   delete publicRawFeatures.sessionId;
   delete publicRawFeatures.passphraseState;
+  const publicRaw = snapshot.raw
+    ? {
+        ...snapshot.raw,
+        protocolV1Features: publicRawFeatures,
+      }
+    : undefined;
   const rawOneKeyFeatures = snapshot.raw?.protocolV1OneKeyFeatures ?? {};
   const bootloaderMode =
     snapshot.protocol === 'V1'
@@ -84,7 +90,7 @@ export const projectFeatures = (state: StoredDeviceState): Features => {
     se04BootVersion: snapshot.versions.se04Boot,
     seVersion: snapshot.versions.se ?? null,
     verify: snapshot.verification,
-    raw: snapshot.raw,
+    raw: publicRaw,
     device_id: snapshot.identity.deviceId ?? undefined,
     ble_name: snapshot.identity.bleName ?? undefined,
     passphrase_protection: snapshot.status.passphraseProtection ?? undefined,

package/src/events/logBlockEvent.ts

@@ -8,6 +8,7 @@ export const LogBlockEvent: Set<string> = new Set([
 const LogBlockMethod: Set<string> = new Set([
   'evmSignTypedData',
   'openWalletSession',
+  'DeviceSessionOpen',
   'deviceUploadWallpaper',
   'uploadPortfolio',
   'fileWrite',

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,