@onekeyfe/hd-core 1.2.0-alpha.145 → 1.2.0-alpha.147

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);
   }
 
@@ -914,13 +918,10 @@ function canSkipInitialize(method: BaseMethod, device: Device): boolean {
   return true;
 }
 
-export function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
-  const typedError = error as { errorCode?: unknown; message?: unknown };
-  const message =
-    typeof typedError?.message === 'string' ? typedError.message : String(error ?? '');
+function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
+  const message = error instanceof Error ? error.message : String(error ?? '');
   return (
     method.payload.connectProtocol === 'V2' &&
-    typedError?.errorCode === HardwareErrorCode.RuntimeError &&
     message.includes('Device protocol mismatch') &&
     message.includes('expected V2') &&
     message.includes('did not respond to expected protocol')
@@ -941,7 +942,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 (method.payload.forceProtocolDetection && device.hasDeviceAcquire()) {
       await device.release();
@@ -952,9 +1006,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) {
@@ -1000,7 +1088,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;
     }
@@ -1105,7 +1193,7 @@ const ensureConnected = async (
             if (abort()) {
               return;
             }
-            await connectDeviceForBle(method, device);
+            await connectDeviceForBle(method, device, abortSignal);
           }
           resolve(device);
           return;

package/src/index.ts

@@ -21,6 +21,10 @@ export { executeCallback, cleanupCallback };
 export { preloadSessionCache } from './device/Device';
 export { projectFeatures as projectDeviceStateFeatures } from './device/DeviceStateProjector';
 export { getMethodSupportedProtocols } from './api/utils';
+export {
+  parseProtocolV2ResourceManifest,
+  selectProtocolV2ResourceManifestFiles,
+} from './protocols/protocol-v2/resources';
 export { prepareFirmwareUpdateV4MemoryHost } from './api/firmware/FirmwareMemoryHost';
 export type {
   FirmwareMemoryArtifact,

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

@@ -1,20 +1,29 @@
-import { bytesToHex } from '@noble/hashes/utils';
-
-import type { IProtocolV2Resources, IVersionArray } from '../../types';
+import type {
+  IProtocolV2ResourceManifest,
+  IProtocolV2ResourceManifestFile,
+  IProtocolV2Resources,
+} from '../../types';
+import type { FirmwareUpdateV4Target } from '../../types/api/firmwareUpdate';
 
 export const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH =
   'vol0:/loaders/bootloader/boot_resource.okpkg';
 export const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH = `${PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH}.staging`;
 export const PROTOCOL_V2_ROM_PARAMS_PACKAGE_PATH = 'vol0:/loaders/rom/params.okpkg';
-export const PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE = 0x5f90;
 
-const PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_VERSION = 1;
-const PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_OFFSET = 0x6c;
-const PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_SIZE = 64;
-const PROTOCOL_V2_RESOURCE_PACKAGE_PAYLOAD_HASH_OFFSET = 0x200;
-const PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_HASH_OFFSET = 0x240;
-const PROTOCOL_V2_RESOURCE_PACKAGE_HASH_SIZE = 64;
-const PROTOCOL_V2_RESOURCE_PACKAGE_TYPE = 'RESC';
+const SHA256_HEX_LENGTH = 64;
+
+function normalizeHex(value: unknown, expectedLength: number, field: string): string {
+  if (typeof value !== 'string') {
+    throw new Error(`Invalid Pro2 resource ${field}: expected a hexadecimal string`);
+  }
+  const normalized = value.replace(/^0x/i, '').toLowerCase();
+  if (normalized.length !== expectedLength || !/^[0-9a-f]+$/.test(normalized)) {
+    throw new Error(
+      `Invalid Pro2 resource ${field}: expected ${expectedLength} hexadecimal characters`
+    );
+  }
+  return normalized;
+}
 
 /** Validate a complete Pro2 stable resource set from remote configuration. */
 export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources | undefined {
@@ -49,113 +58,114 @@ export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources |
   };
 }
 
-const PROTOCOL_V2_RESOURCE_DEVICE_ROOTS = ['vol0:/bundles/', 'vol0:/loaders/rom/'] as const;
+const PROTOCOL_V2_RESOURCE_MANIFEST_DEVICE_ROOTS = [
+  'vol0:/bundles/',
+  'vol0:/loaders/rom/',
+] as const;
 
-function isAllowedResourceDevicePath(path: string): boolean {
+function isAllowedManifestDevicePath(path: string): boolean {
   if (
+    !path.endsWith('.okpkg') ||
     path.includes('\\') ||
     path.includes('//') ||
-    [...path].some(char => {
-      const code = char.charCodeAt(0);
-      return code <= 0x1f || code === 0x7f;
-    }) ||
     path.split('/').some(part => part === '.' || part === '..')
   ) {
     return false;
   }
-  if (path === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH) {
+  if (path === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH) {
     return true;
   }
-  return (
-    path.endsWith('.okpkg') && PROTOCOL_V2_RESOURCE_DEVICE_ROOTS.some(root => path.startsWith(root))
-  );
+  return PROTOCOL_V2_RESOURCE_MANIFEST_DEVICE_ROOTS.some(root => path.startsWith(root));
 }
 
-function readAscii(bytes: Uint8Array, offset: number, length: number): string {
-  return Array.from(bytes.slice(offset, offset + length))
-    .map(byte => String.fromCharCode(byte))
-    .join('');
+function assertManifestString(value: unknown, field: string): string {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`Invalid Pro2 resource manifest ${field}`);
+  }
+  return value;
 }
 
-function readResourceDevicePath(bytes: Uint8Array): string {
-  const metadata = bytes.slice(
-    PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_OFFSET,
-    PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_OFFSET + PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_SIZE
-  );
-  const terminator = metadata.indexOf(0);
-  const pathBytes = terminator === -1 ? metadata : metadata.slice(0, terminator);
-  const padding = terminator === -1 ? new Uint8Array(0) : metadata.slice(terminator);
+function assertManifestRelativePath(value: unknown, field: string): string {
+  const path = assertManifestString(value, field);
   if (
-    pathBytes.byteLength === 0 ||
-    Array.from(pathBytes).some(byte => byte < 0x20 || byte > 0x7e) ||
-    Array.from(padding).some(byte => byte !== 0)
+    path.startsWith('/') ||
+    path.includes('\\') ||
+    path.includes(':') ||
+    path.split('/').some(part => !part || part === '.' || part === '..')
   ) {
-    throw new Error('Invalid Pro2 RESOURCE package device path metadata');
-  }
-  const path = readAscii(pathBytes, 0, pathBytes.byteLength);
-  if (!isAllowedResourceDevicePath(path)) {
-    throw new Error(`Invalid Pro2 RESOURCE package device path: ${path}`);
+    throw new Error(`Invalid Pro2 resource manifest ${field}`);
   }
   return path;
 }
 
-export type ProtocolV2ResourcePackageHeader = {
-  version: IVersionArray;
-  payloadLength: number;
-  devicePath: string;
-  payloadHash: string;
-  headerHash: string;
-};
+function parseProtocolV2ResourceManifestFile(
+  value: unknown,
+  index: number
+): IProtocolV2ResourceManifestFile {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}]`);
+  }
+  const file = value as Partial<IProtocolV2ResourceManifestFile>;
+  const archivePath = assertManifestRelativePath(file.archive_path, `files[${index}].archive_path`);
+  const originalName =
+    file.original_name === undefined
+      ? archivePath.split('/').pop() ?? archivePath
+      : assertManifestRelativePath(file.original_name, `files[${index}].original_name`);
+  if (originalName.includes('/')) {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}].original_name`);
+  }
+  const devicePath = assertManifestString(file.device_path, `files[${index}].device_path`);
+  if (!isAllowedManifestDevicePath(devicePath)) {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}].device_path`);
+  }
+  if (!Number.isSafeInteger(file.size) || Number(file.size) <= 0) {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}].size`);
+  }
+  const digest = normalizeHex(file.sha256, SHA256_HEX_LENGTH, `files[${index}].sha256`);
+  if (!archivePath.endsWith('.okpkg') || !originalName.endsWith('.okpkg')) {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}] package extension`);
+  }
+  return {
+    archive_path: archivePath,
+    original_name: originalName,
+    device_path: devicePath,
+    size: Number(file.size),
+    sha256: digest,
+    ...(file.signed === undefined ? {} : { signed: file.signed }),
+    ...(file.sig_algo === undefined ? {} : { sig_algo: file.sig_algo }),
+    ...(file.payload_version === undefined ? {} : { payload_version: file.payload_version }),
+  };
+}
 
-export function parseProtocolV2ResourcePackageHeader(
-  bytes: Uint8Array,
-  packageSize: number
-): ProtocolV2ResourcePackageHeader {
-  if (bytes.byteLength < PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE) {
-    throw new Error('Pro2 RESOURCE package is shorter than its header');
-  }
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const headerVersion = view.getUint32(0x04, true);
-  const headerLength = view.getUint32(0x0c, true);
-  const payloadLength = view.getUint32(0x14, true);
+export function parseProtocolV2ResourceManifest(value: unknown): IProtocolV2ResourceManifest {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('Invalid Pro2 resource manifest');
+  }
+  const manifest = value as Partial<IProtocolV2ResourceManifest>;
+  if (!Array.isArray(manifest.files)) {
+    throw new Error('Invalid Pro2 resource manifest files');
+  }
+  const files = manifest.files.map(parseProtocolV2ResourceManifestFile);
+  const devicePaths = new Set(files.map(file => file.device_path));
+  const archivePaths = new Set(files.map(file => file.archive_path));
   if (
-    readAscii(bytes, 0, 4) !== 'OKPP' ||
-    readAscii(bytes, 0x08, 4) !== PROTOCOL_V2_RESOURCE_PACKAGE_TYPE ||
-    headerVersion !== PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_VERSION ||
-    headerLength !== PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE ||
-    payloadLength <= 0 ||
-    headerLength + payloadLength !== packageSize
+    files.length === 0 ||
+    devicePaths.size !== files.length ||
+    archivePaths.size !== files.length
   ) {
-    throw new Error('Invalid Pro2 RESOURCE package header');
+    throw new Error('Invalid Pro2 resource manifest file set');
   }
-
-  const packedVersion = view.getUint32(0x10, true);
   return {
-    version: [
-      Math.floor(packedVersion / 0x10000) % 0x100,
-      Math.floor(packedVersion / 0x100) % 0x100,
-      packedVersion % 0x100,
-    ],
-    payloadLength,
-    devicePath: readResourceDevicePath(bytes),
-    payloadHash: bytesToHex(
-      bytes.slice(
-        PROTOCOL_V2_RESOURCE_PACKAGE_PAYLOAD_HASH_OFFSET,
-        PROTOCOL_V2_RESOURCE_PACKAGE_PAYLOAD_HASH_OFFSET + PROTOCOL_V2_RESOURCE_PACKAGE_HASH_SIZE
-      )
-    ),
-    headerHash: bytesToHex(
-      bytes.slice(
-        PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_HASH_OFFSET,
-        PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_HASH_OFFSET + PROTOCOL_V2_RESOURCE_PACKAGE_HASH_SIZE
-      )
-    ),
+    files,
   };
 }
 
-export function parseProtocolV2ResourcePackage(
-  binary: ArrayBuffer | Uint8Array
-): ProtocolV2ResourcePackageHeader {
-  const bytes = binary instanceof Uint8Array ? binary : new Uint8Array(binary);
-  return parseProtocolV2ResourcePackageHeader(bytes, bytes.byteLength);
+export function selectProtocolV2ResourceManifestFiles({
+  manifest,
+  targetsToUpdate,
+}: {
+  manifest: IProtocolV2ResourceManifest;
+  targetsToUpdate: readonly FirmwareUpdateV4Target[];
+}): IProtocolV2ResourceManifestFile[] {
+  return targetsToUpdate.includes('resource') ? [...manifest.files] : [];
 }

package/src/types/settings.ts

@@ -74,6 +74,21 @@ export type IProtocolV2Resources = {
   source: IProtocolV2ResourceSource;
 };
 
+export type IProtocolV2ResourceManifestFile = {
+  archive_path: string;
+  original_name?: string;
+  device_path: string;
+  size: number;
+  sha256: string;
+  signed?: boolean;
+  sig_algo?: string;
+  payload_version?: string | null;
+};
+
+export type IProtocolV2ResourceManifest = {
+  files: IProtocolV2ResourceManifestFile[];
+};
+
 /** STM32 firmware config */
 export type IFirmwareReleaseInfo = {
   required: boolean;

package/src/utils/deviceInfoUtils.ts

@@ -30,13 +30,8 @@ export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
   if (/^T/i.test(name)) return EDeviceType.Touch;
   if (/^Touch/i.test(name)) return EDeviceType.Touch;
 
-  const compactName = name.replace(/[\s-]/g, '');
-  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)) {
-    return EDeviceType.Neo;
-  }
+  if (/\bPro\s*2\b/i.test(name) || /^Pro2/i.test(name)) return EDeviceType.Pro2;
+  if (/\bNeo\b/i.test(name) || /^Neo/i.test(name)) return EDeviceType.Neo;
   if (/\bPro\b/i.test(name) || /^Pro/i.test(name)) return EDeviceType.Pro;
 
   return EDeviceType.Unknown;