@ukeyfe/hardware-core 1.1.13

package/src/api/device/DeviceSettings.ts

@@ -0,0 +1,56 @@
+import { ApplySettings } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+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' },
+    ]);
+
+    // 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,
+    };
+  }
+
+  getVersionRange() {
+    if (this.payload.usePassphrase) {
+      return {
+        model_mini: {
+          min: '2.4.0',
+        },
+      };
+    }
+    return {};
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('ApplySettings', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceSupportFeatures.ts

@@ -0,0 +1,28 @@
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-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,12 @@
+import { LockDevice } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+
+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,78 @@
+import { Deferred, ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BaseMethod } from '../BaseMethod';
+import { getSysResourceBinary } from '../firmware/getBinary';
+import { updateBootloader } from '../firmware/uploadFirmware';
+import { createUiMessage } from '../../events/ui-request';
+import { DeviceModelToTypes } from '../../types';
+import { DataManager } from '../../data-manager';
+import { checkBootloaderLength, checkNeedUpdateBootForTouch } from '../firmware/updateBootloader';
+import { getDeviceType } from '../../utils';
+
+import type { Device } from '../../device/Device';
+import type { Features, KnownDevice } from '../../types';
+
+export default class DeviceUpdateBootloader extends BaseMethod {
+  checkPromise: Deferred<any> | null = null;
+
+  init() {
+    this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
+    this.requireDeviceMode = [];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  postTipMessage = (message: string) => {
+    this.postMessage(
+      createUiMessage(UI_REQUEST.FIRMWARE_TIP, {
+        device: this.device.toMessageObject() as KnownDevice,
+        data: {
+          message,
+        },
+      })
+    );
+  };
+
+  async updateTouchBootloader(device: Device, features?: Features) {
+    if (features && !features.bootloader_mode) {
+      let { binary } = this.payload;
+      if (!binary) {
+        this.postTipMessage('CheckLatestUiResource');
+        const resourceUrl = DataManager.getBootloaderResource(features);
+        if (resourceUrl) {
+          this.postTipMessage('DownloadLatestBootloaderResource');
+          const resource = await getSysResourceBinary(resourceUrl);
+          this.postTipMessage('DownloadLatestBootloaderResourceSuccess');
+          if (resource) {
+            binary = resource.binary;
+          }
+        }
+      }
+
+      if (!checkBootloaderLength(binary)) {
+        throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
+      }
+      await updateBootloader(
+        this.device.getCommands().typedCall.bind(this.device.getCommands()),
+        this.postMessage,
+        device,
+        binary
+      );
+      return Promise.resolve(true);
+    }
+
+    return Promise.resolve(true);
+  }
+
+  async run() {
+    const { device } = this;
+    const { features } = device;
+
+    const deviceType = getDeviceType(features);
+    if (DeviceModelToTypes.model_touch.includes(deviceType)) {
+      return this.updateTouchBootloader(device, features);
+    }
+
+    return Promise.resolve(true);
+  }
+}

package/src/api/device/DeviceUpdateReboot.ts

@@ -0,0 +1,16 @@
+import { DeviceBackToBoot } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+
+// 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,140 @@
+import semver from 'semver';
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { bytesToHex } from '@noble/hashes/utils';
+import { ResourceUpload, Success } from '@ukeyfe/hardware-transport';
+import { blake2s } from '@noble/hashes/blake2s';
+import { isEmpty } from 'lodash';
+import { TypedResponseMessage } from '../../device/DeviceCommands';
+import { DeviceModelToTypes, DeviceUploadResourceParams } from '../../types';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { hexToBytes } from '../helpers/hexUtils';
+import { createUiMessage, UI_REQUEST } from '../../events';
+import { getDeviceType, getDeviceFirmwareVersion } from '../../utils';
+import { PROTO } from '../../constants';
+
+export default class DeviceUploadResource extends BaseMethod<ResourceUpload> {
+  paramsData = {
+    data: new Uint8Array(),
+    thumbnailData: new Uint8Array(),
+  };
+
+  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: 'resType', type: 'number', required: true },
+      { name: 'nftMetaData', type: 'string' },
+      { name: 'fileNameNoExt', type: 'string' },
+    ]);
+
+    const { suffix, dataHex, thumbnailDataHex, resType, nftMetaData } = this
+      .payload as DeviceUploadResourceParams;
+
+    // init params
+    this.paramsData = {
+      data: hexToBytes(dataHex),
+      thumbnailData: hexToBytes(thumbnailDataHex),
+    };
+
+    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,
+      res_type: resType,
+      nft_meta_data: nftMetaData,
+      file_name_no_ext,
+    };
+  }
+
+  processResourceRequest = async (
+    res:
+      | TypedResponseMessage<'ResourceRequest'>
+      | TypedResponseMessage<'ZoomRequest'>
+      | TypedResponseMessage<'Success'>
+  ): Promise<Success> => {
+    if (res.type === 'Success') {
+      return res.message;
+    }
+
+    const { offset, data_length } = res.message;
+    const { data, thumbnailData } = this.paramsData;
+
+    if (offset === undefined) {
+      throw new Error('offset is undefined');
+    }
+
+    let payload: Uint8Array;
+    if (res.type === 'ResourceRequest') {
+      payload = new Uint8Array(data.slice(offset, Math.min(offset + data_length, data.byteLength)));
+    } else {
+      payload = new Uint8Array(
+        thumbnailData.slice(offset, Math.min(offset + data_length, thumbnailData.byteLength))
+      );
+    }
+
+    const digest = blake2s(payload);
+
+    const resourceAckParams = {
+      data_chunk: bytesToHex(payload),
+      hash: bytesToHex(digest),
+    };
+
+    const response = await this.device.commands.typedCall(
+      'ResourceAck',
+      ['ResourceRequest', 'ZoomRequest', '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', 'Success'],
+      this.params
+    );
+
+    this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW));
+
+    return this.processResourceRequest(res);
+  }
+}

