@onekeyfe/hd-core 1.2.0-alpha.56 → 1.2.0-alpha.57

package/src/api/firmware/FirmwareErase.ts

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+type Params = {
+  binary?: ArrayBuffer;
+  version?: number[];
+  updateType: 'firmware' | 'ble';
+};
+
+export default class FirmwareErase extends BaseMethod<Params> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    return this.device.getCommands().typedCall('FirmwareErase', 'Success');
+  }
+}

package/src/api/firmware/FirmwareEraseEx.ts

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+type Params = {
+  binary?: ArrayBuffer;
+  version?: number[];
+  updateType: 'firmware' | 'ble';
+};
+
+export default class FirmwareEraseEx extends BaseMethod<Params> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    return this.device.getCommands().typedCall('FirmwareErase_ex', 'Success');
+  }
+}

package/src/api/firmware/FirmwareUpdateEmmcTest.ts

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { FirmwareUpdateEmmc } from '@onekeyfe/hd-transport';
+
+export default class FirmwareUpdateEmmcTest extends BaseMethod<FirmwareUpdateEmmc> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = {
+      path: this.payload.path,
+      reboot_on_success: this.payload.reboot_on_success,
+    };
+  }
+
+  async run() {
+    return this.device.getCommands().typedCall('FirmwareUpdateEmmc', 'Success', this.params);
+  }
+}

package/src/api/firmware/FirmwareUploadTest.ts

@@ -0,0 +1,17 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { FirmwareUpload } from '@onekeyfe/hd-transport';
+
+export default class FirmwareUploadTest extends BaseMethod<FirmwareUpload> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = {
+      payload: new ArrayBuffer(0),
+    };
+  }
+
+  async run() {
+    return this.device.getCommands().typedCall('FirmwareUpload', 'Success', this.params);
+  }
+}

package/src/api/firmware/Reboot.ts

@@ -0,0 +1,17 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { Reboot as HardwareReboot } from '@onekeyfe/hd-transport';
+
+export default class Reboot extends BaseMethod<HardwareReboot> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = {
+      reboot_type: this.payload.reboot_type,
+    };
+  }
+
+  async run() {
+    return this.device.getCommands().typedCall('Reboot', 'Success', this.params);
+  }
+}

package/src/api/firmware/SelfTest.ts

@@ -0,0 +1,17 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { SelfTest as HardwareSelfTest } from '@onekeyfe/hd-transport';
+
+export default class SelfTest extends BaseMethod<HardwareSelfTest> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = {
+      payload: this.payload.payload,
+    };
+  }
+
+  async run() {
+    return this.device.getCommands().typedCall('SelfTest', 'Success', this.params);
+  }
+}

package/src/api/index.ts

@@ -49,6 +49,9 @@ export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 // Pro2 business API
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
 export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
+export { default as deviceReadFactoryInfo } from './protocol-v2/DeviceFactoryInfoGet';
+export { default as deviceReadFactoryCertificate } from './protocol-v2/DeviceFactoryCertificateRead';
+export { default as deviceSignFactoryChallenge } from './protocol-v2/DeviceFactoryChallengeSign';
 export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
 export { default as deviceUploadNft } from './protocol-v2/DeviceUploadNft';
 export { default as uploadPortfolio } from './UploadPortfolio';

package/src/api/manager/DeviceCancelAuthorization.ts

