@onekeyfe/hd-core 1.2.0-alpha.6 → 1.2.0-alpha.60

package/src/api/BaseMethod.ts

@@ -1,15 +1,19 @@
 import semver from 'semver';
 import {
+  type EFirmwareType,
+  ERRORS,
+  HardwareErrorCode,
   createDeviceNotSupportMethodError,
   createNeedUpgradeFirmwareHardwareError,
 } from '@onekeyfe/hd-shared';
+import { Enum_SafetyCheckLevel, type ProtocolType } from '@onekeyfe/hd-transport';
 
 import { createDeviceMessage } from '../events/device';
 import { UI_REQUEST } from '../constants/ui-request';
 import { DEVICE, FIRMWARE, createFirmwareMessage, createUiMessage } from '../events';
 import { getHDPath, toHardened } from './helpers/pathUtils';
 import { getBleFirmwareReleaseInfo, getFirmwareReleaseInfo } from './firmware/releaseHelper';
-import { LoggerNames, getFirmwareType, getLogger, isMethodVersionRangeUnsupported } from '../utils';
+import { LoggerNames, getLogger } from '../utils';
 import { generateInstanceId } from '../utils/tracing';
 import { DeviceModelToTypes } from '../types';
 
@@ -17,9 +21,15 @@ import type { Device } from '../device/Device';
 import type DeviceConnector from '../device/DeviceConnector';
 import type { DeviceFirmwareRange, KnownDevice } from '../types';
 import type { CoreMessage } from '../events';
+import type { UnlockPolicy } from '../protocols/protocol-v2/unlockPolicy';
+import type { ProtocolV2InteractionDescriptor } from '../protocols/protocol-v2/uiInteraction';
+import type { ProtocolV2UnlockContext } from '../protocols/protocol-v2/unlockPolicyRunner';
 import type { RequestContext } from '../utils/tracing';
 import type { CoreContext } from '../core';
 
