@onekeyfe/hd-core 1.1.18 → 1.1.19-alpha.1

package/src/api/firmware/updateBootloader.ts

@@ -1,16 +1,17 @@
 import ByteBuffer from 'bytebuffer';
 import semver from 'semver';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import { DeviceModelToTypes, Features } from '../../types';
 import { getDeviceType, getDeviceBootloaderVersion, getDeviceFirmwareVersion } from '../../utils';
 import { DataManager } from '../../data-manager';
 import { shouldUpdateBootloaderForClassicAndMini } from './bootloaderHelper';
 
-export function checkNeedUpdateBootForTouch(features: Features) {
+export function checkNeedUpdateBootForTouch(features: Features, firmwareType: EFirmwareType) {
   const deviceType = getDeviceType(features);
   if (!DeviceModelToTypes.model_touch.includes(deviceType)) return false;
   const currentVersion = getDeviceFirmwareVersion(features).join('.');
   const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
-  const targetBootloaderVersion = DataManager.getBootloaderTargetVersion(features);
+  const targetBootloaderVersion = DataManager.getBootloaderTargetVersion(features, firmwareType);
   if (!targetBootloaderVersion) return false;
 
   return (
@@ -23,22 +24,29 @@ export function checkNeedUpdateBootForTouch(features: Features) {
   );
 }
 
-export function checkNeedUpdateBootForClassicAndMini(
-  features: Features,
-  willUpdateFirmware?: string
-) {
+export function checkNeedUpdateBootForClassicAndMini({
+  features,
+  willUpdateFirmware,
+  firmwareType,
+}: {
+  features: Features;
+  willUpdateFirmware?: string;
+  firmwareType: EFirmwareType;
+}) {
   const deviceType = getDeviceType(features);
   if (!DeviceModelToTypes.model_mini.includes(deviceType)) return false;
   if (!willUpdateFirmware) return false;
   const currentVersion = getDeviceFirmwareVersion(features).join('.');
   const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
-  const targetBootloaderVersion = DataManager.getBootloaderTargetVersion(features);
+  const targetBootloaderVersion = DataManager.getBootloaderTargetVersion(features, firmwareType);
   if (targetBootloaderVersion && semver.gte(bootloaderVersion, targetBootloaderVersion.join('.'))) {
     return false;
   }
 
-  const bootloaderRelatedFirmwareVersion =
-    DataManager.getBootloaderRelatedFirmwareVersion(features);
+  const bootloaderRelatedFirmwareVersion = DataManager.getBootloaderRelatedFirmwareVersion(
+    features,
+    firmwareType
+  );
   if (!bootloaderRelatedFirmwareVersion) return false;
 
   return shouldUpdateBootloaderForClassicAndMini({

package/src/api/firmware/uploadFirmware.ts

@@ -2,29 +2,27 @@ import semver from 'semver';
 import { blake2s } from '@noble/hashes/blake2s';
 import JSZip from 'jszip';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { Success } from '@onekeyfe/hd-transport';
+
 import {
-  wait,
+  LoggerNames,
   getDeviceBootloaderVersion,
   getDeviceType,
-  LoggerNames,
   getLogger,
+  wait,
 } from '../../utils';
-import {
-  DEVICE,
-  CoreMessage,
-  createUiMessage,
-  UI_REQUEST,
-  IFirmwareUpdateProgressType,
-} from '../../events';
-import { PROTO } from '../../constants';
-import type { Device } from '../../device/Device';
-import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
-import { DeviceModelToTypes, KnownDevice } from '../../types';
+import { DEVICE, UI_REQUEST, createUiMessage } from '../../events';
+import { DeviceModelToTypes } from '../../types';
 import { bytesToHex } from '../helpers/hexUtils';
 import { DataManager } from '../../data-manager';
 import { DevicePool } from '../../device/DevicePool';
 
+import type { KnownDevice } from '../../types';
+import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
+import type { PROTO } from '../../constants';
+import type { CoreMessage, IFirmwareUpdateProgressType } from '../../events';
+import type { Success } from '@onekeyfe/hd-transport';
+import type { Device } from '../../device/Device';
+
 const NEW_BOOT_UPRATE_FIRMWARE_VERSION = '2.4.5';
 const SESSION_ERROR = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
@@ -111,7 +109,45 @@ export const uploadFirmware = async (
   if (DeviceModelToTypes.model_mini.includes(deviceType)) {
     postConfirmationMessage(device);
     postProgressTip(device, 'ConfirmOnDevice', postMessage);
-    const eraseCommand = updateType === 'firmware' ? 'FirmwareErase' : 'FirmwareErase_ex';
+    const isFirmware = updateType === 'firmware';
+
+    const deviceBootloaderVersion = getDeviceBootloaderVersion(device.features).join('.');
+    const supportUpgradeFileHeader = semver.gt(deviceBootloaderVersion, '2.1.0');
+
+    Log.debug(
+      'supportUpgradeFileHeader:',
+      supportUpgradeFileHeader,
+      'deviceBootloaderVersion:',
+      deviceBootloaderVersion
+    );
+    if (isFirmware && supportUpgradeFileHeader) {
+      // Extract and validate firmware header (first 1KB)
+      const HEADER_SIZE = 1024;
+      if (payload.byteLength < HEADER_SIZE) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `firmware payload too small: ${payload.byteLength} bytes, expected at least ${HEADER_SIZE} bytes`
+        );
+      }
+
+      Log.debug('Uploading firmware header:', { size: HEADER_SIZE, totalSize: payload.byteLength });
+      postProgressTip(device, 'UploadingFirmwareHeader', postMessage);
+
+      const header = new Uint8Array(payload.slice(0, HEADER_SIZE));
+      const headerRes = (await typedCall('UpgradeFileHeader', 'Success', {
+        data: bytesToHex(header),
+      })) as TypedResponseMessage<'Success'>;
+
+      const isUnexpectedMessage = headerRes.message?.message?.includes('Failure_UnexpectedMessage');
+      if (headerRes.type !== 'Success' && !isUnexpectedMessage) {
+        Log.error('Firmware header upload failed:', headerRes);
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'failed to upload firmware header');
+      }
+
+      Log.debug('Firmware header uploaded successfully, isUnexpectedMessage:', isUnexpectedMessage);
+    }
+
+    const eraseCommand = isFirmware ? 'FirmwareErase' : 'FirmwareErase_ex';
     const eraseRes = await typedCall(eraseCommand as unknown as any, 'Success', {});
     if (eraseRes.type !== 'Success') {
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'erase firmware error');

package/src/api/sui/SuiSignTransaction.ts

@@ -1,6 +1,6 @@
-import { SuiSignTx as HardwareSuiSignTx, TypedCall, SuiSignedTx } from '@onekeyfe/hd-transport';
 import semver from 'semver';
 import { bytesToHex } from '@noble/hashes/utils';
+
 import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
@@ -8,6 +8,12 @@ import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 import { getDeviceFirmwareVersion, getDeviceType } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
+
+import type {
+  SuiSignTx as HardwareSuiSignTx,
+  SuiSignedTx,
+  TypedCall,
+} from '@onekeyfe/hd-transport';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 
 type SuiSignTx = Omit<HardwareSuiSignTx, 'data_initial_chunk' | 'data_length'> & HardwareSuiSignTx;

package/src/core/index.ts

@@ -22,12 +22,23 @@ import {
   setLoggerPostMessage,
   wait,
   getMethodVersionRange,
+  getFirmwareType,
 } from '../utils';
 import {
   findDefectiveBatchDevice,
   getDefectiveDeviceInfo,
 } from '../utils/findDefectiveBatchDevice';
 import { supportNewPassphrase } from '../utils/deviceFeaturesUtils';
+import {
+  completeRequestContext,
+  createRequestContext,
+  createSdkTracingContext,
+  formatRequestContext,
+  getActiveRequestsByDeviceInstance,
+  SdkTracingContext,
+  updateRequestContext,
+  cleanupSdkInstance,
+} from '../utils/tracing';
 import { Device, DeviceEvents, InitOptions, RunOptions } from '../device/Device';
 import { DeviceList } from '../device/DeviceList';
 import { DevicePool } from '../device/DevicePool';
@@ -96,6 +107,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'));
@@ -107,6 +142,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);
@@ -115,10 +159,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 });
     }
   }
