@onekeyfe/hd-core 1.2.2-alpha.1 → 1.2.2-alpha.10

package/src/api/helpers/protocolV2FileWrite.ts

@@ -36,6 +36,8 @@ export type ProtocolV2FileWriteOptions = {
   chunkSize?: number;
   chunkLen?: number;
   chunkSizeLimit?: number;
+  /** BLE-only limit for a caller whose fixed short path has a verified larger frame budget. */
+  bleChunkSizeLimit?: number;
   overwrite?: boolean;
   append?: boolean;
   uiPercentage?: number;
@@ -114,11 +116,15 @@ export function isProtocolV2ResponseTimeout(error: unknown) {
   );
 }
 
-function getProtocolV2FileChunkLimit() {
+function getProtocolV2FileChunkLimit(bleChunkSizeLimit?: number) {
   const env = DataManager.getSettings('env');
-  return env && DataManager.isBleConnect(env)
-    ? PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
-    : PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+  if (env && DataManager.isBleConnect(env)) {
+    const configuredLimit = Number(bleChunkSizeLimit);
+    return Number.isFinite(configuredLimit) && configuredLimit > 0
+      ? Math.floor(configuredLimit)
+      : PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+  }
+  return PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
 }
 
 async function dataToUint8Array(data: ProtocolV2FileWriteData): Promise<Uint8Array> {
@@ -178,7 +184,7 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
     );
   }
 
-  const defaultChunkSizeLimit = getProtocolV2FileChunkLimit();
+  const defaultChunkSizeLimit = getProtocolV2FileChunkLimit(options.bleChunkSizeLimit);
   const configuredChunkSizeLimit = Number(options.chunkSizeLimit);
   const chunkSizeLimit =
     Number.isFinite(configuredChunkSizeLimit) && configuredChunkSizeLimit > 0

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -49,6 +49,7 @@ const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
 const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
 const FILESYSTEM_DIR_MAKE_MESSAGE_TYPE = 60809;
+const WALLPAPER_PACKAGE_BLE_CHUNK_SIZE = 1960;
 const Log = getLogger(LoggerNames.Method);
 
 function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
@@ -130,7 +131,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     this.directoryReady = true;
   }
 
