@ukeyfe/hardware-core 1.1.13

package/src/api/conflux/ConfluxSignTransaction.ts

@@ -0,0 +1,134 @@
+import { ConfluxSignTx, ConfluxTxRequest } from '@ukeyfe/hardware-transport';
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import {
+  ConfluxSignedTx,
+  ConfluxSignTransactionParams,
+  ConfluxTransaction,
+} from '../../types/api/confluxSignTransaction';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { SchemaParam, validateParams } from '../helpers/paramsValidator';
+
+import { cutString } from '../helpers/stringUtils';
+import { formatAnyHex, stripHexStartZeroes } from '../helpers/hexUtils';
+
+export default class ConfluxSignTransaction extends BaseMethod {
+  addressN: number[] = [];
+
+  formattedTx: ConfluxTransaction | undefined;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'transaction', type: 'object', required: true },
+    ]);
+    const { path, transaction } = this.payload;
+    this.addressN = validatePath(path, 3);
+
+    const tx: ConfluxSignTransactionParams['transaction'] = transaction;
+
+    // check if transaction is valid
+    const schema: SchemaParam[] = [
+      { name: 'to', type: 'hexString', required: true },
+      { name: 'value', type: 'hexString', required: true },
+      { name: 'gasLimit', type: 'hexString', required: true },
+      { name: 'gasPrice', type: 'hexString', required: true },
+      { name: 'nonce', type: 'hexString', required: true },
+      { name: 'epochHeight', type: 'hexString', required: true },
+      { name: 'storageLimit', type: 'hexString', required: true },
+      { name: 'chainId', type: 'number', required: true },
+      { name: 'data', type: 'hexString' },
+    ];
+
+    validateParams(tx, schema);
+
+    this.formattedTx = formatAnyHex(tx);
+  }
+
+  processTxRequest = async (request: ConfluxTxRequest, data: string): Promise<ConfluxSignedTx> => {
+    if (!request.data_length) {
+      const v = request.signature_v;
+      const r = request.signature_r;
+      const s = request.signature_s;
+
+      if (v == null || r == null || s == null) {
+        throw ERRORS.TypedError(HardwareErrorCode.CallMethodError, 'sign transaction failed');
+      }
+
+      return Promise.resolve({
+        v: `0x${v.toString(16)}`,
+        r: `0x${r}`,
+        s: `0x${s}`,
+      });
+    }
+
+    const [first, rest] = cutString(data, request.data_length * 2);
+    const response = await this.device.commands.typedCall('ConfluxTxAck', 'ConfluxTxRequest', {
+      data_chunk: first,
+    });
+
+    return this.processTxRequest(response.message, rest);
+  };
+
+  evmSignTx = async (addressN: number[], tx: ConfluxTransaction) => {
+    const { to, value, gasPrice, gasLimit, nonce, data, chainId, epochHeight, storageLimit } = tx;
+
+    const length = data == null ? 0 : data.length / 2;
+
+    const [first, rest] = cutString(data, 1024 * 2);
+
+    let message: ConfluxSignTx = {
+      address_n: addressN,
+      nonce: stripHexStartZeroes(nonce),
+      gas_price: stripHexStartZeroes(gasPrice),
+      gas_limit: stripHexStartZeroes(gasLimit),
+      to,
+      value: stripHexStartZeroes(value),
+      epoch_height: stripHexStartZeroes(epochHeight),
+      storage_limit: stripHexStartZeroes(storageLimit),
+      chain_id: chainId,
+    };
+
+    if (length !== 0) {
+      message = {
+        ...message,
+        data_length: length,
+        data_initial_chunk: first,
+      };
+    }
+
+    const response = await this.device.commands.typedCall(
+      'ConfluxSignTx',
+      'ConfluxTxRequest',
+      message
+    );
+
+    return this.processTxRequest(response.message, rest);
+  };
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const { addressN, formattedTx } = this;
+    if (formattedTx == null) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'ConfluxSignTransaction: format tx error'
+      );
+    }
+
+    const signedTx = await this.evmSignTx(addressN, formattedTx);
+
+    return Promise.resolve(signedTx);
+  }
+}

package/src/api/cosmos/CosmosGetAddress.ts

