@onetokenfe/hd-core 1.1.23

package/src/api/device/DeviceReset.ts

@@ -0,0 +1,46 @@
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { ResetDevice } from '@onetokenfe/hd-transport';
+
+export default class DeviceReset extends BaseMethod<ResetDevice> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'displayRandom', type: 'boolean' },
+      { name: 'strength', type: 'number' },
+      { name: 'passphraseProtection', type: 'boolean' },
+      { name: 'pinProtection', type: 'boolean' },
+      { name: 'language', type: 'string' },
+      { name: 'label', type: 'string' },
+      { name: 'u2fCounter', type: 'number' },
+      { name: 'skipBackup', type: 'boolean' },
+      { name: 'noBackup', type: 'boolean' },
+      { name: 'backupType' },
+    ]);
+
+    // init params
+    this.params = {
+      display_random: this.payload.displayRandom,
+      strength: this.payload.strength || 256,
+      passphrase_protection: this.payload.passphraseProtection,
+      pin_protection: this.payload.pinProtection,
+      language: this.payload.language,
+      label: this.payload.label,
+      u2f_counter: this.payload.u2fCounter || Math.floor(Date.now() / 1000),
+      skip_backup: this.payload.skipBackup,
+      no_backup: this.payload.noBackup,
+      backup_type: this.payload.backupType,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('ResetDevice', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceSettings.ts

@@ -0,0 +1,96 @@
+import { HardwareErrorCode, TypedError } from '@onetokenfe/hd-shared';
+
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { LANGUAGE_LABELS } from '../../utils/deviceSettings';
+
+import type { ApplySettings } from '@onetokenfe/hd-transport';
+
+export default class DeviceSettings extends BaseMethod<ApplySettings> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'language', type: 'string' },
+      { name: 'label', type: 'string' },
+      { name: 'usePassphrase', type: 'boolean' },
+      { name: 'homescreen', type: 'string' },
+      { name: 'passphraseSource', type: 'number' },
+      { name: 'autoLockDelayMs', type: 'number' },
+      { name: 'displayRotation', type: 'number' },
+      { name: 'passphraseAlwaysOnDevice', type: 'boolean' },
+      { name: 'safetyChecks', type: 'number' },
+      { name: 'experimentalFeatures', type: 'boolean' },
+      { name: 'autoShutdownDelayMs', type: 'number' },
+      { name: 'changeBrightness', type: 'boolean' },
+      { name: 'hapticFeedback', type: 'boolean' },
+    ]);
+
+    // init params
+    this.params = {
+      language: this.payload.language,
+      label: this.payload.label,
+      use_passphrase: this.payload.usePassphrase,
+      homescreen: this.payload.homescreen,
+      _passphrase_source: this.payload.passphraseSource,
+      auto_lock_delay_ms: this.payload.autoLockDelayMs,
+      display_rotation: this.payload.displayRotation,
+      passphrase_always_on_device: this.payload.passphraseAlwaysOnDevice,
+      safety_checks: this.payload.safetyChecks,
+      experimental_features: this.payload.experimentalFeatures,
+      auto_shutdown_delay_ms: this.payload.autoShutdownDelayMs,
+      ...(this.payload.changeBrightness
+        ? { change_brightness: this.payload.changeBrightness }
+        : undefined),
+      haptic_feedback: this.payload.hapticFeedback,
+    };
+  }
+
+  getVersionRange() {
+    if (this.payload.usePassphrase) {
+      return {
+        model_mini: {
+          min: '2.4.0',
+        },
+      };
+    }
+    return {};
+  }
+
+  async run() {
+    try {
+      const res = await this.device.commands.typedCall('ApplySettings', 'Success', {
+        ...this.params,
+      });
+      return res.message;
+    } catch (error) {
+      if (error.message?.toLowerCase().includes('no setting provided')) {
+        return Promise.reject(
+          TypedError(HardwareErrorCode.DeviceSettingsNotProvided, error.message)
+        );
+      }
+      if (error.message?.includes('all support ISO_639-1 language keys include')) {
+        const supportedLanguages: string[] = error.message
+          ?.replace('all support ISO_639-1 language keys include', '')
+          ?.trim()
+          ?.split(' ');
+
+        const errorMessage = supportedLanguages.reduce((acc, language) => {
+          const label = LANGUAGE_LABELS?.[language as keyof typeof LANGUAGE_LABELS];
+          if (label) {
+            acc.push(label);
+          }
+          return acc;
+        }, [] as string[]);
+
+        return Promise.reject(
+          TypedError(HardwareErrorCode.DeviceSettingsLanguageNotSupport, error.message, {
+            languages: errorMessage.join(', '),
+          })
+        );
+      }
+      throw error;
+    }
+  }
+}

