@onekeyfe/hd-core 1.2.0-alpha.3 → 1.2.0-alpha.30

package/src/api/GetDeviceState.ts

@@ -0,0 +1,59 @@
+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'>>
+> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
+  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 { 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,
@@ -18,9 +20,9 @@ export default class GetFeatures extends BaseMethod {
     if (this.payload?.detectBootloaderDevice && this.device.isBootloader()) {
       return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceDetectInBootloaderMode));
     }
-    if (this.device.isProtocolV2()) {
-      return this.device.getFeatures();
-    }
-    return Promise.resolve(this.device.features);
+    const state = await this.device.getDeviceState({
+      includeRaw: true,
+    });
+    return projectFeatures(state);
   }
 }

package/src/api/GetOnekeyFeatures.ts

@@ -2,82 +2,19 @@ import semver from 'semver';
 
 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,
@@ -88,17 +25,6 @@ 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);
-    }
-
     const { message } = await this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
     normalizeOnekeyFirmwareVersion(message);
     return Promise.resolve(message);

package/src/api/GetPassphraseState.ts

@@ -1,37 +1,37 @@
-import { EDeviceType } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
 import { BaseMethod } from './BaseMethod';
 
 export default class GetPassphraseState extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
     this.useDevicePassphraseState = false;
   }
 
   async run() {
-    const { passphraseState, newSession, unlockedAttachPin } =
-      await getPassphraseStateWithRefreshDeviceInfo(this.device, {
-        expectPassphraseState: this.payload.passphraseState,
-        onlyMainPin: this.payload.useEmptyPassphrase,
-        allowCreateAttachPin: this.payload.allowCreateAttachPin,
-        initSession: this.payload.initSession,
-      });
+    if (!this.device.features) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+    }
+
+    const isProtocolV2 = this.device.isProtocolV2();
+    const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(
+      this.device,
+      isProtocolV2
+        ? {
+            onlyMainPin: this.payload.useEmptyPassphrase === true,
+            initSession: this.payload.initSession === true,
+          }
+        : undefined
+    );
 
-    const { features } = this.device;
-    const passphraseProtection = this.device.getCurrentPassphraseProtection() ?? null;
-    const deviceType = this.device.getCurrentDeviceType();
-    const isProSeries = deviceType === EDeviceType.Pro || deviceType === EDeviceType.Pro2;
+    const passphraseProtection = this.device.getCurrentPassphraseProtection();
 
-    // refresh device info
-    return Promise.resolve({
-      passphraseState: isProSeries || passphraseProtection === true ? passphraseState : undefined,
-      sessionId: this.payload.initSession
-        ? newSession ?? undefined
-        : newSession ?? features?.sessionId ?? undefined,
-      unlockedAttachPin: unlockedAttachPin ?? features?.unlockedAttachPin,
-      passphraseProtection,
-    });
+    return Promise.resolve(passphraseProtection === true ? passphraseState : undefined);
   }
 }

package/src/api/OpenWalletSession.ts

