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

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -15,6 +15,11 @@ import { DEVICE, IFRAME, createUiMessage } from '../../events';
 import { getDeviceFirmwareVersion, getMethodVersionRange } from '../../utils';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { onDeviceButtonHandler } from '../../core';
+import {
+  completeRequestContext,
+  createRequestContext,
+  updateRequestContext,
+} from '../../utils/tracing';
 
 import type { Device, DeviceEvents } from '../../device/Device';
 import type { CoreApi } from '../../types';
@@ -321,6 +326,27 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
 
     method.connector = this.connector;
     method.postMessage = this.postMessage;
+    if (this.context) {
+      method.setContext?.(this.context);
+    }
+
+    method.requestContext = createRequestContext(method.responseID, methodName, {
+      sdkInstanceId: this.sdkInstanceId,
+      connectId: this.payload.connectId,
+      parentResponseID: this.responseID,
+    });
+
+    const onSignalAbort = () => {
+      this.abortController?.abort(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
+    };
+
+    const buttonListener = (...[device, request]: [...DeviceEvents['button']]) => {
+      if (request.code === 'ButtonRequest_PinEntry' || request.code === 'ButtonRequest_AttachPin') {
+        onSignalAbort();
+      } else {
+        onDeviceButtonHandler(device, request);
+      }
+    };
 
     let result: AllNetworkAddress[];
     try {
@@ -328,23 +354,15 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       method.setDevice?.(this.device);
       method.context = this.context;
 
-      const onSignalAbort = () => {
-        this.abortController?.abort(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
-      };
-
-      const _onDeviceButtonHandler = (...[device, request]: [...DeviceEvents['button']]) => {
-        if (
-          request.code === 'ButtonRequest_PinEntry' ||
-          request.code === 'ButtonRequest_AttachPin'
-        ) {
-          onSignalAbort();
-        } else {
-          onDeviceButtonHandler(device, request);
-        }
-      };
+      if (method.requestContext && this.device) {
+        updateRequestContext(method.requestContext.responseID, {
+          deviceInstanceId: this.device.instanceId,
+          commandsInstanceId: this.device.commands?.instanceId,
+        });
+      }
 
       // pro pin event
-      this.device.on(DEVICE.BUTTON, _onDeviceButtonHandler);
+      this.device.on(DEVICE.BUTTON, buttonListener);
       // classic pin event
       this.device.on(DEVICE.PIN, onSignalAbort);
       this.device.on(DEVICE.PASSPHRASE, onSignalAbort);
@@ -365,6 +383,9 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
           rootFingerprint,
         },
       }));
+      if (method.requestContext) {
+        completeRequestContext(method.requestContext.responseID);
+      }
     } catch (e: any) {
       const error = handleSkippableHardwareError(e, this.device, method);
 
@@ -383,6 +404,16 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       } else {
         throw e;
       }
+      if (method.requestContext) {
+        completeRequestContext(
+          method.requestContext.responseID,
+          e instanceof Error ? e : new Error(String(e))
+        );
+      }
+    } finally {
+      this.device.off(DEVICE.BUTTON, buttonListener);
+      this.device.off(DEVICE.PIN, onSignalAbort);
+      this.device.off(DEVICE.PASSPHRASE, onSignalAbort);
     }
 
     return result;

package/src/api/evm/EVMSignTypedData.ts

@@ -1,7 +1,7 @@
 import semver from 'semver';
 import { get } from 'lodash';
 import BigNumber from 'bignumber.js';