package/src/api/device/DeviceSupportFeatures.ts

@@ -0,0 +1,29 @@
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import {
+  supportInputPinOnSoftware,
+  supportModifyHomescreen,
+} from '../../utils/deviceFeaturesUtils';
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceSupportFeatures extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  run() {
+    if (!this.device.features)
+      return Promise.reject(
+        ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device not initialized')
+      );
+
+    const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
+    const modifyHomescreen = supportModifyHomescreen(this.device.features);
+    return Promise.resolve({
+      inputPinOnSoftware,
+      modifyHomescreen,
+      device: this.device.toMessageObject(),
+    });
+  }
+}

package/src/api/device/DeviceUnlock.ts

@@ -0,0 +1,13 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { LockDevice } from '@onetokenfe/hd-transport';
+
+export default class DeviceUnlock extends BaseMethod<LockDevice> {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  async run() {
+    return this.device.unlockDevice();
+  }
+}

package/src/api/device/DeviceUpdateBootloader.ts

@@ -0,0 +1,111 @@
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+import { RebootType } from '@onetokenfe/hd-transport';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { FirmwareUpdateTipMessage } from '../../events/ui-request';
+import { FirmwareUpdateBaseMethod } from '../firmware/FirmwareUpdateBaseMethod';
+import { getSysResourceBinary } from '../firmware/getBinary';
+import { updateBootloader } from '../firmware/uploadFirmware';
+import { DeviceModelToTypes } from '../../types';
+import { DataManager } from '../../data-manager';
+import { checkBootloaderLength } from '../firmware/updateBootloader';
+import { getDeviceType, getFirmwareType } from '../../utils';
+
+import type { DeviceUpdateBootloaderParams } from '../../types/api/deviceUpdateBootloader';
+import type { EFirmwareType } from '@onetokenfe/hd-shared';
+import type { Device } from '../../device/Device';
+import type { Features } from '../../types';
+
+export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any> {
+  init() {
+    this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
+    this.requireDeviceMode = [];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async updateBootloaderWithEmmcFileWrite(_device: Device, binary: ArrayBuffer) {
+    const filePath = '0:boot/bootloader.bin';
+
+    this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
+
+    // Use the more robust emmcCommonUpdateProcess from FirmwareUpdateBaseMethod
+    await this.emmcCommonUpdateProcess({
+      payload: binary,
+      filePath,
+    });
+
+    this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
+
+    // Reboot to apply bootloader update using the inherited reboot method
+    await this.reboot(RebootType.Normal); // Normal reboot (RebootType.Normal = 0)
+
+    this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloaderSuccess);
+    return true;
+  }
+
+  async updateTouchBootloader({
+    device,
+    features,
+    firmwareType,
+  }: {
+    device: Device;
+    features?: Features;
+    firmwareType: EFirmwareType;
+  }) {
+    let { binary } = this.payload;
+    if (!binary) {
+      this.postTipMessage(FirmwareUpdateTipMessage.CheckLatestUiResource);
+      const resourceUrl = features
+        ? DataManager.getBootloaderResource(features, firmwareType)
+        : null;
+      if (resourceUrl) {
+        this.postTipMessage(FirmwareUpdateTipMessage.DownloadLatestBootloaderResource);
+        const resource = await getSysResourceBinary(resourceUrl);
+        this.postTipMessage(FirmwareUpdateTipMessage.DownloadLatestBootloaderResourceSuccess);
+        if (resource) {
+          binary = resource.binary;
+        }
+      }
+    }
+
+    if (!checkBootloaderLength(binary)) {
+      throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
+    }
+
+    // Check if device is in bootloader mode
+    if (features && features.bootloader_mode) {
+      // Use emmcFileWrite + reboot logic for bootloader mode
+      this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
+      return this.updateBootloaderWithEmmcFileWrite(device, binary);
+    }
+
+    if (features && !features.bootloader_mode) {
+      // Use original updateBootloader logic for normal mode
+      await updateBootloader(
+        this.device.getCommands().typedCall.bind(this.device.getCommands()),
+        this.postMessage,
+        device,
+        binary
+      );
+      return Promise.resolve(true);
+    }
+  }
+
+  async run() {
+    const { device } = this;
+    const { features } = device;
+
+    const payload = this.payload as DeviceUpdateBootloaderParams;
+
+    const deviceType = getDeviceType(features);
+    const deviceFirmwareType = getFirmwareType(features);
+    const firmwareType = payload.firmwareType ?? deviceFirmwareType;
+
+    if (DeviceModelToTypes.model_touch.includes(deviceType)) {
+      return this.updateTouchBootloader({ device, features, firmwareType });
+    }
+
+    return Promise.resolve(true);
+  }
+}