@@ -0,0 +1,80 @@
+import { CosmosGetAddress as HardwareCosmosGetAddress } from '@ukeyfe/hardware-transport';
+
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { CosmosAddress, CosmosGetAddressParams } from '../../types';
+
+export default class CosmosGetAddress extends BaseMethod<HardwareCosmosGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode];
+
+    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: CosmosGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'hrp', type: 'string' },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+      const { hrp } = batch;
+
+      this.params.push({
+        address_n: addressN,
+        hrp,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.10.0',
+      },
+      model_touch: {
+        min: '4.0.0',
+      },
+    };
+  }
+
+  async run() {
+    // TODO: add batch support
+    const responses: CosmosAddress[] = [];
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('CosmosGetAddress', 'CosmosAddress', {
+        ...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/cosmos/CosmosGetPublicKey.ts

@@ -0,0 +1,76 @@
+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 { CosmosAddress, CosmosGetPublicKeyParams } from '../../types';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+
+export default class CosmosGetPublicKey extends BaseMethod<any> {
+  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' }]);
+
+    if (payload.bundle.length === 0) {
+      throw new Error('Bundle is empty');
+    }
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: CosmosGetPublicKeyParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'curve', type: 'string' },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+      const curveName = batch.curve ?? 'secp256k1';
+
+      if (curveName !== 'secp256k1') {
+        throw new Error('Curve name is not supported');
+      }
+
+      this.params.push({
+        address_n: addressN,
+        curve: curveName,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.10.0',
+      },
+      model_touch: {
+        min: '4.0.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await batchGetPublickeys(this.device, this.params, this.params[0].curve, 118);
+    const responses: CosmosAddress[] = res.public_keys.map((publicKey: string, index: number) => ({
+      path: serializedPath((this.params as unknown as any[])[index].address_n),
+      pub: publicKey,
+      publicKey,
+    }));
+
+    validateResult(responses, ['pub'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/cosmos/CosmosSignTransaction.ts

@@ -0,0 +1,54 @@
+import { CosmosSignTx as HardwareCosmosSignTx } from '@ukeyfe/hardware-transport';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { CosmosSignTransactionParams } from '../../types';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class CosmosSignTransaction extends BaseMethod<HardwareCosmosSignTx> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+    ]);
+
+    // init params
+    const { path, rawTx } = this.payload as CosmosSignTransactionParams;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.10.0',
+      },
+      model_touch: {
+        min: '4.0.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('CosmosSignTx', 'CosmosSignedTx', {
+      ...this.params,
+    });
+
+    const { signature } = res.message;
+
+    return {
+      path: serializedPath(this.params.address_n),
+      signature,
+    };
+  }
+}

package/src/api/device/DeviceBackup.ts

@@ -0,0 +1,14 @@
+import { BackupDevice } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceBackup extends BaseMethod<BackupDevice> {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('BackupDevice', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceCancel.ts

@@ -0,0 +1,14 @@
+import { Cancel } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceCancel extends BaseMethod<Cancel> {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('Cancel', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceChangePin.ts

@@ -0,0 +1,24 @@
+import { ChangePin } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+export default class DeviceChangePin extends BaseMethod<ChangePin> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    // check payload
+    validateParams(this.payload, [{ name: 'remove', type: 'boolean' }]);
+
+    this.params = {
+      remove: this.payload.remove,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('ChangePin', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceFlags.ts

@@ -0,0 +1,25 @@
+import { ApplyFlags } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+export default class DeviceFlags extends BaseMethod<ApplyFlags> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    // check payload
+    validateParams(this.payload, [{ name: 'flags', type: 'number' }]);
+
+    // init params
+    this.params = {
+      flags: this.payload.flags,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('ApplyFlags', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceFullyUploadResource.ts

@@ -0,0 +1,71 @@
+import { Deferred, EDeviceType } from '@ukeyfe/hardware-shared';
+import semver from 'semver';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BaseMethod } from '../BaseMethod';
+import { getSysResourceBinary } from '../firmware/getBinary';
+import { updateResources } from '../firmware/uploadFirmware';
+import { getDeviceType, getDeviceFirmwareVersion } from '../../utils';
+import { createUiMessage } from '../../events/ui-request';
+import type { KnownDevice, Features } from '../../types';
+import { DataManager } from '../../data-manager';
+
+export default class DeviceFullyUploadResource extends BaseMethod {
+  checkPromise: Deferred<any> | null = null;
+
+  init() {
+    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,
+        },
+      })
+    );
+  };
+
+  isSupportResourceUpdate(features: Features, updateType: string) {
+    if (updateType !== 'firmware') return false;
+
+    const deviceType = getDeviceType(features);
+    const isTouchMode = deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro;
+    const currentVersion = getDeviceFirmwareVersion(features).join('.');
+
+    return isTouchMode && semver.gte(currentVersion, '3.4.0');
+  }
+
+  async run() {
+    const { device } = this;
+    const { features } = device;
+
+    if (!features?.bootloader_mode && features) {
+      // check & upgrade firmware resource
+      if (features) {
+        let { binary } = this.payload;
+        if (!binary) {
+          this.postTipMessage('CheckLatestUiResource');
+          const resourceUrl = DataManager.getSysFullResource(features);
+          if (resourceUrl) {
+            this.postTipMessage('DownloadLatestUiResource');
+            const resource = await getSysResourceBinary(resourceUrl);
+            this.postTipMessage('DownloadLatestUiResourceSuccess');
+            if (resource) {
+              binary = resource.binary;
+            }
+          }
+        }
+        await updateResources(
+          this.device.getCommands().typedCall.bind(this.device.getCommands()),
+          this.postMessage,
+          device,
+          binary
+        );
+      }
+    }
+  }
+}

package/src/api/device/DeviceLock.ts

@@ -0,0 +1,14 @@
+import { LockDevice } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceLock extends BaseMethod<LockDevice> {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('LockDevice', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceRebootToBoardloader.ts

@@ -0,0 +1,29 @@
+import { BaseMethod } from '../BaseMethod';
+import type { RebootToBoardloaderParams } from '../../types/api/deviceRebootToBoardloader';
+
+// Reboot BoardLoader
+export default class DeviceRebootToBoardloader extends BaseMethod<RebootToBoardloaderParams> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  getVersionRange() {
+    return {
+      classic: {
+        min: '2.1.11',
+      },
+      mini: {
+        min: '2.1.11',
+      },
+    };
+  }
+
+  async run() {
+    // On Touch devices, messsage code 904 is RebootToBoardloader
+    // so BininOutMessageSE message code 904 is used here
+    const res = await this.device.commands.typedCall('BixinOutMessageSE', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceRebootToBootloader.ts

@@ -0,0 +1,27 @@
+import { RebootToBootloader } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+
+// Reboot BootLoader
+export default class DeviceRebootToBootloader extends BaseMethod<RebootToBootloader> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  getVersionRange() {
+    return {
+      classic: {
+        min: '2.1.11',
+      },
+      mini: {
+        min: '2.1.11',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('RebootToBootloader', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceRecovery.ts

@@ -0,0 +1,43 @@
+import { RecoveryDevice } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+export default class DeviceRecovery extends BaseMethod<RecoveryDevice> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'wordCount', type: 'number' },
+      { name: 'passphraseProtection', type: 'boolean' },
+      { name: 'pinProtection', type: 'boolean' },
+      { name: 'language', type: 'string' },
+      { name: 'label', type: 'string' },
+      { name: 'enforceWordlist', type: 'boolean' },
+      { name: 'type', type: 'object' },
+      { name: 'u2fCounter', type: 'number' },
+      { name: 'dryRun', type: 'boolean' },
+    ]);
+
+    // init params
+    this.params = {
+      word_count: this.payload.wordCount,
+      passphrase_protection: this.payload.passphraseProtection,
+      pin_protection: this.payload.pinProtection,
+      language: this.payload.language,
+      label: this.payload.label,
+      enforce_wordlist: this.payload.enforceWordlist,
+      type: this.payload.type,
+      u2f_counter: this.payload.u2fCounter || Math.floor(Date.now() / 1000),
+      dry_run: this.payload.dryRun,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('RecoveryDevice', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceReset.ts

@@ -0,0 +1,45 @@
+import { ResetDevice } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+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);
+  }
+}