@onekeyfe/hd-core 1.1.27-alpha.4 → 1.1.27-alpha.41

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

@@ -1,8 +1,8 @@
 export { default as testInitializeDeviceDuration } from './test/TestInitializeDeviceDuration';
-export { default as preInitialize } from './device/PreInitialize';
 
 export { default as searchDevices } from './SearchDevices';
 export { default as getFeatures } from './GetFeatures';
+export { default as getDeviceInfo } from './GetDeviceInfo';
 export { default as getOnekeyFeatures } from './GetOnekeyFeatures';
 export { default as getPassphraseState } from './GetPassphraseState';
 export { default as getLogs } from './GetLogs';
@@ -38,8 +38,37 @@ export { default as getNextU2FCounter } from './u2f/GetNextU2FCounter';
 export { default as firmwareUpdate } from './FirmwareUpdate';
 export { default as firmwareUpdateV2 } from './FirmwareUpdateV2';
 export { default as firmwareUpdateV3 } from './FirmwareUpdateV3';
+export { default as firmwareUpdateV4 } from './FirmwareUpdateV4';
 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 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';
+export { default as filesystemFormat } from './protocol-v2/FilesystemFormat';
+export { default as filesystemDiskControl } from './protocol-v2/FilesystemDiskControl';
+export { default as fileRead } from './FileRead';
+export { default as fileWrite } from './FileWrite';
+export { default as fileDelete } from './FileDelete';
+export { default as dirList } from './DirList';
+export { default as dirMake } from './DirMake';
+export { default as dirRemove } from './DirRemove';
+export { default as pathInfo } from './PathInfo';
+export { default as filesystemFileRead } from './FileRead';
+export { default as filesystemFileWrite } from './FileWrite';
+export { default as filesystemFileDelete } from './FileDelete';
+export { default as filesystemDirList } from './DirList';
+export { default as filesystemDirMake } from './DirMake';
+export { default as filesystemDirRemove } from './DirRemove';
+export { default as filesystemPathInfoQuery } from './PathInfo';
+
 export { default as cipherKeyValue } from './CipherKeyValue';
 
 export { default as allNetworkGetAddress } from './allnetwork/AllNetworkGetAddress';

package/src/api/kaspa/KaspaSignTransaction.ts

@@ -22,7 +22,6 @@ export default class KaspaSignTransaction extends BaseMethod<KaspaSignTransactio
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     const payload = this.payload as KaspaSignTransactionParams;
 

package/src/api/near/NearSignTransaction.ts