package/src/api/device/DeviceUpdateReboot.ts

@@ -0,0 +1,17 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DeviceBackToBoot } from '@onetokenfe/hd-transport';
+
+// Upload hint Reboot BootLoader
+export default class DeviceUpdateReboot extends BaseMethod<DeviceBackToBoot> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DeviceBackToBoot', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceUploadResource.ts

@@ -0,0 +1,204 @@
+import semver from 'semver';
+import { EDeviceType, ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+import { bytesToHex } from '@noble/hashes/utils';
+import { blake2s } from '@noble/hashes/blake2s';
+import { isEmpty } from 'lodash';
+
+import { DeviceModelToTypes } from '../../types';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { hexToBytes } from '../helpers/hexUtils';
+import { getDeviceFirmwareVersion, getDeviceType } from '../../utils';
+import { PROTO } from '../../constants';
+
+import type { DeviceUploadResourceParams, DeviceUploadResourceResponse } from '../../types';
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type { ResourceUpload } from '@onetokenfe/hd-transport';
+
+export default class DeviceUploadResource extends BaseMethod<ResourceUpload> {
+  paramsData = {
+    data: new Uint8Array(),
+    thumbnailData: new Uint8Array(),
+    blurData: new Uint8Array(),
+  };
+
+  private uploadProgress = {
+    totalBytes: 0,
+    uploadedBytes: 0,
+    currentFile: 'main' as 'main' | 'thumbnail' | 'blur',
+  };
+
+  getVersionRange() {
+    return {
+      model_touch: {
+        min: '3.2.0',
+      },
+    };
+  }
+
+  checkUploadNFTSupport() {
+    const deviceType = getDeviceType(this.device.features);
+    const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+    if (!DeviceModelToTypes.model_touch.includes(deviceType)) {
+      throw ERRORS.TypedError(HardwareErrorCode.CallMethodError, 'Device Not Support Upload NFT');
+    }
+
+    if (semver.lt(currentVersion, '4.1.0')) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodNeedUpgradeFirmware,
+        `Device firmware version is too low, please update to 4.1.0`,
+        { current: currentVersion, require: '4.1.0' }
+      );
+    }
+  }
+
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'suffix', type: 'string', required: true },
+      { name: 'dataHex', type: 'string', required: true },
+      { name: 'thumbnailDataHex', type: 'string', required: true },
+      { name: 'blurDataHex', type: 'hexString', required: true },
+      { name: 'resType', type: 'number', required: true },
+      { name: 'nftMetaData', type: 'string' },
+      { name: 'fileNameNoExt', type: 'string' },
+    ]);
+
+    const { suffix, dataHex, thumbnailDataHex, blurDataHex, resType, nftMetaData } = this
+      .payload as DeviceUploadResourceParams;
+
+    // init params
+    this.paramsData = {
+      data: new Uint8Array(hexToBytes(dataHex)),
+      thumbnailData: new Uint8Array(hexToBytes(thumbnailDataHex)),
+      blurData: new Uint8Array(hexToBytes(blurDataHex)),
+    };
+
+    this.uploadProgress.totalBytes =
+      this.paramsData.data.byteLength +
+      this.paramsData.thumbnailData.byteLength +
+      this.paramsData.blurData.byteLength;
+    this.uploadProgress.uploadedBytes = 0;
+
+    const fileHash = bytesToHex(blake2s(this.payload.dataHex)).slice(0, 8);
+    const file_name_no_ext = isEmpty(this.payload.fileNameNoExt)
+      ? `${resType === 0 ? 'wp' : 'nft'}-${fileHash}-${Math.floor(Date.now() / 1000)}`
+      : this.payload.fileNameNoExt;
+
+    this.params = {
+      extension: suffix,
+      data_length: this.paramsData.data.byteLength,
+      zoom_data_length: this.paramsData.thumbnailData.byteLength,
+      blur_data_length: this.paramsData.blurData.byteLength,
+      res_type: resType,
+      nft_meta_data: nftMetaData,
+      file_name_no_ext,
+    };
+  }
+
+  private getDataChunk(sourceData: Uint8Array, offset: number, length: number): Uint8Array {
+    const endOffset = Math.min(offset + length, sourceData.byteLength);
+
+    return sourceData.subarray(offset, endOffset);
+  }
+
+  private updateProgress(chunkSize: number, requestType: string) {
+    this.uploadProgress.uploadedBytes += chunkSize;
+
+    if (requestType === 'ResourceRequest') {
+      this.uploadProgress.currentFile = 'main';
+    } else if (requestType === 'ZoomRequest') {
+      this.uploadProgress.currentFile = 'thumbnail';
+    } else {
+      this.uploadProgress.currentFile = 'blur';
+    }
+
+    const progress = Math.round(
+      (this.uploadProgress.uploadedBytes / this.uploadProgress.totalBytes) * 100
+    );
+
+    if (process.env.NODE_ENV === 'development') {
+      console.log(`Upload progress: ${progress}% (${this.uploadProgress.currentFile})`);
+    }
+  }
+
+  processResourceRequest = async (
+    res:
+      | TypedResponseMessage<'ResourceRequest'>
+      | TypedResponseMessage<'ZoomRequest'>
+      | TypedResponseMessage<'BlurRequest'>
+      | TypedResponseMessage<'Success'>
+  ): Promise<DeviceUploadResourceResponse> => {
+    if (res.type === 'Success') {
+      const response: DeviceUploadResourceResponse = {
+        message: res.message.message,
+      };
+      response.applyScreen = true;
+
+      const firmwareVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+      const deviceType = getDeviceType(this.device.features);
+      if (deviceType === EDeviceType.Pro && semver.gte(firmwareVersion, '4.17.0')) {
+        response.applyScreen = false;
+      }
+
+      return response;
+    }
+
+    const { offset, data_length } = res.message;
+    const { data, thumbnailData, blurData } = this.paramsData;
+
+    if (offset === undefined) {
+      throw new Error('offset is undefined');
+    }
+
+    let sourceData: Uint8Array;
+
+    switch (res.type) {
+      case 'ResourceRequest':
+        sourceData = data;
+        break;
+      case 'BlurRequest':
+        sourceData = blurData;
+        break;
+      case 'ZoomRequest':
+        sourceData = thumbnailData;
+        break;
+      default:
+        throw new Error('Invalid request type');
+    }
+
+    const payload = this.getDataChunk(sourceData, offset, data_length);
+    const digest = blake2s(payload);
+
+    this.updateProgress(payload.byteLength, res.type);
+
+    const resourceAckParams = {
+      data_chunk: bytesToHex(payload),
+      hash: bytesToHex(digest),
+    };
+
+    const response = await this.device.commands.typedCall(
+      'ResourceAck',
+      ['ResourceRequest', 'ZoomRequest', 'BlurRequest', 'Success'],
+      resourceAckParams
+    );
+    return this.processResourceRequest(response);
+  };
+
+  async run() {
+    if (this.payload.resType === PROTO.ResourceType.Nft) {
+      this.checkUploadNFTSupport();
+    }
+
+    const res = await this.device.commands.typedCall(
+      'ResourceUpload',
+      ['ResourceRequest', 'ZoomRequest', 'BlurRequest', 'Success'],
+      this.params
+    );
+
+    return this.processResourceRequest(res);
+  }
+}