@@ -0,0 +1,202 @@
+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 wasResumed = (session: unknown) =>
+  !!session &&
+  typeof session === 'object' &&
+  'resumed' in session &&
+  (session as { resumed?: unknown }).resumed === true;
+
+const requireHiddenWalletResponse = (session: { passphraseState?: string }) => {
+  if (!session.passphraseState) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.DeviceInitializeFailed,
+      'Hidden wallet response is missing passphraseState'
+    );
+  }
+  return {
+    passphraseState: session.passphraseState,
+  };
+};
+
+const normalizeParams = (payload: Record<string, unknown>): OpenWalletSessionParams => {
+  if (payload.mode === undefined) {
+    throw invalidParameter('Parameter [mode] is required.');
+  }
+  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(
+      'Legacy parameters [useEmptyPassphrase] and [initSession] are not supported by openWalletSession.'
+    );
+  }
+  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'),
+  };
+};
+
+export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParams> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
+  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 isProtocolV2 = this.device.isProtocolV2();
+    const state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    let currentDeviceId = state.identity.deviceId;
+    const requireDeviceId = () => {
+      if (!currentDeviceId) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+      }
+      return currentDeviceId;
+    };
+    const refreshProtocolV2DeviceId = async () => {
+      const refreshedState = await this.device.getDeviceState({ refreshSections: ['status'] });
+      currentDeviceId = refreshedState.identity.deviceId;
+      return requireDeviceId();
+    };
+
+    const protocol = isProtocolV2 ? 'V2' : 'V1';
+
+    if (this.params.mode === 'standard') {
+      this.device.passphraseState = undefined;
+      const session = isProtocolV2
+        ? await getProtocolV2WalletSession(this.device, { onlyMainPin: true })
+        : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
+            onlyMainPin: true,
+            initSession: this.payload.initSession,
+          });
+      const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
+      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,
+        passphraseState: null,
+        resumed: wasResumed(session),
+      };
+    }
+
+    if (this.params.mode === 'resume-hidden') {
+      if (isProtocolV2) {
+        if (this.device.features?.unlocked === false) {
+          await this.device.unlockDevice();
+        }
+        const refreshedDeviceId = await refreshProtocolV2DeviceId();
+        if (refreshedDeviceId !== this.params.deviceId) {
+          deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
+          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+        }
+      } else if (requireDeviceId() !== 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 (!isProtocolV2) {
+        await this.device.initialize({
+          deviceId: this.params.deviceId,
+          passphraseState: this.params.passphraseState,
+        });
+      }
+      const session = isProtocolV2
+        ? await getProtocolV2WalletSession(this.device, {
+            expectedPassphraseState: this.params.passphraseState,
+          })
+        : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
+            expectPassphraseState: this.params.passphraseState,
+          });
+      const deviceId = requireDeviceId();
+      if (!session.passphraseState) {
+        this.device.clearInternalState();
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+      }
+      return {
+        protocol,
+        walletType: 'hidden',
+        deviceId,
+        ...requireHiddenWalletResponse(session),
+        resumed: wasResumed(session) || session.newSession === cachedSessionId,
+      };
+    }
+
+    this.device.passphraseState = undefined;
+    const session = isProtocolV2
+      ? await getProtocolV2WalletSession(this.device, { initSession: true })
+      : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
+    const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
+    const responseBase = {
+      protocol,
+      deviceId,
+      resumed: wasResumed(session),
+    } as const;
+    return this.device.getCurrentPassphraseProtection() === false
+      ? {
+          ...responseBase,
+          walletType: 'standard',
+          passphraseState: null,
+        }
+      : {
+          ...responseBase,
+          walletType: 'hidden',
+          ...requireHiddenWalletResponse(session),
+        };
+  }
+}

package/src/api/PathInfo.ts

@@ -1,7 +1,7 @@
 import { BaseMethod } from './BaseMethod';
 import {
-  validateNonEmptyString,
   validateOptionalNonNegativeInteger,
+  validateProtocolV2FilesystemPath,
 } from './helpers/filesystemValidation';
 
 export type PathInfoParams = {
@@ -10,13 +10,18 @@ export type PathInfoParams = {
 };
 
 export default class PathInfo extends BaseMethod<PathInfoParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
-    this.requireProtocolV2 = true;
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     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 = 'none';
+    // 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/AlephiumGetAddress.ts

@@ -45,10 +45,6 @@ export default class AlephiumGetAddress extends BaseMethod<HardwareAlephiumGetAd
 
   getVersionRange(): DeviceFirmwareRange {
     return {
-      pro2: {
-        min: '0.0.0',
-        unsupported: true,
-      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/alephium/AlephiumSignMessage.ts

@@ -33,10 +33,6 @@ export default class AlephiumSignMessage extends BaseMethod<HardwareAlephiumSign
 
   getVersionRange(): DeviceFirmwareRange {
     return {
-      pro2: {
-        min: '0.0.0',
-        unsupported: true,
-      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/alephium/AlephiumSignTransaction.ts

@@ -42,10 +42,6 @@ export default class AlephiumSignTransaction extends BaseMethod<HardwareAlephium
 
   getVersionRange(): DeviceFirmwareRange {
     return {
-      pro2: {
-        min: '0.0.0',
-        unsupported: true,
-      },
       model_touch: {
         min: '4.10.0',
       },
@@ -63,8 +59,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/algo/AlgoGetAddress.ts

@@ -6,6 +6,10 @@ import type { AlgorandGetAddress as HardwareAlgoGetAddress } from '@onekeyfe/hd-
 import type { AlgoAddress, AlgoGetAddressParams } from '../../types';
 
 export default class AlgoGetAddress extends BaseMethod<HardwareAlgoGetAddress[]> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {

package/src/api/algo/AlgoSignTransaction.ts

@@ -7,6 +7,10 @@ import type { SolanaSignTransactionParams } from '../../types';
 import type { AlgorandSignTx as HardwareAlgorandSignTx } from '@onekeyfe/hd-transport';
 
 export default class AlgoSignTransaction extends BaseMethod<HardwareAlgorandSignTx> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {