@onekeyfe/hd-core 1.2.0-alpha.20 → 1.2.0-alpha.22

package/src/api/helpers/protocolV2FileWrite.ts

@@ -152,6 +152,12 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
         options.throwIfAborted?.();
       }
     }
+    if (!response) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'FilesystemFileWrite completed without a response'
+      );
+    }
     options.throwIfAborted?.();
     lastMessage = response.message;
     const rawProcessedByte = response.message?.processed_byte;

package/src/api/index.ts

@@ -48,27 +48,6 @@ export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
 export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
 export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
-// Protocol V2 development APIs. These remain public while Pro2 integration is in development.
-export { default as deviceInfoGet } from './protocol-v2/DeviceInfoGet';
-export { default as deviceStatusGet } from './protocol-v2/DeviceStatusGet';
-export { default as deviceSettingsGet } from './protocol-v2/DeviceSettingsGet';
-export { default as protocolInfoRequest } from './protocol-v2/ProtocolInfoRequest';
-export { default as ping } from './protocol-v2/Ping';
-export { default as deviceFirmwareUpdate } from './protocol-v2/DeviceFirmwareUpdate';
-export { default as deviceGetFirmwareUpdateStatus } from './protocol-v2/DeviceGetFirmwareUpdateStatus';
-export { default as deviceFactoryInfoSet } from './protocol-v2/DeviceFactoryInfoSet';
-export { default as deviceFactoryInfoGet } from './protocol-v2/DeviceFactoryInfoGet';
-export { default as deviceSettingsSet } from './protocol-v2/DeviceSettingsSet';
-export { default as deviceSettingsPageShow } from './protocol-v2/DeviceSettingsPageShow';
-export { default as filesystemPermissionFix } from './protocol-v2/FilesystemPermissionFix';
-export { default as filesystemFormat } from './protocol-v2/FilesystemFormat';
-export { default as fileRead } from './FileRead';
-export { default as fileWrite } from './FileWrite';
-export { default as fileDelete } from './FileDelete';
-export { default as dirList } from './DirList';
-export { default as dirMake } from './DirMake';
-export { default as dirRemove } from './DirRemove';
-export { default as pathInfo } from './PathInfo';
 export { default as uploadPortfolio } from './UploadPortfolio';
 
 export { default as cipherKeyValue } from './CipherKeyValue';

package/src/api/nexa/NexaSignTransaction.ts