-  private async upload(path: string, data: Uint8Array) {
+  private async upload(path: string, data: Uint8Array, bleChunkSizeLimit?: number) {
     if (this.uploaded) return;
 
     await writeProtocolV2File({
@@ -139,6 +140,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
       data,
       totalSize: data.byteLength,
       chunkSize: this.params.chunkSize,
+      bleChunkSizeLimit,
       maxChunkRetries: 3,
       overwrite: true,
       append: false,
@@ -164,7 +166,11 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
       ? buildPro2HostAssetPackage([{ name: WALLPAPER_PACKAGE_ENTRY, data: encoded.data }])
       : encoded.data;
     if (useHostAssetPackage) this.path = WALLPAPER_PACKAGE_PATH;
-    await this.upload(this.path, data);
+    await this.upload(
+      this.path,
+      data,
+      useHostAssetPackage ? WALLPAPER_PACKAGE_BLE_CHUNK_SIZE : undefined
+    );
     const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
       settings: { wallpaper_path: this.path },
     });

package/src/core/RequestQueue.ts

@@ -56,11 +56,20 @@ export default class RequestQueue {
     return false;
   }
 
+  private isRequestForConnectId(request: RequestTask, connectId: string) {
+    const { method } = request;
+    return (
+      method.connectId === connectId ||
+      method.device?.mainId === connectId ||
+      method.device?.getConnectId() === connectId
+    );
+  }
+
   // 取消与指定connectId相关的所有请求
   public abortRequestsByConnectId(connectId: string) {
     let count = 0;
     this.requestQueue.forEach((request, _) => {
-      if (request.abortController && request.method.connectId === connectId) {
+      if (request.abortController && this.isRequestForConnectId(request, connectId)) {
         request.abortController.abort();
         request.abortController = undefined;
         count++;
@@ -69,6 +78,12 @@ export default class RequestQueue {
     return count;
   }
 
+  public getRequestTasksIdByConnectId(connectId: string) {
+    return Array.from(this.requestQueue.values())
+      .filter(request => this.isRequestForConnectId(request, connectId))
+      .map(request => request.id);
+  }
+
   // 取消所有请求
   public abortAllRequests() {
     let count = 0;

package/src/core/index.ts

@@ -2,7 +2,11 @@ import semver from 'semver';
 import EventEmitter from 'events';
 import {
   DeviceSessionPinType,
+  type LowlevelTransportSharedPlugin,
+  type OneKeyDeviceInfo,
+  type ProtocolType,
   TRANSPORT_EVENT,
+  type TransportDeviceDisconnectEvent,
   isProtocolV2LinkDisabledError,
 } from '@onekeyfe/hd-transport';
 import {
@@ -74,11 +78,6 @@ import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } fro
 import type { DeviceEvents, InitOptions, RunOptions } from '../device/Device';
 import type { SdkTracingContext } from '../utils/tracing';
 import type { Deferred } from '@onekeyfe/hd-shared';
-import type {
-  LowlevelTransportSharedPlugin,
-  OneKeyDeviceInfo,
-  TransportDeviceDisconnectEvent,
-} from '@onekeyfe/hd-transport';
 import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
@@ -92,7 +91,7 @@ const preWarmDoneAt = new Map<string, number>();
 
 export type CoreContext = ReturnType<Core['getCoreContext']>;
 
-function hasDeriveCardano(method: BaseMethod): boolean {
+function resolveDeriveCardano(method: BaseMethod): boolean | undefined {
   if (
     method.name.startsWith('allNetworkGetAddress') &&
     method.payload &&
@@ -102,15 +101,22 @@ function hasDeriveCardano(method: BaseMethod): boolean {
   ) {
     return true;
   }
-
-  return method.name.startsWith('cardano') || method.payload?.deriveCardano;
+  if (method.name.startsWith('cardano')) {
+    return true;
+  }
+  // V1 Initialize only sends derive_cardano on an explicit true.
+  // V2 AskPassphrase maps true to [Standard, Cardano] and anything else to [Standard].
+  if (method.payload?.deriveCardano === true) {
+    return true;
+  }
+  return undefined;
 }
 
 const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   initSession: method?.payload.initSession,
   passphraseState: method?.payload.useEmptyPassphrase ? undefined : method?.payload.passphraseState,
   deviceId: method?.payload.deviceId,
-  deriveCardano: method && hasDeriveCardano(method),
+  deriveCardano: method ? resolveDeriveCardano(method) : undefined,
   connectProtocol: method?.payload.connectProtocol,
   forceProtocolDetection: method?.payload.forceProtocolDetection,
   protocolV2DeviceInfoTimeoutMs: method?.payload.protocolV2DeviceInfoTimeoutMs,
@@ -651,7 +657,7 @@ const onCallDevice = async (
                 method.payload?.passphraseState,
                 method.payload?.useEmptyPassphrase,
                 method.payload?.skipPassphraseCheck,
-                hasDeriveCardano(method),
+                resolveDeriveCardano(method),
                 method.protocolV2UnlockContext?.preflightMainPinSelected
               );
 
@@ -1037,6 +1043,7 @@ async function connectDeviceForBle(
       !device.commands ||
       device.commands.disposed;
     if (shouldAcquire) {
+      const connectProtocol = resolveBleConnectProtocol(method);
       // 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
@@ -1048,13 +1055,13 @@ async function connectDeviceForBle(
         throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
       }
       if (!useAcquireGuards) {
-        await device.acquire(method.payload.connectProtocol, {
+        await device.acquire(connectProtocol, {
           forceProtocolDetection: method.payload.forceProtocolDetection,
         });
       } else {
         try {
           await raceBleAcquire(
-            device.acquire(method.payload.connectProtocol, {
+            device.acquire(connectProtocol, {
               forceProtocolDetection: method.payload.forceProtocolDetection,
             }),
             abortSignal
@@ -1120,6 +1127,14 @@ async function connectDeviceForBle(
   }
 }
 
+export function resolveBleConnectProtocol(method: BaseMethod): ProtocolType | undefined {
+  if (method.payload.connectProtocol === 'V1' || method.payload.connectProtocol === 'V2') {
+    return method.payload.connectProtocol;
+  }
+  const supportedProtocols = method.getSupportedProtocols();
+  return supportedProtocols.length === 1 && supportedProtocols[0] === 'V2' ? 'V2' : undefined;
+}
+
 type IPollFn<T> = (time?: number) => T;
 // eslint-disable-next-line @typescript-eslint/require-await
 const ensureConnected = async (
@@ -1318,7 +1333,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
       // cancel callback tasks
       requestQueue.cancelCallbackTasks(connectId);
 
-      const requestIds = requestQueue.getRequestTasksId();
+      const requestIds = requestQueue.getRequestTasksIdByConnectId(connectId);
       Log.debug(
         `Cancel Api connect requestQueues: length:${requestIds.length} requestIds:${requestIds.join(
           ','
@@ -1326,6 +1341,8 @@ export const cancel = (context: CoreContext, connectId?: string) => {
       );
       // Abort before rejecting: rejectRequest releases the task and would make
       // its AbortController unreachable to an in-flight method loop.
+      // Match both the requested connectId and a device selected internally by the
+      // method, such as Desktop WebUSB firmwareUpdateV4.
       requestQueue.abortRequestsByConnectId(connectId);
       const canceledDevices: Device[] = [];
       const interruptDevice = (device: Device | undefined, deviceConnectId: string) => {
@@ -1342,7 +1359,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
           // During ensureConnected the method has a connectId but device is
           // assigned only after the poll succeeds. Interrupt the cached BLE
           // Device so an in-flight acquire/initialize cannot finish.
-          interruptDevice(task.method?.device, task.method.connectId ?? connectId);
+          interruptDevice(task.method?.device, connectId);
           interruptDevice(deviceCacheMap.get(connectId), connectId);
           requestQueue.rejectRequest(
             requestId,
@@ -1357,10 +1374,11 @@ export const cancel = (context: CoreContext, connectId?: string) => {
     }
   } else {
     const env = DataManager.getSettings('env');
+    // Abort every method before rejecting its queue task. Non-BLE methods also
+    // use the signal to stop recovery loops after the public promise is rejected.
+    requestQueue.abortAllRequests();
     if (DataManager.isBleConnect(env)) {
       Log.debug('Cancel Api all _deviceList: ');
-      // Keep method abort signals observable until every active task is rejected.
-      requestQueue.abortAllRequests();
       const canceledDevices: Device[] = [];
       const interruptDevice = (device?: Device) => {
         if (!device || canceledDevices.includes(device)) {
@@ -1403,8 +1421,10 @@ export const cancel = (context: CoreContext, connectId?: string) => {
     }
   }
 
-  cleanup();
-  closePopup();
+  cleanup(connectId);
+  if (!connectId || _uiPromises.length === 0) {
+    closePopup();
+  }
 };
 
 const checkPassphraseEnableState = (method: BaseMethod, features?: Features) => {
@@ -1442,9 +1462,16 @@ const shouldCheckPassphraseState = (method: BaseMethod, device: Device) => {
   return device.hasUsePassphrase();
 };
 
-const cleanup = () => {
-  const pendingUiPromises = _uiPromises;
-  _uiPromises = [];
+const cleanup = (connectId?: string) => {
+  const pendingUiPromises = connectId
+    ? _uiPromises.filter(
+        uiPromise =>
+          uiPromise.data?.mainId === connectId || uiPromise.data?.getConnectId() === connectId
+      )
+    : _uiPromises;
+  _uiPromises = connectId
+    ? _uiPromises.filter(uiPromise => !pendingUiPromises.includes(uiPromise))
+    : [];
   rejectUiPromises(
     pendingUiPromises,
     ERRORS.TypedError(HardwareErrorCode.ActionCancelled, 'UI request was cancelled')