@onekeyfe/hd-core 1.1.19-alpha.0 → 1.1.19-alpha.2

package/src/core/index.ts

@@ -1,62 +1,75 @@
 import semver from 'semver';
 import EventEmitter from 'events';
-import { Features, LowlevelTransportSharedPlugin, OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
 import {
-  createDeferred,
-  Deferred,
   ERRORS,
   HardwareError,
   HardwareErrorCode,
+  createDefectiveFirmwareError,
+  createDeferred,
   createDeprecatedHardwareError,
   createNeedUpgradeFirmwareHardwareError,
   createNewFirmwareForceUpdateHardwareError,
   createNewFirmwareUnReleaseHardwareError,
-  createDefectiveFirmwareError,
 } from '@onekeyfe/hd-shared';
+
 import {
-  getDeviceFirmwareVersion,
-  getDeviceBLEFirmwareVersion,
+  LoggerNames,
   enableLog,
+  getDeviceBLEFirmwareVersion,
+  getDeviceFirmwareVersion,
+  getFirmwareType,
   getLogger,
-  LoggerNames,
+  getMethodVersionRange,
   setLoggerPostMessage,
   wait,
-  getMethodVersionRange,
-  getFirmwareType,
 } from '../utils';
 import {
   findDefectiveBatchDevice,
   getDefectiveDeviceInfo,
 } from '../utils/findDefectiveBatchDevice';
 import { supportNewPassphrase } from '../utils/deviceFeaturesUtils';
-import { Device, DeviceEvents, InitOptions, RunOptions } from '../device/Device';
+import {
+  cleanupSdkInstance,
+  completeRequestContext,
+  createRequestContext,
+  createSdkTracingContext,
+  formatRequestContext,
+  getActiveRequestsByDeviceInstance,
+  updateRequestContext,
+} from '../utils/tracing';
+import { Device } from '../device/Device';
 import { DeviceList } from '../device/DeviceList';
 import { DevicePool } from '../device/DevicePool';
 import { findMethod } from '../api/utils';
 import { DataManager } from '../data-manager';
-
 import { UI_REQUEST as UI_REQUEST_CONST } from '../constants/ui-request';
 import {
   CORE_EVENT,
-  CoreMessage,
-  createDeviceMessage,
-  createResponseMessage,
-  createUiMessage,
   DEVICE,
   IFRAME,
-  IFrameCallMessage,
   UI_REQUEST,
   UI_RESPONSE,
-  UiPromise,
-  UiPromiseResponse,
+  createDeviceMessage,
+  createResponseMessage,
+  createUiMessage,
 } from '../events';
-import type { BaseMethod } from '../api/BaseMethod';
-import type { ConnectSettings, KnownDevice } from '../types';
 import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
 import RequestQueue from './RequestQueue';
 import { getSynchronize } from '../utils/getSynchronize';
 
+import type { ConnectSettings, KnownDevice } from '../types';
+import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
+import type { DeviceEvents, InitOptions, RunOptions } from '../device/Device';
+import type { SdkTracingContext } from '../utils/tracing';
+import type { Deferred } from '@onekeyfe/hd-shared';
+import type {
+  Features,
+  LowlevelTransportSharedPlugin,
+  OneKeyDeviceInfo,
+} from '@onekeyfe/hd-transport';
+import type { BaseMethod } from '../api/BaseMethod';
+
 const Log = getLogger(LoggerNames.Core);
 
 export type CoreContext = ReturnType<Core['getCoreContext']>;
@@ -97,6 +110,30 @@ let preConnectCache: {
   passphraseState: undefined,
 };
 
+const toError = (error: unknown): Error | undefined => {
+  if (error instanceof Error) return error;
+  if (error == null) return undefined;
+  if (typeof error === 'string') return new Error(error);
+  try {
+    return new Error(JSON.stringify(error));
+  } catch {
+    return new Error(String(error));
+  }
+};
+
+const updateMethodRequestContext = (method: BaseMethod, updates: any) => {
+  if (method.requestContext) {
+    updateRequestContext(method.requestContext.responseID, updates);
+  }
+};
+
+const completeMethodRequestContext = (method: BaseMethod, error?: unknown) => {
+  if (!method.requestContext) {
+    return;
+  }
+  completeRequestContext(method.requestContext.responseID, toError(error));
+};
+
 export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   if (!message.id || !message.payload || message.type !== IFRAME.CALL) {
     return Promise.reject(ERRORS.TypedError('on call: message.id or message.payload is missing'));
@@ -108,6 +145,15 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
     method = findMethod(message as IFrameCallMessage);
     method.connector = _connector;
     method.postMessage = postMessage;
+    method.setContext?.(context);
+
+    method.requestContext = createRequestContext(method.responseID, method.name, {
+      sdkInstanceId: context.sdkInstanceId,
+      connectId: method.connectId,
+    });
+
+    Log.debug(`[${context.sdkInstanceId}] callAPI: ${formatRequestContext(method.requestContext)}`);
+
     method.init();
   } catch (error) {
     return Promise.reject(error);
@@ -116,10 +162,13 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   DevicePool.emitter.on(DEVICE.CONNECT, onDeviceConnectHandler);
 
   if (!method.useDevice) {
+    updateMethodRequestContext(method, { status: 'running' });
     try {
       const response = await method.run();
+      completeMethodRequestContext(method);
       return createResponseMessage(method.responseID, true, response);
     } catch (error) {
+      completeMethodRequestContext(method, error);
       return createResponseMessage(method.responseID, false, { error });
     }
   }
@@ -191,6 +240,8 @@ const onCallDevice = async (
 
   const { requestQueue, getPrePendingCallPromise, setPrePendingCallPromise } = context;
 
+  updateMethodRequestContext(method, { status: 'running' });
+
   const connectStateChange = preConnectCache.passphraseState !== method.payload.passphraseState;
 
   preConnectCache = {
@@ -225,6 +276,8 @@ const onCallDevice = async (
   } catch (e) {
     console.log('ensureConnected error: ', e);
 
+    completeMethodRequestContext(method, e);
+
     if (e.name === 'AbortError' || e.message === 'Request aborted') {
       requestQueue.releaseTask(method.responseID);
       return createResponseMessage(method.responseID, false, {
@@ -239,6 +292,19 @@ const onCallDevice = async (
   method.setDevice?.(device);
   method.context = context;
 
+  updateMethodRequestContext(method, {
+    deviceInstanceId: device.instanceId,
+    commandsInstanceId: device.commands?.instanceId,
+  });
+
+  const activeRequests = getActiveRequestsByDeviceInstance(device.instanceId);
+  if (activeRequests.length > 0) {
+    Log.warn(
+      `[${method.instanceId}] Device ${device.instanceId} has ${activeRequests.length} active requests:`,
+      activeRequests.map(formatRequestContext)
+    );
+  }
+
   device.on(DEVICE.PIN, onDevicePinHandler);
   device.on(DEVICE.BUTTON, onDeviceButtonHandler);
   device.on(
@@ -452,10 +518,12 @@ const onCallDevice = async (
         Log.debug('Call API - Inner Method Run: ');
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
+        completeMethodRequestContext(method);
       } catch (error) {
-        Log.debug('Call API - Inner Method Run Error: ', error);
+        Log.debug(`Call API - Inner Method Run Error`, error);
         messageResponse = createResponseMessage(method.responseID, false, { error });
         requestQueue.resolveRequest(method.responseID, messageResponse);
+        completeMethodRequestContext(method, error);
       }
     };
     Log.debug('Call API - Device Run: ', device.mainId);
@@ -471,6 +539,7 @@ const onCallDevice = async (
       return await task.callPromise.promise;
     } catch (e) {
       Log.debug('Device Run Error: ', e);
+      completeMethodRequestContext(method, e);
       return createResponseMessage(method.responseID, false, { error: e });
     }
   } catch (error) {
@@ -480,6 +549,7 @@ const onCallDevice = async (
       ERRORS.TypedError(HardwareErrorCode.CallMethodError, error.message)
     );
     Log.debug('Call API - Run Error: ', error);
+    completeMethodRequestContext(method, error);
   } finally {
     const response = messageResponse;
 
@@ -507,7 +577,21 @@ const onCallDevice = async (
 
     cleanup();
 
-    removeDeviceListener(device);
+    if (device) {
+      const stillActive = getActiveRequestsByDeviceInstance(device.instanceId);
+      if (stillActive.length > 1) {
+        Log.warn(
+          `[${method.instanceId}] Removing listeners while ${stillActive.length} requests are active!`,
+          {
+            deviceInstanceId: device.instanceId,
+            activeRequests: stillActive.map(formatRequestContext),
+            pinListeners: device.listenerCount(DEVICE.PIN),
+          }
+        );
+      } else {
+        removeDeviceListener(device);
+      }
+    }
   }
 };
 
@@ -587,7 +671,10 @@ function initDeviceForBle(method: BaseMethod) {
   if (deviceCacheMap.has(method.connectId)) {
     device = deviceCacheMap.get(method.connectId) as Device;
   } else {
-    device = Device.fromDescriptor({ id: method.connectId } as OneKeyDeviceInfo);
+    device = Device.fromDescriptor(
+      { id: method.connectId } as OneKeyDeviceInfo,
+      method.sdkInstanceId
+    );
     deviceCacheMap.set(method.connectId, device);
   }
   device.deviceConnector = _connector;
@@ -642,7 +729,7 @@ const ensureConnected = async (
           if (timer) {
             clearTimeout(timer);
           }
-          reject(ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
+          reject(ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled));
           return true;
         }
         return false;
@@ -806,7 +893,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
           }
           requestQueue.rejectRequest(
             requestId,
-            ERRORS.TypedError(HardwareErrorCode.ActionCancelled)
+            ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)
           );
         }
       }
@@ -831,7 +918,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
 
           requestQueue.rejectRequest(
             requestId,
-            ERRORS.TypedError(HardwareErrorCode.ActionCancelled)
+            ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)
           );
         }
       }
@@ -844,7 +931,10 @@ export const cancel = (context: CoreContext, connectId?: string) => {
       });
 
       requestQueue.getRequestTasksId().forEach(requestId => {
-        requestQueue.rejectRequest(requestId, ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
+        requestQueue.rejectRequest(
+          requestId,
+          ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)
+        );
       });
     }
   }
