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

package/src/core/index.ts

@@ -415,10 +415,6 @@ 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);
   }
 
@@ -918,16 +914,32 @@ function canSkipInitialize(method: BaseMethod, device: Device): boolean {
   return true;
 }
 
-function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
-  const message = error instanceof Error ? error.message : String(error ?? '');
+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 ?? '');
   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')
   );
 }
 
+export function isRetryableBleConnectionError(method: BaseMethod, error: unknown) {
+  if (method.device?.wasInterruptedByUser()) {
+    return false;
+  }
+  const typedError = error as { errorCode?: unknown };
+  return (
+    typedError?.errorCode === HardwareErrorCode.BleTimeoutError ||
+    typedError?.errorCode === HardwareErrorCode.BleConnectedError ||
+    isRetryableBleProtocolV2ProbeError(method, error) ||
+    isMissingDetectedProtocolV2Error(method, error)
+  );
+}
+
 export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unknown) {
   const typedError = error as { errorCode?: unknown; message?: unknown };
   return (
@@ -942,61 +954,14 @@ 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)
  */
-// 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
-) {
+async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
   try {
+    if (retryCount === 0) {
+      device.beginConnectionAttempt();
+    }
+    if (device.wasInterruptedByUser()) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+    }
     if (method.payload.forceProtocolDetection && device.hasDeviceAcquire()) {
       await device.release();
     }
@@ -1006,43 +971,9 @@ async function connectDeviceForBle(
       !device.commands ||
       device.commands.disposed;
     if (shouldAcquire) {
-      // 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;
-        }
-      }
+      await device.acquire(method.payload.connectProtocol, {
+        forceProtocolDetection: method.payload.forceProtocolDetection,
+      });
     }
     if (method.payload?.onlyConnectBleDevice) {
       if (shouldAcquire) {
@@ -1078,17 +1009,11 @@ async function connectDeviceForBle(
       // next attempt skip acquire and initialize onto the link we just cut.
       device.markTransportDisconnected();
     }
-    if (
-      (err.errorCode === HardwareErrorCode.BleTimeoutError ||
-        err.errorCode === HardwareErrorCode.BleConnectedError ||
-        isRetryableBleProtocolV2ProbeError(method, err) ||
-        requiresColdReconnect) &&
-      retryCount < 6
-    ) {
+    if (isRetryableBleConnectionError(method, err) && retryCount < 6) {
       const nextRetry = retryCount + 1;
       Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
       await wait(3000);
-      await connectDeviceForBle(method, device, abortSignal, nextRetry);
+      await connectDeviceForBle(method, device, nextRetry);
     } else {
       throw err;
     }
@@ -1193,7 +1118,7 @@ const ensureConnected = async (
             if (abort()) {
               return;
             }
-            await connectDeviceForBle(method, device, abortSignal);
+            await connectDeviceForBle(method, device);
           }
           resolve(device);
           return;

package/src/device/Device.ts

@@ -235,6 +235,15 @@ export class Device extends EventEmitter {
    */
   private deviceAcquired = false;
 
+  /**
+   * Connection-attempt generation. interruptionFromUser() pins the current
+   * attempt so a late acquire cannot finish, while the next public connect
+   * increments this and is allowed to proceed.
+   */
+  private connectionAttempt = 0;
+
+  private interruptedAttempt: number | null = null;
+
   /** Canonical device-state cache; legacy Features is a compatibility projection. */
   private stateStore = new DeviceStateStore();
 
@@ -429,6 +438,8 @@ export class Device extends EventEmitter {
     expectedProtocol?: HardwareConnectProtocol,
     options?: { throwOnRunPromiseError?: boolean; forceProtocolDetection?: boolean }
   ) {
+    const attempt = this.connectionAttempt;
+    this.throwIfInterruptedByUser();
     const env = DataManager.getSettings('env');
     const mainIdKey = DataManager.isBleConnect(env) ? 'id' : 'session';
     const previousProtocol = this.originalDescriptor.protocolType;
@@ -483,6 +494,15 @@ export class Device extends EventEmitter {
       if (detectedProtocol) {
         this.originalDescriptor.protocolType = detectedProtocol;
       }
+      if (this.interruptedAttempt === attempt || this.connectionAttempt !== attempt) {
+        const session = this.mainId;
+        if (session && this.deviceConnector?.disconnect) {
+          await this.deviceConnector.disconnect(session).catch(disconnectError => {
+            Log.debug('Ignored disconnect after user cancel during acquire', disconnectError);
+          });
+        }
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+      }
       this.deviceAcquired = true;
       this.updateDescriptor({ [mainIdKey]: this.mainId } as unknown as DeviceDescriptor);
 
@@ -903,6 +923,7 @@ export class Device extends EventEmitter {
   }
 
   async initialize(options?: InitOptions) {
+    this.throwIfInterruptedByUser();
     // Protocol V2 does not support legacy Initialize; use its dedicated flow.
     if (this.isProtocolV2()) {
       this.passphraseState = options?.passphraseState;
@@ -1445,6 +1466,7 @@ export class Device extends EventEmitter {
       Log.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
     }
 
+    this.beginConnectionAttempt();
     options = parseRunOptions(options);
 
     const runPromise = createDeferred<void>();
@@ -1574,21 +1596,24 @@ export class Device extends EventEmitter {
 
   async interruptionFromUser() {
     const error = ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+    this.interruptedAttempt = this.connectionAttempt;
     const cleanupPromise = this.runCleanupPromise;
     const { cancelableAction } = this;
-    const env = DataManager.getSettings('env');
     if (cancelableAction) {
       await cancelableAction(error);
-    } else if (
-      this.isProtocolV2() &&
-      (DataManager.isBleConnect(env) ||
-        DataManager.isBrowserWebUsb(env) ||
-        DataManager.isDesktopWebUsb(env)) &&
-      this.hasDeviceAcquire()
-    ) {
+    } else if (this.shouldSendFallbackProtocolCancel()) {
       await this.commands?.cancelDevice?.().catch(cancelError => {
         Log.debug('Protocol V2 fallback cancel error', cancelError);
       });
+    } else if (!this.hasDeviceAcquire()) {
+      // Pairing / connect-native / probe: drop the physical link only.
+      // Never acquire or send protocol Cancel just to abort setup.
+      if (this.mainId && this.deviceConnector?.disconnect) {
+        await this.deviceConnector.disconnect(this.mainId).catch(disconnectError => {
+          Log.debug('Ignored disconnect during user cancel without acquire', disconnectError);
+        });
+      }
+      this.markTransportDisconnected();
     }
     await this.commands?.cancel();
 
@@ -1652,6 +1677,44 @@ export class Device extends EventEmitter {
     return typeof this.originalDescriptor.session === 'string';
   }
 
+  beginConnectionAttempt() {
+    this.connectionAttempt += 1;
+    return this.connectionAttempt;
+  }
+
+  wasInterruptedByUser() {
+    return (
+      typeof this.interruptedAttempt === 'number' &&
+      this.interruptedAttempt === this.connectionAttempt
+    );
+  }
+
+  private throwIfInterruptedByUser() {
+    if (this.wasInterruptedByUser()) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+    }
+  }
+
+  /**
+   * Protocol Cancel is only for an acquired session that is already in a
+   * user-facing prompt. Connect, probe and initialize must not send Cancel
+   * and must not re-acquire just to deliver one.
+   */
+  private shouldSendFallbackProtocolCancel() {
+    if (!this.hasDeviceAcquire() || !this.isProtocolV2()) {
+      return false;
+    }
+    if (!this.hasOpenProtocolV2UiInteraction()) {
+      return false;
+    }
+    const env = DataManager.getSettings('env');
+    return (
+      DataManager.isBleConnect(env) ||
+      DataManager.isBrowserWebUsb(env) ||
+      DataManager.isDesktopWebUsb(env)
+    );
+  }
+
   hasDeviceAcquire() {
     const env = DataManager.getSettings('env');
     if (DataManager.isBleConnect(env)) {

package/src/index.ts

@@ -21,10 +21,6 @@ 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,29 +1,20 @@
-import type {
-  IProtocolV2ResourceManifest,
-  IProtocolV2ResourceManifestFile,
-  IProtocolV2Resources,
-} from '../../types';
-import type { FirmwareUpdateV4Target } from '../../types/api/firmwareUpdate';
+import { bytesToHex } from '@noble/hashes/utils';
+
+import type { IProtocolV2Resources, IVersionArray } from '../../types';
 
 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 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;
-}
+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';
 
 /** Validate a complete Pro2 stable resource set from remote configuration. */
 export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources | undefined {
@@ -58,114 +49,113 @@ export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources |
   };
 }
 
-const PROTOCOL_V2_RESOURCE_MANIFEST_DEVICE_ROOTS = [
-  'vol0:/bundles/',
-  'vol0:/loaders/rom/',
-] as const;
+const PROTOCOL_V2_RESOURCE_DEVICE_ROOTS = ['vol0:/bundles/', 'vol0:/loaders/rom/'] as const;
 
-function isAllowedManifestDevicePath(path: string): boolean {
+function isAllowedResourceDevicePath(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_PATH) {
+  if (path === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH) {
     return true;
   }
-  return PROTOCOL_V2_RESOURCE_MANIFEST_DEVICE_ROOTS.some(root => path.startsWith(root));
+  return (
+    path.endsWith('.okpkg') && PROTOCOL_V2_RESOURCE_DEVICE_ROOTS.some(root => path.startsWith(root))
+  );
 }
 
-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 readAscii(bytes: Uint8Array, offset: number, length: number): string {
+  return Array.from(bytes.slice(offset, offset + length))
+    .map(byte => String.fromCharCode(byte))
+    .join('');
 }
 
-function assertManifestRelativePath(value: unknown, field: string): string {
-  const path = assertManifestString(value, field);
+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);
   if (
-    path.startsWith('/') ||
-    path.includes('\\') ||
-    path.includes(':') ||
-    path.split('/').some(part => !part || part === '.' || part === '..')
+    pathBytes.byteLength === 0 ||
+    Array.from(pathBytes).some(byte => byte < 0x20 || byte > 0x7e) ||
+    Array.from(padding).some(byte => byte !== 0)
   ) {
-    throw new Error(`Invalid Pro2 resource manifest ${field}`);
+    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}`);
   }
   return path;
 }
 
-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 type ProtocolV2ResourcePackageHeader = {
+  version: IVersionArray;
+  payloadLength: number;
+  devicePath: string;
+  payloadHash: string;
+  headerHash: string;
+};
 
-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));
+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);
   if (
-    files.length === 0 ||
-    devicePaths.size !== files.length ||
-    archivePaths.size !== files.length
+    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
   ) {
-    throw new Error('Invalid Pro2 resource manifest file set');
+    throw new Error('Invalid Pro2 RESOURCE package header');
   }
+
+  const packedVersion = view.getUint32(0x10, true);
   return {
-    files,
+    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
+      )
+    ),
   };
 }
 
-export function selectProtocolV2ResourceManifestFiles({
-  manifest,
-  targetsToUpdate,
-}: {
-  manifest: IProtocolV2ResourceManifest;
-  targetsToUpdate: readonly FirmwareUpdateV4Target[];
-}): IProtocolV2ResourceManifestFile[] {
-  return targetsToUpdate.includes('resource') ? [...manifest.files] : [];
+export function parseProtocolV2ResourcePackage(
+  binary: ArrayBuffer | Uint8Array
+): ProtocolV2ResourcePackageHeader {
+  const bytes = binary instanceof Uint8Array ? binary : new Uint8Array(binary);
+  return parseProtocolV2ResourcePackageHeader(bytes, bytes.byteLength);
 }

package/src/types/settings.ts

@@ -74,21 +74,6 @@ 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,8 +30,13 @@ export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
   if (/^T/i.test(name)) return EDeviceType.Touch;
   if (/^Touch/i.test(name)) return EDeviceType.Touch;
 
-  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;
+  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\b/i.test(name) || /^Pro/i.test(name)) return EDeviceType.Pro;
 
   return EDeviceType.Unknown;