@onekeyfe/hd-core 1.2.0-alpha.19 → 1.2.0-alpha.20

package/src/api/OpenWalletSession.ts

@@ -0,0 +1,221 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
+import { getProtocolV2WalletSession } from '../protocols/protocol-v2/walletSession';
+import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
+import { BaseMethod } from './BaseMethod';
+import { invalidParameter } from './helpers/paramsValidator';
+
+import type {
+  OpenWalletSessionParams,
+  OpenWalletSessionPayload,
+} from '../types/api/openWalletSession';
+
+const requiredString = (value: unknown, name: string) => {
+  if (value === undefined || value === null) {
+    throw invalidParameter(`Missing required parameter: ${name}`);
+  }
+  if (typeof value !== 'string' || !value.trim()) {
+    throw invalidParameter(`Parameter [${name}] must be a non-empty string.`);
+  }
+  return value.trim();
+};
+
+const optionalBoolean = (value: unknown, name: string) => {
+  if (value !== undefined && typeof value !== 'boolean') {
+    throw invalidParameter(`Parameter [${name}] must be a boolean.`);
+  }
+  return value;
+};
+
+const wasResumed = (session: unknown) =>
+  !!session &&
+  typeof session === 'object' &&
+  'resumed' in session &&
+  (session as { resumed?: unknown }).resumed === true;
+
+type NormalizedOpenWalletSessionParams = OpenWalletSessionParams & {
+  legacySessionToClear?: {
+    deviceId?: string;
+    passphraseState: string;
+  };
+};
+
+const normalizeParams = (payload: Record<string, unknown>): NormalizedOpenWalletSessionParams => {
+  if (payload.mode !== undefined) {
+    if (
+      payload.mode !== 'standard' &&
+      payload.mode !== 'select-hidden' &&
+      payload.mode !== 'resume-hidden'
+    ) {
+      throw invalidParameter(
+        'Parameter [mode] must be one of standard, select-hidden, or resume-hidden.'
+      );
+    }
+    if (payload.useEmptyPassphrase !== undefined || payload.initSession !== undefined) {
+      throw invalidParameter(
+        'Parameters [useEmptyPassphrase] and [initSession] cannot be used with [mode].'
+      );
+    }
+    if (payload.mode === 'standard' || payload.mode === 'select-hidden') {
+      if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
+        throw invalidParameter(
+          'Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].'
+        );
+      }
+      return { mode: payload.mode };
+    }
+    return {
+      mode: 'resume-hidden',
+      deviceId: requiredString(payload.deviceId, 'deviceId'),
+      passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
+    };
+  }
+
+  const useEmptyPassphrase = optionalBoolean(payload.useEmptyPassphrase, 'useEmptyPassphrase');
+  const initSession = optionalBoolean(payload.initSession, 'initSession');
+  if (useEmptyPassphrase === true) {
+    return { mode: 'standard' };
+  }
+  if (initSession === true) {
+    const deviceId =
+      payload.deviceId === undefined ? undefined : requiredString(payload.deviceId, 'deviceId');
+    const passphraseState =
+      payload.passphraseState === undefined
+        ? undefined
+        : requiredString(payload.passphraseState, 'passphraseState');
+    return {
+      mode: 'select-hidden',
+      ...(passphraseState
+        ? {
+            legacySessionToClear: {
+              deviceId,
+              passphraseState,
+            },
+          }
+        : {}),
+    };
+  }
+
+  const hasWalletBinding = payload.deviceId !== undefined || payload.passphraseState !== undefined;
+  if (!hasWalletBinding) {
+    return { mode: 'select-hidden' };
+  }
+  return {
+    mode: 'resume-hidden',
+    deviceId: requiredString(payload.deviceId, 'deviceId'),
+    passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
+  };
+};
+
+export default class OpenWalletSession extends BaseMethod<NormalizedOpenWalletSessionParams> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
+    this.payload.useEmptyPassphrase = this.params.mode === 'standard';
+  }
+
+  async run(): Promise<OpenWalletSessionPayload> {
+    const state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    const currentDeviceId = state.identity.deviceId;
+    if (!currentDeviceId) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+    }
+
+    const { legacySessionToClear } = this.params;
+    if (
+      legacySessionToClear &&
+      (!legacySessionToClear.deviceId || legacySessionToClear.deviceId === currentDeviceId)
+    ) {
+      deviceWalletSessionStore.delete(currentDeviceId, legacySessionToClear.passphraseState);
+    }
+
+    const protocol = this.device.isProtocolV2() ? 'V2' : 'V1';
+
+    if (this.params.mode === 'standard') {
+      this.device.passphraseState = undefined;
+      const session = this.device.isProtocolV2()
+        ? await getProtocolV2WalletSession(this.device, { onlyMainPin: true })
+        : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
+            onlyMainPin: true,
+            initSession: this.payload.initSession,
+          });
+      if (session.unlockedAttachPin) {
+        try {
+          await this.device.lockDevice();
+        } catch {
+          // The wallet context is rejected even when an older device cannot be locked.
+        }
+        this.device.clearInternalState();
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
+      }
+      return {
+        protocol,
+        walletType: 'standard',
+        deviceId: currentDeviceId,
+        passphraseState: null,
+        resumed: wasResumed(session),
+      };
+    }
+
+    if (this.params.mode === 'resume-hidden') {
+      if (currentDeviceId !== this.params.deviceId) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+      }
+      this.device.passphraseState = this.params.passphraseState;
+      const cachedSessionId = deviceWalletSessionStore.get(
+        this.params.deviceId,
+        this.params.passphraseState
+      );
+      if (!cachedSessionId) {
+        throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
+      }
+      if (!this.device.isProtocolV2()) {
+        await this.device.initialize({
+          deviceId: this.params.deviceId,
+          passphraseState: this.params.passphraseState,
+        });
+      }
+      const session = this.device.isProtocolV2()
+        ? await getProtocolV2WalletSession(this.device, {
+            expectedPassphraseState: this.params.passphraseState,
+          })
+        : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
+            expectPassphraseState: this.params.passphraseState,
+          });
+      if (!session.passphraseState) {
+        this.device.clearInternalState();
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+      }
+      return {
+        protocol,
+        walletType: 'hidden',
+        deviceId: currentDeviceId,
+        passphraseState: session.passphraseState ?? null,
+        resumed: wasResumed(session) || session.newSession === cachedSessionId,
+      };
+    }
+
+    this.device.passphraseState = undefined;
+    const session = this.device.isProtocolV2()
+      ? await getProtocolV2WalletSession(this.device, { initSession: true })
+      : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
+    const responseBase = {
+      protocol,
+      deviceId: currentDeviceId,
+      resumed: wasResumed(session),
+    } as const;
+    return session.passphraseState
+      ? {
+          ...responseBase,
+          walletType: 'hidden',
+          passphraseState: session.passphraseState,
+        }
+      : {
+          ...responseBase,
+          walletType: 'standard',
+          passphraseState: null,
+        };
+  }
+}

