@onekeyfe/hd-core 1.2.0-alpha.101 → 1.2.0-alpha.102

package/src/api/FirmwareUpdateV4.ts

@@ -28,6 +28,7 @@ import { DevicePool } from '../device/DevicePool';
 import {
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
   ProtocolV2FirmwareTargetType,
+  isLegacyProtocolV2ProtocolInfo,
 } from '../protocols/protocol-v2';
 import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
 import {
@@ -393,6 +394,13 @@ const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
   );
 };
 
+const isProtocolV2FirmwareUpdateEndpointUnavailable = (error: unknown) => {
+  const message = getProtocolV2UnknownErrorText(error).toLowerCase();
+  return (
+    message.includes('handler not registered') || message.includes('message handler not found')
+  );
+};
+
 const isProtocolV2TerminalInstallStatusError = (error: unknown) =>
   error instanceof HardwareError &&
   (error.errorCode === HardwareErrorCode.FirmwareError ||
@@ -587,6 +595,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2ExecutionInLoader = false;
 
+  private protocolV2LegacyDirectUpdate = false;
+
   private protocolV2BootResourceStagingSafe = false;
 
   private protocolV2CompletedTargetVersions = new Map<number, number>();
@@ -2067,21 +2077,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return this.device.features?.mode === 'romloader';
   }
 
-  async enterProtocolV2BootloaderMode() {
-    // romloader is the first update environment and forwards targets to bootloader.
-    // It rejects DeviceRebootType.Bootloader, so reuse the current connection.
-    if (this.isProtocolV2RomloaderMode()) {
-      Log.debug('Protocol V2 device is in romloader mode; start firmware update directly');
-      this.protocolV2ExecutionInLoader = true;
-      return false;
-    }
-    if (this.isProtocolV2BootloaderMode()) {
-      Log.debug('Protocol V2 device is already in bootloader mode, skip reboot');
-      this.protocolV2ExecutionInLoader = true;
-      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
-      return false;
-    }
+  private isLegacyProtocolV2Runtime() {
+    const protocolInfo = this.device.state?.raw?.protocolV2ProtocolInfo;
+    return protocolInfo ? isLegacyProtocolV2ProtocolInfo(protocolInfo) : false;
+  }
 
+  private async rebootProtocolV2ToBootloader() {
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.AutoRebootToBootloader);
       await this.protocolV2Reboot(DeviceRebootType.Bootloader);
@@ -2099,6 +2100,27 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
   }
 
