@onekeyfe/hd-core 1.2.0-alpha.162 → 1.2.0-alpha.164

package/src/core/index.ts

@@ -415,6 +415,10 @@ const onCallDevice = async (
   if (method.payload?.onlyConnectBleDevice) {
     preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
+    // This early return bypasses the normal-path releaseTask at the end of the
+    // call; without it the task leaks and haunts every later queue snapshot
+    // and cancel sweep (field log: a completed task lingered for 6 minutes).
+    requestQueue.releaseTask(method.responseID);
     return createResponseMessage(method.responseID, true, null);
   }
 
@@ -954,7 +958,60 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
  * If the Bluetooth connection times out, retry up to 6 times
  * @param retryCount - Current retry count (default 0)
  */
-async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
+// device.acquire awaits a transport reply with no deadline of its own; a
+// transport that never settles (field case: Electron main lost an IPC reply,
+// "reply was never sent" after 5 minutes) hangs the call forever and cancel()
+// only takes effect at poll checkpoints. Race acquire against a deadline and
+// the caller's abort signal so the hang is bounded and cancel is immediate.
+const BLE_ACQUIRE_DEADLINE_MS = 60 * 1000;
+
+function raceBleAcquire<T>(acquirePromise: Promise<T>, abortSignal?: AbortSignal): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    let settled = false;
+    const settle = (fn: () => void) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      abortSignal?.removeEventListener('abort', onAbort);
+      fn();
+    };
+    const onAbort = () =>
+      settle(() => reject(ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)));
+    const deadline = setTimeout(
+      () =>
+        settle(() =>
+          reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.BleTimeoutError,
+              `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`
+            )
+          )
+        ),
+      BLE_ACQUIRE_DEADLINE_MS
+    );
+    // Attach before any early return so a late settlement of acquirePromise
+    // is always consumed — an abort or deadline must never leave the acquire
+    // rejection unhandled.
+    acquirePromise.then(
+      value => settle(() => resolve(value)),
+      error => settle(() => reject(error))
+    );
+    if (abortSignal) {
+      if (abortSignal.aborted) {
+        onAbort();
+        return;
+      }
+      abortSignal.addEventListener('abort', onAbort);
+    }
+  });
+}
+
+async function connectDeviceForBle(
+  method: BaseMethod,
+  device: Device,
+  abortSignal?: AbortSignal,
+  retryCount = 0
+) {
   try {
     if (device.wasInterruptedByUser()) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
@@ -968,9 +1025,43 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
       !device.commands ||
       device.commands.disposed;
     if (shouldAcquire) {
-      await device.acquire(method.payload.connectProtocol, {
-        forceProtocolDetection: method.payload.forceProtocolDetection,
-      });
+      // The deadline/abort guards are scoped to the desktop electron
+      // transport: its IPC acquire is the only path with a proven
+      // never-settling failure mode, while react-native/lowlevel acquire may
+      // legitimately block on a user-driven system bonding prompt for longer
+      // than any sane deadline. Other envs keep the plain acquire unchanged.
+      const useAcquireGuards = DataManager.getSettings('env') === 'desktop-web-ble';
+      // A cancel landing during the retry backoff must not start a new acquire.
+      if (useAcquireGuards && abortSignal?.aborted) {
+        throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
+      }
+      if (!useAcquireGuards) {
+        await device.acquire(method.payload.connectProtocol, {
+          forceProtocolDetection: method.payload.forceProtocolDetection,
+        });
+      } else {
+        try {
+          await raceBleAcquire(
+            device.acquire(method.payload.connectProtocol, {
+              forceProtocolDetection: method.payload.forceProtocolDetection,
+            }),
+            abortSignal
+          );
+        } catch (err) {
+          // A deadline hit means the transport is wedged mid-acquire; drop the
+          // link before the retry so it cold-connects instead of stacking a
+          // second connect onto the half-open one.
+          if (
+            err.errorCode === HardwareErrorCode.BleTimeoutError &&
+            device.mainId &&
+            device.deviceConnector
+          ) {
+            await device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
+            device.markTransportDisconnected();
+          }
+          throw err;
+        }
+      }
     }
     if (method.payload?.onlyConnectBleDevice) {
       if (shouldAcquire) {
@@ -1010,7 +1101,7 @@ async function connectDeviceForBle(method: BaseMethod, device: Device, retryCoun
       const nextRetry = retryCount + 1;
       Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
       await wait(3000);
-      await connectDeviceForBle(method, device, nextRetry);
+      await connectDeviceForBle(method, device, abortSignal, nextRetry);
     } else {
       throw err;
     }
@@ -1120,7 +1211,7 @@ const ensureConnected = async (
             if (tryCount === 1) {
               device.beginConnectionAttempt();
             }
-            await connectDeviceForBle(method, device);
+            await connectDeviceForBle(method, device, abortSignal);
           }
           resolve(device);
           return;

package/src/device/Device.ts

@@ -9,7 +9,6 @@ import {
   ERROR_CODES_REQUIRE_RELEASE,
   HardwareError,
   HardwareErrorCode,
-  canonicalizePro2BleAdvertisementName,
   createDeferred,
   createDeviceNotSupportMethodError,
 } from '@onekeyfe/hd-shared';
@@ -673,8 +672,7 @@ export class Device extends EventEmitter {
   }
 
   getCurrentBleName() {
-    const bleName = this.state?.identity.bleName ?? null;
-    return bleName ? canonicalizePro2BleAdvertisementName(bleName) : null;
+    return this.state?.identity.bleName ?? null;
   }
 
   getCurrentLabel() {

package/src/device/DeviceStateMapper.ts

@@ -1,4 +1,4 @@
-import { EFirmwareType, canonicalizePro2BleAdvertisementName } from '@onekeyfe/hd-shared';
+import { EFirmwareType, normalizePro2FindMyAdvertisementName } from '@onekeyfe/hd-shared';
 
 import { buildProtocolV1FeaturesPayload } from '../deviceProfile/buildDeviceFeatures';
 import { resolveProtocolV2DeviceIdentity } from '../deviceProfile/protocolV2DeviceIdentity';
@@ -248,7 +248,7 @@ export const mapProtocolV2DeviceInfoToState = (
       vendor: 'onekey.so',
       serialNo: info.hw?.serial_no,
       bleName: info.coprocessor?.bt_adv_name
-        ? canonicalizePro2BleAdvertisementName(info.coprocessor.bt_adv_name)
+        ? normalizePro2FindMyAdvertisementName(info.coprocessor.bt_adv_name)
         : undefined,
       deviceId: loader ? null : undefined,
     }),

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -1,8 +1,4 @@
-import {
-  EDeviceType,
-  EFirmwareType,
-  canonicalizePro2BleAdvertisementName,
-} from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
 import {
   resolveDeviceBleFirmwareVersion,
@@ -249,8 +245,7 @@ export const buildProtocolV2FeaturesPayload = ({
   const deviceId = status?.device_id ?? cached?.deviceId ?? null;
   const serialNo = firstValue(incomingSerialNo, cached?.serialNo) ?? '';
   const label = cached?.label ?? null;
-  const rawBleName = firstValue(info?.coprocessor?.bt_adv_name, cached?.bleName);
-  const bleName = rawBleName ? canonicalizePro2BleAdvertisementName(rawBleName) : rawBleName;
+  const bleName = firstValue(info?.coprocessor?.bt_adv_name, cached?.bleName);
   const initialized = firstValue(status?.init_states, cached?.initialized) ?? null;
   // passphrase_enabled from a locked Pro2 is not authoritative. Only DeviceStatus
   // after PIN unlock can determine the final passphrase setting.

package/src/index.ts

@@ -21,6 +21,12 @@ export { executeCallback, cleanupCallback };
 export { preloadSessionCache } from './device/Device';
 export { projectFeatures as projectDeviceStateFeatures } from './device/DeviceStateProjector';
 export { getMethodSupportedProtocols } from './api/utils';
+export { prepareFirmwareUpdateV4MemoryHost } from './api/firmware/FirmwareMemoryHost';
+export type {
+  FirmwareMemoryArtifact,
+  FirmwareMemoryArtifactEntry,
+  FirmwareUpdateV4MemoryHost,
+} from './api/firmware/FirmwareMemoryHost';
 export {
   getFirmwareUpdateHostBindingGeneration,
   registerFirmwareUpdateHostBinding,

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

@@ -49,22 +49,10 @@ export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources |
   };
 }
 
-export function isProtocolV2ResourceArchiveEntryName(entryName: string): boolean {
-  const normalized = entryName.replace(/\\/g, '/');
-  if (!normalized.toLowerCase().endsWith('.okpkg')) {
-    return false;
-  }
-  const parts = normalized.split('/');
-  const fileName = parts[parts.length - 1] ?? '';
-  return (
-    fileName.length > 0 &&
-    !fileName.startsWith('.') &&
-    !parts.some(part => part === '__MACOSX' || part === '.' || part === '..' || part === '')
-  );
-}
+const PROTOCOL_V2_RESOURCE_DEVICE_ROOTS = ['vol0:/bundles/', 'vol0:/loaders/rom/'] as const;
 
-function isSafeResourceDevicePath(path: string): boolean {
-  return !(
+function isAllowedResourceDevicePath(path: string): boolean {
+  if (
     path.includes('\\') ||
     path.includes('//') ||
     [...path].some(char => {
@@ -72,6 +60,14 @@ function isSafeResourceDevicePath(path: string): boolean {
       return code <= 0x1f || code === 0x7f;
     }) ||
     path.split('/').some(part => part === '.' || part === '..')
+  ) {
+    return false;
+  }
+  if (path === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH) {
+    return true;
+  }
+  return (
+    path.endsWith('.okpkg') && PROTOCOL_V2_RESOURCE_DEVICE_ROOTS.some(root => path.startsWith(root))
   );
 }
 
@@ -97,7 +93,7 @@ function readResourceDevicePath(bytes: Uint8Array): string {
     throw new Error('Invalid Pro2 RESOURCE package device path metadata');
   }
   const path = readAscii(pathBytes, 0, pathBytes.byteLength);
-  if (!isSafeResourceDevicePath(path)) {
+  if (!isAllowedResourceDevicePath(path)) {
     throw new Error(`Invalid Pro2 RESOURCE package device path: ${path}`);
   }
   return path;

package/src/types/api/firmwareUpdate.ts

@@ -158,7 +158,7 @@ export interface FirmwareUpdateV4Params {
   se02Binary?: ArrayBuffer;
   se03Binary?: ArrayBuffer;
   se04Binary?: ArrayBuffer;
-  /** Complete Protocol V2 resource ZIP. Core parses RESC packages and writes only changed files. */
+  /** Complete Protocol V2 resource ZIP for local development; Core converts it to a local PreparedPlan. */
   resourceArchiveBinary?: ArrayBuffer;
   forcedUpdateRes?: boolean;
   artifactReader?: FirmwareArtifactReader;

package/src/utils/deviceFeaturesCompat.ts

@@ -1,8 +1,4 @@
-import {
-  EDeviceType,
-  EFirmwareType,
-  canonicalizePro2BleAdvertisementName,
-} from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 import { Enum_Capability } from '@onekeyfe/hd-transport';
 
 import type { PROTO } from '../constants';
@@ -129,10 +125,9 @@ export const resolveDeviceFirmwareType = (features?: DeviceFeaturesInput): EFirm
 export const resolveDeviceBleName = (features?: DeviceFeaturesInput): string | null => {
   if (!features) return null;
   const compatible = asCompatibleFeatures(features);
-  const bleName =
-    firstNonEmptyString(compatible.bleName, compatible.onekey_ble_name, compatible.ble_name) ??
-    null;
-  return bleName ? canonicalizePro2BleAdvertisementName(bleName) : null;
+  return (
+    firstNonEmptyString(compatible.bleName, compatible.onekey_ble_name, compatible.ble_name) ?? null
+  );
 };
 
 export const resolveDeviceFirmwareVersion = (features?: DeviceFeaturesInput): string | null => {

package/src/utils/deviceInfoUtils.ts

@@ -31,9 +31,7 @@ export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
   if (/^Touch/i.test(name)) return EDeviceType.Touch;
 
   const compactName = name.replace(/[\s-]/g, '');
-  // Require a 4-hex Pro2 suffix in the compact form. A bare `^Pro2` prefix
-  // would also match OneKey Pro names such as "Pro 22D8" / "Pro 2D8F".
-  if (/\bPro\s*2\b/i.test(name) || /^(?:OneKey)?Pro2[a-f0-9]{4}$/i.test(compactName)) {
+  if (/\bPro\s*2\b/i.test(name) || /^Pro2/i.test(name) || /^(?:OneKey)?Pro2/i.test(compactName)) {
     return EDeviceType.Pro2;
   }
   if (/\bNeo\b/i.test(name) || /^Neo/i.test(name) || /^(?:OneKey)?Neo/i.test(compactName)) {