@@ -0,0 +1,15 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { CancelAuthorization } from '@onekeyfe/hd-transport';
+
+export default class DeviceCancelAuthorization extends BaseMethod<CancelAuthorization> {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('CancelAuthorization', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceChangeWipeCode.ts

@@ -0,0 +1,19 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { ChangeWipeCode } from '@onekeyfe/hd-transport';
+
+export default class DeviceChangeWipeCode extends BaseMethod<ChangeWipeCode> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      remove: this.payload.remove,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('ChangeWipeCode', 'Success', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceDoPreauthorized.ts

@@ -0,0 +1,15 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DoPreauthorized } from '@onekeyfe/hd-transport';
+
+export default class DeviceDoPreauthorized extends BaseMethod<DoPreauthorized> {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DoPreauthorized', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceEndSession.ts

@@ -0,0 +1,19 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { EndSession } from '@onekeyfe/hd-transport';
+
+export default class DeviceEndSession extends BaseMethod<EndSession> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      size: this.payload.size,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('EndSession', 'Success', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceGetEntropy.ts

@@ -0,0 +1,19 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { GetEntropy } from '@onekeyfe/hd-transport';
+
+export default class DeviceGetEntropy extends BaseMethod<GetEntropy> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      size: this.payload.size,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('GetEntropy', 'Entropy', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceGetFirmwareHash.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { GetFirmwareHash } from '@onekeyfe/hd-transport';
+
+export default class DeviceGetFirmwareHash extends BaseMethod<GetFirmwareHash> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      challenge: this.payload.challenge,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'GetFirmwareHash',
+      'FirmwareHash',
+      this.params
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceInfoSettings.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { DeviceInfoSettings as HardwareDeviceInfoSettings } from '@onekeyfe/hd-transport';
+
+export default class DeviceInfoSettings extends BaseMethod<HardwareDeviceInfoSettings> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.skipForceUpdateCheck = true;
+    this.params = {
+      serial_no: this.payload.serial_no,
+      cpu_info: this.payload.cpu_info,
+      pre_firmware: this.payload.pre_firmware,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DeviceInfoSettings', 'Success', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceLoad.ts

@@ -0,0 +1,27 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { LoadDevice } from '@onekeyfe/hd-transport';
+
+export default class DeviceLoad extends BaseMethod<LoadDevice> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      mnemonics: this.payload.mnemonics.split(' '),
+      pin: this.payload.pin,
+      passphrase_protection: this.payload.passphrase_protection,
+      language: this.payload.language,
+      label: this.payload.label,
+      skip_checksum: this.payload.skip_checksum,
+      u2f_counter: this.payload.u2f_counter,
+      needs_backup: this.payload.needs_backup,
+      no_backup: this.payload.no_backup,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('LoadDevice', 'Success', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DevicePing.ts

@@ -0,0 +1,19 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { Ping } from '@onekeyfe/hd-transport';
+
+export default class DevicePing extends BaseMethod<Ping> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.params = {
+      message: this.payload.message,
+      button_protection: this.payload.button_protection,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('Ping', 'Success', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceReadSEPublicCert.ts

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { ReadSEPublicCert } from '@onekeyfe/hd-transport';
+
+export default class DeviceReadSEPublicCert extends BaseMethod<ReadSEPublicCert> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('ReadSEPublicCert', 'SEPublicCert');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceSESignMessage.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { SESignMessage } from '@onekeyfe/hd-transport';
+
+export default class DeviceSESignMessage extends BaseMethod<SESignMessage> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.params = {
+      message: this.payload.message,
+    };
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('SESignMessage', 'SEMessageSignature', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceSdProtect.ts

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { SdProtect } from '@onekeyfe/hd-transport';
+
+export default class DeviceSdProtect extends BaseMethod<SdProtect> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.params = {
+      operation: this.payload.operation,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('SdProtect', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceSpiFlashRead.ts

@@ -0,0 +1,22 @@
+import { BaseMethod } from '../BaseMethod';
+import { formatAnyHex } from '../helpers/hexUtils';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { SpiFlashRead } from '@onekeyfe/hd-transport';
+
+export default class DeviceSpiFlashRead extends BaseMethod<SpiFlashRead> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.params = {
+      address: this.payload.address,
+      len: formatAnyHex(this.payload.data),
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('SpiFlashRead', 'SpiFlashData', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceSpiFlashWrite.ts

@@ -0,0 +1,22 @@
+import { BaseMethod } from '../BaseMethod';
+import { formatAnyHex } from '../helpers/hexUtils';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { SpiFlashWrite } from '@onekeyfe/hd-transport';
+
+export default class DeviceSpiFlashWrite extends BaseMethod<SpiFlashWrite> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.params = {
+      address: this.payload.address,
+      data: formatAnyHex(this.payload.data),
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('SpiFlashWrite', 'Success', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceUnlockPath.ts

@@ -0,0 +1,26 @@
+import { BaseMethod } from '../BaseMethod';
+import { validatePath } from '../helpers/pathUtils';
+
+import type { UnlockPath } from '@onekeyfe/hd-transport';
+
+export default class DeviceUnlockPath extends BaseMethod<UnlockPath> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    const addressN = validatePath(this.payload.address_n, 3);
+    this.params = {
+      address_n: addressN,
+      mac: this.payload.mac,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'UnlockPath',
+      'UnlockedPathRequest',
+      this.params
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceWriteSEPrivateKey.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { WriteSEPrivateKey } from '@onekeyfe/hd-transport';
+
+export default class DeviceWriteSEPrivateKey extends BaseMethod<WriteSEPrivateKey> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.params = {
+      private_key: this.payload.private_key,
+    };
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('WriteSEPrivateKey', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/DeviceWriteSEPublicCert.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { WriteSEPublicCert } from '@onekeyfe/hd-transport';
+
+export default class DeviceWriteSEPublicCert extends BaseMethod<WriteSEPublicCert> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.params = {
+      public_cert: this.payload.public_cert,
+    };
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('WriteSEPublicCert', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/GetDeviceInfoSettings.ts

@@ -0,0 +1,20 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { GetDeviceInfo } from '@onekeyfe/hd-transport';
+
+export default class GetDeviceInfoSettings extends BaseMethod<GetDeviceInfo> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.skipForceUpdateCheck = true;
+
+    this.params = {};
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('GetDeviceInfo', 'DeviceInfo');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/GetPublicKeyMultiple.ts

@@ -0,0 +1,24 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { GetPublicKeyMultiple as HardwareGetPublicKeyMultiple } from '@onekeyfe/hd-transport';
+
+export default class GetPublicKeyMultiple extends BaseMethod<HardwareGetPublicKeyMultiple> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      addresses: this.payload.addresses,
+      ecdsa_curve_name: this.payload.ecdsa_curve_name,
+      show_display: this.payload.show_display,
+      coin_name: this.payload.coin_name,
+      script_type: this.payload.script_type,
+      ignore_xpub_magic: this.payload.ignore_xpub_magic,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('GetPublicKeyMultiple', 'PublicKeyMultiple');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/ListResDir.ts

@@ -0,0 +1,19 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { ListResDir as HardwareListResDir } from '@onekeyfe/hd-transport';
+
+export default class ListResDir extends BaseMethod<HardwareListResDir> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      path: this.payload.path,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('ListResDir', 'FileInfoList');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/NFTWriteData.ts

@@ -0,0 +1,21 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { NFTWriteData as HardwareNFTWriteData } from '@onekeyfe/hd-transport';
+
+export default class NFTWriteData extends BaseMethod<HardwareNFTWriteData> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      index: this.payload.index,
+      data: this.payload.data,
+      offset: this.payload.offset,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('NFTWriteData', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/NFTWriteInfo.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { NFTWriteInfo as HardwareNFTWriteInfo } from '@onekeyfe/hd-transport';
+
+export default class NFTWriteInfo extends BaseMethod<HardwareNFTWriteInfo> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      index: this.payload.index,
+      width: this.payload.width,
+      height: this.payload.height,
+      name_zh: this.payload.name_zh,
+      name_en: this.payload.name_en,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('NFTWriteInfo', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/ReadSEPublicKey.ts

@@ -0,0 +1,20 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { ReadSEPublicKey as HardwareReadSEPublicKey } from '@onekeyfe/hd-transport';
+
+export default class ReadSEPublicKey extends BaseMethod<HardwareReadSEPublicKey> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+
+    this.params = {};
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('ReadSEPublicKey', 'SEPublicKey');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/manager/ResourceUpdate.ts

@@ -0,0 +1,22 @@
+import { BaseMethod } from '../BaseMethod';
+import { updateResource } from '../firmware/uploadFirmware';
+
+export default class ResourceUpdate extends BaseMethod<any> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      name: this.payload.name,
+      data: this.payload.data,
+    };
+  }
+
+  async run() {
+    await updateResource(
+      this.device.commands.typedCall.bind(this.device.commands),
+      this.payload.name,
+      this.payload.data
+    );
+    return Promise.resolve(true);
+  }
+}