@onekeyfe/hd-core 1.2.0-alpha.25 → 1.2.0-alpha.27

package/src/api/firmware/FirmwareUpdatePlan.ts

@@ -12,6 +12,7 @@ import {
 import type {
   FirmwareUpdatePlan,
   FirmwareUpdatePlanArtifact,
+  FirmwareUpdatePlanForceTarget,
   FirmwareUpdatePlanTarget,
 } from '../../types/api/firmwareUpdatePlan';
 import type { Features } from '../../types';
@@ -498,6 +499,7 @@ export const buildFirmwareUpdatePlan = ({
   firmware,
   ble,
   bootloader,
+  forceUpdateTargets,
 }: {
   features: Features;
   firmwareType: EFirmwareType;
@@ -505,18 +507,22 @@ export const buildFirmwareUpdatePlan = ({
   firmware: ReleaseSelection;
   ble: ReleaseSelection;
   bootloader?: ReleaseSelection;
+  forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
 }): FirmwareUpdatePlan => {
   const executor = getExecutor(features);
   let artifacts: FirmwareUpdatePlanArtifact[] = [];
   let targetsToUpdate: FirmwareUpdatePlanTarget[] = [];
   const firmwareRelease = asRelease(firmware);
+  const forcedTargets = new Set(forceUpdateTargets);
+  const shouldUpdateFirmware = isUpgrade(firmware) || forcedTargets.has('firmware');
+  const shouldUpdateResource = isUpgrade(firmware) || forcedTargets.has('resource');
 
-  if (executor === 'v4' && isUpgrade(firmware)) {
+  if (executor === 'v4' && (shouldUpdateFirmware || shouldUpdateResource)) {
     const protocolV2 = buildProtocolV2Artifacts(firmwareRelease ?? {});
     artifacts = protocolV2.artifacts;
     targetsToUpdate = protocolV2.targets;
   } else {
-    if (isUpgrade(bootloader)) {
+    if (isUpgrade(bootloader) || forcedTargets.has('bootloader')) {
       artifacts.push({
         artifactId: 'bootloader',
         role: 'bootloader',
@@ -534,52 +540,56 @@ export const buildFirmwareUpdatePlan = ({
           : {}),
       });
     }
-    if (isUpgrade(firmware)) {
+    if (shouldUpdateFirmware || shouldUpdateResource) {
       if (!firmwareRelease) {
         throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Firmware release is invalid', {
           firmwareUpdateCode: 'FirmwarePlanInvalid',
         });
       }
-      artifacts.push({
-        artifactId: 'firmware',
-        role: 'firmware',
-        target: 'firmware',
-        url: assertArtifactUrl(firmwareRelease.url, 'Firmware release'),
-        container: 'raw',
-        ...asIntegrity({
-          size: firmwareRelease.expectedSize,
-          sha256: firmwareRelease.fingerprint,
-        }),
-        ...(asVersion(firmwareRelease.version)
-          ? { targetVersion: asVersion(firmwareRelease.version) }
-          : {}),
-      });
-      const resourceUrl = selectResourceUrl({
-        release: firmwareRelease,
-        features,
-        platform,
-      });
-      if (resourceUrl) {
+      if (shouldUpdateFirmware) {
         artifacts.push({
-          artifactId: 'resource',
-          role: 'resource',
-          target: 'resource',
-          url: assertArtifactUrl(resourceUrl, 'Firmware resource release'),
-          container: 'zip',
+          artifactId: 'firmware',
+          role: 'firmware',
+          target: 'firmware',
+          url: assertArtifactUrl(firmwareRelease.url, 'Firmware release'),
+          container: 'raw',
           ...asIntegrity({
-            size:
-              resourceUrl === asString(firmwareRelease.fullResource)
-                ? firmwareRelease.fullResourceExpectedSize
-                : firmwareRelease.resourceExpectedSize,
-            sha256:
-              resourceUrl === asString(firmwareRelease.fullResource)
-                ? firmwareRelease.fullResourceFingerprint
-                : firmwareRelease.resourceFingerprint,
+            size: firmwareRelease.expectedSize,
+            sha256: firmwareRelease.fingerprint,
           }),
+          ...(asVersion(firmwareRelease.version)
+            ? { targetVersion: asVersion(firmwareRelease.version) }
+            : {}),
         });
       }
+      if (shouldUpdateResource) {
+        const resourceUrl = selectResourceUrl({
+          release: firmwareRelease,
+          features,
+          platform,
+        });
+        if (resourceUrl) {
+          artifacts.push({
+            artifactId: 'resource',
+            role: 'resource',
+            target: 'resource',
+            url: assertArtifactUrl(resourceUrl, 'Firmware resource release'),
+            container: 'zip',
+            ...asIntegrity({
+              size:
+                resourceUrl === asString(firmwareRelease.fullResource)
+                  ? firmwareRelease.fullResourceExpectedSize
+                  : firmwareRelease.resourceExpectedSize,
+              sha256:
+                resourceUrl === asString(firmwareRelease.fullResource)
+                  ? firmwareRelease.fullResourceFingerprint
+                  : firmwareRelease.resourceFingerprint,
+            }),
+          });
+        }
+      }
     }
-    if (isUpgrade(ble)) {
+    if (isUpgrade(ble) || forcedTargets.has('ble')) {
       const bleRelease = asRelease(ble);
       artifacts.push({
         artifactId: 'ble',

package/src/api/kaspa/KaspaGetAddress.ts

@@ -67,6 +67,9 @@ export default class KaspaGetAddress extends BaseMethod<HardwareKaspaGetAddress[
       model_classic1s: {
         min: '3.12.0',
       },
+      pro2: {
+        min: '0.0.0',
+      },
     };
   }
 

package/src/api/kaspa/KaspaSignTransaction.ts

@@ -183,6 +183,9 @@ export default class KaspaSignTransaction extends BaseMethod<KaspaSignTransactio
       model_classic1s: {
         min: '3.12.0',
       },
+      pro2: {
+        min: '0.0.0',
+      },
     };
   }
 

package/src/api/tron/TronSignMessage.ts

@@ -57,6 +57,9 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
 
   getMessageV2VersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       pro: {
         min: '4.16.0',
       },

package/src/data-manager/TransportManager.ts

@@ -17,7 +17,7 @@ const LowLevelLogger = getLogger(LoggerNames.HdTransportLowLevel);
 const NodeUsbLogger = getLogger(LoggerNames.HdTransportNodeUsb);
 const WebBleLogger = getLogger(LoggerNames.HdWebBleTransport);
 const WebUsbLogger = getLogger(LoggerNames.HdTransportWebUsb);
-const REACT_NATIVE_BLE_SCAN_TIMEOUT_MS = 8000;
+const REACT_NATIVE_BLE_SCAN_TIMEOUT_MS = 3000;
 
 /**
  * transport 在同一个环境中只会存在一个

package/src/device/Device.ts

@@ -314,6 +314,7 @@ export class Device extends EventEmitter {
       // Keep the legacy top-level field string-compatible while preserving
       // the canonical nullable value at state.identity.label.
       label: displayName ?? '',
+      status: this.getStatus(),
       mode: this.getMode(),
       features,
       state,
@@ -1335,6 +1336,12 @@ export class Device extends EventEmitter {
     return EOneKeyDeviceMode.normal;
   }
 
+  getStatus() {
+    if (this.isUsedElsewhere()) return 'occupied' as const;
+    if (this.isUsedHere()) return 'used' as const;
+    return 'available' as const;
+  }
+
   getFirmwareVersion() {
     if (!this.state) return null;
     return parseDeviceVersion(this.state.versions.firmware);

package/src/device/DeviceCommands.ts

@@ -54,6 +54,13 @@ const DEVICE_SESSION_CALLS = new Set([
   'DeviceSessionAskPassphrase',
 ]);
 
+// Protocol V2 subcodes are domain-scoped, so cross-domain cancellation fallback
+// must use explicit firmware cancellation messages instead of a global number map.
+const isProtocolV2ActionCancelledMessage = (message: string) =>
+  /^(?:cancel(?:led|ed)(?: on device)?|confirm dismissed|user cancel(?:led|ed)(?:\s+.*)?)$/i.test(
+    message
+  );
+
 function shouldReduceDebugForCall(type: string) {
   return HIGH_VOLUME_DEBUG_CALLS.has(type);
 }
@@ -474,9 +481,8 @@ export class DeviceCommands {
 
       if (code === 'Failure_ProcessError') {
         const normalizedMessage = message?.trim() ?? '';
-        const isLegacyProtocolV2ActionCancelledFailure =
-          this.device.isProtocolV2() &&
-          /^(?:cancelled on device|confirm dismissed)$/i.test(normalizedMessage);
+        const isProtocolV2ActionCancelledFailure =
+          this.device.isProtocolV2() && isProtocolV2ActionCancelledMessage(normalizedMessage);
         const isLegacyProtocolV2LockedFailure =
           this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(normalizedMessage);
         if (
@@ -536,7 +542,7 @@ export class DeviceCommands {
           });
         } else if (
           subcode === DeviceErrorCode.DeviceError_ActionCancelled ||
-          isLegacyProtocolV2ActionCancelledFailure
+          isProtocolV2ActionCancelledFailure
         ) {
           error = ERRORS.TypedError(HardwareErrorCode.ActionCancelled, message, {
             failureCode: code,

package/src/protocols/protocol-v2/unlockRetry.ts

@@ -24,6 +24,22 @@ type UiInteractionCoordinator = Pick<
   'enterMethodInteraction' | 'enterUnlockInteraction' | 'resumeMethodInteraction'
 >;
 
+const restoreExpectedWalletSessionAfterUnlock = async (method: RunnableMethod, device: Device) => {
+  const expectedPassphraseState = method.payload?.useEmptyPassphrase
+    ? undefined
+    : method.payload?.passphraseState ?? device.passphraseState;
+  if (
+    !method.useDevicePassphraseState ||
+    typeof expectedPassphraseState !== 'string' ||
+    expectedPassphraseState.length === 0
+  ) {
+    return;
+  }
+
+  await restoreProtocolV2WalletSession(device, expectedPassphraseState);
+  Log.debug('Protocol V2 wallet session restored after unlock', { method: method.name });
+};
+
 export async function runMethodWithUnlockRetry(
   method: RunnableMethod,
   device: Device,
@@ -39,6 +55,7 @@ export async function runMethodWithUnlockRetry(
     }
     await device.unlockDevice();
     Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
+    await restoreExpectedWalletSessionAfterUnlock(method, device);
     if (shouldEmitUi) {
       uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
     }
@@ -65,17 +82,7 @@ export async function runMethodWithUnlockRetry(
     }
     await device.unlockDevice();
     Log.debug('Protocol V2 unlock completed', { method: method.name });
-    const expectedPassphraseState = method.payload?.useEmptyPassphrase
-      ? undefined
-      : method.payload?.passphraseState ?? device.passphraseState;
-    if (
-      method.useDevicePassphraseState &&
-      typeof expectedPassphraseState === 'string' &&
-      expectedPassphraseState.length > 0
-    ) {
-      await restoreProtocolV2WalletSession(device, expectedPassphraseState);
-      Log.debug('Protocol V2 wallet session restored after unlock', { method: method.name });
-    }
+    await restoreExpectedWalletSessionAfterUnlock(method, device);
     if (shouldEmitUi) {
       uiCoordinator?.resumeMethodInteraction();
     }

package/src/types/api/checkAllFirmwareRelease.ts

@@ -2,7 +2,7 @@ import type { IBLEFirmwareReleaseInfo } from '../settings';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { CommonParams, Response } from '../params';
 import type { Features, IDeviceBLEFirmwareStatus, IDeviceFirmwareStatus } from '../device';
-import type { FirmwareUpdatePlan } from './firmwareUpdatePlan';
+import type { FirmwareUpdatePlan, FirmwareUpdatePlanForceTarget } from './firmwareUpdatePlan';
 
 export type FirmwareRelease = {
   shouldUpdate?: boolean;
@@ -28,6 +28,7 @@ export type CheckAllFirmwareReleaseParams = {
   checkBridgeRelease?: boolean;
   firmwareType?: EFirmwareType;
   platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
+  forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
 };
 
 export declare function checkAllFirmwareRelease(

package/src/types/api/export.ts

@@ -39,6 +39,7 @@ export type {
   FirmwareUpdatePlan,
   FirmwareUpdatePlanArtifact,
   FirmwareUpdatePlanArtifactRole,
+  FirmwareUpdatePlanForceTarget,
   FirmwareUpdatePlanTarget,
 } from './firmwareUpdatePlan';
 export type {

package/src/types/api/firmwareUpdatePlan.ts

@@ -11,6 +11,8 @@ export type FirmwareUpdatePlanArtifactRole =
 
 export type FirmwareUpdatePlanTarget = 'firmware' | 'ble' | 'bootloader' | FirmwareUpdateV4Target;
 
+export type FirmwareUpdatePlanForceTarget = 'firmware' | 'ble' | 'bootloader' | 'resource';
+
 export interface FirmwareUpdatePlanArtifact {
   artifactId: string;
   role: FirmwareUpdatePlanArtifactRole;

package/src/types/device.ts

@@ -43,6 +43,8 @@ export type KnownDevice = {
   bleName: string | null;
   name: string;
   error?: typeof undefined;
+  /** Current SDK/transport usage state for connection indicators. */
+  status?: DeviceStatus;
   mode: EOneKeyDeviceMode;
   features?: Features;
   /** Unified SDK device-state snapshot; features remains a legacy projection. */

package/src/utils/deviceSettings.ts

@@ -90,8 +90,18 @@ export const mapLanguageFromProtocolV2 = (language?: string) =>
   language ? PROTOCOL_V2_LANGUAGE_KEY_BY_TAG[language] ?? language : undefined;
 
 const PRO2_LANGUAGE_OPTIONS = [
-  ...Object.entries(LANGUAGE_LABELS).map(([code, label]) => ({ code, label })),
+  { code: 'en', label: 'English' },
+  { code: 'zh_cn', label: '简体中文' },
+  { code: 'zh_hk', label: '繁體中文（香港）' },
   { code: 'zh-Hant-TW', label: '繁體中文（台灣）' },
+  { code: 'ja', label: '日本語' },
+  { code: 'ko', label: '한국어' },
+  { code: 'fr', label: 'Français' },
+  { code: 'de', label: 'Deutsch' },
+  { code: 'ru', label: 'Русский' },
+  { code: 'es', label: 'Español' },
+  { code: 'it', label: 'Italiano' },
+  { code: 'pt_br', label: 'Portuguese (Brazil)' },
   { code: 'vi-Latn-VN', label: 'Tiếng Việt' },
   { code: 'tr-Latn-TR', label: 'Türkçe' },
   { code: 'id-Latn-ID', label: 'Bahasa Indonesia' },