@onekeyfe/hd-core 1.2.0-alpha.2 → 1.2.0-alpha.21

package/src/api/GetDeviceState.ts

@@ -0,0 +1,55 @@
+import { ERRORS, HardwareErrorCode, createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+
+import { UI_REQUEST } from '../constants/ui-request';
+import { BaseMethod } from './BaseMethod';
+
+import type { DeviceStateSection } from '../types';
+import type { DeviceStateScope, GetDeviceStateParams } from '../types/api/getDeviceState';
+
+const SCOPE_SECTIONS: Record<DeviceStateScope, DeviceStateSection[]> = {
+  runtime: ['status'],
+  settings: ['status', 'settings'],
+  firmware: ['status', 'identity', 'versions', 'verification'],
+};
+
+const isLoaderMode = (mode: string) => mode === 'bootloader' || mode === 'romloader';
+
+export default class GetDeviceState extends BaseMethod<
+  Required<Pick<GetDeviceStateParams, 'scope'>>
+> {
+  init() {
+    const scope = (this.payload.scope ?? 'runtime') as DeviceStateScope;
+    if (!Object.prototype.hasOwnProperty.call(SCOPE_SECTIONS, scope)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        `Unsupported device state scope: ${String(scope)}`
+      );
+    }
+    this.allowDeviceMode = [
+      ...this.allowDeviceMode,
+      UI_REQUEST.NOT_INITIALIZE,
+      UI_REQUEST.BOOTLOADER,
+    ];
+    this.unlockPolicy = 'none';
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = { scope };
+  }
+
+  async run() {
+    const state = await this.device.getDeviceState({
+      refreshSections: SCOPE_SECTIONS[this.params.scope],
+    });
+    if (
+      this.params.scope === 'settings' &&
+      this.device.isProtocolV2() &&
+      isLoaderMode(state.status.mode)
+    ) {
+      throw createDeviceNotSupportMethodError(
+        `${this.name}:${this.params.scope}`,
+        this.device.getCurrentFirmwareType()
+      );
+    }
+    return state;
+  }
+}

package/src/api/GetFeatures.ts

@@ -1,10 +1,12 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode, createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
+import { projectFeatures } from '../device/DeviceStateProjector';
 import { BaseMethod } from './BaseMethod';
 
 export default class GetFeatures extends BaseMethod {
   init() {
+    this.unlockPolicy = 'none';
     this.allowDeviceMode = [
       ...this.allowDeviceMode,
       UI_REQUEST.NOT_INITIALIZE,
@@ -19,8 +21,11 @@ export default class GetFeatures extends BaseMethod {
       return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceDetectInBootloaderMode));
     }
     if (this.device.isProtocolV2()) {
-      return this.device.getFeatures();
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
     }
-    return Promise.resolve(this.device.features);
+    const state = await this.device.getDeviceState({
+      includeRaw: true,
+    });
+    return projectFeatures(state);
   }
 }

package/src/api/GetOnekeyFeatures.ts

@@ -1,83 +1,21 @@
 import semver from 'semver';
+import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { fixVersion } from '../utils/deviceFeaturesUtils';
-import { PROTOCOL_V2_DEVICE_INFO_REQUEST } from '../protocols/protocol-v2';
-import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
 import { BaseMethod } from './BaseMethod';
 
 import type { OnekeyFeatures } from '../types';
 
-const ONEKEY_FEATURE_KEYS: Array<keyof OnekeyFeatures> = [
-  'onekey_device_type',
-  'onekey_board_version',
-  'onekey_boot_version',
-  'onekey_firmware_version',
-  'onekey_board_hash',
-  'onekey_boot_hash',
-  'onekey_firmware_hash',
-  'onekey_board_build_id',
-  'onekey_boot_build_id',
-  'onekey_firmware_build_id',
-  'onekey_serial_no',
-  'onekey_ble_name',
-  'onekey_ble_version',
-  'onekey_ble_build_id',
-  'onekey_ble_hash',
-  'onekey_se_type',
-  'onekey_se01_state',
-  'onekey_se02_state',
-  'onekey_se03_state',
-  'onekey_se04_state',
-  'onekey_se01_version',
-  'onekey_se02_version',
-  'onekey_se03_version',
-  'onekey_se04_version',
-  'onekey_se01_hash',
-  'onekey_se02_hash',
-  'onekey_se03_hash',
-  'onekey_se04_hash',
-  'onekey_se01_build_id',
-  'onekey_se02_build_id',
-  'onekey_se03_build_id',
-  'onekey_se04_build_id',
-  'onekey_se01_boot_version',
-  'onekey_se02_boot_version',
-  'onekey_se03_boot_version',
-  'onekey_se04_boot_version',
-  'onekey_se01_boot_hash',
-  'onekey_se02_boot_hash',
-  'onekey_se03_boot_hash',
-  'onekey_se04_boot_hash',
-  'onekey_se01_boot_build_id',
-  'onekey_se02_boot_build_id',
-  'onekey_se03_boot_build_id',
-  'onekey_se04_boot_build_id',
-];
-
 function normalizeOnekeyFirmwareVersion(message: OnekeyFeatures) {
   if (message.onekey_firmware_version && !semver.valid(message.onekey_firmware_version)) {
     message.onekey_firmware_version = fixVersion(message.onekey_firmware_version);
   }
 }
 