+export type { UnlockPolicy } from '../protocols/protocol-v2/unlockPolicy';
+export type ProtocolV2UiMode = 'auto' | 'none';
+
 const Log = getLogger(LoggerNames.Method);
 
 const isEvmLedgerLegacyPathWithHighIndex = (path: unknown) => {
@@ -48,6 +58,8 @@ const isEvmLedgerLegacyPathWithHighIndex = (path: unknown) => {
 const EVM_LEDGER_LEGACY_METHODS = ['evmGetAddress', 'evmGetPublicKey'];
 
 export abstract class BaseMethod<Params = undefined> {
+  abortSignal?: AbortSignal;
+
   responseID: number;
 
   // @ts-expect-error
@@ -114,9 +126,7 @@ export abstract class BaseMethod<Params = undefined> {
    */
   checkDeviceId = false;
 
-  /**
-   * 该方法是否需要校验 passphrase state
-   */
+  /** Whether the method requires wallet-session selection and Protocol V2 pre-unlock. */
   useDevicePassphraseState = true;
 
   /**
@@ -154,13 +164,40 @@ export abstract class BaseMethod<Params = undefined> {
    */
   strictCheckDeviceSupport = false;
 
-  /**
-   * 方法是否仅支持 Protocol V2 设备（Pro2）。
-   * core 调度在设备协议确定（acquire + initialize）后统一守卫，
-   * 非 V2 设备直接抛出 NotSupport 错误，方法内部不必重复判断。
-   * @default false
-   */
-  requireProtocolV2 = false;
+  /** Non-wallet methods may explicitly require Protocol V2 pre-unlock. */
+  unlockPolicy: UnlockPolicy = 'none';
+
+  /** Shared by composite methods so nested calls do not repeat the root preflight. */
+  protocolV2UnlockContext?: ProtocolV2UnlockContext;
+
+  getSupportedProtocols(): readonly ProtocolType[] {
+    return ['V1'];
+  }
+
+  supportsProtocol(protocol: ProtocolType): boolean {
+    return this.getSupportedProtocols().includes(protocol);
+  }
+
+  assertProtocolSupported(protocol: ProtocolType, firmwareType: EFirmwareType): void {
+    if (!this.supportsProtocol(protocol)) {
+      throw createDeviceNotSupportMethodError(this.name, firmwareType);
+    }
+  }
+
+  /** Non-blocking Protocol V2 interaction synthesized by the SDK. */
+  protocolV2UiInteraction?: ProtocolV2InteractionDescriptor;
+
+  /** Special background methods may suppress method-level Protocol V2 UI events. */
+  protocolV2UiMode: ProtocolV2UiMode = 'auto';
+
+  protected throwIfAborted() {
+    if (this.abortSignal?.aborted) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallQueueActionCancelled,
+        'Hardware operation cancelled'
+      );
+    }
+  }
 
   // @ts-expect-error: strictPropertyInitialization
   postMessage: (message: CoreMessage) => void;
@@ -225,11 +262,11 @@ export abstract class BaseMethod<Params = undefined> {
   }
 
   checkFirmwareRelease() {
-    // 固件 release 元数据（DataManager remote config）目前只覆盖 Protocol V1 设备；
-    // Pro2 的更新流程由 firmwareUpdateV4 自行管理，这里显式跳过而不是依赖 features 为空。
+    // DataManager release metadata currently covers Protocol V1 devices only.
+    // firmwareUpdateV4 manages Pro2 updates, so skip them explicitly.
     if (!this.device || this.device.isProtocolV2()) return;
     if (!this.device.features) return;
-    const firmwareType = getFirmwareType(this.device.features);
+    const firmwareType = this.device.getCurrentFirmwareType();
     const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
     this.postMessage(
       createFirmwareMessage(FIRMWARE.RELEASE_INFO, {
@@ -274,10 +311,6 @@ export abstract class BaseMethod<Params = undefined> {
     const firmwareVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
     const versionRange = this.device.getCurrentMethodVersionRange(type => getVersionRange()[type]);
 
-    if (isMethodVersionRangeUnsupported(versionRange)) {
-      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
-    }
-
     if (!versionRange) {
       if (options?.strictCheckDeviceSupport) {
         throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
@@ -333,10 +366,10 @@ export abstract class BaseMethod<Params = undefined> {
     if (this.shouldPromptSafetyCheckForEvmLedgerLegacyPath()) {
       checkFlag = true;
     }
-    if (checkFlag && this.device.getCurrentSafetyChecks() === 'Strict') {
+    if (checkFlag && this.device.getCurrentSafetyChecks() === Enum_SafetyCheckLevel.Strict) {
       Log.debug('will change safety_checks level');
       await this.device.commands.typedCall('ApplySettings', 'Success', {
-        safety_checks: 'PromptTemporarily',
+        safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
       });
       this.temporarySafetyCheckPrompted = true;
       return true;

package/src/api/CheckAllFirmwareRelease.ts

@@ -1,5 +1,8 @@
-import { BaseMethod } from './BaseMethod';
+import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import semver from 'semver';
+
 import { UI_REQUEST } from '../constants/ui-request';
+import { DataManager } from '../data-manager';
 import {
   getBleFirmwareReleaseInfo,
   getBootloaderReleaseInfo,
@@ -7,13 +10,253 @@ import {
 } from './firmware/releaseHelper';
 import { getBridgeReleaseInfo } from '../utils/bridgeUpdate';
 import { getDeviceFirmwareVersion, getDeviceType, getFirmwareType } from '../utils';
+import { BaseMethod } from './BaseMethod';
+import {
+  buildProtocolV2ResourceUpdatePlan,
+  readProtocolV2ResourceInventory,
+} from '../protocols/protocol-v2/resources';
 
 import type {
   AllFirmwareRelease,
   CheckAllFirmwareReleaseParams,
+  ProtocolV2FirmwareComponentRelease,
+  ProtocolV2FirmwareReleaseStatus,
 } from '../types/api/checkAllFirmwareRelease';
+import type { FirmwareUpdateV4Target } from '../types/api/firmwareUpdate';
+import type {
+  DeviceFeaturesVerify,
+  DeviceStateVersions,
+  IFirmwareReleaseInfo,
+  IProtocolV2FirmwareComponent,
+  IProtocolV2FirmwareComponentTarget,
+} from '../types';
+
+const UPDATE_TARGET_BY_COMPONENT_TARGET: Readonly<
+  Partial<Record<IProtocolV2FirmwareComponentTarget, FirmwareUpdateV4Target>>
+> = {
+  BOOTLOADER: 'boot',
+  APPLICATION_P1: 'app_v1',
+  APPLICATION_P2: 'app_v2',
+  COPROCESSOR: 'coprocessor',
+  SE01: 'se01',
+  SE02: 'se02',
+  SE03: 'se03',
+  SE04: 'se04',
+};
+
+const CURRENT_VERSION_BY_COMPONENT_TARGET: Readonly<
+  Record<IProtocolV2FirmwareComponentTarget, keyof DeviceStateVersions | null>
+> = {
+  ROMLOADER: 'board',
+  BOOTLOADER: 'bootloader',
+  APPLICATION_P1: 'applicationP1',
+  APPLICATION_P2: 'applicationP2',
+  COPROCESSOR: 'ble',
+  SE01: 'se01',
+  SE02: 'se02',
+  SE03: 'se03',
+  SE04: 'se04',
+};
+
+const CURRENT_HASH_BY_COMPONENT_TARGET: Readonly<
+  Partial<Record<IProtocolV2FirmwareComponentTarget, keyof DeviceFeaturesVerify>>
+> = {
+  BOOTLOADER: 'bootloaderHash',
+  APPLICATION_P1: 'applicationP1Hash',
+  APPLICATION_P2: 'applicationP2Hash',
+};
+
+function normalizeHex(value: string | undefined): string | undefined {
+  const normalized = value?.replace(/^0x/i, '').toLowerCase();
+  return normalized && /^[0-9a-f]+$/.test(normalized) ? normalized : undefined;
+}
+
+function toVersionString(version: number[] | undefined): string | null {
+  return version?.length ? version.join('.') : null;
+}
+
+function getOrderedComponentEntries(release: IFirmwareReleaseInfo) {
+  const components = release.components ?? {};
+  const orderedKeys = [
+    ...(release.installOrder ?? []),
+    ...Object.keys(components).filter(key => !release.installOrder?.includes(key)),
+  ];
+  return orderedKeys
+    .map(key => {
+      const component = components[key];
+      return component ? ([key, component] as const) : undefined;
+    })
+    .filter((entry): entry is readonly [string, IProtocolV2FirmwareComponent] => !!entry);
+}
+
+function buildComponentRelease({
+  configKey,
+  component,
+  currentVersions,
+  currentVerification,
+  checkFirmwareHash,
+  remotePayloadHash,
+  releaseRequired,
+}: {
+  configKey: string;
+  component: IProtocolV2FirmwareComponent;
+  currentVersions: DeviceStateVersions;
+  currentVerification: Partial<DeviceFeaturesVerify>;
+  checkFirmwareHash: boolean;
+  remotePayloadHash: string | null | undefined;
+  releaseRequired: boolean;
+}): ProtocolV2FirmwareComponentRelease {
+  const componentTarget = component.target.toUpperCase() as IProtocolV2FirmwareComponentTarget;
+  const updateTarget = UPDATE_TARGET_BY_COMPONENT_TARGET[componentTarget] ?? null;
+  const currentVersionKey = CURRENT_VERSION_BY_COMPONENT_TARGET[componentTarget];
+  const currentVersion = currentVersionKey
+    ? currentVersions[currentVersionKey] ??
+      (componentTarget === 'APPLICATION_P1' ? currentVersions.firmware : null) ??
+      null
+    : null;
+  const targetVersion = toVersionString(component.version);
+
+  let status: ProtocolV2FirmwareComponentRelease['status'] = 'unknown';
+  if (!updateTarget) {
+    status = 'unsupported';
+  } else if (
+    currentVersion &&
+    targetVersion &&
+    semver.valid(currentVersion) &&
+    semver.valid(targetVersion)
+  ) {
+    if (semver.lt(currentVersion, targetVersion)) {
+      status = 'outdated';
+    } else if (semver.gt(currentVersion, targetVersion)) {
+      status = 'valid';
+    } else {
+      const currentHashKey = CURRENT_HASH_BY_COMPONENT_TARGET[componentTarget];
+      if (!checkFirmwareHash || !currentHashKey) {
+        status = 'valid';
+      } else {
+        const currentHash = normalizeHex(currentVerification[currentHashKey]);
+        const expectedHash = normalizeHex(remotePayloadHash ?? undefined);
+        if (currentHash && expectedHash) {
+          status = expectedHash.startsWith(currentHash) ? 'valid' : 'outdated';
+        } else {
+          status = 'unknown';
+        }
+      }
+    }
+  }
+
+  return {
+    configKey,
+    componentTarget,
+    updateTarget,
+    currentVersion,
+    targetVersion,
+    status,
+    required: releaseRequired && status === 'outdated',
+  };
+}
+
+type ProtocolV2FirmwareReleasePlan = {
+  firmwareType: EFirmwareType;
+  status: ProtocolV2FirmwareReleaseStatus;
+  hasUpgrade: boolean;
+  required: boolean;
+  currentVersions: DeviceStateVersions;
+  components: ProtocolV2FirmwareComponentRelease[];
+  targetsToUpdate: FirmwareUpdateV4Target[];
+  release: IFirmwareReleaseInfo | undefined;
+};
+
+export function buildProtocolV2FirmwareRelease({
+  currentVersions,
+  currentVerification = {},
+  checkFirmwareHash = false,
+  remotePayloadHashes = {},
+  firmwareType,
+  release,
+}: {
+  currentVersions: DeviceStateVersions;
+  currentVerification?: Partial<DeviceFeaturesVerify>;
+  checkFirmwareHash?: boolean;
+  remotePayloadHashes?: Readonly<Record<string, string | null>>;
+  firmwareType: EFirmwareType;
+  release: IFirmwareReleaseInfo | undefined;
+}): ProtocolV2FirmwareReleasePlan {
+  if (!release) {
+    return {
+      firmwareType,
+      status: 'unavailable' as const,
+      hasUpgrade: false,
+      required: false,
+      currentVersions,
+      components: [],
+      targetsToUpdate: [],
+      release: undefined,
+    };
+  }
+
+  let components = getOrderedComponentEntries(release).map(([configKey, component]) =>
+    buildComponentRelease({
+      configKey,
+      component,
+      currentVersions,
+      currentVerification,
+      checkFirmwareHash,
+      remotePayloadHash: Object.prototype.hasOwnProperty.call(remotePayloadHashes, configKey)
+        ? remotePayloadHashes[configKey]
+        : normalizeHex(component.payloadHash),
+      releaseRequired: release.required,
+    })
+  );
+  if (!currentVersions.applicationP2) {
+    const applicationP1 = components.find(
+      component => component.componentTarget === 'APPLICATION_P1'
+    );
+    if (applicationP1) {
+      components = components.map(component =>
+        component.componentTarget === 'APPLICATION_P2' && component.status === 'unknown'
+          ? {
+              ...component,
+              currentVersion: currentVersions.applicationP1 ?? currentVersions.firmware,
+              status: applicationP1.status,
+              required: applicationP1.required,
+            }
+          : component
+      );
+    }
+  }
+  const targetsToUpdate = components.flatMap(component =>
+    component.status === 'outdated' && component.updateTarget ? [component.updateTarget] : []
+  );
+  const uniqueTargetsToUpdate = Array.from(new Set(targetsToUpdate));
+  const hasUpgrade = uniqueTargetsToUpdate.length > 0;
+  const required = release.required && hasUpgrade;
+  let status: ProtocolV2FirmwareReleaseStatus = 'valid';
+  if (required) {
+    status = 'required';
+  } else if (hasUpgrade) {
+    status = 'outdated';
+  } else if (components.some(component => component.status === 'unknown')) {
+    status = 'unknown';
+  }
+
+  return {
+    firmwareType,
+    status,
+    hasUpgrade,
+    required,
+    currentVersions,
+    components,
+    targetsToUpdate: uniqueTargetsToUpdate,
+    release,
+  };
+}
 
 export default class CheckAllFirmwareRelease extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
     this.useDevicePassphraseState = false;
@@ -21,6 +264,10 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
   }
 
   async run() {
+    if (this.device.isProtocolV2()) {
+      return this.runProtocolV2();
+    }
+
     const { features } = this.device;
     const { checkBridgeRelease, firmwareType: firmwareTypeParams } = this
       .payload as CheckAllFirmwareReleaseParams;
@@ -70,4 +317,96 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
       features,
     } as AllFirmwareRelease;
   }
+
+  private async runProtocolV2(): Promise<AllFirmwareRelease> {
+    const { checkFirmwareHash = false, firmwareType: firmwareTypeParam } = this
+      .payload as CheckAllFirmwareReleaseParams;
+    const state = await this.device.getDeviceState({
+      refreshSections: checkFirmwareHash
+        ? ['identity', 'versions', 'verification']
+        : ['identity', 'versions'],
+    });
+    if (state.identity.deviceType !== 'pro2' && state.identity.deviceType !== 'neo') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceNotSupportMethod,
+        'checkAllFirmwareRelease requires a Pro2 or Neo device for Protocol V2'
+      );
+    }
+
+    const { features } = this.device;
+    if (!features) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'checkAllFirmwareRelease requires initialized device features'
+      );
+    }
+
+    const firmwareType =
+      firmwareTypeParam ?? state.identity.firmwareType ?? EFirmwareType.Universal;
+    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+    const plan = buildProtocolV2FirmwareRelease({
+      currentVersions: state.versions,
+      currentVerification: checkFirmwareHash ? state.verification : undefined,
+      checkFirmwareHash,
+      firmwareType,
+      release,
+    });
+    const resourceDeviceType =
+      state.identity.deviceType === 'neo' ? EDeviceType.Neo : EDeviceType.Pro2;
+    const resources = DataManager.getProtocolV2Resources(resourceDeviceType);
+    let resourceStatus: 'valid' | 'outdated' | 'unknown' = 'unknown';
+    if (resources?.length) {
+      const loaderMode = state.status.mode === 'bootloader' || state.status.mode === 'romloader';
+      // Application mode rejects host access to vol0:/bundles. Resource inventory is
+      // resolved after FirmwareUpdateV4 enters a loader instead of probing here.
+      if (loaderMode) {
+        try {
+          const inventory = await readProtocolV2ResourceInventory({
+            commands: this.device.getCommands(),
+            resources,
+          });
+          resourceStatus = buildProtocolV2ResourceUpdatePlan({
+            resources,
+            inventory,
+            mode: 'bootloader-recovery',
+          }).status;
+        } catch {
+          resourceStatus = buildProtocolV2ResourceUpdatePlan({
+            resources,
+            mode: 'bootloader-recovery',
+          }).status;
+        }
+      }
+    }
+    const targetsToUpdate = [
+      ...plan.targetsToUpdate,
+      ...(resourceStatus === 'outdated' ? (['resource'] as const) : []),
+    ];
+    const firmwareStatus = plan.status === 'unavailable' ? 'unknown' : plan.status;
+    const emptyRelease = 'none' as const;
+
+    return {
+      firmware: {
+        status: firmwareStatus,
+        changelog: release ? [release.changelog] : [],
+        release: release ?? emptyRelease,
+        bootloaderMode: state.status.mode === 'bootloader' || state.status.mode === 'romloader',
+      },
+      ble: {
+        status: 'valid',
+        release: emptyRelease,
+      },
+      bootloader: {
+        status: 'valid',
+        release: emptyRelease,
+      },
+      features,
+      protocol: 'V2',
+      deviceType: state.identity.deviceType,
+      ...plan,
+      resourceStatus,
+      hasUpgrade: plan.hasUpgrade || resourceStatus === 'outdated',
+      targetsToUpdate,
+    };
+  }
 }

package/src/api/CheckBootloaderRelease.ts

@@ -1,7 +1,6 @@
 import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
 import { getBootloaderReleaseInfo } from './firmware/releaseHelper';
-import { getFirmwareType } from '../utils';
 
 import type { CheckBootloaderReleaseParams } from '../types/api/checkBootloaderRelease';
 
@@ -19,7 +18,7 @@ export default class CheckBootloaderRelease extends BaseMethod {
     const { features } = this.device;
     const payload = this.payload as CheckBootloaderReleaseParams;
 
-    const deviceFirmwareType = getFirmwareType(features);
+    const deviceFirmwareType = this.device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     const releaseInfo = getBootloaderReleaseInfo({

package/src/api/CheckFirmwareRelease.ts

@@ -1,7 +1,6 @@
 import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
 import { getFirmwareReleaseInfo } from './firmware/releaseHelper';
-import { getFirmwareType } from '../utils';
 
 import type { CheckFirmwareReleaseParams } from '../types/api/checkFirmwareRelease';
 
@@ -20,7 +19,7 @@ export default class CheckFirmwareRelease extends BaseMethod {
     const payload = this.payload as CheckFirmwareReleaseParams;
 
     if (this.device.features) {
-      const deviceFirmwareType = getFirmwareType(this.device.features);
+      const deviceFirmwareType = this.device.getCurrentFirmwareType();
       const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
       const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);

package/src/api/CipherKeyValue.ts

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

package/src/api/ClearSessionCache.ts

@@ -0,0 +1,32 @@
+import { BaseMethod } from './BaseMethod';
+import { invalidParameter } from './helpers/paramsValidator';
+import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
+
+import type { ClearSessionCacheParams } from '../types/api/sessionCache';
+
+export default class ClearSessionCache extends BaseMethod<ClearSessionCacheParams> {
+  init() {
+    if (this.payload.passphraseState !== undefined && !this.payload.deviceId) {
+      throw invalidParameter('Parameter [deviceId] is required with [passphraseState].');
+    }
+    this.useDevice = false;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = {
+      deviceId: this.payload.deviceId,
+      passphraseState: this.payload.passphraseState,
+    };
+  }
+
+  run() {
+    const { deviceId, passphraseState } = this.params;
+    if (!deviceId) {
+      deviceWalletSessionStore.clear();
+    } else if (!passphraseState) {
+      deviceWalletSessionStore.deleteDevice(deviceId);
+    } else {
+      deviceWalletSessionStore.delete(deviceId, passphraseState);
+    }
+    return Promise.resolve({ cleared: true as const });
+  }
+}

package/src/api/DetectDeviceConnectProtocol.ts

@@ -0,0 +1,18 @@
+import { BaseMethod } from './BaseMethod';
+
+export default class DetectDeviceConnectProtocol extends BaseMethod {
+  init() {
+    this.payload.forceProtocolDetection = true;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.unlockPolicy = 'none';
+  }
+
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
+  run() {
+    return Promise.resolve(this.device.getProtocol());
+  }
+}

package/src/api/DirList.ts

@@ -1,7 +1,7 @@
 import { BaseMethod } from './BaseMethod';
 import {
-  validateNonEmptyString,
   validateOptionalNonNegativeInteger,
+  validateProtocolV2FilesystemPath,
 } from './helpers/filesystemValidation';
 
 export type DirListParams = {
@@ -10,13 +10,18 @@ export type DirListParams = {
 };
 
 export default class DirList extends BaseMethod<DirListParams> {
+  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,
+      }),
       depth: validateOptionalNonNegativeInteger(this.payload.depth, 'depth'),
     };
   }

package/src/api/DirMake.ts

@@ -1,17 +1,20 @@
 import { BaseMethod } from './BaseMethod';
-import { validateNonEmptyString } from './helpers/filesystemValidation';
+import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
 
 export type DirMakeParams = {
   path: string;
 };
 
 export default class DirMake extends BaseMethod<DirMakeParams> {
+  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') };
+    this.params = { path: validateProtocolV2FilesystemPath(this.payload.path, 'path') };
   }
 
   async run() {