-import { ERRORS, HardwareErrorCode, EDeviceType } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import {
   EthereumTypedDataSignature,
   EthereumTypedDataStructAck,
@@ -337,9 +337,15 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
     let biggerLimit = 1024; // 1k
 
     const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+    const currentDeviceType = getDeviceType(this.device.features);
     const supportBiggerDataVersion = '4.4.0';
 
-    if (semver.gte(currentVersion, supportBiggerDataVersion)) {
+    const supportBiggerData =
+      DeviceModelToTypes.model_classic1s.includes(currentDeviceType) ||
+      (DeviceModelToTypes.model_touch.includes(currentDeviceType) &&
+        semver.gte(currentVersion, supportBiggerDataVersion));
+
+    if (supportBiggerData) {
       biggerLimit = 1536; // 1.5k
     }
 

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -1,29 +1,27 @@
 import {
-  createDeferred,
-  Deferred,
   EDeviceType,
   ERRORS,
   HardwareError,
   HardwareErrorCode,
+  createDeferred,
 } from '@onekeyfe/hd-shared';
-import { RebootType } from '@onekeyfe/hd-transport';
-import type { KnownDevice } from '../../types';
 
-import {
-  UI_REQUEST,
-  createUiMessage,
-  FirmwareUpdateTipMessage,
-  IFirmwareUpdateTipMessage,
-  IFirmwareUpdateProgressType,
-} from '../../events/ui-request';
+import { FirmwareUpdateTipMessage, UI_REQUEST, createUiMessage } from '../../events/ui-request';
 import { DevicePool } from '../../device/DevicePool';
-import { getDeviceType, wait, getLogger, LoggerNames, getDeviceUUID } from '../../utils';
+import { LoggerNames, getDeviceType, getDeviceUUID, getLogger, wait } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
-
 import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
-import { PROTO } from '../../constants';
+
+import type {
+  IFirmwareUpdateProgressType,
+  IFirmwareUpdateTipMessage,
+} from '../../events/ui-request';
+import type { PROTO } from '../../constants';
+import type { RebootType } from '@onekeyfe/hd-transport';
+import type { Deferred } from '@onekeyfe/hd-shared';
+import type { KnownDevice } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 
 const Log = getLogger(LoggerNames.Method);
@@ -266,16 +264,16 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
    */
   async startEmmcFirmwareUpdate({ path }: { path: string }) {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    let updaeteResponse: TypedResponseMessage<'Success'>;
+    let updateResponse: TypedResponseMessage<'Success'>;
     try {
-      updaeteResponse = await typedCall('FirmwareUpdateEmmc', 'Success', {
+      updateResponse = await typedCall('FirmwareUpdateEmmc', 'Success', {
         path,
         reboot_on_success: true,
       });
     } catch (error) {
       if (isDeviceDisconnectedError(error)) {
         Log.log('Rebooting device');
-        updaeteResponse = {
+        updateResponse = {
           type: 'Success',
           message: { message: FIRMWARE_UPDATE_CONFIRM },
         };
@@ -283,7 +281,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
         throw error;
       }
     }
-    if (updaeteResponse.type !== 'Success') {
+    if (updateResponse.type !== 'Success') {
       throw ERRORS.TypedError(HardwareErrorCode.FirmwareError, 'firmware update error');
     }
     this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdating);

package/src/api/firmware/bootloaderHelper.ts

@@ -1,8 +1,10 @@
 import semver from 'semver';
 import { EDeviceType } from '@onekeyfe/hd-shared';
-import { Features, IVersionArray } from '../../types';
+
 import { getDeviceType } from '../../utils';
 
+import type { Features, IVersionArray } from '../../types';
+
 export function shouldUpdateBootloaderForClassicAndMini({
   currentVersion,
   bootloaderVersion,

package/src/api/firmware/updateBootloader.ts

@@ -1,11 +1,14 @@
 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 { DeviceModelToTypes } from '../../types';
+import { getDeviceBootloaderVersion, getDeviceFirmwareVersion, getDeviceType } from '../../utils';
 import { DataManager } from '../../data-manager';
 import { shouldUpdateBootloaderForClassicAndMini } from './bootloaderHelper';
 
+import type { Features } from '../../types';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
+
 export function checkNeedUpdateBootForTouch(features: Features, firmwareType: EFirmwareType) {
   const deviceType = getDeviceType(features);
   if (!DeviceModelToTypes.model_touch.includes(deviceType)) return false;

package/src/api/firmware/uploadFirmware.ts

@@ -2,29 +2,28 @@ 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 { getDeviceFirmwareVersion } from '../../utils/deviceVersionUtils';
 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';
@@ -105,29 +104,96 @@ export const uploadFirmware = async (
     rebootOnSuccess,
   }: PROTO.FirmwareUpload & {
     rebootOnSuccess?: boolean;
-  }
+  },
+  isUpdateBootloader?: boolean
 ) => {
   const deviceType = getDeviceType(device.features);
   if (DeviceModelToTypes.model_mini.includes(deviceType)) {
     postConfirmationMessage(device);
     postProgressTip(device, 'ConfirmOnDevice', postMessage);
-    const eraseCommand = updateType === 'firmware' ? 'FirmwareErase' : 'FirmwareErase_ex';
+
+    const isFirmware = updateType === 'firmware';
+
+    if (isFirmware && !isUpdateBootloader) {
+      const newFeatures = await typedCall('GetFeatures', 'Features', {});
+      const deviceBootloaderVersion = getDeviceBootloaderVersion(newFeatures.message).join('.');
+      const supportUpgradeFileHeader = semver.gte(deviceBootloaderVersion, '2.1.0');
+      Log.debug('supportUpgradeFileHeader:', supportUpgradeFileHeader);
+
+      if (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));
+
+        try {
+          const headerRes = await typedCall('UpgradeFileHeader', 'Success', {
+            data: bytesToHex(header),
+          });
+
+          const isUnknownMessage = headerRes.message?.message?.includes('Failure_UnknownMessage');
+
+          if (headerRes.type !== 'Success' && !isUnknownMessage) {
+            Log.error('Firmware header upload failed:', headerRes);
+            throw ERRORS.TypedError(
+              HardwareErrorCode.RuntimeError,
+              'failed to upload firmware header'
+            );
+          }
+        } catch (error) {
+          Log.error('Firmware header upload failed:', error);
+          const message = error instanceof Error ? error.message : String(error ?? '');
+          if (!message.includes('Failure_UnknownMessage')) {
+            throw error;
+          }
+        }
+        Log.debug('Firmware header uploaded successfully');
+      }
+    }
+
+    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');
     }
     postProgressTip(device, 'FirmwareEraseSuccess', postMessage);
+
     postProgressMessage(device, 0, 'installingFirmware', postMessage);
-    const { message, type } = await typedCall('FirmwareUpload', 'Success', {
-      payload,
-    });
+    let updateResponse: TypedResponseMessage<'Success'>;
+    try {
+      updateResponse = await typedCall('FirmwareUpload', 'Success', {
+        payload,
+      });
+    } catch (error) {
+      if (isDeviceDisconnectedError(error)) {
+        Log.log('Rebooting device');
+        updateResponse = {
+          type: 'Success',
+          message: { message: FIRMWARE_UPDATE_CONFIRM },
+        };
+      } else {
+        throw error;
+      }
+    }
     postProgressMessage(device, 100, 'installingFirmware', postMessage);
 
     await waitBleInstall(updateType);
-    if (type !== 'Success') {
+    if (updateResponse.type !== 'Success') {
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'install firmware error');
     }
-    return message;
+    return updateResponse.message;
   }
 
   if (DeviceModelToTypes.model_touch.includes(deviceType)) {