@onekeyfe/hd-core 1.2.0-alpha.184 → 1.2.0-alpha.186

package/src/api/FirmwareUpdateV4.ts

@@ -51,6 +51,7 @@ import {
   getProtocolV2UnknownErrorText,
   isProtocolV2DeviceDisconnectedError,
 } from './protocol-v2/helpers';
+import { isProtocolV2ResponseTimeout } from './helpers/protocolV2FileWrite';
 import {
   openFirmwareByteSource,
   readFirmwareByteSourceFully,
@@ -62,6 +63,7 @@ import {
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
   validateFirmwareUpdatePreparedPlan,
 } from './firmware/FirmwareUpdatePreparedPlan';
+
 import type {
   FirmwareArtifactReference,
   FirmwareUpdateV4Params,
@@ -91,6 +93,7 @@ const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
 const PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT = 15 * 1000;
 const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
 const PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY = 1000;
+const PROTOCOL_V2_INSTALL_FINISHED_AFTER_DISCONNECT_POLLS = 4;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
 const PROTOCOL_V2_TARGET_STATUS_FINISHED = 2;
@@ -189,6 +192,11 @@ const getProtocolV2DeviceTransferProgress = (
 type ProtocolV2FirmwareUpdateStatusTarget = {
   target_id: number | string;
   status?: number | string;
+  progress_percent?: number;
+  phase_info?: {
+    phase: number | string;
+    progress_percent: number;
+  };
   payload_version?: number;
   path?: string;
 };
@@ -409,6 +417,18 @@ const normalizeProtocolV2TargetStatus = (
   return undefined;
 };
 
+const PROTOCOL_V2_INSTALL_PHASE_BY_DECODED_VALUE = new Map<
+  number | string,
+  'prepare' | 'install' | 'verify'
+>([
+  [0, 'prepare'],
+  [1, 'install'],
+  [2, 'verify'],
+  ['FW_MGMT_UPDATER_PHASE_PREPARE', 'prepare'],
+  ['FW_MGMT_UPDATER_PHASE_INSTALL', 'install'],
+  ['FW_MGMT_UPDATER_PHASE_VERIFY', 'verify'],
+]);
+
 const normalizeProtocolV2Hex = (value?: string) => value?.replace(/^0x/i, '').toLowerCase();
 
 const versionArrayToNumber = (version?: IVersionArray) => {
@@ -466,6 +486,11 @@ const toProtocolV2FiniteNumber = (value: unknown) => {
   return undefined;
 };
 
+const normalizeProtocolV2ProgressPercent = (value: unknown) => {
+  const progress = toProtocolV2FiniteNumber(value);
+  return progress === undefined ? undefined : Math.min(100, Math.max(0, progress));
+};
+
 export const isProtocolV2FirmwareFingerprintValid = (
   binary: ArrayBuffer | Uint8Array,
   fingerprint: string | undefined
@@ -2310,6 +2335,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     for (const target of matchingTargets) {
       const targetId = normalizeProtocolV2TargetId(target.target_id);
       const pathConflictsWithCurrentInstall =
+        targetId !== undefined &&
         Boolean(target.path) &&
         Boolean(resolvedExpectedPaths.get(targetId)) &&
         target.path !== resolvedExpectedPaths.get(targetId) &&
@@ -2373,16 +2399,54 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     if (expectedTargetIds.size > 0 && matchingTargets.length > 0) {
-      const hasInProgressTarget = matchingTargets.some(target =>
-        isProtocolV2TargetStatusInProgress(target.status)
-      );
+      let detailedProgress = completedTargetIds.size * 100;
+      let installProgressMetadata:
+        | {
+            installTargetId: number;
+            installPhase: 'prepare' | 'install' | 'verify';
+            installPhaseProgress: number;
+          }
+        | undefined;
+      let hasInProgressTarget = false;
+      matchingTargets.forEach(target => {
+        const targetId = normalizeProtocolV2TargetId(target.target_id);
+        if (
+          targetId === undefined ||
+          completedTargetIds.has(targetId) ||
+          !isProtocolV2TargetStatusInProgress(target.status) ||
+          (liveTargetIds && !liveTargetIds.has(targetId))
+        ) {
+          return;
+        }
+        hasInProgressTarget = true;
+        detailedProgress += normalizeProtocolV2ProgressPercent(target.progress_percent) ?? 0;
+        const installPhase = target.phase_info
+          ? PROTOCOL_V2_INSTALL_PHASE_BY_DECODED_VALUE.get(target.phase_info.phase)
+          : undefined;
+        const installPhaseProgress = normalizeProtocolV2ProgressPercent(
+          target.phase_info?.progress_percent
+        );
+        if (installPhase && installPhaseProgress !== undefined && !installProgressMetadata) {
+          installProgressMetadata = {
+            installTargetId: targetId,
+            installPhase,
+            installPhaseProgress,
+          };
+        }
+      });
       const completedProgress = Math.floor(
         (completedTargetIds.size / expectedTargetIds.size) * 100
       );
-      // The protocol exposes no per-target percentage, so report coarse progress by
-      // completed targets and use 1% once work starts to keep the UI responsive.
-      const progress = Math.min(99, Math.max(completedProgress, hasInProgressTarget ? 1 : 0));
-      this.postProgressMessage(progress, 'installingFirmware');
+      const reportedProgress = Math.floor(detailedProgress / expectedTargetIds.size);
+      const progress = Math.min(
+        99,
+        Math.max(completedProgress, reportedProgress, hasInProgressTarget ? 1 : 0)
+      );
+      if (installProgressMetadata) {
+        this.postProgressMessage(progress, 'installingFirmware', installProgressMetadata);
+      } else {
+        this.postProgressMessage(progress, 'installingFirmware');
+      }
     }
 
     return false;
@@ -2453,6 +2517,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   ) {
     const expectedTargetIds = new Set(targets.map(target => target.target_id));
     const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
+    const isBleCoprocessorInstall =
+      this.isBleReconnect() &&
+      expectedTargetIds.has(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR);
     const startTime = Date.now();
     let lastError: unknown;
     // The loader may release either USB or BLE as installation starts. Recovery reconnects
@@ -2461,6 +2528,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     this.protocolV2InstallNeedsReconnect = false;
     let deviceInfo: ProtocolV2DeviceInfo | undefined;
     let bleInstallLinkReady = false;
+    let installStatusDisconnectObserved = false;
+    let installReconnectObserved = false;
+    let finishedStatusSnapshotKey: string | undefined;
+    let finishedStatusSnapshotPolls = 0;
+    let fastFinishedInstallProgressReported = false;
     let installEvidenceObserved = this.protocolV2InstallTerminalSuccessObserved;
     let currentInstallStatusObserved = false;
     const liveTargetIds = new Set<number>();
@@ -2477,6 +2549,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           deviceInfo = isBleInstallReconnect
             ? undefined
             : await this.verifyProtocolV2ReconnectIdentity();
+          if (isBleInstallReconnect && installStatusDisconnectObserved) {
+            installReconnectObserved = true;
+          }
           shouldReconnect = false;
         }
         let currentDeviceInfo = deviceInfo;
@@ -2487,6 +2562,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             {
               fields: {
                 status: true,
+                progress_percent: true,
+                phase_info: true,
                 payload_version: true,
                 path: true,
               },
@@ -2516,8 +2593,74 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             const targetId = normalizeProtocolV2TargetId(target.target_id);
             return targetId !== undefined && expectedTargetIds.has(targetId);
           });
+          const matchingFinishedTargetIds = new Set<number>();
+          const matchingFinishedStatus = matchingStatusTargets
+            .map(target => {
+              const targetId = normalizeProtocolV2TargetId(target.target_id);
+              const expectedPath = targetId === undefined ? undefined : expectedPaths.get(targetId);
+              const expectedVersion =
+                targetId === undefined
+                  ? undefined
+                  : this.getExpectedProtocolV2TargetVersion(targetId);
+              const payloadVersion = toProtocolV2FiniteNumber(target.payload_version);
+              if (
+                targetId === undefined ||
+                matchingFinishedTargetIds.has(targetId) ||
+                !isProtocolV2TargetStatusFinished(target.status) ||
+                (Boolean(target.path) && Boolean(expectedPath) && target.path !== expectedPath) ||
+                (expectedVersion !== undefined &&
+                  payloadVersion !== undefined &&
+                  payloadVersion !== expectedVersion)
+              ) {
+                return undefined;
+              }
+              matchingFinishedTargetIds.add(targetId);
+              return [targetId, target.path ?? null, payloadVersion ?? null] as const;
+            })
+            .filter((target): target is readonly [number, string | null, number | null] => !!target)
+            .sort(([leftTargetId], [rightTargetId]) => leftTargetId - rightTargetId);
+          const hasCompleteMatchingFinishedStatus =
+            matchingFinishedStatus.length === expectedTargetIds.size &&
+            matchingFinishedTargetIds.size === expectedTargetIds.size &&
+            expectedTargetIds.size > 0;
+          if (
+            requireCurrentInstallStatus &&
+            installReconnectObserved &&
+            hasCompleteMatchingFinishedStatus
+          ) {
+            const nextSnapshotKey = JSON.stringify(matchingFinishedStatus);
+            if (nextSnapshotKey === finishedStatusSnapshotKey) {
+              finishedStatusSnapshotPolls += 1;
+            } else {
+              finishedStatusSnapshotKey = nextSnapshotKey;
+              finishedStatusSnapshotPolls = 1;
+            }
+          } else {
+            finishedStatusSnapshotKey = undefined;
+            finishedStatusSnapshotPolls = 0;
+          }
+          if (
+            requireCurrentInstallStatus &&
+            installReconnectObserved &&
+            hasCompleteMatchingFinishedStatus &&
+            !currentInstallStatusObserved &&
+            !this.protocolV2InstallTerminalSuccessObserved &&
+            !fastFinishedInstallProgressReported
+          ) {
+            // A fast BLE install may finish while disconnected, so IN_PROGRESS can be hidden.
+            // A status response timeout alone is not evidence that the install was accepted.
+            this.postProgressMessage(1, 'installingFirmware');
+            fastFinishedInstallProgressReported = true;
+          }
+          const finishedAfterDisconnectObserved =
+            finishedStatusSnapshotPolls >= PROTOCOL_V2_INSTALL_FINISHED_AFTER_DISCONNECT_POLLS;
           const hasCurrentInstallEvidence =
-            currentInstallStatusObserved || this.protocolV2InstallTerminalSuccessObserved;
+            currentInstallStatusObserved ||
+            this.protocolV2InstallTerminalSuccessObserved ||
+            finishedAfterDisconnectObserved;
+          if (hasCurrentInstallEvidence) {
+            installEvidenceObserved = true;
+          }
           const shouldVerifyTargetCompletion =
             !requireCurrentInstallStatus || hasCurrentInstallEvidence;
           if (
@@ -2526,7 +2669,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               statusTargets,
               expectedTargetIds,
               expectedPaths,
-              requireCurrentInstallStatus && !this.protocolV2InstallTerminalSuccessObserved
+              requireCurrentInstallStatus &&
+                !this.protocolV2InstallTerminalSuccessObserved &&
+                !finishedAfterDisconnectObserved
                 ? liveTargetIds
                 : undefined
             )
@@ -2642,6 +2787,15 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               );
             }
           } else {
+            if (
+              isBleCoprocessorInstall &&
+              isProtocolV2DeviceDisconnectedError(error) &&
+              !isProtocolV2ResponseTimeout(error)
+            ) {
+              installStatusDisconnectObserved = true;
+              finishedStatusSnapshotKey = undefined;
+              finishedStatusSnapshotPolls = 0;
+            }
             shouldReconnect = true;
             deviceInfo = undefined;
             bleInstallLinkReady = false;
@@ -3048,13 +3202,22 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private async protocolV2Reboot(rebootType: DeviceRebootType) {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
     try {
-      const res = await typedCall('DeviceReboot', 'Success', {
-        reboot_type: rebootType,
-      });
+      const res = await typedCall(
+        'DeviceReboot',
+        'Success',
+        {
+          reboot_type: rebootType,
+        },
+        { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT }
+      );
       this.device.markProtocolV2Reboot(rebootType);
       return res.message;
     } catch (error) {
-      if (isProtocolV2DeviceDisconnectedError(error) || isProtocolV2ReconnectProbeError(error)) {
+      if (
+        isProtocolV2DeviceDisconnectedError(error) ||
+        isProtocolV2ReconnectProbeError(error) ||
+        isProtocolV2ResponseTimeout(error)
+      ) {
         this.device.markProtocolV2Reboot(rebootType);
         return { message: 'Device rebooted successfully' };
       }

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -41,9 +41,15 @@ const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
  */
 export const BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS = 5000;
 
-type FirmwareTransferMetrics = Pick<
+type FirmwareProgressMetadata = Pick<
   FirmwareProgress['payload'],
-  'transferredBytes' | 'totalBytes' | 'rateBytesPerSecond' | 'elapsedMs'
+  | 'transferredBytes'
+  | 'totalBytes'
+  | 'rateBytesPerSecond'
+  | 'elapsedMs'
+  | 'installTargetId'
+  | 'installPhase'
+  | 'installPhaseProgress'
 >;
 
 const isDeviceDisconnectedError = (error: unknown) => {
@@ -103,7 +109,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
   postProgressMessage = (
     progress: number,
     progressType: IFirmwareUpdateProgressType,
-    metrics?: FirmwareTransferMetrics
+    metrics?: FirmwareProgressMetadata
   ) => {
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {

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

@@ -4,7 +4,13 @@ import { invalidParameter } from '../helpers/filesystemValidation';
 import type { DeviceFirmwareUpdateStatusGetParams } from './helpers';
 import type { DeviceFirmwareUpdateRecordFields } from '@onekeyfe/hd-transport';
 
-const DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS = ['status', 'payload_version', 'path'] as const;
+const DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS = [
+  'status',
+  'progress_percent',
+  'phase_info',
+  'payload_version',
+  'path',
+] as const;
 
 function normalizeStatusFields(
   fields: DeviceFirmwareUpdateStatusGetParams['fields']

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

@@ -1,4 +1,5 @@
 import { DeviceRebootType } from '@onekeyfe/hd-transport';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { invalidParameter, validateNonEmptyString } from '../helpers/filesystemValidation';
 import { ProtocolV2FirmwareTargetType } from '../../protocols/protocol-v2/firmware';
@@ -103,6 +104,13 @@ export const getProtocolV2UnknownErrorText = (error: unknown) => {
 };
 
 export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
+  const errorCode =
+    error && typeof error === 'object'
+      ? (error as { errorCode?: number; code?: number }).errorCode ??
+        (error as { errorCode?: number; code?: number }).code
+      : undefined;
+  if (errorCode === HardwareErrorCode.BleDeviceDisconnected) return true;
+
   const message = getProtocolV2UnknownErrorText(error).toLowerCase();
   const compactMessage = message.replace(/\s+/g, '');
   return (

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

@@ -446,6 +446,9 @@
         "MessageType_DeviceCertificateSignature": 60423,
         "MessageType_DeviceCertificateSign": 60424,
         "MessageType_DeviceMiscUsbMscControl": 60440,
+        "MessageType_DeviceFindMyTokenState": 60450,
+        "MessageType_DeviceFindMyTokenUpdate": 60451,
+        "MessageType_DeviceFindMyTokenStateGet": 60452,
         "MessageType_DeviceInfoGet": 60600,
         "MessageType_DeviceInfo": 60601,
         "MessageType_DeviceStatusGet": 60602,
@@ -5404,6 +5407,10 @@
         "request_id": {
           "type": "bytes",
           "id": 5
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 6
         }
       }
     },
@@ -5539,6 +5546,14 @@
         "tx_type": {
           "type": "uint32",
           "id": 10
+        },
+        "expected_address": {
+          "type": "bytes",
+          "id": 12
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 13
         }
       }
     },
@@ -5619,6 +5634,14 @@
           "rule": "repeated",
           "type": "EthereumAccessListOneKey",
           "id": 11
+        },
+        "expected_address": {
+          "type": "bytes",
+          "id": 12
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 13
         }
       }
     },
@@ -5795,6 +5818,10 @@
         "chain_id": {
           "type": "uint64",
           "id": 3
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 4
         }
       }
     },
@@ -9474,6 +9501,10 @@
           "rule": "required",
           "type": "bytes",
           "id": 2
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 3
         }
       }
     },
