@onekeyfe/hd-core 1.1.34-alpha.2 → 1.1.34-alpha.3

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,
@@ -14,10 +16,16 @@ export default class GetFeatures extends BaseMethod {
     this.skipForceUpdateCheck = true;
   }
 
-  run() {
-    if (this.payload?.detectBootloaderDevice && this.device.features?.bootloader_mode) {
+  async run() {
+    if (this.payload?.detectBootloaderDevice && this.device.isBootloader()) {
       return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceDetectInBootloaderMode));
     }
-    return Promise.resolve(this.device.features);
+    if (this.device.isProtocolV2()) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
+    }
+    const state = await this.device.getDeviceState({
+      includeRaw: true,
+    });
+    return projectFeatures(state);
   }
 }

package/src/api/GetOnekeyFeatures.ts

@@ -1,11 +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 { BaseMethod } from './BaseMethod';
 
+import type { OnekeyFeatures } from '../types';
+
+function normalizeOnekeyFirmwareVersion(message: OnekeyFeatures) {
+  if (message.onekey_firmware_version && !semver.valid(message.onekey_firmware_version)) {
+    message.onekey_firmware_version = fixVersion(message.onekey_firmware_version);
+  }
+}
+
 export default class GetOnekeyFeatures extends BaseMethod {
   init() {
+    this.unlockPolicy = 'none';
     this.allowDeviceMode = [
       ...this.allowDeviceMode,
       UI_REQUEST.NOT_INITIALIZE,
@@ -16,10 +26,12 @@ export default class GetOnekeyFeatures extends BaseMethod {
   }
 
   async run() {
-    const { message } = await this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
-    if (!!message.onekey_firmware_version && !semver.valid(message.onekey_firmware_version)) {
-      message.onekey_firmware_version = fixVersion(message.onekey_firmware_version);
+    if (this.device.isProtocolV2()) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
     }
+
+    const { message } = await this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
+    normalizeOnekeyFirmwareVersion(message);
     return Promise.resolve(message);
   }
 }

package/src/api/GetPassphraseState.ts

@@ -1,4 +1,4 @@
-import { ERRORS, HardwareErrorCode } 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,18 +11,17 @@ export default class GetPassphraseState extends BaseMethod {
   }
 
   async run() {
-    if (!this.device.features)
-      return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed));
+    if (this.device.isProtocolV2()) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
+    }
+    if (!this.device.features) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+    }
 
     const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(this.device);
 
-    const { features } = this.device;
-
-    // refresh device info
-    if (features && features.passphrase_protection === true) {
-      return Promise.resolve(passphraseState);
-    }
+    const passphraseProtection = this.device.getCurrentPassphraseProtection();
 
-    return Promise.resolve(undefined);
+    return Promise.resolve(passphraseProtection === true ? passphraseState : undefined);
   }
 }

package/src/api/OpenWalletSession.ts

@@ -0,0 +1,211 @@
+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/filesystemValidation';
+
+import type {
+  OpenWalletSessionParams,
+  OpenWalletSessionPayload,
+} from '../types/api/openWalletSession';
+
+const requiredString = (value: unknown, name: string) => {
+  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,
+            recoverInvalidSession: false,
+          })
+        : 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 walletType = session.passphraseState ? 'hidden' : 'standard';
+    return {
+      protocol,
+      walletType,
+      deviceId: currentDeviceId,
+      passphraseState: session.passphraseState ?? null,
+      resumed: wasResumed(session),
+    };
+  }
+}

package/src/api/PathInfo.ts

