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

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

@@ -1,20 +1,16 @@
-import { DevRebootType, DeviceRebootType } from '@onekeyfe/hd-transport';
+import { DeviceRebootType } from '@onekeyfe/hd-transport';
 
 import { invalidParameter, validateNonEmptyString } from '../helpers/filesystemValidation';
+import { ProtocolV2FirmwareTargetType } from '../../protocols/protocol-v2/firmware';
 
 import type {
-  DevFirmwareTarget,
-  DevFirmwareTargetType,
+  DeviceFirmwareTarget,
+  DeviceFirmwareTargetType,
+  DeviceFirmwareUpdateRecordFields,
   TransportCallOptions,
 } from '@onekeyfe/hd-transport';
 
-export type RebootTypeInput =
-  | DevRebootType
-  | DeviceRebootType
-  | keyof typeof DevRebootType
-  | keyof typeof DeviceRebootType
-  | string
-  | number;
+export type RebootTypeInput = DeviceRebootType | keyof typeof DeviceRebootType | string | number;
 
 export type DeviceRebootParams = {
   rebootType?: RebootTypeInput;
@@ -22,38 +18,37 @@ export type DeviceRebootParams = {
 };
 
 export type DeviceFirmwareTargetInput =
-  | DevFirmwareTarget
+  | DeviceFirmwareTarget
   | {
-      targetId?: DevFirmwareTargetType | string | number;
-      target_id?: DevFirmwareTargetType | string | number;
+      targetId?: DeviceFirmwareTargetType | string | number;
+      target_id?: DeviceFirmwareTargetType | string | number;
       path: string;
     };
 
 export type DeviceFirmwareUpdateParams = {
   targets?: DeviceFirmwareTargetInput[];
-  targetId?: DevFirmwareTargetType | string | number;
-  target_id?: DevFirmwareTargetType | string | number;
+  targetId?: DeviceFirmwareTargetType | string | number;
+  target_id?: DeviceFirmwareTargetType | string | number;
   path?: string;
 };
 
-export type FactoryDeviceInfoSettingsParams = {
-  serial_no?: string;
-  serialNo?: string;
-  cpu_info?: string;
-  cpuInfo?: string;
-  pre_firmware?: string;
-  preFirmware?: string;
+export type DeviceFirmwareUpdateStatusGetParams = {
+  fields?: DeviceFirmwareUpdateRecordFields;
 };
 
-const DEV_REBOOT_TYPES: Record<string, DevRebootType> = {
-  Normal: DevRebootType.Normal,
-  normal: DevRebootType.Normal,
-  Romloader: DevRebootType.Boardloader,
-  romloader: DevRebootType.Boardloader,
-  Boardloader: DevRebootType.Boardloader,
-  boardloader: DevRebootType.Boardloader,
-  Bootloader: DevRebootType.Bootloader,
-  bootloader: DevRebootType.Bootloader,
+export type DeviceFactoryInfoSetParams = {
+  version?: number;
+  serial_number?: string;
+  burn_in_completed?: boolean;
+  factory_test_completed?: boolean;
+  manufacture_time?: {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+  };
 };
 
 const DEVICE_REBOOT_TYPES: Record<string, DeviceRebootType> = {
@@ -68,13 +63,13 @@ const DEVICE_REBOOT_TYPES: Record<string, DeviceRebootType> = {
 };
 
 export const PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS: TransportCallOptions = {
-  intermediateTypes: ['DevFirmwareInstallProgress'],
+  intermediateTypes: ['DeviceFirmwareUpdateStatus'],
 };
 
 export const PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES: (
   | 'Success'
-  | 'DevFirmwareUpdateStatus'
-)[] = ['Success', 'DevFirmwareUpdateStatus'];
+  | 'DeviceFirmwareUpdateStatus'
+)[] = ['Success', 'DeviceFirmwareUpdateStatus'];
 
 export const getProtocolV2UnknownErrorText = (error: unknown) => {
   if (!error) {
@@ -123,9 +118,6 @@ export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
     message.includes('connection has timed out unexpectedly') ||
     message.includes('connection error has occured') ||
     message.includes('connection error has occurred') ||
-    message.includes('transferIn') ||
-    message.includes('transferin') ||
-    message.includes('usbdevice') ||
     message.includes('multiplatformbleadapter') ||
     message.includes('multipalformebleadapter') ||
     compactMessage.includes('rxerrorerror6') ||
@@ -133,19 +125,7 @@ export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
   );
 };
 
-export function normalizeRebootType(value: RebootTypeInput | undefined): DevRebootType {
-  if (typeof value === 'number') return value;
-  if (typeof value === 'string') {
-    const numeric = Number(value);
-    if (Number.isFinite(numeric)) return numeric;
-    if (value in DEV_REBOOT_TYPES) return DEV_REBOOT_TYPES[value];
-  }
-  return DevRebootType.Normal;
-}
-
-export function normalizeDeviceRebootType(
-  value: RebootTypeInput | undefined
-): DeviceRebootType {
+export function normalizeRebootType(value: RebootTypeInput | undefined): DeviceRebootType {
   if (typeof value === 'number') return value;
   if (typeof value === 'string') {
     const numeric = Number(value);
@@ -155,30 +135,46 @@ export function normalizeDeviceRebootType(
   return DeviceRebootType.Normal;
 }
 
-// 当前 firmware-pro2 子模块的 DevFirmwareTargetType 合法值。
-const VALID_FIRMWARE_TARGET_IDS = new Set<number>([0, 1, 2, 3, 4, 5, 6, 10]);
+// 与 firmware-pro2 的 proto_target_to_firmware_target 安装白名单保持一致。
+const INSTALLABLE_FIRMWARE_TARGET_IDS = new Set<number>([
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04,
+]);
+const FIRMWARE_TARGET_ID_BY_NAME = new Map<string, DeviceFirmwareTargetType>(
+  Object.entries(ProtocolV2FirmwareTargetType).flatMap(([key, value]) =>
+    INSTALLABLE_FIRMWARE_TARGET_IDS.has(value) ? [[key, value as DeviceFirmwareTargetType]] : []
+  )
+);
 
 function normalizeTargetId(
-  value: DevFirmwareTargetType | string | number | undefined,
+  value: DeviceFirmwareTargetType | string | number | undefined,
   name: string
-): DevFirmwareTargetType {
+): DeviceFirmwareTargetType {
   if (value === undefined || value === null) {
     throw invalidParameter(`Missing required parameter: ${name}`);
   }
-  const numeric = typeof value === 'number' ? value : Number(value);
-  // 校验值域：仅接受 DevFirmwareTargetType 中定义的 target id，
-  // 不再放行任意非负整数。
-  if (Number.isSafeInteger(numeric) && VALID_FIRMWARE_TARGET_IDS.has(numeric)) {
-    return numeric as DevFirmwareTargetType;
+  const named = typeof value === 'string' ? FIRMWARE_TARGET_ID_BY_NAME.get(value) : undefined;
+  const numeric = named ?? (typeof value === 'number' ? value : Number(value));
+  if (Number.isSafeInteger(numeric) && INSTALLABLE_FIRMWARE_TARGET_IDS.has(numeric)) {
+    return numeric as DeviceFirmwareTargetType;
   }
   throw invalidParameter(
-    `Parameter [${name}] must be a valid firmware target id (one of ${[
-      ...VALID_FIRMWARE_TARGET_IDS,
+    `Parameter [${name}] must be an installable firmware target id (one of ${[
+      ...INSTALLABLE_FIRMWARE_TARGET_IDS,
     ].join(', ')}).`
   );
 }
 
-export function normalizeFirmwareTargets(params: DeviceFirmwareUpdateParams): DevFirmwareTarget[] {
+export function normalizeFirmwareTargets(
+  params: DeviceFirmwareUpdateParams
+): DeviceFirmwareTarget[] {
   const targets =
     params.targets ??
     (params.path

package/src/api/ton/TonSignData.ts

@@ -51,11 +51,7 @@ export default class TonSignData extends BaseMethod<HardwareTonSignData> {
   }
 
   getVersionRange() {
-    return {
-      pro2: {
-        min: '0.0.0',
-      },
-    };
+    return {};
   }
 
   async run() {

package/src/api/utils.ts

@@ -2,16 +2,20 @@ import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import * as ApiMethods from './index';
 
+import type { BaseMethod } from './BaseMethod';
 import type { IFrameCallMessage } from '../events';
 
-export function findMethod(message: IFrameCallMessage & { id?: number }) {
+type MethodConstructor = new (message: IFrameCallMessage & { id?: number }) => BaseMethod<any>;
+
+const publicMethodRegistry = ApiMethods as unknown as Record<string, MethodConstructor>;
+
+export function findMethod(message: IFrameCallMessage & { id?: number }): BaseMethod<any> {
   const { method } = message.payload;
   if (typeof method !== 'string') {
     throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
   }
 
-  // @ts-expect-error
-  const MethodConstructor = ApiMethods[method];
+  const MethodConstructor = publicMethodRegistry[method];
   if (MethodConstructor) {
     return new MethodConstructor(message);
   }

package/src/constants/index.ts

@@ -1,2 +1,8 @@
 export { safeThrowError } from './errors';
-export { Messages as PROTO, TonSignDataType } from '@onekeyfe/hd-transport';
+export {
+  Messages as PROTO,
+  ResourceType,
+  TonSignDataType,
+  TonWalletVersion,
+} from '@onekeyfe/hd-transport';
+export type { HDNodeType, Success as DeviceSuccess } from '@onekeyfe/hd-transport';

package/src/core/RequestQueue.ts

@@ -1,21 +1,47 @@
+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) {
@@ -30,11 +56,94 @@ export default class RequestQueue {
       method.responseID = requestId;
     }
     const abortController = new AbortController();
-    const task = { id: requestId, method, abortController };
+    method.abortSignal = abortController.signal;
+    const task = {
+      id: requestId,
+      method,
+      abortController,
+      settled: createDeferred<void>(),
+      released: createDeferred<void>(),
+    };
     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);
   }
@@ -77,6 +186,7 @@ export default class RequestQueue {
         count++;
       }
     });
+    this.pendingOperationCancellations.clear();
     return count;
   }
 
@@ -90,8 +200,8 @@ export default class RequestQueue {
     const request = this.requestQueue.get(requestId);
     if (request) {
       request.callPromise?.resolve(response);
+      request.settled.resolve();
     }
-    this.releaseTask(requestId);
   }
 
   // 拒绝请求
@@ -99,12 +209,22 @@ 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/deviceEventRegistration.ts

@@ -0,0 +1,23 @@
+import { DEVICE } from '../events';
+
+import type { Device, DeviceEvents } from '../device/Device';
+
+export type HardwareUiEventHandlers = {
+  pin: (...event: DeviceEvents[typeof DEVICE.PIN]) => void;
+  button: (...event: DeviceEvents[typeof DEVICE.BUTTON]) => void;
+  passphrase: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE]) => void;
+  passphraseOnDevice: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE_ON_DEVICE]) => void;
+  attachPinOnDevice: (...event: DeviceEvents[typeof DEVICE.ATTACH_PIN_ON_DEVICE]) => void;
+};
+
+export function registerHardwareUiEventListeners(
+  device: Pick<Device, 'on'>,
+  handlers: HardwareUiEventHandlers
+) {
+  device.on(DEVICE.PIN, handlers.pin);
+  device.on(DEVICE.BUTTON, handlers.button);
+  device.on(DEVICE.PASSPHRASE, handlers.passphrase);
+  device.on(DEVICE.PASSPHRASE_ON_DEVICE, handlers.passphraseOnDevice);
+  device.on(DEVICE.ATTACH_PIN_ON_DEVICE, handlers.attachPinOnDevice);
+  return true;
+}