@onekeyfe/hd-core 1.1.26-alpha.2 → 1.1.26-alpha.30

package/src/device/DeviceConnector.ts

@@ -1,3 +1,5 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import { safeThrowError } from '../constants';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
@@ -6,6 +8,7 @@ import { resolveAfter } from '../utils/promiseUtils';
 import { LoggerNames, getLogger } from '../utils';
 
 import type { DeviceDescriptorDiff } from './DevicePool';
+import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 import type { OneKeyDeviceInfo as DeviceDescriptor, Transport } from '@onekeyfe/hd-transport';
 
 const Log = getLogger(LoggerNames.DeviceConnector);
@@ -75,15 +78,37 @@ export default class DeviceConnector {
     this.listening = false;
   }
 
-  async acquire(path: string, session?: string | null, forceCleanRunPromise?: boolean) {
-    Log.debug('acquire', path, session);
+  async acquire(
+    path: string,
+    session?: string | null,
+    forceCleanRunPromise?: boolean,
+    connectProtocol?: HardwareConnectProtocol
+  ) {
+    Log.debug('acquire', path, session, connectProtocol);
     const env = DataManager.getSettings('env');
     try {
       let res;
       if (DataManager.isBleConnect(env)) {
-        res = await this.transport.acquire({ uuid: path, forceCleanRunPromise });
+        res = await this.transport.acquire({
+          uuid: path,
+          forceCleanRunPromise,
+          expectedProtocol: connectProtocol,
+        });
       } else {
-        res = await this.transport.acquire({ path, previous: session ?? null });
+        res = await this.transport.acquire({
+          path,
+          previous: session ?? null,
+          expectedProtocol: connectProtocol,
+        });
+      }
+      if (connectProtocol) {
+        const detectedProtocol = this.transport.getProtocolType(path);
+        if (detectedProtocol !== connectProtocol) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            `Device protocol mismatch: expected ${connectProtocol}, detected ${detectedProtocol}`
+          );
+        }
       }
       return res;
     } catch (error) {

package/src/device/DevicePool.ts

@@ -150,7 +150,7 @@ export class DevicePool extends EventEmitter {
     if (!device) {
       device = Device.fromDescriptor(descriptor);
       device.deviceConnector = this.connector;
-      await device.connect();
+      await device.connect(initOptions?.connectProtocol);
       await device.initialize(initOptions);
       await device.release();
     }

package/src/events/ui-request.ts

@@ -129,6 +129,10 @@ export interface FirmwareProgress {
     device: Device;
     progress: number;
     progressType: IFirmwareUpdateProgressType;
+    transferredBytes?: number;
+    totalBytes?: number;
+    rateBytesPerSecond?: number;
+    elapsedMs?: number;
   };
 }
 
@@ -144,6 +148,10 @@ export interface DeviceProgress {
   type: typeof UI_REQUEST.DEVICE_PROGRESS;
   payload: {
     progress?: number;
+    transferredBytes?: number;
+    totalBytes?: number;
+    rateBytesPerSecond?: number;
+    elapsedMs?: number;
   };
 }
 

package/src/inject.ts

@@ -103,7 +103,7 @@ export const createCoreApi = (
   /**
    * 搜索设备
    */
-  searchDevices: () => call({ method: 'searchDevices' }),
+  searchDevices: params => call({ ...params, method: 'searchDevices' }),
 
   /**
    * 获取设备信息
@@ -148,6 +148,46 @@ export const createCoreApi = (
   deviceFlags: (connectId, params) => call({ ...params, connectId, method: 'deviceFlags' }),
   deviceRebootToBoardloader: connectId => call({ connectId, method: 'deviceRebootToBoardloader' }),
   deviceRebootToBootloader: connectId => call({ connectId, method: 'deviceRebootToBootloader' }),
+
+  // File system & device control API (Protocol V2 only)
+  getProtoVersion: (connectId, params) =>
+    call({ ...params, connectId, method: 'getProtoVersion' }),
+  ping: (connectId, params) => call({ ...params, connectId, method: 'ping' }),
+  devReboot: (connectId, params) => call({ ...params, connectId, method: 'devReboot' }),
+  devGetDeviceInfo: (connectId, params) =>
+    call({ ...params, connectId, method: 'devGetDeviceInfo' }),
+  devGetOnboardingStatus: (connectId, params) =>
+    call({ ...params, connectId, method: 'devGetOnboardingStatus' }),
+  devFirmwareUpdate: (connectId, params) =>
+    call({ ...params, connectId, method: 'devFirmwareUpdate' }),
+  devGetFirmwareUpdateStatus: (connectId, params) =>
+    call({ ...params, connectId, method: 'devGetFirmwareUpdateStatus' }),
+  factoryDeviceInfoSettings: (connectId, params) =>
+    call({ ...params, connectId, method: 'factoryDeviceInfoSettings' }),
+  factoryGetDeviceInfo: connectId => call({ connectId, method: 'factoryGetDeviceInfo' }),
+  filesystemFixPermission: connectId => call({ connectId, method: 'filesystemFixPermission' }),
+  fileRead: (connectId, params) => call({ ...params, connectId, method: 'fileRead' }),
+  fileWrite: (connectId, params) => call({ ...params, connectId, method: 'fileWrite' }),
+  fileDelete: (connectId, params) => call({ ...params, connectId, method: 'fileDelete' }),
+  dirList: (connectId, params) => call({ ...params, connectId, method: 'dirList' }),
+  dirMake: (connectId, params) => call({ ...params, connectId, method: 'dirMake' }),
+  dirRemove: (connectId, params) => call({ ...params, connectId, method: 'dirRemove' }),
+  pathInfo: (connectId, params) => call({ ...params, connectId, method: 'pathInfo' }),
+  filesystemFileRead: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemFileRead' }),
+  filesystemFileWrite: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemFileWrite' }),
+  filesystemFileDelete: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemFileDelete' }),
+  filesystemDirList: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemDirList' }),
+  filesystemDirMake: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemDirMake' }),
+  filesystemDirRemove: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemDirRemove' }),
+  filesystemPathInfoQuery: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemPathInfoQuery' }),
+  filesystemFormat: connectId => call({ connectId, method: 'filesystemFormat' }),
   deviceRecovery: (connectId, params) => call({ ...params, connectId, method: 'deviceRecovery' }),
   deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),
   deviceSettings: (connectId, params) => call({ ...params, connectId, method: 'deviceSettings' }),
@@ -260,6 +300,8 @@ export const createCoreApi = (
     call({ ...params, connectId, method: 'firmwareUpdateV2' }),
   firmwareUpdateV3: (connectId, params) =>
     call({ ...params, connectId, method: 'firmwareUpdateV3' }),
+  firmwareUpdateV4: (connectId, params) =>
+    call({ ...params, connectId, method: 'firmwareUpdateV4' }),
   promptWebDeviceAccess: params => call({ ...params, method: 'promptWebDeviceAccess' }),
 
   tronGetAddress: (connectId, deviceId, params) =>
@@ -377,6 +419,8 @@ export const createCoreApi = (
     call({ ...params, connectId, deviceId, method: 'tonSignMessage' }),
   tonSignProof: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'tonSignProof' }),
+  tonSignData: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'tonSignData' }),
 
   scdoGetAddress: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'scdoGetAddress' }),

package/src/protocols/protocol-v2/features.ts

@@ -0,0 +1,259 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import type { Features } from '../../types';
+import type { DeviceCommands } from '../../device/DeviceCommands';
+import type { OneKeyDeviceInfo as DeviceDescriptor, Messages } from '@onekeyfe/hd-transport';
+
+type ProtocolV2Bytes = Uint8Array | number[] | string;
+
+type ProtocolV2FirmwareImageInfo = {
+  version?: string;
+  build_id?: string;
+  hash?: ProtocolV2Bytes;
+};
+
+type ProtocolV2SEInfo = {
+  boot?: ProtocolV2FirmwareImageInfo;
+  app?: ProtocolV2FirmwareImageInfo;
+  type?: number;
+  state?: number;
+};
+
+type ProtocolV2DeviceInfo = {
+  protocol_version?: number;
+  hw?: {
+    device_type?: number;
+    serial_no?: string;
+    hardware_version?: string;
+    hardware_version_raw_adc?: number;
+  };
+  fw?: {
+    board?: ProtocolV2FirmwareImageInfo;
+    boot?: ProtocolV2FirmwareImageInfo;
+    app?: ProtocolV2FirmwareImageInfo;
+  };
+  bt?: {
+    boot?: ProtocolV2FirmwareImageInfo;
+    app?: ProtocolV2FirmwareImageInfo;
+    adv_name?: string;
+    mac?: ProtocolV2Bytes;
+  };
+  se1?: ProtocolV2SEInfo;
+  se2?: ProtocolV2SEInfo;
+  se3?: ProtocolV2SEInfo;
+  se4?: ProtocolV2SEInfo;
+  status?: {
+    language?: string;
+    bt_enable?: boolean;
+    init_states?: boolean;
+    backup_required?: boolean;
+    passphrase_protection?: boolean;
+    label?: string;
+  };
+};
+
+const PROTOCOL_V2_DEVICE_INFO_REQUEST: Messages.MessageType['DevGetDeviceInfo'] = {
+  targets: {
+    hw: true,
+    fw: true,
+    bt: true,
+    se1: true,
+    se2: true,
+    se3: true,
+    se4: true,
+    status: true,
+  },
+  types: {
+    version: true,
+    build_id: true,
+    hash: true,
+    specific: true,
+  },
+};
+
+function parseVersion(version?: string | null): [number, number, number] {
+  if (!version) return [0, 0, 0];
+  const [major = 0, minor = 0, patch = 0] = version.split('.').map(part => Number(part) || 0);
+  return [major, minor, patch];
+}
+
+function bytesToHex(value: unknown): string | undefined {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (value instanceof Uint8Array) {
+    return Array.from(value)
+      .map(byte => byte.toString(16).padStart(2, '0'))
+      .join('');
+  }
+  if (Array.isArray(value)) {
+    return value.map(byte => Number(byte).toString(16).padStart(2, '0')).join('');
+  }
+  return undefined;
+}
+
+function getDescriptorId(descriptor: DeviceDescriptor) {
+  return descriptor.path || descriptor.id || '';
+}
+
+function getImageVersion(image?: ProtocolV2FirmwareImageInfo) {
+  return image?.version || undefined;
+}
+
+function getImageBuildId(image?: ProtocolV2FirmwareImageInfo) {
+  return image?.build_id || undefined;
+}
+
+function getImageHash(image?: ProtocolV2FirmwareImageInfo) {
+  return bytesToHex(image?.hash);
+}
+
+function getSeState(se?: ProtocolV2SEInfo) {
+  switch (se?.state) {
+    case 0:
+      return 'BOOT';
+    case 51:
+      return 'APP_FACTORY';
+    case 85:
+      return 'APP';
+    default:
+      return null;
+  }
+}
+
+function createBaseFeatures(descriptor: DeviceDescriptor): Features {
+  const descriptorId = getDescriptorId(descriptor);
+  return {
+    vendor: 'onekey.so',
+    major_version: 0,
+    minor_version: 0,
+    patch_version: 0,
+    bootloader_mode: false,
+    device_id: descriptorId,
+    pin_protection: null,
+    passphrase_protection: false,
+    language: null,
+    label: null,
+    initialized: false,
+    revision: null,
+    bootloader_hash: null,
+    imported: null,
+    unlocked: false,
+    firmware_present: false,
+    needs_backup: null,
+    flags: null,
+    model: 'pro2',
+    fw_major: 0,
+    fw_minor: 0,
+    fw_patch: 0,
+    fw_vendor: null,
+    unfinished_backup: null,
+    no_backup: null,
+    recovery_mode: null,
+    capabilities: [],
+    backup_type: null,
+    sd_card_present: null,
+    sd_protection: null,
+    wipe_code_protection: null,
+    session_id: null,
+    passphrase_always_on_device: null,
+    safety_checks: null,
+    auto_lock_delay_ms: null,
+    display_rotation: null,
+    experimental_features: null,
+    onekey_device_type: EDeviceType.Pro2,
+    onekey_serial_no: descriptorId,
+    serial_no: descriptorId,
+  };
+}
+
+export function normalizeProtocolV2Features(
+  descriptor: DeviceDescriptor,
+  deviceInfo?: ProtocolV2DeviceInfo
+): Features {
+  const features = createBaseFeatures(descriptor);
+  if (!deviceInfo) return features;
+
+  const serialNo =
+    deviceInfo.hw?.serial_no || features.onekey_serial_no || getDescriptorId(descriptor);
+  const firmwareVersion = getImageVersion(deviceInfo.fw?.app);
+  const [fwMajor, fwMinor, fwPatch] = parseVersion(firmwareVersion);
+
+  return {
+    ...features,
+    major_version: fwMajor,
+    minor_version: fwMinor,
+    patch_version: fwPatch,
+    fw_major: fwMajor,
+    fw_minor: fwMinor,
+    fw_patch: fwPatch,
+    device_id: serialNo,
+    serial_no: serialNo,
+    onekey_serial_no: serialNo,
+    label: deviceInfo.status?.label ?? features.label,
+    language: deviceInfo.status?.language ?? features.language,
+    initialized: deviceInfo.status?.init_states ?? features.initialized,
+    passphrase_protection:
+      deviceInfo.status?.passphrase_protection ?? features.passphrase_protection,
+    needs_backup: deviceInfo.status?.backup_required ?? features.needs_backup,
+    ble_enable: deviceInfo.status?.bt_enable,
+    onekey_ble_name: deviceInfo.bt?.adv_name,
+    ble_name: deviceInfo.bt?.adv_name,
+    onekey_firmware_version: firmwareVersion,
+    onekey_firmware_build_id: getImageBuildId(deviceInfo.fw?.app),
+    onekey_firmware_hash: getImageHash(deviceInfo.fw?.app),
+    onekey_boot_version: getImageVersion(deviceInfo.fw?.boot),
+    bootloader_version: getImageVersion(deviceInfo.fw?.boot),
+    onekey_boot_build_id: getImageBuildId(deviceInfo.fw?.boot),
+    onekey_boot_hash: getImageHash(deviceInfo.fw?.boot),
+    onekey_board_version: getImageVersion(deviceInfo.fw?.board),
+    onekey_board_hash: getImageHash(deviceInfo.fw?.board),
+    onekey_ble_version: getImageVersion(deviceInfo.bt?.app),
+    ble_ver: getImageVersion(deviceInfo.bt?.app),
+    onekey_ble_build_id: getImageBuildId(deviceInfo.bt?.app),
+    onekey_ble_hash: getImageHash(deviceInfo.bt?.app),
+    onekey_se01_version: getImageVersion(deviceInfo.se1?.app),
+    onekey_se01_hash: getImageHash(deviceInfo.se1?.app),
+    onekey_se01_build_id: getImageBuildId(deviceInfo.se1?.app),
+    onekey_se01_state: getSeState(deviceInfo.se1),
+    onekey_se02_version: getImageVersion(deviceInfo.se2?.app),
+    onekey_se02_state: getSeState(deviceInfo.se2),
+    onekey_se03_version: getImageVersion(deviceInfo.se3?.app),
+    onekey_se03_state: getSeState(deviceInfo.se3),
+    onekey_se04_version: getImageVersion(deviceInfo.se4?.app),
+    onekey_se04_state: getSeState(deviceInfo.se4),
+  };
+}
+
+export async function getProtocolV2Features({
+  commands,
+  descriptor,
+  onDeviceInfoError,
+  timeoutMs,
+}: {
+  commands: DeviceCommands;
+  descriptor: DeviceDescriptor;
+  onDeviceInfoError?: (error: unknown) => void;
+  timeoutMs?: number;
+}) {
+  const callOptions = timeoutMs ? { timeoutMs } : undefined;
+  if (callOptions) {
+    await commands.typedCall('Ping', 'Success', { message: 'init' }, callOptions);
+  } else {
+    await commands.typedCall('Ping', 'Success', { message: 'init' });
+  }
+
+  try {
+    const { message } = callOptions
+      ? await commands.typedCall(
+          'DevGetDeviceInfo',
+          'DeviceInfo',
+          PROTOCOL_V2_DEVICE_INFO_REQUEST,
+          callOptions
+        )
+      : await commands.typedCall('DevGetDeviceInfo', 'DeviceInfo', PROTOCOL_V2_DEVICE_INFO_REQUEST);
+    return normalizeProtocolV2Features(descriptor, message as unknown as ProtocolV2DeviceInfo);
+  } catch (error) {
+    onDeviceInfoError?.(error);
+    throw error;
+  }
+}

package/src/protocols/protocol-v2/firmware.ts

@@ -0,0 +1,26 @@
+/**
+ * Protocol V2 DevFirmwareTargetType enum (from messages-pro2.json).
+ */
+export const ProtocolV2FirmwareTargetType = {
+  TARGET_MAIN_APP: 0,
+  TARGET_MAIN_BOOT: 1,
+  TARGET_BT: 2,
+  TARGET_SE1: 3,
+  TARGET_SE2: 4,
+  TARGET_SE3: 5,
+  TARGET_SE4: 6,
+  TARGET_RESOURCE: 10,
+} as const;
+
+/**
+ * Map Protocol V2 firmware file name to DevFirmwareUpdate target_id.
+ */
+export function protocolV2FileNameToTargetId(fileName: string): number {
+  if (fileName.includes('ble')) return ProtocolV2FirmwareTargetType.TARGET_BT;
+  if (fileName.includes('bootloader')) return ProtocolV2FirmwareTargetType.TARGET_MAIN_BOOT;
+  if (fileName.includes('se1')) return ProtocolV2FirmwareTargetType.TARGET_SE1;
+  if (fileName.includes('se2')) return ProtocolV2FirmwareTargetType.TARGET_SE2;
+  if (fileName.includes('se3')) return ProtocolV2FirmwareTargetType.TARGET_SE3;
+  if (fileName.includes('se4')) return ProtocolV2FirmwareTargetType.TARGET_SE4;
+  return ProtocolV2FirmwareTargetType.TARGET_MAIN_APP;
+}

package/src/protocols/protocol-v2/index.ts

@@ -0,0 +1,2 @@
+export * from './features';
+export * from './firmware';

package/src/types/api/export.ts

@@ -28,6 +28,7 @@ export type {
   FirmwareUpdateParams,
   FirmwareUpdateBinaryParams,
   FirmwareUpdateV3Params,
+  FirmwareUpdateV4Params,
 } from './firmwareUpdate';
 export type { AllFirmwareRelease } from './checkAllFirmwareRelease';
 
@@ -179,6 +180,7 @@ export type { DnxTxKey, DnxSignTransactionParams, DnxSignature } from './dnxSign
 export type { TonAddress, TonGetAddressParams } from './tonGetAddress';
 export type { TonSignMessageParams } from './tonSignMessage';
 export type { TonSignProofParams } from './tonSignProof';
+export type { TonSignDataParams } from './tonSignData';
 
 export type { ScdoAddress, ScdoGetAddressParams } from './scdoGetAddress';
 export type { ScdoSignMessageParams } from './scdoSignMessage';

package/src/types/api/firmwareUpdate.ts

@@ -41,6 +41,7 @@ export declare function firmwareUpdateV2(
 export interface FirmwareUpdateV3Params {
   bleVersion?: number[];
   bleBinary?: ArrayBuffer;
+  chunkSize?: number;
 
   firmwareVersion?: number[];
   firmwareBinary?: ArrayBuffer;
@@ -56,6 +57,8 @@ export interface FirmwareUpdateV3Params {
   platform: IPlatform;
 }
 
+export type FirmwareUpdateV4Params = FirmwareUpdateV3Params;
+
 export declare function firmwareUpdateV3(
   connectId: string | undefined,
   params: Params<FirmwareUpdateV3Params>
@@ -64,3 +67,12 @@ export declare function firmwareUpdateV3(
   firmwareVersion: string;
   bootloaderVersion: string;
 }>;
+
+export declare function firmwareUpdateV4(
+  connectId: string | undefined,
+  params: Params<FirmwareUpdateV4Params>
+): Response<{
+  bleVersion: string;
+  firmwareVersion: string;
+  bootloaderVersion: string;
+}>;

package/src/types/api/index.ts

@@ -1,3 +1,30 @@
+import type {
+  devFirmwareUpdate,
+  devGetDeviceInfo,
+  devGetFirmwareUpdateStatus,
+  devGetOnboardingStatus,
+  devReboot,
+  dirList,
+  dirMake,
+  dirRemove,
+  factoryDeviceInfoSettings,
+  factoryGetDeviceInfo,
+  fileDelete,
+  fileRead,
+  fileWrite,
+  filesystemDirList,
+  filesystemDirMake,
+  filesystemDirRemove,
+  filesystemFileDelete,
+  filesystemFileRead,
+  filesystemFileWrite,
+  filesystemFixPermission,
+  filesystemFormat,
+  filesystemPathInfoQuery,
+  getProtoVersion,
+  pathInfo,
+  ping,
+} from './protocolV2';
 import type { off, on, removeAllListeners } from './event';
 import type { uiResponse } from './uiResponse';
 import type { init, updateSettings } from './init';
@@ -14,7 +41,12 @@ import type { getOnekeyFeatures } from './getOnekeyFeatures';
 import type { getPassphraseState } from './getPassphraseState';
 import type { checkFirmwareRelease } from './checkFirmwareRelease';
 import type { checkBLEFirmwareRelease } from './checkBLEFirmwareRelease';
-import type { firmwareUpdate, firmwareUpdateV2, firmwareUpdateV3 } from './firmwareUpdate';
+import type {
+  firmwareUpdate,
+  firmwareUpdateV2,
+  firmwareUpdateV3,
+  firmwareUpdateV4,
+} from './firmwareUpdate';
 import type { promptWebDeviceAccess } from './promptWebDeviceAccess';
 import type { deviceReset } from './deviceReset';
 import type { deviceRecovery } from './deviceRecovery';
@@ -114,6 +146,7 @@ import type { dnxSignTransaction } from './dnxSignTransaction';
 import type { tonGetAddress } from './tonGetAddress';
 import type { tonSignMessage } from './tonSignMessage';
 import type { tonSignProof } from './tonSignProof';
+import type { tonSignData } from './tonSignData';
 import type { scdoGetAddress } from './scdoGetAddress';
 import type { scdoSignMessage } from './scdoSignMessage';
 import type { scdoSignTransaction } from './scdoSignTransaction';
@@ -194,8 +227,38 @@ export type CoreApi = {
   firmwareUpdate: typeof firmwareUpdate;
   firmwareUpdateV2: typeof firmwareUpdateV2;
   firmwareUpdateV3: typeof firmwareUpdateV3;
+  firmwareUpdateV4: typeof firmwareUpdateV4;
   cipherKeyValue: typeof cipherKeyValue;
 
+  /**
+   * File system & device control API (Protocol V2 only)
+   */
+  getProtoVersion: typeof getProtoVersion;
+  ping: typeof ping;
+  devReboot: typeof devReboot;
+  devGetDeviceInfo: typeof devGetDeviceInfo;
+  devGetOnboardingStatus: typeof devGetOnboardingStatus;
+  devFirmwareUpdate: typeof devFirmwareUpdate;
+  devGetFirmwareUpdateStatus: typeof devGetFirmwareUpdateStatus;
+  factoryDeviceInfoSettings: typeof factoryDeviceInfoSettings;
+  factoryGetDeviceInfo: typeof factoryGetDeviceInfo;
+  filesystemFixPermission: typeof filesystemFixPermission;
+  fileRead: typeof fileRead;
+  fileWrite: typeof fileWrite;
+  fileDelete: typeof fileDelete;
+  dirList: typeof dirList;
+  dirMake: typeof dirMake;
+  dirRemove: typeof dirRemove;
+  pathInfo: typeof pathInfo;
+  filesystemFileRead: typeof filesystemFileRead;
+  filesystemFileWrite: typeof filesystemFileWrite;
+  filesystemFileDelete: typeof filesystemFileDelete;
+  filesystemDirList: typeof filesystemDirList;
+  filesystemDirMake: typeof filesystemDirMake;
+  filesystemDirRemove: typeof filesystemDirRemove;
+  filesystemPathInfoQuery: typeof filesystemPathInfoQuery;
+  filesystemFormat: typeof filesystemFormat;
+
   /**
    * All network function
    */
@@ -373,6 +436,7 @@ export type CoreApi = {
   tonGetAddress: typeof tonGetAddress;
   tonSignMessage: typeof tonSignMessage;
   tonSignProof: typeof tonSignProof;
+  tonSignData: typeof tonSignData;
 
   /**
    * SCDO Network