package/src/api/device/DeviceVerify.ts

@@ -0,0 +1,65 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+import { bytesToHex } from '@noble/hashes/utils';
+
+import { formatAnyHex } from '../helpers/hexUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { getDeviceType } from '../../utils';
+import { DeviceModelToTypes } from '../../types';
+
+import type { BixinVerifyDeviceRequest } from '@onetokenfe/hd-transport';
+import type { DeviceVerifySignature } from '../../types';
+
+export default class DeviceVerify extends BaseMethod<BixinVerifyDeviceRequest> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    // check payload
+    validateParams(this.payload, [{ name: 'dataHex', type: 'hexString' }]);
+
+    // init params
+    this.params = {
+      data: formatAnyHex(this.payload.dataHex),
+    };
+  }
+
+  async run() {
+    // For Classic、Mini device we use EthereumSignTypedData
+    const deviceType = getDeviceType(this.device.features);
+    let response: DeviceVerifySignature | undefined;
+
+    if (DeviceModelToTypes.model_classic.includes(deviceType)) {
+      const res = await this.device.commands.typedCall(
+        'BixinVerifyDeviceRequest',
+        'BixinVerifyDeviceAck',
+        {
+          ...this.params,
+          data: bytesToHex(sha256(this.params.data)),
+        }
+      );
+      response = res.message;
+    } else {
+      const signatureRes = await this.device.commands.typedCall(
+        'SESignMessage',
+        'SEMessageSignature',
+        {
+          message: this.params.data,
+        }
+      );
+      const certRes = await this.device.commands.typedCall('ReadSEPublicCert', 'SEPublicCert');
+      response = {
+        cert: certRes.message.public_cert,
+        signature: signatureRes.message.signature,
+      };
+    }
+
+    validateResult(response, ['cert', 'signature']);
+
+    if (response) return Promise.resolve(response);
+
+    return Promise.reject(
+      ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device not support verify')
+    );
+  }
+}

package/src/api/device/DeviceWipe.ts

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

package/src/api/dynex/DnxGetAddress.ts

@@ -0,0 +1,75 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+
+import type { DnxGetAddress as HardwareDnxGetAddress } from '@onetokenfe/hd-transport';
+import type { DnxAddress, DnxGetAddressParams } from '../../types';
+
+export default class DnxGetAddress extends BaseMethod<HardwareDnxGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: DnxGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      classic: {
+        min: '3.8.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: DnxAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('DnxGetAddress', 'DnxAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        address,
+      };
+      responses.push(result);
+      this.postPreviousAddressMessage(result);
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}