+  async enterProtocolV2BootloaderMode() {
+    this.protocolV2LegacyDirectUpdate = false;
+    // romloader is the first update environment and forwards targets to bootloader.
+    // It rejects DeviceRebootType.Bootloader, so reuse the current connection.
+    if (this.isProtocolV2RomloaderMode()) {
+      Log.debug('Protocol V2 device is in romloader mode; start firmware update directly');
+      this.protocolV2LegacyDirectUpdate = this.isLegacyProtocolV2Runtime();
+      this.protocolV2ExecutionInLoader = true;
+      return false;
+    }
+    if (this.isProtocolV2BootloaderMode()) {
+      Log.debug('Protocol V2 device is already in bootloader mode, skip reboot');
+      this.protocolV2LegacyDirectUpdate = this.isLegacyProtocolV2Runtime();
+      this.protocolV2ExecutionInLoader = true;
+      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
+      return false;
+    }
+
+    return this.rebootProtocolV2ToBootloader();
+  }
+
   private async waitForProtocolV2BootloaderMode(
     timeout = PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT,
     retryInterval = 1000
@@ -2120,7 +2142,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
         const features = await this.device.probeProtocolV2RuntimeState(
           deviceInfo,
-          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+          { allowLegacyProtocolV2ProtocolInfo: true }
         );
         if (features?.mode === 'bootloader') {
           return features;
@@ -2809,7 +2832,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private async probeProtocolV2NormalMode(deviceInfo: ProtocolV2DeviceInfo) {
     const features = await this.device.probeProtocolV2RuntimeState(
       deviceInfo,
-      PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+      PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+      { allowLegacyProtocolV2ProtocolInfo: true }
     );
     return features.mode === 'normal' && !features.bootloaderMode;
   }
@@ -2871,7 +2895,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
         const features = await this.device.probeProtocolV2RuntimeState(
           deviceInfo,
-          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+          { allowLegacyProtocolV2ProtocolInfo: true }
         );
         if (features.mode === 'normal' && !features.bootloaderMode) {
           return features;
@@ -3044,12 +3069,34 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     targets: Array<{ target_id: number; path: string }>;
   }) {
     const commands = this.device.getCommands();
-    const response: ProtocolV2FirmwareUpdateStartResponse = await commands.typedCall(
-      'DeviceFirmwareUpdateRequest',
-      'Success',
-      { targets },
-      { timeoutMs: PROTOCOL_V2_START_UPDATE_TIMEOUT }
-    );
+    const startUpdate = () =>
+      commands.typedCall(
+        'DeviceFirmwareUpdateRequest',
+        'Success',
+        { targets },
+        { timeoutMs: PROTOCOL_V2_START_UPDATE_TIMEOUT }
+      );
+    let response: ProtocolV2FirmwareUpdateStartResponse;
+    try {
+      response = await startUpdate();
+    } catch (error) {
+      if (
+        !this.protocolV2LegacyDirectUpdate ||
+        !isProtocolV2FirmwareUpdateEndpointUnavailable(error)
+      ) {
+        throw error;
+      }
+
+      // Both legacy loaders register this request. A missing handler therefore identifies
+      // a legacy App before dispatch, so it is safe to reboot and retry the unhandled request.
+      this.protocolV2LegacyDirectUpdate = false;
+      Log.debug(
+        '[FirmwareUpdateV4] legacy App does not expose DeviceFirmwareUpdateRequest; rebooting to bootloader'
+      );
+      await this.rebootProtocolV2ToBootloader();
+      response = await startUpdate();
+    }
+    this.protocolV2LegacyDirectUpdate = false;
     // Success acknowledges that the device accepted installation. End confirmation
     // and begin status polling only after receiving this ACK.
     this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdating);

package/src/api/GetDeviceState.ts

@@ -43,6 +43,7 @@ export default class GetDeviceState extends BaseMethod<
   async run() {
     const state = await this.device.getDeviceState({
       refreshSections: SCOPE_SECTIONS[this.params.scope],
+      ...(this.params.scope === 'firmware' ? { allowLegacyProtocolV2ProtocolInfo: true } : {}),
     });
     if (
       this.params.scope === 'settings' &&

package/src/api/SearchDevices.ts

@@ -63,6 +63,8 @@ export default class SearchDevices extends BaseMethod {
           connectProtocol: undefined,
           forceProtocolDetection: true,
           refreshRuntimeState: true,
+          // Old loader firmware predates build_fingerprint. Keep this recovery-only.
+          allowLegacyProtocolV2ProtocolInfo: true,
         });
         deviceList.push(...result.deviceList);
       } catch (error) {

package/src/api/firmware/protocolV2Release.ts

@@ -60,6 +60,7 @@ export async function loadProtocolV2FirmwareReleaseContext({
     refreshSections: checkFirmwareHash
       ? ['identity', 'versions', 'verification']
       : ['identity', 'versions'],
+    allowLegacyProtocolV2ProtocolInfo: true,
   });
   if (state.identity.deviceType !== 'pro2' && state.identity.deviceType !== 'neo') {
     throw ERRORS.TypedError(

package/src/api/ton/TonSignMessage.ts

@@ -174,12 +174,14 @@ export default class TonSignMessage extends BaseMethod<HardwareTonSignMessage> {
     if (!request.init_data_length) {
       const deviceType = this.device.getCurrentDeviceType();
       const hasClassic = DeviceModelToTypes.model_classic1s.includes(deviceType);
-      // use signing_message_repr sign, not exists signning_message, skip validate
-      const hasSigningMessageRepr = request.signning_message == null;
+      const signingMessage = request.signing_message ?? request.signning_message;
+      // Blind signing omits the signing message in both protocol schemas.
+      const shouldSkipValidation = signingMessage == null;
 
       return Promise.resolve({
         ...request,
-        skip_validate: hasClassic || hasSigningMessageRepr,
+        signing_message: signingMessage,
+        skip_validate: hasClassic || shouldSkipValidation,
       });
     }
 

package/src/api/utils.ts

@@ -1,6 +1,7 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import * as ApiMethods from './index';
+import { decodeBridgeBinaryPayload } from '../utils/bridgeBinaryPayload';
 
 import type { BaseMethod } from './BaseMethod';
 import type { IFrameCallMessage } from '../events';
@@ -11,14 +12,16 @@ type MethodConstructor = new (message: IFrameCallMessage & { id?: number }) => B
 const publicMethodRegistry = ApiMethods as unknown as Record<string, MethodConstructor>;
 
 export function findMethod(message: IFrameCallMessage & { id?: number }): BaseMethod<any> {
-  const { method } = message.payload;
+  const payload = decodeBridgeBinaryPayload(message.payload) as IFrameCallMessage['payload'];
+  const normalizedMessage = payload === message.payload ? message : { ...message, payload };
+  const { method } = payload;
   if (typeof method !== 'string') {
     throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
   }
 
   const MethodConstructor = publicMethodRegistry[method];
   if (MethodConstructor) {
-    return new MethodConstructor(message);
+    return new MethodConstructor(normalizedMessage);
   }
 
   throw ERRORS.TypedError(

package/src/core/index.ts

@@ -64,6 +64,7 @@ import {
   isProtocolV2UiEnabled,
 } from '../protocols/protocol-v2/uiInteraction';
 import { createUiProgressMessageFilter } from '../utils/uiProgressThrottle';
+import { isLegacyProtocolV2FirmwareRecoveryMethod } from './protocolV2LegacyRecovery';
 
 import type { ConnectSettings, Features, KnownDevice } from '../types';
 import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
@@ -109,6 +110,9 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   connectProtocol: method?.payload.connectProtocol,
   forceProtocolDetection: method?.payload.forceProtocolDetection,
   protocolV2DeviceInfoTimeoutMs: method?.payload.protocolV2DeviceInfoTimeoutMs,
+  ...(isLegacyProtocolV2FirmwareRecoveryMethod(method)
+    ? { allowLegacyProtocolV2ProtocolInfo: true }
+    : {}),
 });
 
 let _core: Core | undefined;

package/src/core/protocolV2LegacyRecovery.ts

@@ -0,0 +1,12 @@
+import type { BaseMethod } from '../api/BaseMethod';
+
+type CoreMethodDescriptor = Pick<BaseMethod, 'name' | 'payload'>;
+
+/**
+ * TEMPORARY COMPATIBILITY: Legacy ProtocolInfo is accepted only by the
+ * firmware recovery entry points used before and during Protocol V2 updates.
+ */
+export const isLegacyProtocolV2FirmwareRecoveryMethod = (method?: CoreMethodDescriptor): boolean =>
+  method?.name === 'firmwareUpdateV4' ||
+  method?.name === 'checkAllFirmwareRelease' ||
+  (method?.name === 'getDeviceState' && method.payload.scope === 'firmware');

package/src/device/Device.ts

@@ -61,6 +61,7 @@ import {
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
   type ProtocolV2RuntimeMode,
   getProtocolV2RuntimeMode,
+  isLegacyProtocolV2ProtocolInfo,
   requestProtocolV2DeviceInfo,
   requestProtocolV2DeviceStatus,
   requestProtocolV2ProtocolInfo,
@@ -99,6 +100,8 @@ export type InitOptions = {
   protocolV2DeviceInfoTimeoutMs?: number;
   /** Refresh Protocol V2 runtime state before returning discovery results. */
   refreshRuntimeState?: boolean;
+  /** Recovery-only compatibility used by discovery and Protocol V2 firmware updates. */
+  allowLegacyProtocolV2ProtocolInfo?: boolean;
   /**
    * Protocol V1 Initialize response timeout override. Reboot-wait polling passes a
    * short value so an unanswered probe settles before the next poll tick.
@@ -977,10 +980,16 @@ export class Device extends EventEmitter {
       });
       // The default request excludes SE/hash data and therefore uses basic scope.
       // Full version and verification data require getDeviceState({ scope: 'firmware' }).
-      const features = await this.probeProtocolV2RuntimeState(
-        deviceInfo,
-        options?.protocolV2DeviceInfoTimeoutMs
-      );
+      const features = options?.allowLegacyProtocolV2ProtocolInfo
+        ? await this.probeProtocolV2RuntimeState(
+            deviceInfo,
+            options.protocolV2DeviceInfoTimeoutMs,
+            { allowLegacyProtocolV2ProtocolInfo: true }
+          )
+        : await this.probeProtocolV2RuntimeState(
+            deviceInfo,
+            options?.protocolV2DeviceInfoTimeoutMs
+          );
       Log.debug('Protocol V2 features:', features);
     } catch (error) {
       Log.error('Protocol V2 initialization failed:', error);
@@ -1017,7 +1026,13 @@ export class Device extends EventEmitter {
           commands: this.commands,
           request: getProtocolV2DeviceInfoRequest(),
         });
-        await this.probeProtocolV2RuntimeState(deviceInfo);
+        if (params.allowLegacyProtocolV2ProtocolInfo) {
+          await this.probeProtocolV2RuntimeState(deviceInfo, undefined, {
+            allowLegacyProtocolV2ProtocolInfo: true,
+          });
+        } else {
+          await this.probeProtocolV2RuntimeState(deviceInfo);
+        }
         refreshedDeviceInfo = deviceInfo;
         initializedWithDeviceInfo = true;
       } else {
@@ -1053,7 +1068,16 @@ export class Device extends EventEmitter {
       }
 
       if (refresh.has('status') && !initializedWithDeviceInfo) {
-        await this.probeProtocolV2RuntimeState(refreshedDeviceInfo);
+        const cachedMode = this.state?.status.mode;
+        await this.probeProtocolV2RuntimeState(refreshedDeviceInfo, undefined, {
+          // Loader firmware does not support DeviceStatusGet. Renegotiate ProtocolInfo
+          // during an explicit refresh so a device rebooted into application firmware
+          // can leave the cached loader state.
+          forceRuntimeContextRefresh: cachedMode === 'bootloader' || cachedMode === 'romloader',
+          ...(params.allowLegacyProtocolV2ProtocolInfo
+            ? { allowLegacyProtocolV2ProtocolInfo: true }
+            : {}),
+        });
       }
 
       if (refresh.has('settings') && this.state?.status.mode === 'normal') {
@@ -1124,19 +1148,39 @@ export class Device extends EventEmitter {
     return this.features;
   }
 
-  async ensureProtocolV2RuntimeContext(timeoutMs?: number): Promise<ProtocolInfo> {
+  async ensureProtocolV2RuntimeContext(
+    timeoutMs?: number,
+    options?: {
+      forceRefresh?: boolean;
+      allowLegacyProtocolV2ProtocolInfo?: boolean;
+    }
+  ): Promise<ProtocolInfo> {
+    const assertProtocolInfoAllowed = (protocolInfo: ProtocolInfo) => {
+      if (
+        isLegacyProtocolV2ProtocolInfo(protocolInfo) &&
+        options?.allowLegacyProtocolV2ProtocolInfo !== true
+      ) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.DeviceInitializeFailed,
+          'Legacy Protocol V2 ProtocolInfo is supported only during device discovery and firmware update.'
+        );
+      }
+      return protocolInfo;
+    };
     const cachedProtocolInfo =
-      this.protocolV2RuntimeContext ??
-      (!this.protocolV2StateNeedsReload
-        ? this.state?.raw?.protocolV2ProtocolInfo ?? undefined
-        : undefined);
+      options?.forceRefresh === true
+        ? undefined
+        : this.protocolV2RuntimeContext ??
+          (!this.protocolV2StateNeedsReload
+            ? this.state?.raw?.protocolV2ProtocolInfo ?? undefined
+            : undefined);
     if (cachedProtocolInfo) {
       this.protocolV2RuntimeContext = cachedProtocolInfo;
-      return cachedProtocolInfo;
+      return assertProtocolInfoAllowed(cachedProtocolInfo);
     }
 
     if (this.protocolV2RuntimeContextPromise) {
-      return this.protocolV2RuntimeContextPromise;
+      return assertProtocolInfoAllowed(await this.protocolV2RuntimeContextPromise);
     }
 
     const requestToken = {};
@@ -1158,7 +1202,7 @@ export class Device extends EventEmitter {
     this.protocolV2RuntimeContextPromise = pendingRequest;
 
     try {
-      return await pendingRequest;
+      return assertProtocolInfoAllowed(await pendingRequest);
     } finally {
       if (this.protocolV2RuntimeContextPromise === pendingRequest) {
         this.protocolV2RuntimeContextPromise = undefined;
@@ -1169,9 +1213,20 @@ export class Device extends EventEmitter {
     }
   }
 
-  async probeProtocolV2RuntimeState(deviceInfo?: ProtocolV2DeviceInfo, timeoutMs?: number) {
-    const protocolInfo = await this.ensureProtocolV2RuntimeContext(timeoutMs);
+  async probeProtocolV2RuntimeState(
+    deviceInfo?: ProtocolV2DeviceInfo,
+    timeoutMs?: number,
+    options?: {
+      forceRuntimeContextRefresh?: boolean;
+      allowLegacyProtocolV2ProtocolInfo?: boolean;
+    }
+  ) {
+    const protocolInfo = await this.ensureProtocolV2RuntimeContext(timeoutMs, {
+      forceRefresh: options?.forceRuntimeContextRefresh,
+      allowLegacyProtocolV2ProtocolInfo: options?.allowLegacyProtocolV2ProtocolInfo,
+    });
     const runtimeMode = getProtocolV2RuntimeMode(protocolInfo);
+    const legacyProtocolInfo = isLegacyProtocolV2ProtocolInfo(protocolInfo);
     const runtimeDeviceInfo = deviceInfo ?? this.state?.raw?.protocolV2DeviceInfo;
     const protocolV2DeviceType = runtimeDeviceInfo
       ? resolveProtocolV2DeviceIdentity(runtimeDeviceInfo.hw?.Device_type).deviceType
@@ -1186,10 +1241,9 @@ export class Device extends EventEmitter {
         'Protocol V2 romloader mode is only supported for Pro2 and Neo.'
       );
     }
-    const deviceStatusSupported = supportsProtocolV2Message(
-      protocolInfo,
-      PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE
-    );
+    const deviceStatusSupported =
+      legacyProtocolInfo ||
+      supportsProtocolV2Message(protocolInfo, PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE);
 
     if (runtimeMode === 'bootloader' || runtimeMode === 'romloader') {
       return this.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
@@ -1491,6 +1545,10 @@ export class Device extends EventEmitter {
 
   async interruptionFromUser() {
     const error = ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+    // Cancellation often ends the transport session, especially during firmware
+    // update reboot or exit. Invalidate V2 state before awaiting asynchronous
+    // cancellation callbacks so the next request cannot reuse a stale runtime mode.
+    this.markTransportDisconnected();
     await this.cancelableAction?.(error);
     await this.commands?.cancel();
 

package/src/device/DevicePool.ts

@@ -182,7 +182,7 @@ export class DevicePool extends EventEmitter {
       try {
         await device.initialize(initOptions);
         if (initOptions?.refreshRuntimeState && device.isProtocolV2()) {
-          await this._refreshProtocolV2DiscoveryState(device);
+          await this._refreshProtocolV2DiscoveryState(device, initOptions);
         }
       } finally {
         await device.release();
@@ -197,7 +197,7 @@ export class DevicePool extends EventEmitter {
     await device.run(
       async () => {
         try {
-          await this._refreshProtocolV2DiscoveryState(device);
+          await this._refreshProtocolV2DiscoveryState(device, initOptions);
         } catch (error) {
           // Device.run releases after the callback; then propagate the actual read error.
           refreshError = error;
@@ -206,6 +206,9 @@ export class DevicePool extends EventEmitter {
       {
         connectProtocol: initOptions.connectProtocol,
         forceProtocolDetection: initOptions.forceProtocolDetection,
+        ...(initOptions.allowLegacyProtocolV2ProtocolInfo
+          ? { allowLegacyProtocolV2ProtocolInfo: true }
+          : {}),
       }
     );
     if (refreshError instanceof Error) throw refreshError;
@@ -217,10 +220,19 @@ export class DevicePool extends EventEmitter {
    * error; settings only supplies a label, so its failure retains the existing name.
    * Device.getDeviceState skips unsupported status/settings calls in loader mode.
    */
-  static async _refreshProtocolV2DiscoveryState(device: Device) {
-    await device.getDeviceState({ refreshSections: ['status'] });
+  static async _refreshProtocolV2DiscoveryState(device: Device, initOptions?: InitOptions) {
+    const stateReadOptions = initOptions?.allowLegacyProtocolV2ProtocolInfo
+      ? { allowLegacyProtocolV2ProtocolInfo: true as const }
+      : {};
+    await device.getDeviceState({
+      refreshSections: ['status'],
+      ...stateReadOptions,
+    });
     try {
-      await device.getDeviceState({ refreshSections: ['settings'] });
+      await device.getDeviceState({
+        refreshSections: ['settings'],
+        ...stateReadOptions,
+      });
     } catch (error) {
       Log.debug('Unable to refresh Protocol V2 device label during discovery', error);
     }

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

@@ -56,6 +56,16 @@ export const getProtocolV2SeType = (se?: DeviceSEInfo): string | null =>
 
 export type ProtocolV2RuntimeMode = 'normal' | 'bootloader' | 'romloader';
 
+export type ProtocolV2ProtocolInfo = ProtocolInfo & {
+  /** Present only when hd-transport decoded the pre-build-fingerprint wire layout. */
+  protobuf_definition?: string | null;
+};
+
+export const isLegacyProtocolV2ProtocolInfo = (
+  protocolInfo: ProtocolInfo
+): protocolInfo is ProtocolV2ProtocolInfo & { protobuf_definition: string | null } =>
+  Object.prototype.hasOwnProperty.call(protocolInfo, 'protobuf_definition');
+
 /**
  * Protocol V2 fingerprints use:
  * <binary>__<version>__<commit>__<PROD|DEV>__<DEBUG|RELEASE>

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

@@ -7,6 +7,7 @@ export {
   getProtocolV2RuntimeMode,
   getProtocolV2SeState,
   getProtocolV2SeType,
+  isLegacyProtocolV2ProtocolInfo,
   parseProtocolV2BuildFingerprint,
   requestProtocolV2ProtocolInfo,
   supportsProtocolV2Message,
@@ -18,6 +19,7 @@ export type {
   ProtocolV2SEInfo,
   ProtocolV2SeStateLabel,
   ProtocolV2RuntimeMode,
+  ProtocolV2ProtocolInfo,
 } from './features';
 export * from './firmware';
 export * from './walletSession';

package/src/topLevelInject.ts

@@ -2,6 +2,7 @@ import EventEmitter from 'events';
 
 import { createCoreApi, createProtocolAwareCall } from './inject';
 import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
+import { encodeBridgeBinaryPayload } from './utils/bridgeBinaryPayload';
 
 import type { ConnectSettings } from './types/settings';
 import type { CoreApi } from './types/api';
@@ -16,9 +17,10 @@ const eventEmitter = new EventEmitter();
 
 export const topLevelInject = () => {
   let lowLevelApi: LowLevelCoreApi | undefined;
-  const call = (params: any) => {
+  const call = async (params: any) => {
     if (!lowLevelApi) return Promise.resolve(undefined);
-    return lowLevelApi.call(params);
+    const encodedParams = await encodeBridgeBinaryPayload(params);
+    return lowLevelApi.call(encodedParams as any);
   };
   const protocolAwareCall = createProtocolAwareCall(call);
   const api: CoreApi = {

package/src/types/api/getDeviceState.ts

@@ -11,6 +11,8 @@ export type GetDeviceStateParams = CommonParams & {
 export type DeviceStateReadOptions = {
   refreshSections?: DeviceStateSection[];
   includeRaw?: boolean;
+  /** Internal recovery-only compatibility used by discovery and firmware update flows. */
+  allowLegacyProtocolV2ProtocolInfo?: boolean;
 };
 
 export declare function getDeviceState(