@@ -10,7 +10,6 @@ export default class NearSignTransaction extends BaseMethod<HardwareNearSignTx>
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     // check payload
     validateParams(this.payload, [

package/src/api/nem/NEMSignTransaction.ts

@@ -230,7 +230,6 @@ export default class NEMSignTransaction extends BaseMethod<NEMSignTx> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     validateParams(this.payload, [
       { name: 'path', required: true },

package/src/api/neo/NeoGetAddress.ts

@@ -5,6 +5,7 @@ import { UI_REQUEST } from '../../constants/ui-request';
 
 import type { NeoGetAddress as HardwareNeoGetAddress } from '@onekeyfe/hd-transport';
 import type { NeoAddress, NeoGetAddressParams } from '../../types/api/neoGetAddress';
+import type { DeviceFirmwareRange } from '../../types';
 
 export default class NeoGetAddress extends BaseMethod<HardwareNeoGetAddress[]> {
   hasBundle = false;
@@ -37,8 +38,12 @@ export default class NeoGetAddress extends BaseMethod<HardwareNeoGetAddress[]> {
     });
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       pro: {
         min: '4.12.0',
       },

package/src/api/neo/NeoSignTransaction.ts

@@ -5,12 +5,12 @@ import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 
 import type { NeoSignTx } from '@onekeyfe/hd-transport';
+import type { DeviceFirmwareRange } from '../../types';
 
 export default class NeoSignTransaction extends BaseMethod<NeoSignTx> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
     this.strictCheckDeviceSupport = true;
 
     validateParams(this.payload, [
@@ -29,8 +29,12 @@ export default class NeoSignTransaction extends BaseMethod<NeoSignTx> {
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       pro: {
         min: '4.12.0',
       },

package/src/api/nervos/NervosGetAddress.ts

@@ -4,7 +4,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 
 import type { NervosGetAddress as HardwareNervosGetAddress } from '@onekeyfe/hd-transport';
-import type { NervosAddress, NervosGetAddressParams } from '../../types';
+import type { DeviceFirmwareRange, NervosAddress, NervosGetAddressParams } from '../../types';
 
 export default class NervosGetAddress extends BaseMethod<HardwareNervosGetAddress[]> {
   hasBundle = false;
@@ -40,8 +40,12 @@ export default class NervosGetAddress extends BaseMethod<HardwareNervosGetAddres
     });
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_mini: {
         min: '3.7.0',
       },

package/src/api/nervos/NervosSignTransaction.ts

@@ -5,7 +5,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 
-import type { NervosSignTransactionParams, NervosSignedTx } from '../../types';
+import type { DeviceFirmwareRange, NervosSignTransactionParams, NervosSignedTx } from '../../types';
 import type { NervosSignTx as HardwareNervosSignTx, TypedCall } from '@onekeyfe/hd-transport';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 
@@ -19,7 +19,6 @@ export default class NervosSignTransaction extends BaseMethod<NervosSignTx> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode];
-    this.allowUsePreInitialize = true;
 
     // check payload
     validateParams(this.payload, [
@@ -41,8 +40,12 @@ export default class NervosSignTransaction extends BaseMethod<NervosSignTx> {
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_mini: {
         min: '3.7.0',
       },

package/src/api/nexa/NexaGetAddress.ts

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

package/src/api/nexa/NexaSignTransaction.ts

@@ -6,14 +6,12 @@ import { validateParams } from '../helpers/paramsValidator';
 
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 import type { TypedCall } from '@onekeyfe/hd-transport';
-import type { NexaSignTransactionParams, NexaSignature } from '../../types';
+import type { DeviceFirmwareRange, NexaSignTransactionParams, NexaSignature } from '../../types';
 
 export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionParams> {
   hasBundle = false;
 
   init() {
-    this.allowUsePreInitialize = true;
-
     const payload = this.payload as NexaSignTransactionParams;
 
     payload.inputs.forEach(input => {
@@ -27,8 +25,12 @@ export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionP
     this.params = payload;
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_mini: {
         min: '3.2.0',
       },

package/src/api/nostr/NostrSignEvent.ts

@@ -15,7 +15,6 @@ export default class NostrSignEvent extends BaseMethod<SignEvent> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     const { payload } = this;
     if (!validateEvent(payload.event)) {

package/src/api/nostr/NostrSignSchnorr.ts

@@ -11,7 +11,6 @@ export default class NostrSignSchnorr extends BaseMethod<SignSchnorr> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     const { payload } = this;
     validateParams(payload, [

package/src/api/polkadot/PolkadotSignTransaction.ts

@@ -13,7 +13,6 @@ export default class PolkadotSignTransaction extends BaseMethod<HardwarePolkadot
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode];
-    this.allowUsePreInitialize = true;
 
     // check payload
     validateParams(this.payload, [

package/src/api/protocol-v2/DeviceFirmwareUpdate.ts

@@ -0,0 +1,50 @@
+import { BaseMethod } from '../BaseMethod';
+import {
+  PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS,
+  PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
+  normalizeFirmwareTargets,
+} from './helpers';
+import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
+import type { KnownDevice } from '../../types';
+
+import type { DeviceFirmwareUpdateParams } from './helpers';
+
+export default class DeviceFirmwareUpdate extends BaseMethod<DeviceFirmwareUpdateParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      targets: this.payload.targets,
+      targetId: this.payload.targetId,
+      target_id: this.payload.target_id,
+      path: this.payload.path,
+    };
+  }
+
+  async run() {
+    const targets = normalizeFirmwareTargets(this.params);
+    const res = await this.device.commands.typedCall(
+      'DeviceFirmwareUpdate',
+      PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
+      {
+        targets,
+      },
+      {
+        ...PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS,
+        onIntermediateResponse: response => {
+          if (response.type !== 'DeviceFirmwareInstallProgress') return;
+          const progress = Number(response.message?.progress);
+          if (!Number.isFinite(progress)) return;
+          this.postMessage(
+            createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
+              device: this.device.toMessageObject() as KnownDevice,
+              progress: Math.min(Math.max(progress, 0), 100),
+              progressType: 'installingFirmware',
+            })
+          );
+        },
+      }
+    );
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/protocol-v2/DeviceGetDeviceInfo.ts

@@ -0,0 +1,35 @@
+import { BaseMethod } from '../BaseMethod';
+import { buildTargets, buildTypes } from './helpers';
+
+import type { DeviceGetDeviceInfoParams } from './helpers';
+
+export default class DeviceGetDeviceInfo extends BaseMethod<DeviceGetDeviceInfoParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      targets: this.payload.targets,
+      types: this.payload.types,
+      targetHw: this.payload.targetHw,
+      targetFw: this.payload.targetFw,
+      targetBt: this.payload.targetBt,
+      targetSe1: this.payload.targetSe1,
+      targetSe2: this.payload.targetSe2,
+      targetSe3: this.payload.targetSe3,
+      targetSe4: this.payload.targetSe4,
+      targetStatus: this.payload.targetStatus,
+      includeVersion: this.payload.includeVersion,
+      includeBuildId: this.payload.includeBuildId,
+      includeHash: this.payload.includeHash,
+      includeSpecific: this.payload.includeSpecific,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DeviceGetDeviceInfo', 'DeviceInfo', {
+      targets: buildTargets(this.params),
+      types: buildTypes(this.params),
+    });
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/protocol-v2/DeviceGetFirmwareUpdateStatus.ts

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

package/src/api/protocol-v2/DeviceGetOnboardingStatus.ts

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

package/src/api/protocol-v2/DeviceReboot.ts

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

package/src/api/protocol-v2/FactoryDeviceInfoSettings.ts

@@ -0,0 +1,27 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { FactoryDeviceInfoSettingsParams } from './helpers';
+
+export default class FactoryDeviceInfoSettings extends BaseMethod<FactoryDeviceInfoSettingsParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      serial_no: this.payload.serial_no,
+      serialNo: this.payload.serialNo,
+      cpu_info: this.payload.cpu_info,
+      cpuInfo: this.payload.cpuInfo,
+      pre_firmware: this.payload.pre_firmware,
+      preFirmware: this.payload.preFirmware,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FactoryDeviceInfoSettings', 'Success', {
+      serial_no: this.params.serial_no ?? this.params.serialNo,
+      cpu_info: this.params.cpu_info ?? this.params.cpuInfo,
+      pre_firmware: this.params.pre_firmware ?? this.params.preFirmware,
+    });
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/protocol-v2/FactoryGetDeviceInfo.ts

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FactoryGetDeviceInfo extends BaseMethod {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'FactoryGetDeviceInfo',
+      'FactoryDeviceInfo',
+      {}
+    );
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/protocol-v2/FilesystemDiskControl.ts

@@ -0,0 +1,34 @@
+import { BaseMethod } from '../BaseMethod';
+import {
+  validateNonNegativeInteger,
+  validateOptionalNonNegativeInteger,
+} from '../helpers/filesystemValidation';
+
+export type FilesystemDiskControlParams = {
+  enable?: number | string;
+  timeoutMs?: number | string;
+};
+
+export default class FilesystemDiskControl extends BaseMethod<FilesystemDiskControlParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      enable: validateNonNegativeInteger(this.payload.enable, 'enable', 0),
+      timeoutMs: validateOptionalNonNegativeInteger(this.payload.timeoutMs, 'timeoutMs'),
+    };
+  }
+
+  async run() {
+    const timeoutMs = Number(this.params.timeoutMs);
+    const res = await this.device.commands.typedCall(
+      'FilesystemDiskControl',
+      'Success',
+      {
+        enable: Number(this.params.enable ?? 0),
+      },
+      Number.isFinite(timeoutMs) && timeoutMs > 0 ? { timeoutMs } : undefined
+    );
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/protocol-v2/FilesystemFixPermission.ts

@@ -0,0 +1,14 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FilesystemFixPermission extends BaseMethod {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemFixPermission', 'Success', {});
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/protocol-v2/FilesystemFormat.ts

@@ -0,0 +1,14 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FilesystemFormat extends BaseMethod {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemFormat', 'Success', {});
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/protocol-v2/GetProtoVersion.ts

@@ -0,0 +1,14 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class GetProtoVersion extends BaseMethod {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('GetProtoVersion', 'ProtoVersion', {});
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/protocol-v2/Ping.ts

@@ -0,0 +1,16 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class Ping extends BaseMethod<{ message?: string }> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { message: this.payload.message };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('Ping', 'Success', {
+      message: this.params.message ?? '',
+    });
+    return Promise.resolve(res.message);
+  }
+}