-function pickOnekeyFeatures(features?: OnekeyFeatures | null): OnekeyFeatures {
-  const message: OnekeyFeatures = {};
-  if (!features) return message;
-
-  for (const key of ONEKEY_FEATURE_KEYS) {
-    const value = features[key];
-    if (value !== undefined && value !== null) {
-      (message as Record<string, unknown>)[key] = value;
-    }
-  }
-
-  normalizeOnekeyFirmwareVersion(message);
-  return message;
-}
-
 export default class GetOnekeyFeatures extends BaseMethod {
   init() {
+    this.unlockPolicy = 'none';
     this.allowDeviceMode = [
       ...this.allowDeviceMode,
       UI_REQUEST.NOT_INITIALIZE,
@@ -89,14 +27,7 @@ export default class GetOnekeyFeatures extends BaseMethod {
 
   async run() {
     if (this.device.isProtocolV2()) {
-      // V2 没有 OnekeyGetFeatures 消息：
-      // 取完整 DevGetDeviceInfo（含 SE/hash/build_id）后刷新结构化 features 缓存。
-      const deviceInfo = await requestProtocolV2DeviceInfo({
-        commands: this.device.commands,
-        request: PROTOCOL_V2_DEVICE_INFO_REQUEST,
-      });
-      const features = this.device.updateProtocolV2Features(deviceInfo);
-      return pickOnekeyFeatures(features as OnekeyFeatures);
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
     }
 
     const { message } = await this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');

package/src/api/GetPassphraseState.ts

@@ -1,4 +1,4 @@
-import { EDeviceType } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode, createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
@@ -11,24 +11,17 @@ export default class GetPassphraseState extends BaseMethod {
   }
 
   async run() {
-    const { passphraseState, newSession, unlockedAttachPin } =
-      await getPassphraseStateWithRefreshDeviceInfo(this.device, {
-        expectPassphraseState: this.payload.passphraseState,
-        onlyMainPin: this.payload.useEmptyPassphrase,
-        allowCreateAttachPin: this.payload.allowCreateAttachPin,
-      });
+    if (this.device.isProtocolV2()) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
+    }
+    if (!this.device.features) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+    }
 
-    const { features } = this.device;
-    const passphraseProtection = this.device.getCurrentPassphraseProtection() ?? null;
-    const deviceType = this.device.getCurrentDeviceType();
-    const isProSeries = deviceType === EDeviceType.Pro || deviceType === EDeviceType.Pro2;
+    const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(this.device);
 
-    // refresh device info
-    return Promise.resolve({
-      passphrase_state: isProSeries || passphraseProtection === true ? passphraseState : undefined,
-      session_id: newSession ?? features?.sessionId ?? undefined,
-      unlocked_attach_pin: unlockedAttachPin ?? features?.unlockedAttachPin,
-      passphrase_protection: passphraseProtection,
-    });
+    const passphraseProtection = this.device.getCurrentPassphraseProtection();
+
+    return Promise.resolve(passphraseProtection === true ? passphraseState : undefined);
   }
 }

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

@@ -1,11 +1,13 @@
 import { BaseMethod } from './BaseMethod';
 import TransportManager from '../data-manager/TransportManager';
 import { DataManager } from '../data-manager';
-import { getDeviceTypeByBleName } from '../utils';
+import { LoggerNames, getDeviceTypeByBleName, getLogger } from '../utils';
 import { DevicePool } from '../device/DevicePool';
 
 import type DeviceConnector from '../device/DeviceConnector';
 
+const Log = getLogger(LoggerNames.DevicePool);
+
 export default class SearchDevices extends BaseMethod {
   connector?: DeviceConnector;
 
@@ -39,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),
           });
@@ -47,9 +53,28 @@ export default class SearchDevices extends BaseMethod {
       return devices;
     }
 
-    const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined, {
-      connectProtocol: this.payload.connectProtocol,
-    });
+    const deviceList = [];
+    for (const descriptor of devicesDescriptor) {
+      try {
+        // 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,
+        });
+        deviceList.push(...result.deviceList);
+      } catch (error) {
+        const errorCode =
+          error && typeof error === 'object' && 'errorCode' in error
+            ? (error as { errorCode?: unknown }).errorCode
+            : undefined;
+        Log.debug('Skip unavailable device during search', {
+          path: descriptor.path,
+          ...(errorCode !== undefined ? { errorCode } : {}),
+        });
+      }
+    }
+
     return deviceList.map(device => device.toMessageObject());
   }
 }

package/src/api/UploadPortfolio.ts

@@ -0,0 +1,40 @@
+import FileWrite from './FileWrite';
+
+export type UploadPortfolioParams = {
+  packageBytes: ArrayBuffer | Uint8Array | Blob;
+  timeoutMs?: number | string;
+};
+
+const PORTFOLIO_PENDING_PATH = 'vol1:/portfolio/portfolio.okpkg.pending';
+const PORTFOLIO_CHUNK_SIZE = 2048;
+
+export default class UploadPortfolio extends FileWrite {
+  init() {
+    const { packageBytes, timeoutMs } = this.payload as UploadPortfolioParams;
+    this.payload = {
+      ...this.payload,
+      path: PORTFOLIO_PENDING_PATH,
+      offset: 0,
+      data: packageBytes,
+      chunkSize: PORTFOLIO_CHUNK_SIZE,
+      overwrite: true,
+      append: false,
+      emitProgress: false,
+      timeoutMs,
+    };
+    super.init();
+    this.unlockPolicy = 'retry-on-locked';
+    // 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', {});
+    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/cardano/CardanoSignMessage.ts

@@ -14,7 +14,7 @@ export default class CardanoSignMessage extends BaseMethod<CardanoSignMessagePar
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
+    this.allowUsePreInitialize = false;
 
     const { payload } = this;
     validateParams(payload, [

package/src/api/cardano/CardanoSignTransaction.ts

@@ -48,7 +48,7 @@ export default class CardanoSignTransaction extends BaseMethod<any> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
+    this.allowUsePreInitialize = false;
 
     this.hasBundle = !!this.payload?.bundle;