@onekeyfe/hd-core 1.1.27-alpha.30 → 1.1.27-alpha.32

package/src/api/GetPassphraseState.ts

@@ -1,7 +1,8 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
+import { getDeviceType } from '../utils/deviceInfoUtils';
 import { BaseMethod } from './BaseMethod';
 
 export default class GetPassphraseState extends BaseMethod {
@@ -14,9 +15,24 @@ export default class GetPassphraseState extends BaseMethod {
     if (!this.device.features)
       return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed));
 
-    const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(this.device);
+    const { passphraseState, newSession, unlockedAttachPin } =
+      await getPassphraseStateWithRefreshDeviceInfo(this.device, {
+        expectPassphraseState: this.payload.passphraseState,
+        onlyMainPin: this.payload.useEmptyPassphrase,
+        allowCreateAttachPin: this.payload.allowCreateAttachPin,
+      });
 
     const { features } = this.device;
+    const isPro2 = getDeviceType(features) === EDeviceType.Pro2;
+
+    if (isPro2) {
+      return Promise.resolve({
+        passphrase_state: passphraseState,
+        session_id: newSession ?? features?.session_id ?? undefined,
+        unlocked_attach_pin: unlockedAttachPin,
+        passphrase_protection: features?.passphrase_protection ?? null,
+      });
+    }
 
     // refresh device info
     if (features && features.passphrase_protection === true) {

package/src/api/PathInfo.ts

@@ -1,4 +1,5 @@
 import { BaseMethod } from './BaseMethod';
+import { validateNonEmptyString } from './helpers/filesystemValidation';
 
 export type PathInfoParams = {
   path: string;
@@ -8,7 +9,7 @@ export default class PathInfo extends BaseMethod<PathInfoParams> {
   init() {
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    this.params = { path: this.payload.path };
+    this.params = { path: validateNonEmptyString(this.payload.path, 'path') };
   }
 
   async run() {

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -492,9 +492,20 @@ function handleSkippableHardwareError(
   method: BaseMethod
 ): HardwareError | undefined {
   let error: HardwareError | undefined;
+  const skipMethodSupportCheck = shouldSkipMethodSupportCheck(
+    device.features,
+    device.originalDescriptor?.protocolType
+  );
 
   if (e instanceof HardwareError && e.errorCode !== HardwareErrorCode.RuntimeError) {
     const { errorCode } = e;
+    if (
+      skipMethodSupportCheck &&
+      (errorCode === HardwareErrorCode.CallMethodNeedUpgradeFirmware ||
+        errorCode === HardwareErrorCode.DeviceNotSupportMethod)
+    ) {
+      return undefined;
+    }
     if (errorCode === HardwareErrorCode.CallMethodNeedUpgradeFirmware) {
       error = e;
     } else if (errorCode === HardwareErrorCode.DeviceNotSupportMethod) {
@@ -504,6 +515,10 @@ function handleSkippableHardwareError(
     e.message?.includes('Failure_UnexpectedMessage') ||
     e.message?.includes('Failure_UnknownMessage')
   ) {
+    if (skipMethodSupportCheck) {
+      return undefined;
+    }
+
     const versionRange = getMethodVersionRange(
       device.features,
       type => method.getVersionRange()[type]

package/src/api/conflux/ConfluxSignTransaction.ts

@@ -34,7 +34,7 @@ export default class ConfluxSignTransaction extends BaseMethod {
 
     // check if transaction is valid
     const schema: SchemaParam[] = [
-      { name: 'to', type: 'hexString', required: true },
+      { name: 'to', type: 'string', required: true },
       { name: 'value', type: 'hexString', required: true },
       { name: 'gasLimit', type: 'hexString', required: true },
       { name: 'gasPrice', type: 'hexString', required: true },
@@ -47,7 +47,10 @@ export default class ConfluxSignTransaction extends BaseMethod {
 
     validateParams(tx, schema);
 
-    this.formattedTx = formatAnyHex(tx);
+    this.formattedTx = {
+      ...formatAnyHex(tx),
+      to: tx.to,
+    };
   }
 
   processTxRequest = async (request: ConfluxTxRequest, data: string): Promise<ConfluxSignedTx> => {

package/src/api/device/DeviceRebootToBoardloader.ts

@@ -1,4 +1,4 @@
-import { DevRebootType } from '@onekeyfe/hd-transport';
+import { DeviceRebootType } from '@onekeyfe/hd-transport';
 
 import { BaseMethod } from '../BaseMethod';
 
@@ -23,10 +23,10 @@ export default class DeviceRebootToBoardloader extends BaseMethod<RebootToBoardl
   }
 
   async run() {
-    // Protocol V2 uses DevReboot with reboot_type enum.
+    // Protocol V2 uses DeviceReboot with reboot_type enum.
     if (this.device.originalDescriptor?.protocolType === 'V2') {
-      const res = await this.device.commands.typedCall('DevReboot', 'Success', {
-        reboot_type: DevRebootType.Boardloader,
+      const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
+        reboot_type: DeviceRebootType.Boardloader,
       });
       return Promise.resolve(res.message);
     }

package/src/api/device/DeviceRebootToBootloader.ts

@@ -1,4 +1,4 @@
-import { DevRebootType } from '@onekeyfe/hd-transport';
+import { DeviceRebootType } from '@onekeyfe/hd-transport';
 
 import { BaseMethod } from '../BaseMethod';
 
@@ -23,10 +23,10 @@ export default class DeviceRebootToBootloader extends BaseMethod<RebootToBootloa
   }
 
   async run() {
-    // Protocol V2 uses DevReboot with reboot_type enum.
+    // Protocol V2 uses DeviceReboot with reboot_type enum.
     if (this.device.originalDescriptor?.protocolType === 'V2') {
-      const res = await this.device.commands.typedCall('DevReboot', 'Success', {
-        reboot_type: DevRebootType.Bootloader,
+      const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
+        reboot_type: DeviceRebootType.Bootloader,
       });
       return Promise.resolve(res.message);
     }

package/src/api/dynex/DnxGetAddress.ts

@@ -1,7 +1,10 @@
+import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { getFirmwareType } from '../../utils';
 
 import type { DnxGetAddress as HardwareDnxGetAddress } from '@onekeyfe/hd-transport';
 import type { DnxAddress, DnxGetAddressParams } from '../../types';
@@ -47,6 +50,10 @@ export default class DnxGetAddress extends BaseMethod<HardwareDnxGetAddress[]> {
   }
 
   async run() {
+    if (this.device.originalDescriptor?.protocolType === 'V2') {
+      throw createDeviceNotSupportMethodError(this.name, getFirmwareType(this.device.features));
+    }
+
     const responses: DnxAddress[] = [];
 
     for (let i = 0; i < this.params.length; i++) {

package/src/api/dynex/DnxSignTransaction.ts

@@ -1,8 +1,11 @@
+import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { stripHexPrefix } from '../helpers/hexUtils';
+import { getFirmwareType } from '../../utils';
 
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 import type { DnxSignature } from '../../types';
@@ -115,6 +118,10 @@ export default class DnxSignTransaction extends BaseMethod<DnxSignTx> {
   }
 
   async run() {
+    if (this.device.originalDescriptor?.protocolType === 'V2') {
+      throw createDeviceNotSupportMethodError(this.name, getFirmwareType(this.device.features));
+    }
+
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
 
     const res = await this.device.commands.typedCall('DnxSignTx', 'DnxInputRequest', {

package/src/api/evm/EVMGetAddress.ts

@@ -44,7 +44,7 @@ export default class EvmGetAddress extends BaseMethod<EthereumGetAddressOneKey[]
   }
 
   async getEvmAddress(param: EthereumGetAddressOneKey) {
-    if (TransportManager.getMessageVersion() === 'v1') {
+    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
       return getAddressLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         param,

package/src/api/evm/EVMGetPublicKey.ts

@@ -57,7 +57,7 @@ export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneK
   }
 
   getEvmPublicKey(param: EthereumGetPublicKey) {
-    if (TransportManager.getMessageVersion() === 'v1') {
+    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
       return getPublicKeyLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         param,

package/src/api/evm/EVMSignMessage.ts

@@ -34,7 +34,7 @@ export default class EVMSignMessage extends BaseMethod<EthereumSignMessageOneKey
   }
 
   async run() {
-    if (TransportManager.getMessageVersion() === 'v1') {
+    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
       return signMessageLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         params: this.params,

package/src/api/evm/EVMSignTransaction.ts

@@ -120,7 +120,7 @@ export default class EVMSignTransaction extends BaseMethod {
 
     if (formattedTx == null) throw ERRORS.TypedError('Runtime', 'formattedTx is not set');
 
-    if (TransportManager.getMessageVersion() === 'v1') {
+    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
       return signTransactionLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         addressN,

package/src/api/evm/EVMSignTypedData.ts

@@ -260,8 +260,8 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     let supportTrezor = false;
     let response: MessageResponse<MessageKey>;
-    switch (TransportManager.getMessageVersion()) {
-      case 'v1':
+    switch (TransportManager.getProtocolV1MessageSchema()) {
+      case 'v1LegacySchema':
         supportTrezor = true;
         response = await signTypedDataLegacyV1({
           typedCall: this.device.commands.typedCall.bind(this.device.commands),
@@ -272,7 +272,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
         });
         break;
 
-      case 'latest':
+      case 'v1CurrentSchema':
       default:
         supportTrezor = false;
         response = await signTypedData({
@@ -308,8 +308,8 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
   }) {
     if (!domainHash) throw ERRORS.TypedError('Runtime', 'domainHash is required');
 
-    switch (TransportManager.getMessageVersion()) {
-      case 'v1':
+    switch (TransportManager.getProtocolV1MessageSchema()) {
+      case 'v1LegacySchema':
         return signTypedHashLegacyV1({
           typedCall,
           addressN,
@@ -319,7 +319,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
           device: this.device,
         });
 
-      case 'latest':
+      case 'v1CurrentSchema':
       default:
         return signTypedHash({
           typedCall,

package/src/api/evm/EVMVerifyMessage.ts

@@ -31,7 +31,7 @@ export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessageOneK
   }
 
   async run() {
-    if (TransportManager.getMessageVersion() === 'v1') {
+    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
       return verifyMessageLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         params: this.params,

package/src/api/helpers/batchGetPublickeys.ts

@@ -7,7 +7,7 @@ import {
 import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
 import { isEqualBip44CoinType } from './pathUtils';
 import { splitArray } from '../../utils/arrayUtils';
-import { getDeviceType, getFirmwareType } from '../../utils';
+import { getDeviceType, getFirmwareType, shouldSkipMethodSupportCheck } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
 
 import type { EcdsaPublicKeys, Path } from '@onekeyfe/hd-transport';
@@ -28,7 +28,9 @@ export async function batchGetPublickeys(
     throw TypedError(HardwareErrorCode.ForbiddenKeyPath, 'Path length must be greater than 3');
   }
 
-  const supportsBatchPublicKey = supportBatchPublicKey(device.features, options);
+  const supportsBatchPublicKey =
+    shouldSkipMethodSupportCheck(device.features, device.originalDescriptor?.protocolType) ||
+    supportBatchPublicKey(device.features, options);
   if (!supportsBatchPublicKey) {
     throw createDeviceNotSupportMethodError('BatchGetPublickeys', getFirmwareType(device.features));
   }

package/src/api/helpers/filesystemValidation.ts

@@ -0,0 +1,51 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+export const invalidParameter = (message: string) =>
+  ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, message);
+
+export function validateNonEmptyString(value: unknown, name: string): string {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw invalidParameter(`Parameter [${name}] is required and must be a non-empty string.`);
+  }
+  return value;
+}
+
+export function validateNonNegativeInteger(
+  value: unknown,
+  name: string,
+  defaultValue?: number
+): number {
+  if (value === undefined || value === null) {
+    if (defaultValue !== undefined) return defaultValue;
+    throw invalidParameter(`Missing required parameter: ${name}`);
+  }
+
+  const numeric = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+  if (typeof numeric !== 'number' || !Number.isSafeInteger(numeric) || numeric < 0) {
+    throw invalidParameter(`Parameter [${name}] must be a non-negative integer.`);
+  }
+  return numeric;
+}
+
+export function validateOptionalNonNegativeInteger(
+  value: unknown,
+  name: string
+): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  return validateNonNegativeInteger(value, name);
+}
+
+export function validateOptionalPercentage(value: unknown, name: string): number | undefined {
+  const numeric = validateOptionalNonNegativeInteger(value, name);
+  if (numeric === undefined) return undefined;
+  if (numeric > 100) {
+    throw invalidParameter(`Parameter [${name}] must be between 0 and 100.`);
+  }
+  return numeric;
+}
+
+export function validateRequiredData(value: unknown, name: string): void {
+  if (value === undefined || value === null) {
+    throw invalidParameter(`Missing required parameter: ${name}`);
+  }
+}

package/src/api/index.ts

@@ -43,11 +43,11 @@ export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 // File system & device control API (Protocol V2 only)
 export { default as getProtoVersion } from './protocol-v2/GetProtoVersion';
 export { default as ping } from './protocol-v2/Ping';
-export { default as devReboot } from './protocol-v2/DevReboot';
-export { default as devGetDeviceInfo } from './protocol-v2/DevGetDeviceInfo';
-export { default as devGetOnboardingStatus } from './protocol-v2/DevGetOnboardingStatus';
-export { default as devFirmwareUpdate } from './protocol-v2/DevFirmwareUpdate';
-export { default as devGetFirmwareUpdateStatus } from './protocol-v2/DevGetFirmwareUpdateStatus';
+export { default as deviceReboot } from './protocol-v2/DeviceReboot';
+export { default as deviceGetDeviceInfo } from './protocol-v2/DeviceGetDeviceInfo';
+export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
+export { default as deviceFirmwareUpdate } from './protocol-v2/DeviceFirmwareUpdate';
+export { default as deviceGetFirmwareUpdateStatus } from './protocol-v2/DeviceGetFirmwareUpdateStatus';
 export { default as factoryDeviceInfoSettings } from './protocol-v2/FactoryDeviceInfoSettings';
 export { default as factoryGetDeviceInfo } from './protocol-v2/FactoryGetDeviceInfo';
 export { default as filesystemFixPermission } from './protocol-v2/FilesystemFixPermission';

package/src/api/protocol-v2/{DevFirmwareUpdate.ts → DeviceFirmwareUpdate.ts}

@@ -5,9 +5,9 @@ import {
   normalizeFirmwareTargets,
 } from './helpers';
 
-import type { DevFirmwareUpdateParams } from './helpers';
+import type { DeviceFirmwareUpdateParams } from './helpers';
 
-export default class DevFirmwareUpdate extends BaseMethod<DevFirmwareUpdateParams> {
+export default class DeviceFirmwareUpdate extends BaseMethod<DeviceFirmwareUpdateParams> {
   init() {
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
@@ -20,11 +20,12 @@ export default class DevFirmwareUpdate extends BaseMethod<DevFirmwareUpdateParam
   }
 
   async run() {
+    const targets = normalizeFirmwareTargets(this.params);
     const res = await this.device.commands.typedCall(
-      'DevFirmwareUpdate',
+      'DeviceFirmwareUpdate',
       PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
       {
-        targets: normalizeFirmwareTargets(this.params),
+        targets,
       },
       PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS
     );

package/src/api/protocol-v2/{DevGetDeviceInfo.ts → DeviceGetDeviceInfo.ts}

@@ -1,9 +1,9 @@
 import { BaseMethod } from '../BaseMethod';
 import { buildTargets, buildTypes } from './helpers';
 
-import type { DevGetDeviceInfoParams } from './helpers';
+import type { DeviceGetDeviceInfoParams } from './helpers';
 
-export default class DevGetDeviceInfo extends BaseMethod<DevGetDeviceInfoParams> {
+export default class DeviceGetDeviceInfo extends BaseMethod<DeviceGetDeviceInfoParams> {
   init() {
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
@@ -26,7 +26,7 @@ export default class DevGetDeviceInfo extends BaseMethod<DevGetDeviceInfoParams>
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('DevGetDeviceInfo', 'DeviceInfo', {
+    const res = await this.device.commands.typedCall('DeviceGetDeviceInfo', 'DeviceInfo', {
       targets: buildTargets(this.params),
       types: buildTypes(this.params),
     });

package/src/api/protocol-v2/{DevGetFirmwareUpdateStatus.ts → DeviceGetFirmwareUpdateStatus.ts}

@@ -1,6 +1,6 @@
 import { BaseMethod } from '../BaseMethod';
 
-export default class DevGetFirmwareUpdateStatus extends BaseMethod {
+export default class DeviceGetFirmwareUpdateStatus extends BaseMethod {
   init() {
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
@@ -9,8 +9,8 @@ export default class DevGetFirmwareUpdateStatus extends BaseMethod {
 
   async run() {
     const res = await this.device.commands.typedCall(
-      'DevGetFirmwareUpdateStatus',
-      'DevFirmwareUpdateStatus',
+      'DeviceGetFirmwareUpdateStatus',
+      'DeviceFirmwareUpdateStatus',
       {}
     );
     return Promise.resolve(res.message);

package/src/api/protocol-v2/{DevGetOnboardingStatus.ts → DeviceGetOnboardingStatus.ts}

@@ -1,6 +1,6 @@
 import { BaseMethod } from '../BaseMethod';
 
-export default class DevGetOnboardingStatus extends BaseMethod {
+export default class DeviceGetOnboardingStatus extends BaseMethod {
   init() {
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
@@ -9,8 +9,8 @@ export default class DevGetOnboardingStatus extends BaseMethod {
 
   async run() {
     const res = await this.device.commands.typedCall(
-      'DevGetOnboardingStatus',
-      'DevOnboardingStatus',
+      'DeviceGetOnboardingStatus',
+      'DeviceOnboardingStatus',
       {}
     );
     return Promise.resolve(res.message);

package/src/api/protocol-v2/{DevReboot.ts → DeviceReboot.ts}

@@ -1,9 +1,9 @@
 import { BaseMethod } from '../BaseMethod';
 import { normalizeRebootType } from './helpers';
 
-import type { DevRebootParams } from './helpers';
+import type { DeviceRebootParams } from './helpers';
 
-export default class DevReboot extends BaseMethod<DevRebootParams> {
+export default class DeviceReboot extends BaseMethod<DeviceRebootParams> {
   init() {
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
@@ -14,7 +14,7 @@ export default class DevReboot extends BaseMethod<DevRebootParams> {
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('DevReboot', 'Success', {
+    const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
       reboot_type: normalizeRebootType(this.params.reboot_type ?? this.params.rebootType),
     });
     return Promise.resolve(res.message);