package/src/api/device/DeviceVerify.ts

@@ -0,0 +1,63 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { BixinVerifyDeviceRequest } from '@ukeyfe/hardware-transport';
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-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 { 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,14 @@
+import { WipeDevice } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+
+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 type { DnxGetAddress as HardwareDnxGetAddress } from '@ukeyfe/hardware-transport';
+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 { DnxGetAddressParams, DnxAddress } 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: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  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]);
+  }
+}

package/src/api/dynex/DnxSignTransaction.ts

@@ -0,0 +1,126 @@
+import type { DnxSignTx, TypedCall } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { DnxSignature } from '../../types';
+import { TypedResponseMessage } from '../../device/DeviceCommands';
+import { stripHexPrefix } from '../helpers/hexUtils';
+
+export default class DnxSignTransaction extends BaseMethod<DnxSignTx> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { payload } = this;
+    // init params
+    const addressN = validatePath(payload.path, 3);
+
+    validateParams(payload, [
+      { name: 'path', required: true },
+      { name: 'inputs', type: 'array', required: true },
+      { name: 'toAddress', type: 'string', required: true },
+      { name: 'amount', required: true },
+      { name: 'fee', required: true },
+      { name: 'paymentIdHex', type: 'string' },
+    ]);
+
+    if (payload.paymentIdHex && stripHexPrefix(payload.paymentIdHex).length !== 64) {
+      throw new Error('Payment ID must be 32 bytes long');
+    }
+
+    this.params = {
+      address_n: addressN,
+      inputs_count: payload.inputs.length,
+      to_address: payload.toAddress,
+      amount: payload.amount,
+      fee: payload.fee,
+    };
+    if (payload.paymentIdHex) {
+      this.params.payment_id = stripHexPrefix(payload.paymentIdHex);
+    }
+  }
+
+  getVersionRange() {
+    return {
+      classic: {
+        min: '3.8.0',
+      },
+    };
+  }
+
+  async processTxRequest(
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'DnxInputRequest'>,
+    signature: Partial<DnxSignature>
+  ): Promise<DnxSignature> {
+    if (res.type === 'DnxInputRequest') {
+      const { inputs } = this.payload;
+      const { request_index, tx_key, computed_key_image } = res.message;
+
+      if (tx_key?.ephemeral_tx_sec_key && tx_key?.ephemeral_tx_pub_key) {
+        signature = {
+          ...signature,
+          txKey: {
+            ephemeralTxSecKey: tx_key.ephemeral_tx_sec_key,
+            ephemeralTxPubKey: tx_key.ephemeral_tx_pub_key,
+          },
+        };
+      }
+
+      if (computed_key_image?.key_image) {
+        signature = {
+          ...signature,
+          computedKeyImages: [...(signature.computedKeyImages ?? []), computed_key_image.key_image],
+        };
+      }
+
+      if (request_index) {
+        const input = inputs[request_index - 1];
+
+        const signRes = await typedCall('DnxInputAck', 'DnxInputRequest', {
+          prev_index: input.prevIndex,
+          global_index: input.globalIndex,
+          tx_pubkey: input.txPubkey,
+          prev_out_pubkey: input.prevOutPubkey,
+          amount: input.amount,
+        });
+
+        return this.processTxRequest(typedCall, signRes, signature);
+      }
+
+      const signRes = await typedCall('DnxRTSigsRequest', 'DnxSignedTx', {});
+
+      if (
+        signature.txKey == null ||
+        signature.txKey.ephemeralTxSecKey == null ||
+        signature.txKey.ephemeralTxPubKey == null
+      ) {
+        throw new Error('signatures or tx_key missing in response');
+      }
+
+      return {
+        path: serializedPath(this.params.address_n),
+        txKey: signature.txKey,
+        computedKeyImages: signature.computedKeyImages ?? [],
+        signatures: signRes.message.signatures,
+        outputKeys: signRes.message.output_keys,
+      };
+    }
+
+    throw new Error('Unexpected response');
+  }
+
+  async run() {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+
+    const res = await this.device.commands.typedCall('DnxSignTx', 'DnxInputRequest', {
+      ...this.params,
+    });
+
+    return this.processTxRequest(typedCall, res, {});
+  }
+}