@@ -9518,6 +9549,10 @@
         "application_domain": {
           "type": "bytes",
           "id": 5
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 6
         }
       }
     },
@@ -9535,6 +9570,10 @@
           "rule": "required",
           "type": "bytes",
           "id": 2
+        },
+        "source_fingerprint": {
+          "type": "uint32",
+          "id": 3
         }
       }
     },
@@ -11764,6 +11803,27 @@
         }
       }
     },
+    "DeviceFindMyTokenUpdate": {
+      "fields": {
+        "token": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
+    "DeviceFindMyTokenStateGet": {
+      "fields": {}
+    },
+    "DeviceFindMyTokenState": {
+      "fields": {
+        "burned": {
+          "rule": "required",
+          "type": "bool",
+          "id": 1
+        }
+      }
+    },
     "DeviceFactoryAck": {
       "values": {
         "FACTORY_ACK_SUCCESS": 0,
@@ -11893,6 +11953,13 @@
         "FW_MGMT_UPDATER_TASK_STATUS_FAILED_ENTRY_OUT_OF_BOUNDS": 10
       }
     },
+    "DeviceFirmwareUpdatePhase": {
+      "values": {
+        "FW_MGMT_UPDATER_PHASE_PREPARE": 0,
+        "FW_MGMT_UPDATER_PHASE_INSTALL": 1,
+        "FW_MGMT_UPDATER_PHASE_VERIFY": 2
+      }
+    },
     "DeviceFirmwareTarget": {
       "fields": {
         "target_id": {
@@ -11917,7 +11984,26 @@
       }
     },
     "DeviceFirmwareUpdateRequest": {
-      "fields": {}
+      "fields": {
+        "reboot_after_update": {
+          "type": "bool",
+          "id": 1
+        }
+      }
+    },
+    "DeviceFirmwareUpdatePhaseInfo": {
+      "fields": {
+        "phase": {
+          "rule": "required",
+          "type": "DeviceFirmwareUpdatePhase",
+          "id": 1
+        },
+        "progress_percent": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        }
+      }
     },
     "DeviceFirmwareUpdateRecord": {
       "fields": {
@@ -11930,6 +12016,14 @@
           "type": "DeviceFirmwareUpdateTaskStatus",
           "id": 10
         },
+        "progress_percent": {
+          "type": "uint32",
+          "id": 11
+        },
+        "phase_info": {
+          "type": "DeviceFirmwareUpdatePhaseInfo",
+          "id": 12
+        },
         "payload_version": {
           "type": "uint32",
           "id": 20
@@ -11946,6 +12040,14 @@
           "type": "bool",
           "id": 10
         },
+        "progress_percent": {
+          "type": "bool",
+          "id": 11
+        },
+        "phase_info": {
+          "type": "bool",
+          "id": 12
+        },
         "payload_version": {
           "type": "bool",
           "id": 20
@@ -12713,6 +12815,10 @@
         "text_id": {
           "type": "uint32",
           "id": 3
+        },
+        "text_arg": {
+          "type": "string",
+          "id": 4
         }
       }
     },
@@ -12780,6 +12886,10 @@
         "title_id": {
           "type": "uint32",
           "id": 8
+        },
+        "title_arg": {
+          "type": "string",
+          "id": 9
         }
       }
     },

package/src/events/ui-request.ts

@@ -189,6 +189,9 @@ export interface FirmwareProgress {
     totalBytes?: number;
     rateBytesPerSecond?: number;
     elapsedMs?: number;
+    installTargetId?: number;
+    installPhase?: 'prepare' | 'install' | 'verify';
+    installPhaseProgress?: number;
   };
 }
 

package/src/types/settings.ts

@@ -77,7 +77,8 @@ export type IProtocolV2Resources = {
 /** STM32 firmware config */
 export type IFirmwareReleaseInfo = {
   required: boolean;
-  url: string;
+  /** Legacy release artifact URL. Protocol V2 releases use component URLs. */
+  url?: string;
   /**
    * Firmware type (bitcoinonly or universal)
    * This field is not present in the remote config, but will be inferred from the firmware field name
@@ -106,7 +107,8 @@ export type IFirmwareReleaseInfo = {
   bootloaderChangelog?: {
     [k in ILocale]: string;
   };
-  fingerprint: string;
+  /** Legacy release artifact SHA-256. Protocol V2 releases use component fingerprints. */
+  fingerprint?: string;
   expectedSize?: number;
   version: IVersionArray;
   changelog: {