@@ -190,6 +237,8 @@ const onCallDevice = async (
 
   const { requestQueue, getPrePendingCallPromise, setPrePendingCallPromise } = context;
 
+  updateMethodRequestContext(method, { status: 'running' });
+
   const connectStateChange = preConnectCache.passphraseState !== method.payload.passphraseState;
 
   preConnectCache = {
@@ -224,6 +273,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, {
@@ -238,6 +289,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(
@@ -282,7 +346,8 @@ const onCallDevice = async (
           }
         }
 
-        const newVersionStatus = DataManager.getFirmwareStatus(device.features);
+        const deviceFirmwareType = getFirmwareType(device.features);
+        const newVersionStatus = DataManager.getFirmwareStatus(device.features, deviceFirmwareType);
         const bleVersionStatus = DataManager.getBLEFirmwareStatus(device.features);
 
         const currentFirmwareVersion = getDeviceFirmwareVersion(device.features).join('.');
@@ -450,10 +515,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);
@@ -469,6 +536,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) {
@@ -478,6 +546,7 @@ const onCallDevice = async (
       ERRORS.TypedError(HardwareErrorCode.CallMethodError, error.message)
     );
     Log.debug('Call API - Run Error: ', error);
+    completeMethodRequestContext(method, error);
   } finally {
     const response = messageResponse;
 
@@ -505,7 +574,20 @@ 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),
+          }
+        );
+      }
+      removeDeviceListener(device);
+    }
   }
 };
 
@@ -585,7 +667,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;
@@ -640,7 +725,7 @@ const ensureConnected = async (
           if (timer) {
             clearTimeout(timer);
           }
-          reject(ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
+          reject(ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled));
           return true;
         }
         return false;
@@ -804,7 +889,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
           }
           requestQueue.rejectRequest(
             requestId,
-            ERRORS.TypedError(HardwareErrorCode.ActionCancelled)
+            ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)
           );
         }
       }
@@ -829,7 +914,7 @@ export const cancel = (context: CoreContext, connectId?: string) => {
 
           requestQueue.rejectRequest(
             requestId,
-            ERRORS.TypedError(HardwareErrorCode.ActionCancelled)
+            ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)
           );
         }
       }
@@ -842,7 +927,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)
+        );
       });
     }
   }
@@ -1021,6 +1109,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
@@ -1028,8 +1120,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,
@@ -1107,6 +1208,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": {