@@ -0,0 +1,41 @@
+import { BaseMethod } from './BaseMethod';
+import {
+  validateOptionalNonNegativeInteger,
+  validateProtocolV2FilesystemPath,
+} from './helpers/filesystemValidation';
+
+export type PathInfoParams = {
+  path: string;
+  timeoutMs?: number | string;
+};
+
+export default class PathInfo extends BaseMethod<PathInfoParams> {
+  init() {
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      path: validateProtocolV2FilesystemPath(this.payload.path, 'path', {
+        allowVolumeRoot: true,
+      }),
+      timeoutMs: validateOptionalNonNegativeInteger(this.payload.timeoutMs, 'timeoutMs'),
+    };
+  }
+
+  async run() {
+    const timeoutMs =
+      this.params.timeoutMs === undefined ? undefined : Number(this.params.timeoutMs);
+    const res = await this.device.commands.typedCall(
+      'FilesystemPathInfoQuery',
+      'FilesystemPathInfo',
+      {
+        path: this.params.path,
+      },
+      {
+        timeoutMs,
+      }
+    );
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/PromptWebDeviceAccess.ts

@@ -51,9 +51,18 @@ export default class PromptWebDeviceAccess extends BaseMethod {
         }
 
         if (isWebUsbEnv) {
+          const usbDevice = device as USBDevice;
+          let path = usbDevice.serialNumber ?? '';
+          if (!path) {
+            // 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 ?? '';
+          }
           devicesDescriptor = [
             {
-              path: (device as USBDevice).serialNumber ?? '',
+              path,
               device,
               debug: true,
             },

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;
 
@@ -34,17 +36,45 @@ export default class SearchDevices extends BaseMethod {
         const lowerId = device.id?.toLowerCase();
         if (!seenIds.has(lowerId)) {
           seenIds.add(lowerId);
+          const bleName =
+            device.name ?? (device as unknown as { localName?: string }).localName ?? '';
           devices.push({
             ...device,
             connectId: device.id,
-            deviceType: getDeviceTypeByBleName(device.name ?? ''),
+            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),
           });
         }
       }
       return devices;
     }
 
-    const { deviceList } = await DevicePool.getDevices(devicesDescriptor);
+    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,50 @@
+import FileWrite from './FileWrite';
+
+export type UploadPortfolioParams = {
+  packageBytes: ArrayBuffer | Uint8Array | Blob;
+  operationId?: string;
+  timeoutMs?: number | string;
+};
+
+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,
+      offset: 0,
+      data: packageBytes,
+      chunkSize: PORTFOLIO_CHUNK_SIZE,
+      overwrite: true,
+      append: false,
+      emitProgress: false,
+      timeoutMs: responseTimeoutMs,
+    };
+    super.init();
+    this.executionPriority = 'background';
+    this.maxAbortLatencyMs = PORTFOLIO_MAX_ABORT_LATENCY_MS;
+    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();
+    const timeoutMs = Number(this.params.timeoutMs);
+    await this.device.commands.typedCall('PortfolioUpdate', 'Success', {}, { timeoutMs });
+    return {
+      ...stagedFile,
+      portfolioUpdated: true,
+    };
+  }
+}

package/src/api/alephium/AlephiumGetAddress.ts

@@ -4,7 +4,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 
 import type { AlephiumGetAddress as HardwareAlephiumGetAddress } from '@onekeyfe/hd-transport';
-import type { AlephiumAddress, AlephiumGetAddressParams } from '../../types';
+import type { AlephiumAddress, AlephiumGetAddressParams, DeviceFirmwareRange } from '../../types';
 
 export default class AlephiumGetAddress extends BaseMethod<HardwareAlephiumGetAddress[]> {
   hasBundle = false;
@@ -43,8 +43,12 @@ export default class AlephiumGetAddress extends BaseMethod<HardwareAlephiumGetAd
     });
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/alephium/AlephiumSignMessage.ts

@@ -5,6 +5,7 @@ import { validateParams } from '../helpers/paramsValidator';
 import { stripHexPrefix } from '../helpers/hexUtils';
 
 import type { AlephiumSignMessage as HardwareAlephiumSignMessage } from '@onekeyfe/hd-transport';
+import type { DeviceFirmwareRange } from '../../types';
 
 export default class AlephiumSignMessage extends BaseMethod<HardwareAlephiumSignMessage> {
   init() {
@@ -30,8 +31,12 @@ export default class AlephiumSignMessage extends BaseMethod<HardwareAlephiumSign
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/alephium/AlephiumSignTransaction.ts

@@ -8,10 +8,11 @@ import { validateParams } from '../helpers/paramsValidator';
 
 import type {
   AlephiumSignedTx,
+  AlephiumTxRequest,
   AlephiumSignTx as HardwareAlephiumSignTx,
   TypedCall,
 } from '@onekeyfe/hd-transport';
-import type { AlephiumSignTransactionParams } from '../../types';
+import type { AlephiumSignTransactionParams, DeviceFirmwareRange } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 
 export default class AlephiumSignTransaction extends BaseMethod<HardwareAlephiumSignTx> {
@@ -39,8 +40,12 @@ export default class AlephiumSignTransaction extends BaseMethod<HardwareAlephium
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_touch: {
         min: '4.10.0',
       },
@@ -58,7 +63,10 @@ export default class AlephiumSignTransaction extends BaseMethod<HardwareAlephium
     data: Buffer,
     scriptOpt?: Buffer,
     dataOffset = 0
-  ): Promise<AlephiumSignedTx> => {
+    // 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') {
       return res.message;
     }
@@ -109,7 +117,10 @@ export default class AlephiumSignTransaction extends BaseMethod<HardwareAlephium
       return this.processTxRequest(typedCall, response, data, scriptOpt, dataOffset);
     }
 
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `Unknown response type: ${res.type}`);
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `Unknown response type: ${responseType}`
+    );
   };
 
   async run() {