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

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/firmwareUpdatePlan.ts

@@ -20,8 +20,8 @@ export interface FirmwareUpdatePlanArtifact {
   url: string;
   container: 'raw' | 'zip';
   logicalName?: string;
-  expectedSize: number;
-  expectedSha256: string;
+  expectedSize?: number;
+  expectedSha256?: string;
   targetVersion?: string;
 }
 

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(

package/src/utils/bridgeBinaryPayload.ts

@@ -0,0 +1,137 @@
+import { Buffer } from 'buffer';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+// Top-level and low-level SDK instances can be separated by JSON-only hosts,
+// including browser extension background/offscreen message bridges.
+const BRIDGE_BINARY_PAYLOAD_MARKER = '__onekey_hd_bridge_binary_payload__';
+
+type BridgeBinaryPayload = {
+  [BRIDGE_BINARY_PAYLOAD_MARKER]: 1;
+  data: string;
+  type: 'array-buffer' | 'uint8-array';
+};
+
+const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+
+const invalidBinaryPayload = (message: string) =>
+  ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, message);
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function isArrayBufferValue(value: unknown): value is ArrayBuffer {
+  return Boolean(
+    typeof ArrayBuffer !== 'undefined' &&
+      (value instanceof ArrayBuffer ||
+        Object.prototype.toString.call(value) === '[object ArrayBuffer]')
+  );
+}
+
+function isBlobValue(value: unknown): value is Blob {
+  return Boolean(
+    typeof Blob !== 'undefined' &&
+      (value instanceof Blob || Object.prototype.toString.call(value) === '[object Blob]') &&
+      typeof (value as Blob).arrayBuffer === 'function'
+  );
+}
+
+function readBinaryPayload(value: unknown): BridgeBinaryPayload | undefined {
+  if (!isPlainObject(value) || !(BRIDGE_BINARY_PAYLOAD_MARKER in value)) return undefined;
+  const payload = value as Partial<BridgeBinaryPayload>;
+  if (
+    payload[BRIDGE_BINARY_PAYLOAD_MARKER] !== 1 ||
+    (payload.type !== 'array-buffer' && payload.type !== 'uint8-array') ||
+    typeof payload.data !== 'string'
+  ) {
+    throw invalidBinaryPayload('Invalid bridge binary payload');
+  }
+  return payload as BridgeBinaryPayload;
+}
+
+function bytesToPayload(bytes: Uint8Array, type: BridgeBinaryPayload['type']): BridgeBinaryPayload {
+  return {
+    [BRIDGE_BINARY_PAYLOAD_MARKER]: 1,
+    data: Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('base64'),
+    type,
+  };
+}
+
+function payloadToBytes(payload: BridgeBinaryPayload): Uint8Array {
+  if (payload.data.length % 4 !== 0 || !BASE64_PATTERN.test(payload.data)) {
+    throw invalidBinaryPayload('Invalid bridge binary payload data');
+  }
+  const decoded = Buffer.from(payload.data, 'base64');
+  if (decoded.toString('base64') !== payload.data) {
+    throw invalidBinaryPayload('Invalid bridge binary payload data');
+  }
+  return Uint8Array.from(decoded);
+}
+
+async function encodeValue(value: unknown, seen: WeakSet<object>): Promise<unknown> {
+  if (isArrayBufferValue(value)) {
+    return bytesToPayload(new Uint8Array(value), 'array-buffer');
+  }
+  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(value)) {
+    return bytesToPayload(
+      new Uint8Array(value.buffer, value.byteOffset, value.byteLength),
+      'uint8-array'
+    );
+  }
+  if (isBlobValue(value)) {
+    return bytesToPayload(new Uint8Array(await value.arrayBuffer()), 'uint8-array');
+  }
+
+  const encodedPayload = readBinaryPayload(value);
+  if (encodedPayload) return encodedPayload;
+  if (Array.isArray(value)) {
+    if (seen.has(value)) throw invalidBinaryPayload('Circular bridge payload');
+    seen.add(value);
+    try {
+      const encoded: unknown[] = [];
+      for (const item of value) {
+        encoded.push(await encodeValue(item, seen));
+      }
+      return encoded.some((item, index) => item !== value[index]) ? encoded : value;
+    } finally {
+      seen.delete(value);
+    }
+  }
+  if (!isPlainObject(value)) return value;
+  if (seen.has(value)) throw invalidBinaryPayload('Circular bridge payload');
+  seen.add(value);
+  try {
+    const entries: [string, unknown][] = [];
+    for (const [key, item] of Object.entries(value)) {
+      entries.push([key, await encodeValue(item, seen)]);
+    }
+    return entries.some(([key, item]) => item !== value[key]) ? Object.fromEntries(entries) : value;
+  } finally {
+    seen.delete(value);
+  }
+}
+
+function decodeValue(value: unknown): unknown {
+  const payload = readBinaryPayload(value);
+  if (payload) {
+    const bytes = payloadToBytes(payload);
+    return payload.type === 'array-buffer' ? bytes.buffer : bytes;
+  }
+  if (Array.isArray(value)) {
+    const decoded = value.map(decodeValue);
+    return decoded.some((item, index) => item !== value[index]) ? decoded : value;
+  }
+  if (!isPlainObject(value)) return value;
+  const entries = Object.entries(value).map(([key, item]) => [key, decodeValue(item)] as const);
+  return entries.some(([key, item]) => item !== value[key]) ? Object.fromEntries(entries) : value;
+}
+
+export async function encodeBridgeBinaryPayload(value: unknown): Promise<unknown> {
+  return encodeValue(value, new WeakSet());
+}
+
+export function decodeBridgeBinaryPayload(value: unknown): unknown {
+  return decodeValue(value);
+}