@@ -1005,6 +1095,9 @@ const onSelectDeviceInBootloaderForWebDeviceHandler = async (
  * @memberof Core
  */
 const postMessage = (message: CoreMessage) => {
+  if (!_core) {
+    return;
+  }
   _core.emit(CORE_EVENT, message);
 };
 
@@ -1023,6 +1116,10 @@ const removeUiPromise = (promise: Deferred<any>) => {
 };
 
 export default class Core extends EventEmitter {
+  private tracingContext: SdkTracingContext;
+
+  public readonly sdkInstanceId: string;
+
   private requestQueue = new RequestQueue();
 
   // background task
@@ -1030,8 +1127,17 @@ export default class Core extends EventEmitter {
 
   private methodSynchronize = getSynchronize();
 
+  constructor() {
+    super();
+    this.tracingContext = createSdkTracingContext();
+    this.sdkInstanceId = this.tracingContext.sdkInstanceId;
+    Log.debug(`[Core] Created SDK instance: ${this.sdkInstanceId}`);
+  }
+
   private getCoreContext() {
     return {
+      sdkInstanceId: this.sdkInstanceId,
+      tracingContext: this.tracingContext,
       requestQueue: this.requestQueue,
       methodSynchronize: this.methodSynchronize,
       getPrePendingCallPromise: () => this.prePendingCallPromise,
@@ -1109,6 +1215,8 @@ export default class Core extends EventEmitter {
   dispose() {
     _deviceList = undefined;
     _connector = undefined;
+    Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
+    cleanupSdkInstance(this.sdkInstanceId);
   }
 }
 

package/src/data/messages/messages.json

@@ -1997,6 +1997,15 @@
         }
       }
     },
+    "UpgradeFileHeader": {
+      "fields": {
+        "data": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
     "CardanoDerivationType": {
       "values": {
         "LEDGER": 0,
@@ -12397,7 +12406,8 @@
         "MessageType_GetPassphraseState": 10028,
         "MessageType_PassphraseState": 10029,
         "MessageType_UnLockDevice": 10030,
-        "MessageType_UnLockDeviceResponse": 10031
+        "MessageType_UnLockDeviceResponse": 10031,
+        "MessageType_UpgradeFileHeader": 10050
       }
     },
     "google": {

package/src/device/Device.ts

@@ -24,6 +24,7 @@ import {
   fixFeaturesFirmwareVersion,
   getPassphraseStateWithRefreshDeviceInfo,
 } from '../utils/deviceFeaturesUtils';
+import { generateInstanceId } from '../utils/tracing';
 
 import type DeviceConnector from './DeviceConnector';
 // eslint-disable-next-line import/no-cycle
@@ -99,6 +100,15 @@ export class Device extends EventEmitter {
    */
   originalDescriptor: DeviceDescriptor;
 
+  sdkInstanceId?: string;
+
+  /**
+   * 设备实例唯一标识
+   */
+  instanceId: string;
+
+  createdAt: number;
+
   /**
    * 设备主 ID
    * 蓝牙连接时是设备的 UUID
@@ -158,14 +168,22 @@ export class Device extends EventEmitter {
 
   pendingCallbackPromise?: Deferred<void>;
 
-  constructor(descriptor: DeviceDescriptor) {
+  constructor(descriptor: DeviceDescriptor, sdkInstanceId?: string) {
     super();
     this.originalDescriptor = descriptor;
+    this.sdkInstanceId = sdkInstanceId;
+    this.instanceId = generateInstanceId('Device', this.sdkInstanceId);
+    this.createdAt = Date.now();
+    Log.debug(
+      `[Device] Created: ${this.instanceId}${
+        this.sdkInstanceId ? ` for SDK: ${this.sdkInstanceId}` : ''
+      }`
+    );
   }
 
-  static fromDescriptor(originalDescriptor: DeviceDescriptor) {
+  static fromDescriptor(originalDescriptor: DeviceDescriptor, sdkInstanceId?: string) {
     const descriptor = { ...originalDescriptor };
-    return new Device(descriptor);
+    return new Device(descriptor, sdkInstanceId);
   }
 
   // simplified object to pass via postMessage
@@ -183,6 +201,9 @@ export class Device extends EventEmitter {
       connectId: DataManager.isBleConnect(env) ? this.mainId || null : getDeviceUUID(this.features),
       /** Hardware ID, will not change at any time */
       uuid: getDeviceUUID(this.features),
+      sdkInstanceId: this.sdkInstanceId,
+      instanceId: this.instanceId,
+      createdAt: this.createdAt,
       deviceType,
       /** ID for current seeds, will clear after replace a new seed at device */
       deviceId: this.features.device_id || null,

package/src/device/DeviceCommands.ts

@@ -1,11 +1,18 @@
-import type { Transport, Messages, FailureType } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import TransportManager from '../data-manager/TransportManager';
 import DataManager from '../data-manager/DataManager';
-import { patchFeatures, getLogger, LoggerNames, getDeviceType } from '../utils';
-import type { Device } from './Device';
+import { LoggerNames, getDeviceType, getLogger, patchFeatures } from '../utils';
 import { DEVICE, type PassphraseRequestPayload } from '../events';
 import { DeviceModelToTypes } from '../types';
+import {
+  formatRequestContext,
+  generateInstanceId,
+  getActiveRequestsByDeviceInstance,
+} from '../utils/tracing';
+
+import type { Device } from './Device';
+import type { FailureType, Messages, Transport } from '@onekeyfe/hd-transport';
 
 export type PassphrasePromptResponse = {
   passphrase?: string;
@@ -114,12 +121,17 @@ export const cancelDeviceWithInitialize = (device: Device) => {
 };
 
 const Log = getLogger(LoggerNames.DeviceCommands);
+const LogCore = getLogger(LoggerNames.Core);
 
 /**
  * The life cycle begins with the acquisition of the device and ends with the disposal device commands
  * acquire device -> create DeviceCommands -> release device -> dispose DeviceCommands
  */
 export class DeviceCommands {
+  instanceId: string;
+
+  currentResponseID?: number;
+
   device: Device;
 
   transport: Transport;
@@ -135,6 +147,9 @@ export class DeviceCommands {
     this.mainId = mainId;
     this.transport = TransportManager.getTransport();
     this.disposed = false;
+    this.instanceId = generateInstanceId('DeviceCommands', device.sdkInstanceId);
+
+    Log.debug(`[DeviceCommands] Created: ${this.instanceId}, device: ${this.device.instanceId}`);
   }
 
   async dispose(_cancelRequest: boolean) {
@@ -217,10 +232,14 @@ export class DeviceCommands {
       const promise = this.transport.call(this.mainId, type, msg) as any;
       this.callPromise = promise;
       const res = await promise;
-      Log.debug('[DeviceCommands] [call] Received', res.type);
+      if (res.type === 'Failure') {
+        LogCore.debug('[DeviceCommands] [call] Received', res.type, res.message);
+      } else {
+        LogCore.debug('[DeviceCommands] [call] Received', res.type);
+      }
       return res;
     } catch (error) {
-      Log.debug('[DeviceCommands] [call] Received error', error);
+      LogCore.debug('[DeviceCommands] [call] Received error', error);
       if (error.errorCode === HardwareErrorCode.BleDeviceBondError) {
         return {
           type: 'BleDeviceBondError',
@@ -400,14 +419,16 @@ export class DeviceCommands {
           message?.includes('verify failed')
         ) {
           error = ERRORS.TypedError(HardwareErrorCode.FirmwareVerificationFailed, message);
+        } else if (message?.includes('Firmware downgrade not allowed')) {
+          // Check firmware check failed
+          error = ERRORS.TypedError(HardwareErrorCode.FirmwareDowngradeNotAllowed, message);
         }
       }
 
       if (code === 'Failure_UnexpectedMessage') {
         if (callType === 'PassphraseAck') {
           error = ERRORS.TypedError(HardwareErrorCode.UnexpectPassphrase);
-        }
-        if (message === 'Not in Signing mode') {
+        } else if (message === 'Not in Signing mode') {
           error = ERRORS.TypedError(HardwareErrorCode.NotInSigningMode);
         }
       }
@@ -500,7 +521,7 @@ export class DeviceCommands {
         cancelDeviceInPrompt(this.device, false)
           .then(onCancel => {
             const error = ERRORS.TypedError(
-              HardwareErrorCode.ActionCancelled,
+              HardwareErrorCode.CallQueueActionCancelled,
               `${DEVICE.PIN} canceled`
             );
             // onCancel not void
@@ -515,7 +536,15 @@ export class DeviceCommands {
             reject(error);
           });
 
-      if (this.device.listenerCount(DEVICE.PIN) > 0) {
+      const listenerCount = this.device.listenerCount(DEVICE.PIN);
+
+      Log.debug(`[${this.instanceId}] _promptPin called`, {
+        responseID: this.currentResponseID,
+        deviceInstanceId: this.device.instanceId,
+        listenerCount,
+      });
+
+      if (listenerCount > 0) {
         this.device.setCancelableAction(cancelAndReject);
         this.device.emit(DEVICE.PIN, this.device, type, (err, pin) => {
           this.device.clearCancelableAction();
@@ -526,11 +555,22 @@ export class DeviceCommands {
           }
         });
       } else {
-        console.warn('[DeviceCommands] [call] PIN callback not configured, cancelling request');
+        const activeRequests = getActiveRequestsByDeviceInstance(this.device.instanceId);
+        const errorInfo = {
+          commandsInstanceId: this.instanceId,
+          deviceInstanceId: this.device.instanceId,
+          currentResponseID: this.currentResponseID,
+          listenerCount,
+          activeRequests: activeRequests.map(formatRequestContext),
+        };
+
+        LogCore.error('[DeviceCommands] [call] PIN callback not configured, cancelling request', {
+          ...errorInfo,
+        });
         reject(
           ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            '_promptPin: PIN callback not configured'
+            `_promptPin: PIN callback not configured: ${JSON.stringify(errorInfo)}`
           )
         );
       }
@@ -543,7 +583,7 @@ export class DeviceCommands {
         cancelDeviceInPrompt(this.device, false)
           .then(onCancel => {
             const error = ERRORS.TypedError(
-              HardwareErrorCode.ActionCancelled,
+              HardwareErrorCode.CallQueueActionCancelled,
               `${DEVICE.PASSPHRASE} canceled`
             );
             // onCancel not void
@@ -574,7 +614,9 @@ export class DeviceCommands {
           }
         );
       } else {
-        Log.error('[DeviceCommands] [call] Passphrase callback not configured, cancelling request');
+        LogCore.error(
+          '[DeviceCommands] [call] Passphrase callback not configured, cancelling request'
+        );
         reject(
           ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,

package/src/types/device.ts

@@ -35,6 +35,11 @@ export type KnownDevice = {
   unavailableCapabilities: UnavailableCapabilities;
   bleFirmwareVersion: IVersionArray | null;
   firmwareVersion: IVersionArray | null;
+
+  // debug sdk
+  instanceId?: string;
+  sdkInstanceId?: string;
+  createdAt?: number;
 };
 
 export type SearchDevice = {

package/src/utils/index.ts

@@ -2,6 +2,7 @@ export { getLogger, enableLog, LoggerNames, getLog, setLoggerPostMessage } from
 export * from './assets';
 export * from './versionUtils';
 export * from './patch';
+export * from './tracing';
 // Device utils
 export {
   getDeviceTypeByBleName,

package/src/utils/logger.ts

@@ -1,5 +1,6 @@
-import { CoreMessage } from '../events';
-import { createLogMessage, LOG } from '../events/log';
+import { LOG, createLogMessage } from '../events/log';
+
+import type { CoreMessage } from '../events';
 
 type LogMessage = {
   level: string;