@@ -9,6 +9,8 @@ import type { TypedCall } from '@onekeyfe/hd-transport';
 import type { DeviceFirmwareRange, NexaSignTransactionParams, NexaSignature } from '../../types';
 
 export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionParams> {
+  checkDeviceId = true;
+
   hasBundle = false;
 
   init() {

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

@@ -71,7 +71,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
     this.params = { width, height, rgba: rgbaBytes, fileName, chunkSize };
     this.requireProtocolV2 = true;
-    this.unlockPolicy = 'retry-on-locked';
+    this.unlockPolicy = 'unlock-before-run';
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
   }

package/src/core/RequestQueue.ts

@@ -1,47 +1,21 @@
-import { type Deferred, createDeferred } from '@onekeyfe/hd-shared';
-
 import { LoggerNames, getLogger } from '../utils';
 
+import type { Deferred } from '@onekeyfe/hd-shared';
 import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
-const OPERATION_PRE_CANCEL_TTL_MS = 30_000;
-const DEFAULT_BACKGROUND_PREEMPT_TIMEOUT_MS = 5_500;
-
 export type RequestTask = {
   id: number;
   method: BaseMethod;
   callPromise?: Deferred<any> | undefined;
   abortController?: AbortController;
-  settled: Deferred<void>;
-  released: Deferred<void>;
-};
-
-export type RequestAdmission =
-  | { status: 'reserved'; task: RequestTask }
-  | { status: 'busy'; blockingTask?: RequestTask };
-
-export type RequestAdmissionOptions = {
-  backgroundPreemptTimeoutMs?: number;
 };
 
 export default class RequestQueue {
   private requestQueue = new Map<number, RequestTask>();
 
-  private operationRequestIds = new Map<string, number>();
-
-  private pendingOperationCancellations = new Map<string, number>();
-
   private pendingCallbackTasks = new Map<string, Deferred<void>>();
 
-  private prunePendingOperationCancellations(now = Date.now()) {
-    this.pendingOperationCancellations.forEach((expiresAt, operationId) => {
-      if (expiresAt <= now) {
-        this.pendingOperationCancellations.delete(operationId);
-      }
-    });
-  }
-
   // 生成唯一请求ID
   public generateRequestId = (method?: BaseMethod) => {
     if (method && method.responseID != null) {
@@ -57,93 +31,11 @@ export default class RequestQueue {
     }
     const abortController = new AbortController();
     method.abortSignal = abortController.signal;
-    const task = {
-      id: requestId,
-      method,
-      abortController,
-      settled: createDeferred<void>(),
-      released: createDeferred<void>(),
-    };
+    const task = { id: requestId, method, abortController };
     this.requestQueue.set(requestId, task);
-    const operationId = method.payload?.operationId;
-    if (typeof operationId === 'string' && operationId) {
-      this.operationRequestIds.set(operationId, requestId);
-      this.prunePendingOperationCancellations();
-      if (this.pendingOperationCancellations.delete(operationId)) {
-        abortController.abort();
-      }
-    }
     return task;
   }
 
-  public async admitTask(
-    method: BaseMethod,
-    options: RequestAdmissionOptions = {}
-  ): Promise<RequestAdmission> {
-    const activeTasks = Array.from(this.requestQueue.values()).filter(
-      task => task.method.connectId === method.connectId
-    );
-
-    if (method.executionPriority === 'background') {
-      if (activeTasks.length) {
-        Log.debug(
-          `Reject background method ${method.name}: device is occupied by ${activeTasks[0].method.name}`
-        );
-        return { status: 'busy', blockingTask: activeTasks[0] };
-      }
-      return { status: 'reserved', task: this.createTask(method) };
-    }
-
-    const backgroundTasks = activeTasks.filter(
-      task => task.method.executionPriority === 'background'
-    );
-    if (!backgroundTasks.length) {
-      return { status: 'reserved', task: this.createTask(method) };
-    }
-
-    Log.debug(
-      `Preempt ${backgroundTasks.length} background request(s) for user method ${method.name}`
-    );
-    backgroundTasks.forEach(task => task.abortController?.abort());
-    const timeoutMs =
-      options.backgroundPreemptTimeoutMs ??
-      Math.max(
-        DEFAULT_BACKGROUND_PREEMPT_TIMEOUT_MS,
-        ...backgroundTasks.map(task => task.method.maxAbortLatencyMs ?? 0)
-      );
-    const released = await this.waitForTasksReleased(backgroundTasks, timeoutMs);
-    if (!released) {
-      Log.warn(`Background request cleanup timed out before user method ${method.name}`);
-      return { status: 'busy', blockingTask: backgroundTasks[0] };
-    }
-
-    return { status: 'reserved', task: this.createTask(method) };
-  }
-
-  private async waitForTasksReleased(tasks: RequestTask[], timeoutMs: number) {
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    const timeoutPromise = new Promise<false>(resolve => {
-      timer = setTimeout(() => resolve(false), timeoutMs);
-    });
-    const releasedPromise = Promise.all(tasks.map(task => task.released.promise)).then(() => true);
-    const released = await Promise.race([releasedPromise, timeoutPromise]);
-    if (timer) {
-      clearTimeout(timer);
-    }
-    return released;
-  }
-
-  public abortOperation(operationId: string) {
-    const requestId = this.operationRequestIds.get(operationId);
-    if (requestId !== undefined) {
-      return this.abortRequest(requestId);
-    }
-    const now = Date.now();
-    this.prunePendingOperationCancellations(now);
-    this.pendingOperationCancellations.set(operationId, now + OPERATION_PRE_CANCEL_TTL_MS);
-    return false;
-  }
-
   public getTask(requestId: number): RequestTask | undefined {
     return this.requestQueue.get(requestId);
   }
@@ -186,7 +78,6 @@ export default class RequestQueue {
         count++;
       }
     });
-    this.pendingOperationCancellations.clear();
     return count;
   }
 