package/src/api/PathInfo.ts

@@ -1,7 +1,7 @@
 import { BaseMethod } from './BaseMethod';
 import {
-  validateNonEmptyString,
   validateOptionalNonNegativeInteger,
+  validateProtocolV2FilesystemPath,
 } from './helpers/filesystemValidation';
 
 export type PathInfoParams = {
@@ -11,12 +11,14 @@ export type PathInfoParams = {
 
 export default class PathInfo extends BaseMethod<PathInfoParams> {
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.requireProtocolV2 = true;
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
     this.params = {
-      path: validateNonEmptyString(this.payload.path, 'path'),
+      path: validateProtocolV2FilesystemPath(this.payload.path, 'path', {
+        allowVolumeRoot: true,
+      }),
       timeoutMs: validateOptionalNonNegativeInteger(this.payload.timeoutMs, 'timeoutMs'),
     };
   }

package/src/api/PromptWebDeviceAccess.ts

@@ -54,9 +54,8 @@ export default class PromptWebDeviceAccess extends BaseMethod {
           const usbDevice = device as USBDevice;
           let path = usbDevice.serialNumber ?? '';
           if (!path) {
-            // 早期 Pro2 工程板 USB descriptor 没有 serial number。
-            // 授权后重新枚举，transport 会为空 serial 设备生成会话内稳定的 mock path，
-            // 这里按 USBDevice 对象身份找回该 path，保证后续 acquire 能匹配。
+            // Early Pro2 boards have no USB serial number. Re-enumeration assigns a
+            // session-stable mock path, which is recovered by USBDevice identity here.
             const diff = await this.connector?.enumerate();
             const matched = diff?.descriptors?.find(d => (d as any).device === usbDevice);
             path = matched?.path ?? '';

package/src/api/SearchDevices.ts

@@ -41,6 +41,10 @@ export default class SearchDevices extends BaseMethod {
           devices.push({
             ...device,
             connectId: device.id,
+            serialNo: null,
+            // Legacy BLE discovery identifier. The physical serial number is unavailable here.
+            uuid: device.id,
+            deviceId: null,
             name: bleName || device.name,
             deviceType: getDeviceTypeByBleName(bleName),
           });
@@ -52,8 +56,8 @@ export default class SearchDevices extends BaseMethod {
     const deviceList = [];
     for (const descriptor of devicesDescriptor) {
       try {
-        // 设备发现是尽力而为的操作。浏览器可能保留已经离线、忙碌或尚未就绪的
-        // WebUSB 授权记录，单个描述符初始化失败不应中断其余设备的发现。
+        // Discovery is best effort. Browsers may retain WebUSB grants for devices that
+        // are offline, busy, or not ready, so one descriptor must not abort the scan.
         const result = await DevicePool.getDevices([descriptor], descriptor.path, {
           connectProtocol: this.payload.connectProtocol,
           refreshRuntimeState: true,

package/src/api/UploadPortfolio.ts

@@ -8,10 +8,16 @@ export type UploadPortfolioParams = {
 
 const PORTFOLIO_PENDING_PATH = 'vol1:/portfolio/portfolio.okpkg.pending';
 const PORTFOLIO_CHUNK_SIZE = 2048;
+const PORTFOLIO_RESPONSE_TIMEOUT_MS = 5_000;
+const PORTFOLIO_MAX_ABORT_LATENCY_MS = PORTFOLIO_RESPONSE_TIMEOUT_MS * 2 + 2_000;
 
 export default class UploadPortfolio extends FileWrite {
   init() {
     const { packageBytes, timeoutMs } = this.payload as UploadPortfolioParams;
+    const responseTimeoutMs = Math.min(
+      timeoutMs === undefined ? PORTFOLIO_RESPONSE_TIMEOUT_MS : Number(timeoutMs),
+      PORTFOLIO_RESPONSE_TIMEOUT_MS
+    );
     this.payload = {
       ...this.payload,
       path: PORTFOLIO_PENDING_PATH,
@@ -21,18 +27,21 @@ export default class UploadPortfolio extends FileWrite {
       overwrite: true,
       append: false,
       emitProgress: false,
-      timeoutMs,
+      timeoutMs: responseTimeoutMs,
     };
     super.init();
+    this.executionPriority = 'background';
+    this.maxAbortLatencyMs = PORTFOLIO_MAX_ABORT_LATENCY_MS;
     this.unlockPolicy = 'retry-on-locked';
-    // Portfolio 是后台数据写入与应用流程，设备不需要用户确认；包括自动解锁阶段在内均不合成 UI Event。
+    // Portfolio is a background write/apply flow and never synthesizes UI events.
     this.protocolV2UiMode = 'none';
   }
 
   async run() {
     const stagedFile = await super.run();
     this.throwIfAborted();
-    await this.device.commands.typedCall('PortfolioUpdate', 'Success', {});
+    const timeoutMs = Number(this.params.timeoutMs);
+    await this.device.commands.typedCall('PortfolioUpdate', 'Success', {}, { timeoutMs });
     return {
       ...stagedFile,
       portfolioUpdated: true,

package/src/api/alephium/AlephiumSignTransaction.ts

@@ -63,8 +63,8 @@ export default class AlephiumSignTransaction extends BaseMethod<HardwareAlephium
     data: Buffer,
     scriptOpt?: Buffer,
     dataOffset = 0
-    // 设备可能在最后一个 AlephiumTxRequest（无 data_length）里返回签名，
-    // 该消息没有 address 字段，返回类型如实声明为联合类型
+    // The final AlephiumTxRequest may return a signature without data_length or address,
+    // so the result accurately uses a union type.
   ): Promise<AlephiumSignedTx | AlephiumTxRequest> => {
     const responseType = res.type;
     if (res.type === 'AlephiumSignedTx') {

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -352,6 +352,7 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
     };
 
     let result: AllNetworkAddress[];
+    let requestError: Error | undefined;
     try {
       method.init();
       method.setDevice?.(this.device);
@@ -394,10 +395,8 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
           rootFingerprint,
         },
       }));
-      if (method.requestContext) {
-        completeRequestContext(method.requestContext.responseID);
-      }
     } catch (e: any) {
+      requestError = e instanceof Error ? e : new Error(String(e));
       const error = handleSkippableHardwareError(e, this.device, method);
 
       if (error) {
@@ -415,13 +414,10 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       } else {
         throw e;
       }
+    } finally {
       if (method.requestContext) {
-        completeRequestContext(
-          method.requestContext.responseID,
-          e instanceof Error ? e : new Error(String(e))
-        );
+        completeRequestContext(method.requestContext.responseID, requestError);
       }
-    } finally {
       this.device.off(DEVICE.BUTTON, buttonListener);
       this.device.off(DEVICE.PIN, onSignalAbort);
       this.device.off(DEVICE.PASSPHRASE, onSignalAbort);

package/src/api/benfen/BenfenGetAddress.ts

@@ -78,7 +78,7 @@ export default class BenfenGetAddress extends BaseMethod<HardwareBenfenGetAddres
             'BenfenAddress',
             param
           );
-          // proto 里 BenfenAddress.address 是 optional；正常响应必然携带
+          // BenfenAddress.address is optional in proto but always present on success.
           address = addressRes.message.address ?? '';
         } else {
           address = publicKeyToAddress(publicKey);

package/src/api/btc/BTCGetPublicKey.ts

@@ -78,7 +78,7 @@ export default class BTCGetPublicKey extends BaseMethod<GetPublicKey[]> {
       }
 
       for (const param of this.params) {
-        // init() 必然设置 coin_name；生成类型里该字段为 optional，这里兜底空串
+        // init() sets coin_name; keep an empty fallback for the generated optional type.
         const versionBytes = getVersionBytes(param.coin_name ?? '', param.script_type);
         if (!versionBytes) {
           throw new Error(

package/src/api/device/DeviceChangePin.ts

@@ -8,6 +8,7 @@ import type { ChangePin } from '@onekeyfe/hd-transport';
 
 export default class DeviceChangePin extends BaseMethod<ChangePin> {
   init() {
+    this.unlockPolicy = 'retry-on-locked';
     this.useDevicePassphraseState = false;
 
     // check payload

package/src/api/device/DeviceFullyUploadResource.ts

@@ -5,12 +5,11 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { BaseMethod } from '../BaseMethod';
 import { getSysResourceBinary } from '../firmware/getBinary';
 import { updateResources } from '../firmware/uploadFirmware';
-import { getDeviceFirmwareVersion, getFirmwareType } from '../../utils';
 import { createUiMessage } from '../../events/ui-request';
 import { DataManager } from '../../data-manager';
 
 import type { Deferred } from '@onekeyfe/hd-shared';
-import type { Features, KnownDevice } from '../../types';
+import type { KnownDevice } from '../../types';
 import type { DeviceFullyUploadResourceParams } from '../../types/api/deviceFullyUploadResource';
 
 export default class DeviceFullyUploadResource extends BaseMethod {
@@ -33,12 +32,12 @@ export default class DeviceFullyUploadResource extends BaseMethod {
     );
   };
 
-  isSupportResourceUpdate(features: Features, updateType: string) {
+  isSupportResourceUpdate(updateType: string) {
     if (updateType !== 'firmware') return false;
 
     const deviceType = this.device.getCurrentDeviceType();
     const isTouchMode = deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro;
-    const currentVersion = getDeviceFirmwareVersion(features).join('.');
+    const currentVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
 
     return isTouchMode && semver.gte(currentVersion, '3.4.0');
   }
@@ -49,7 +48,7 @@ export default class DeviceFullyUploadResource extends BaseMethod {
 
     const payload = this.payload as DeviceFullyUploadResourceParams;
 
-    const deviceFirmwareType = getFirmwareType(features);
+    const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     if (!device.isBootloader() && features) {

package/src/api/device/DeviceSettings.ts

@@ -1,4 +1,5 @@
 import { HardwareErrorCode, TypedError } from '@onekeyfe/hd-shared';
+import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import { BaseMethod } from '../BaseMethod';
 import { invalidParameter } from '../helpers/filesystemValidation';
@@ -8,9 +9,23 @@ import {
   mapCommonSettingsToProtocolV2,
   mapDeviceSettingsToState,
 } from '../../device/DeviceStateMapper';
+import { getProtocolV2SettingsBehavior } from '../../protocols/protocol-v2/settingsUnlockPolicy';
 import { LANGUAGE_LABELS } from '../../utils/deviceSettings';
 
 import type { ApplySettings } from '@onekeyfe/hd-transport';
+import type { DeviceSettingsParams } from '../../types/api/deviceSettings';
+
+const settingsPageForPayload = (
+  payload: DeviceSettingsParams
+): DeviceSettingsPage.DevicePassphrase | DeviceSettingsPage.DeviceAirgap | undefined => {
+  if (payload.usePassphrase !== undefined) {
+    return DeviceSettingsPage.DevicePassphrase;
+  }
+  if (payload.airgapMode !== undefined) {
+    return DeviceSettingsPage.DeviceAirgap;
+  }
+  return undefined;
+};
 
 export default class DeviceSettings extends BaseMethod<ApplySettings> {
   init() {
@@ -33,6 +48,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
       { name: 'brightness', type: 'number' },
       { name: 'hapticFeedback', type: 'boolean' },
       { name: 'bluetoothEnabled', type: 'boolean' },
+      { name: 'airgapMode', type: 'boolean' },
       { name: 'animationEnabled', type: 'boolean' },
       { name: 'tapToWake', type: 'boolean' },
       { name: 'deviceNameDisplayEnabled', type: 'boolean' },
@@ -59,6 +75,28 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
         : undefined),
       haptic_feedback: this.payload.hapticFeedback,
     };
+    const page = settingsPageForPayload(this.payload);
+    const directSettings = mapCommonSettingsToProtocolV2(this.payload);
+    const hasConflictingPages =
+      this.payload.usePassphrase !== undefined && this.payload.airgapMode !== undefined;
+    const combinesPageWithDirectSettings =
+      page !== undefined && Object.keys(directSettings).length > 0;
+    if (hasConflictingPages || combinesPageWithDirectSettings) {
+      // V1 may still accept passphrase plus direct settings. Suppress only the
+      // Protocol V2 pre-run interaction; run() returns the protocol-specific error.
+      this.unlockPolicy = 'none';
+      this.protocolV2UiInteraction = undefined;
+      return;
+    }
+    const behavior =
+      page === undefined
+        ? getProtocolV2SettingsBehavior({
+            kind: 'direct',
+            settings: directSettings,
+          })
+        : getProtocolV2SettingsBehavior({ kind: 'page', page });
+    this.unlockPolicy = behavior.unlockPolicy;
+    this.protocolV2UiInteraction = behavior.uiInteraction;
   }
 
   getVersionRange() {
@@ -76,6 +114,57 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
     try {
       if (this.device.isProtocolV2()) {
         const settings = mapCommonSettingsToProtocolV2(this.payload);
+        const requestedPassphrase = this.payload.usePassphrase;
+        const requestedAirgap = this.payload.airgapMode;
+        const hasPassphrasePage = requestedPassphrase !== undefined;
+        const hasAirgapPage = requestedAirgap !== undefined;
+
+        if (hasPassphrasePage && hasAirgapPage) {
+          throw invalidParameter(
+            'Protocol V2 passphrase and air-gap settings must be changed in separate calls.'
+          );
+        }
+        if ((hasPassphrasePage || hasAirgapPage) && Object.keys(settings).length > 0) {
+          throw invalidParameter(
+            'Protocol V2 on-device settings must not be combined with direct settings.'
+          );
+        }
+        if (requestedPassphrase !== undefined) {
+          const current = await this.device.getDeviceState({ refreshSections: ['status'] });
+          if (current.status.passphraseProtection === requestedPassphrase) {
+            return { message: 'Settings already match requested value.' };
+          }
+
+          const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
+            page: DeviceSettingsPage.DevicePassphrase,
+          });
+          const updated = await this.device.getDeviceState({ refreshSections: ['status'] });
+          if (updated.status.passphraseProtection !== requestedPassphrase) {
+            throw TypedError(
+              HardwareErrorCode.RuntimeError,
+              'Protocol V2 passphrase setting did not reach the requested value.'
+            );
+          }
+          return res.message;
+        }
+        if (requestedAirgap !== undefined) {
+          const current = await this.device.getDeviceState({ refreshSections: ['settings'] });
+          if (current.settings.airgapMode === requestedAirgap) {
+            return { message: 'Settings already match requested value.' };
+          }
+
+          const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
+            page: DeviceSettingsPage.DeviceAirgap,
+          });
+          const updated = await this.device.getDeviceState({ refreshSections: ['settings'] });
+          if (updated.settings.airgapMode !== requestedAirgap) {
+            throw TypedError(
+              HardwareErrorCode.RuntimeError,
+              'Protocol V2 air-gap setting did not reach the requested value.'
+            );
+          }
+          return res.message;
+        }
         if (Object.keys(settings).length === 0) {
           throw invalidParameter('No Protocol V2 compatible setting provided.');
         }
@@ -87,6 +176,10 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
         return res.message;
       }
 
+      if (this.payload.airgapMode !== undefined) {
+        throw invalidParameter('Air-gap settings are not supported by Protocol V1.');
+      }
+
       const res = await this.device.commands.typedCall('ApplySettings', 'Success', {
         ...this.params,
       });

package/src/api/device/DeviceUpdateBootloader.ts

@@ -9,7 +9,6 @@ import { updateBootloader } from '../firmware/uploadFirmware';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
 import { checkBootloaderLength } from '../firmware/updateBootloader';
-import { getFirmwareType } from '../../utils';
 
 import type { DeviceUpdateBootloaderParams } from '../../types/api/deviceUpdateBootloader';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
@@ -99,7 +98,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     const payload = this.payload as DeviceUpdateBootloaderParams;
 
     const deviceType = device.getCurrentDeviceType();
-    const deviceFirmwareType = getFirmwareType(features);
+    const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     if (DeviceModelToTypes.model_touch.includes(deviceType)) {

package/src/api/device/DeviceWipe.ts

@@ -6,6 +6,7 @@ import type { WipeDevice } from '@onekeyfe/hd-transport';
 
 export default class DeviceWipe extends BaseMethod<WipeDevice> {
   init() {
+    this.unlockPolicy = 'retry-on-locked';
     this.useDevicePassphraseState = false;
     this.protocolV2UiInteraction = {
       request: 'button',

package/src/api/evm/EVMSignTypedData.ts

@@ -32,9 +32,8 @@ import type {
 } from '@onekeyfe/hd-transport';
 
 /**
- * EthereumTypedDataStructAckOneKey 与 EthereumTypedDataStructAck 的字段结构与
- * 枚举数值完全一致（生成产物的 OneKey/Trezor 双份消息），仅枚举名义类型不同；
- * 这里做无运行时成本的名义转换，避免在调用点散落 any。
+ * EthereumTypedDataStructAckOneKey and EthereumTypedDataStructAck have identical
+ * fields and enum values. This zero-cost nominal conversion avoids scattered `any`.
  */
 const toOneKeyStructAck = (ack: EthereumTypedDataStructAck): EthereumTypedDataStructAckOneKey =>
   ack as unknown as EthereumTypedDataStructAckOneKey;
@@ -227,8 +226,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
     if (response.type === 'EthereumGnosisSafeTxRequest') {
       const { data } = this.params;
       const verifyingContract = data.domain?.verifyingContract;
-      // EthereumGnosisSafeTxAck.verifyingContract 在 proto 中是 required 字段，
-      // Gnosis Safe 签名缺少 verifyingContract 没有意义，这里给出明确的参数错误。
+      // verifyingContract is required by proto and essential to a Gnosis Safe signature.
       if (!verifyingContract) {
         throw ERRORS.TypedError(
           HardwareErrorCode.CallMethodInvalidParameter,

package/src/api/evm/legacyV1/getAddress.ts

@@ -7,8 +7,8 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetAddressOneKey;
 }): Promise<MessageResponse<'EthereumAddress'>> {
-  // legacy EthereumGetAddress 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: param.address_n,
     show_display: param.show_display,

package/src/api/evm/legacyV1/getPublicKey.ts

@@ -11,8 +11,8 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetPublicKeyOneKey;
 }): Promise<MessageResponse<'EthereumPublicKey'>> {
-  // legacy EthereumGetPublicKey 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: param.address_n,
     show_display: param.show_display,

package/src/api/evm/legacyV1/signMessage.ts

@@ -11,8 +11,8 @@ export default async function ({
   typedCall: TypedCall;
   params: EthereumSignMessageOneKey;
 }): Promise<EthereumMessageSignature> {
-  // legacy EthereumSignMessage 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: params.address_n,
     message: params.message,