@@ -200,8 +91,8 @@ export default class RequestQueue {
     const request = this.requestQueue.get(requestId);
     if (request) {
       request.callPromise?.resolve(response);
-      request.settled.resolve();
     }
+    this.releaseTask(requestId);
   }
 
   // 拒绝请求
@@ -209,22 +100,12 @@ export default class RequestQueue {
     const request = this.requestQueue.get(requestId);
     if (request) {
       request.callPromise?.reject(error);
-      request.settled.resolve();
     }
+    this.releaseTask(requestId);
   }
 
   // 删除请求
   public releaseTask(requestId: number) {
-    const task = this.requestQueue.get(requestId);
-    const operationId = task?.method.payload?.operationId;
-    if (
-      typeof operationId === 'string' &&
-      this.operationRequestIds.get(operationId) === requestId
-    ) {
-      this.operationRequestIds.delete(operationId);
-    }
-    task?.settled.resolve();
-    task?.released.resolve();
     this.requestQueue.delete(requestId);
   }
 

package/src/core/index.ts

@@ -196,25 +196,34 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   //   );
   // }
 
+  const { requestQueue, methodSynchronize } = context;
+  const error = await methodSynchronize(() => {
+    for (const requestId of requestQueue.getRequestTasksId()) {
+      const task = requestQueue.getTask(requestId);
+      Log.debug(
+        'pre request task: ',
+        `task?.id: ${task?.id},
+      task?.method.connectId: ${task?.method.connectId},
+      task?.method.deviceId: ${task?.method.deviceId},
+      task?.method.name: ${task?.method.name}`
+      );
+      // if (task) {
+      //   return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceBusy));
+      // }
+    }
+    return null;
+  });
+
+  if (error) {
+    return createResponseMessage(method.responseID, false, { error });
+  }
+
   // only the pre-warm signal (PreInitialize) forks here; normal methods fall
   // through to onCallDevice below, so the pre-warm dedup/guards never touch them
   if (method.isPreWarmSignal) {
     return handlePreWarmSignal(context, message, method);
   }
 
-  const { requestQueue, methodSynchronize } = context;
-  const admission = await methodSynchronize(
-    () => requestQueue.admitTask(method),
-    method.connectId ?? method.deviceId ?? 'unknown-device'
-  );
-  if (admission.status === 'busy') {
-    const error = ERRORS.TypedError(HardwareErrorCode.DeviceBusy);
-    DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
-    completeMethodRequestContext(method, error);
-    method.dispose();
-    return createResponseMessage(method.responseID, false, { error });
-  }
-
   return onCallDevice(context, message, method);
 };
 
@@ -334,7 +343,7 @@ const onCallDevice = async (
 
   await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
 
-  const task = requestQueue.getTask(method.responseID) ?? requestQueue.createTask(method);
+  const task = requestQueue.createTask(method);
 
   // Pre-warm holds the device as a per-connectId callback task so a concurrent
   // real call waits (before ensureConnected) instead of racing its Initialize.
@@ -378,10 +387,6 @@ const onCallDevice = async (
   if (method.payload?.onlyConnectBleDevice) {
     preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
-    DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
-    requestQueue.releaseTask(method.responseID);
-    completeMethodRequestContext(method);
-    method.dispose();
     return createResponseMessage(method.responseID, true, null);
   }
 
@@ -661,9 +666,8 @@ const onCallDevice = async (
       skipInitialize: canSkipInitialize(method, device),
       ...parseInitOptions(method),
     };
-    const deviceRunPromise = device.run(inner, runOptions);
-    task.callPromise = createDeferred<any>();
-    deviceRunPromise.catch(error => task.callPromise?.reject(error));
+    const deviceRun = () => device.run(inner, runOptions);
+    task.callPromise = createDeferred<any>(deviceRun);
 
     try {
       return await task.callPromise.promise;
@@ -671,8 +675,6 @@ const onCallDevice = async (
       Log.debug('Device Run Error: ', e);
       completeMethodRequestContext(method, e);
       return createResponseMessage(method.responseID, false, { error: e });
-    } finally {
-      await deviceRunPromise.catch(() => undefined);
     }
   } catch (error) {
     messageResponse = createResponseMessage(method.responseID, false, { error });
@@ -1389,10 +1391,6 @@ export default class Core extends EventEmitter {
     Log.debug(`[Core] Created SDK instance: ${this.sdkInstanceId}`);
   }
 
-  cancelOperation(operationId: string) {
-    this.requestQueue.abortOperation(operationId);
-  }
-
   private getCoreContext() {
     return {
       sdkInstanceId: this.sdkInstanceId,
@@ -1468,10 +1466,6 @@ export default class Core extends EventEmitter {
         cancel(this.getCoreContext(), message.payload.connectId);
         break;
       }
-      case IFRAME.CANCEL_OPERATION: {
-        this.cancelOperation(message.payload.operationId);
-        break;
-      }
       case IFRAME.CALLBACK: {
         Log.log('callback message: ', message);
         postMessage(message);

package/src/data/messages/messages-protocol-v2.json

@@ -482,9 +482,9 @@
         "MessageType_DeviceStatus": 60603,
         "MessageType_DevGetOnboardingStatus": 60604,
         "MessageType_DevOnboardingStatus": 60605,
-        "MessageType_DeviceSessionGet": 60606,
         "MessageType_DeviceSession": 60607,
         "MessageType_DeviceSessionAskPin": 60608,
+        "MessageType_DeviceSessionOpen": 60609,
         "MessageType_FilesystemPermissionFix": 60800,
         "MessageType_FilesystemPathInfo": 60801,
         "MessageType_FilesystemPathInfoQuery": 60802,
@@ -506,7 +506,8 @@
         [90, 92],
         [114, 122],
         [300, 304],
-        [309, 312]
+        [309, 312],
+        [60606, 60606]
       ]
     },
     "AlephiumGetAddress": {
@@ -11744,7 +11745,15 @@
       }
     },
     "ProtocolInfoRequest": {
-      "fields": {}
+      "fields": {
+        "eventless_wallet_session": {
+          "type": "bool",
+          "id": 1,
+          "options": {
+            "default": false
+          }
+        }
+      }
     },
     "ProtocolInfo": {
       "fields": {
@@ -12427,14 +12436,78 @@
         }
       }
     },
-    "DeviceSessionGet": {
+    "DeviceSessionErrorCode": {
+      "values": {
+        "DeviceSessionError_None": 0,
+        "DeviceSessionError_UserCancelled": 1,
+        "DeviceSessionError_InvalidSession": 2,
+        "DeviceSessionError_AttachPinUnavailable": 3,
+        "DeviceSessionError_PassphraseDisabled": 4,
+        "DeviceSessionError_Busy": 5
+      }
+    },
+    "DeviceSessionResume": {
       "fields": {
         "session_id": {
+          "rule": "required",
           "type": "bytes",
           "id": 1
         }
       }
     },
+    "DeviceSessionHostPassphrase": {
+      "fields": {
+        "passphrase": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
+    "DeviceSessionPassphraseOnDevice": {
+      "fields": {}
+    },
+    "DeviceSessionAttachPinOnDevice": {
+      "fields": {}
+    },
+    "DeviceSessionSelect": {
+      "oneofs": {
+        "access": {
+          "oneof": ["host_passphrase", "passphrase_on_device", "attach_pin_on_device"]
+        }
+      },
+      "fields": {
+        "host_passphrase": {
+          "type": "DeviceSessionHostPassphrase",
+          "id": 1
+        },
+        "passphrase_on_device": {
+          "type": "DeviceSessionPassphraseOnDevice",
+          "id": 2
+        },
+        "attach_pin_on_device": {
+          "type": "DeviceSessionAttachPinOnDevice",
+          "id": 3
+        }
+      }
+    },
+    "DeviceSessionOpen": {
+      "oneofs": {
+        "mode": {
+          "oneof": ["resume", "select"]
+        }
+      },
+      "fields": {
+        "resume": {
+          "type": "DeviceSessionResume",
+          "id": 1
+        },
+        "select": {
+          "type": "DeviceSessionSelect",
+          "id": 2
+        }
+      }
+    },
     "DeviceSession": {
       "fields": {
         "session_id": {

package/src/data-manager/DataManager.ts

@@ -399,7 +399,17 @@ export default class DataManager {
 
   static async load(settings: ConnectSettings) {
     this.settings = settings;
-    if (!settings.fetchConfig) {
+    const manifestMode =
+      settings.firmwareManifestMode ?? (settings.fetchConfig ? 'sdk-managed' : undefined);
+    if (settings.preloadedConfig) {
+      this.applyRemoteConfig(settings.preloadedConfig);
+      Log.log('[DataConfig] Preloaded firmware config loaded');
+      return;
+    }
+    if (manifestMode === 'external-only') {
+      throw new Error('External firmware config snapshot is required');
+    }
+    if (manifestMode !== 'sdk-managed') {
       return;
     }
 
@@ -409,60 +419,50 @@ export default class DataManager {
 
     const urlWithCache = `${url}?noCache=${getTimeStamp()}`;
     let data: RemoteConfigResponse | null = null;
-    let fetchMethod: 'configFetcher' | 'axios' | 'none' = 'none';
-
-    // 1. Try custom configFetcher first (client-side IP direct connection support)
     if (settings.configFetcher) {
-      Log.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
+      Log.debug('[DataConfig] Trying client configFetcher...');
       try {
         data = await settings.configFetcher(urlWithCache);
-        if (data) {
-          fetchMethod = 'configFetcher';
-          Log.log('[DataConfig] ConfigFetcher success');
-        } else {
-          Log.debug('[DataConfig] ConfigFetcher returned null, will fallback to axios');
-        }
       } catch (e) {
-        Log.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
+        Log.warn('[DataConfig] Client configFetcher failed:', e);
       }
     }
-
-    // 2. Fallback to default axios request
     if (!data) {
-      Log.debug('[DataConfig] Trying axios (SDK default fetcher)...');
+      Log.debug('[DataConfig] Trying SDK-managed config request...');
       try {
         const response = await axios.get<RemoteConfigResponse>(urlWithCache, {
           // because of iframe timeout is 10000
           timeout: 7000,
         });
         data = response.data;
-        fetchMethod = 'axios';
-        Log.log('[DataConfig] Axios fetch success');
+        Log.log('[DataConfig] SDK-managed config request succeeded');
       } catch (e) {
-        Log.warn('[DataConfig] Axios fetch error:', e);
+        Log.warn('[DataConfig] SDK-managed config request failed:', e);
       }
     }
 
-    // 3. Apply config if available
     if (data) {
-      Log.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
-      this.deviceMap = {
-        [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
-        [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
-        [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
-        [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
-        [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
-        [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
-        [EDeviceType.Pro2]: this.enrichFirmwareReleaseInfo(data.pro2),
-      };
-      this.assets = {
-        bridge: data.bridge,
-      };
+      this.applyRemoteConfig(data);
     } else {
-      Log.warn('[DataConfig] All fetch methods failed, using built-in default config');
+      Log.warn('[DataConfig] SDK-managed config request failed, using built-in default config');
     }
   }
 
+  private static applyRemoteConfig(data: RemoteConfigResponse) {
+    this.deviceMap = {
+      [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
+      [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
+      [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
+      [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
+      [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
+      [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
+      [EDeviceType.Pro2]: this.enrichFirmwareReleaseInfo(data.pro2),
+    };
+    this.assets = {
+      bridge: data.bridge,
+    };
+  }
+
   static updateEnv(newEnv: ConnectSettings['env']) {
     if (this.settings) {
       const prevEnv = this.settings.env;

package/src/data-manager/connectSettings.ts

@@ -115,10 +115,21 @@ export const parseConnectSettings = (input: Partial<ConnectSettings> = {}) => {
     settings.fetchConfig = input.fetchConfig;
   }
 
+  if (
+    input.firmwareManifestMode === 'sdk-managed' ||
+    input.firmwareManifestMode === 'external-only'
+  ) {
+    settings.firmwareManifestMode = input.firmwareManifestMode;
+  }
+
   if (input.configFetcher) {
     settings.configFetcher = input.configFetcher;
   }
 
+  if (input.preloadedConfig) {
+    settings.preloadedConfig = input.preloadedConfig;
+  }
+
   return settings;
 };