@onekeyfe/hd-core 0.0.1

package/src/api/BTCSignTransaction.ts

@@ -0,0 +1,141 @@
+import { TxInputType, TxOutputType } from '@onekeyfe/hd-transport/src/types/messages';
+
+import { UI_REQUEST } from '../constants/ui-request';
+import { getOutputScriptType, isSegwitPath, validatePath } from './helpers/pathUtils';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+import {
+  AccountAddresses,
+  BTCSignTransactionParams,
+  RefTransaction,
+  TransactionOptions,
+} from '../types/api/btcSignTransaction';
+import { ERRORS } from '../constants';
+import signtx from './helpers/btc/signtx';
+import signtxLegacy from './helpers/btc/signtxLegacy';
+import { getCoinInfo } from './helpers/btcParamsUtils';
+
+type Params = {
+  inputs: TxInputType[];
+  outputs: TxOutputType[];
+  refTxs: RefTransaction[];
+  addresses?: AccountAddresses;
+  options: TransactionOptions;
+  coinName: string;
+};
+export default class BTCSignTransaction extends BaseMethod<Params> {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'coin', type: 'string', required: true },
+      { name: 'inputs', type: 'array', required: true },
+      { name: 'outputs', type: 'array', required: true },
+      { name: 'refTxs', type: 'array', required: true, allowEmpty: true },
+      { name: 'locktime', type: 'number' },
+      { name: 'version', type: 'number' },
+      { name: 'expiry', type: 'number' },
+      { name: 'overwintered', type: 'boolean' },
+      { name: 'versionGroupId', type: 'number' },
+      { name: 'branchId', type: 'number' },
+      { name: 'timestamp', type: 'number' },
+    ]);
+
+    this.payload.refTxs.forEach((tx: RefTransaction) => {
+      validateParams(tx, [
+        { name: 'hash', type: 'hexString', required: true },
+        { name: 'inputs', type: 'array', required: true },
+        { name: 'bin_outputs', type: 'array', required: !Array.isArray(tx.outputs) },
+        { name: 'outputs', type: 'array' },
+        { name: 'version', type: 'number', required: true },
+        { name: 'lock_time', type: 'number', required: true },
+        { name: 'extra_data', type: 'string' },
+        { name: 'timestamp', type: 'number' },
+        { name: 'version_group_id', type: 'number' },
+      ]);
+    });
+
+    this.payload.inputs.forEach((input: any) => {
+      validatePath(input.address_n);
+      const useAmount = isSegwitPath(input.address_n);
+      validateParams(input, [
+        { name: 'prev_hash', type: 'hexString', required: true },
+        { name: 'prev_index', type: 'number', required: true },
+        { name: 'script_type', type: 'string' },
+        { name: 'amount', type: 'string', required: useAmount },
+        { name: 'sequence', type: 'number' },
+        { name: 'multisig', type: 'object' },
+      ]);
+    });
+
+    this.payload.outputs.forEach((output: any) => {
+      validateParams(output, [
+        { name: 'address_n', type: 'array' },
+        { name: 'address', type: 'string' },
+        { name: 'amount', type: 'string' },
+        { name: 'op_return_data', type: 'string' },
+        { name: 'multisig', type: 'object' },
+      ]);
+
+      if (
+        Object.prototype.hasOwnProperty.call(output, 'address_n') &&
+        Object.prototype.hasOwnProperty.call(output, 'address')
+      ) {
+        throw ERRORS.TypedError(
+          'Method_InvalidParameter',
+          'Cannot use address and address_n in one output'
+        );
+      }
+
+      if (output.address_n) {
+        const scriptType = getOutputScriptType(output.address_n);
+        if (output.script_type !== scriptType)
+          throw ERRORS.TypedError(
+            'Method_InvalidParameter',
+            `Output change script_type should be set to ${scriptType}`
+          );
+      }
+    });
+
+    const { inputs, outputs, refTxs, account, coin } = this.payload as BTCSignTransactionParams;
+
+    const coinName = getCoinInfo(undefined, coin).name;
+
+    this.params = {
+      inputs,
+      outputs,
+      refTxs,
+      addresses: account ? account.addresses : undefined,
+      options: {
+        lock_time: this.payload.locktime,
+        timestamp: this.payload.timestamp,
+        version: this.payload.version,
+        expiry: this.payload.expiry,
+        overwintered: this.payload.overwintered,
+        version_group_id: this.payload.versionGroupId,
+        branch_id: this.payload.branchId,
+      },
+      coinName,
+    };
+  }
+
+  async run() {
+    const { device, params } = this;
+
+    const useLegacySignProcess = device.unavailableCapabilities.replaceTransaction;
+
+    const { refTxs } = params;
+
+    const signTxMethod = !useLegacySignProcess ? signtx : signtxLegacy;
+    const response = await signTxMethod(
+      device.commands.typedCall.bind(device.commands),
+      params.inputs,
+      params.outputs,
+      refTxs,
+      params.options,
+      params.coinName
+    );
+
+    return response;
+  }
+}

package/src/api/BTCVerifyMessage.ts

@@ -0,0 +1,40 @@
+import { VerifyMessage } from '@onekeyfe/hd-transport/src/types/messages';
+import { UI_REQUEST } from '../constants/ui-request';
+
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+import { formatAnyHex } from './helpers/hexUtils';
+import { getCoinInfo } from './helpers/btcParamsUtils';
+
+export default class BTCVerifyMessage extends BaseMethod<VerifyMessage> {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'address', type: 'string', required: true },
+      { name: 'messageHex', type: 'hexString', required: true },
+      { name: 'signature', type: 'hexString', required: true },
+      { name: 'coin', type: 'string', required: true },
+    ]);
+
+    const { coin } = this.payload;
+    const { address, messageHex, signature } = formatAnyHex(this.payload);
+
+    const coinName = getCoinInfo(undefined, coin).name;
+
+    this.params = {
+      address,
+      message: messageHex,
+      signature,
+      coin_name: coinName,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('VerifyMessage', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/BaseMethod.ts

@@ -0,0 +1,71 @@
+import { UI_REQUEST } from '../constants/ui-request';
+import { Device } from '../device/Device';
+import DeviceConnector from '../device/DeviceConnector';
+
+export abstract class BaseMethod<Params = undefined> {
+  responseID: number;
+
+  // @ts-expect-error
+  device: Device;
+
+  // @ts-expect-error
+  params: Params;
+
+  /**
+   * USB: onekey_serial or serial_no
+   * iOS: uuid
+   * Android: MAC address
+   */
+  connectId?: string;
+
+  deviceState?: string;
+
+  /**
+   * method name
+   */
+  name: string;
+
+  /**
+   * 请求携带参数
+   */
+  payload: Record<string, any>;
+
+  connector?: DeviceConnector;
+
+  /**
+   * 是否需要使用设备
+   */
+  useDevice: boolean;
+
+  /**
+   * 许可的设备模式
+   */
+  allowDeviceMode: string[];
+
+  /**
+   * 依赖的设备模式
+   */
+  requireDeviceMode: string[];
+
+  constructor(message: { id?: number; payload: any }) {
+    const { payload } = message;
+    this.name = payload.method;
+    this.payload = payload;
+    this.responseID = message.id || 0;
+    this.connectId = payload.connectId || '';
+    this.useDevice = true;
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE];
+    this.requireDeviceMode = [];
+  }
+
+  abstract init(): void;
+
+  abstract run(): Promise<any>;
+
+  setDevice(device: Device) {
+    this.device = device;
+    this.connectId = device.originalDescriptor.path;
+  }
+
+  dispose() {}
+}

package/src/api/CheckBLEFirmwareRelease.ts

@@ -0,0 +1,18 @@
+import { BaseMethod } from './BaseMethod';
+
+import { UI_REQUEST } from '../constants/ui-request';
+import { DataManager } from '../data-manager';
+
+export default class CheckBLEFirmwareRelease extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+  }
+
+  run() {
+    if (this.device.features) {
+      const firmwareStatus = DataManager.getBLEFirmwareStatus(this.device.features);
+      return Promise.resolve(firmwareStatus);
+    }
+    return Promise.resolve(null);
+  }
+}

package/src/api/CheckFirmwareRelease.ts

@@ -0,0 +1,15 @@
+import { BaseMethod } from './BaseMethod';
+
+import { DataManager } from '../data-manager';
+
+export default class CheckFirmwareRelease extends BaseMethod {
+  init() {}
+
+  run() {
+    if (this.device.features) {
+      const firmwareStatus = DataManager.getFirmwareStatus(this.device.features);
+      return Promise.resolve(firmwareStatus);
+    }
+    return Promise.resolve(null);
+  }
+}

package/src/api/CheckTransportRelease.ts

@@ -0,0 +1,19 @@
+import { DataManager } from '../data-manager';
+import TransportManager from '../data-manager/TransportManager';
+
+import { BaseMethod } from './BaseMethod';
+
+export default class CheckTransportRelease extends BaseMethod {
+  init() {
+    this.useDevice = false;
+  }
+
+  async run() {
+    const transport = TransportManager.getTransport();
+    const localVersion = await transport.init();
+
+    const response = DataManager.getTransportStatus(localVersion);
+
+    return Promise.resolve(response);
+  }
+}

package/src/api/DeviceBackup.ts

@@ -0,0 +1,12 @@
+import { BackupDevice } from '@onekeyfe/hd-transport/src/types/messages';
+import { BaseMethod } from './BaseMethod';
+
+export default class DeviceBackup extends BaseMethod<BackupDevice> {
+  init() {}
+
+  async run() {
+    const res = await this.device.commands.typedCall('BackupDevice', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/DeviceChangePin.ts

@@ -0,0 +1,22 @@
+import { ChangePin } from '@onekeyfe/hd-transport/src/types/messages';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+
+export default class DeviceChangePin extends BaseMethod<ChangePin> {
+  init() {
+    // 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/DeviceFlags.ts

@@ -0,0 +1,23 @@
+import { ApplyFlags } from '@onekeyfe/hd-transport/src/types/messages';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+
+export default class DeviceFlags extends BaseMethod<ApplyFlags> {
+  init() {
+    // 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/DeviceRebootToBootloader.ts

@@ -0,0 +1,13 @@
+import { RebootToBootloader } from '@onekeyfe/hd-transport/src/types/messages';
+import { BaseMethod } from './BaseMethod';
+
+// Reboot BootLoader
+export default class DeviceRebootToBootloader extends BaseMethod<RebootToBootloader> {
+  init() {}
+
+  async run() {
+    const res = await this.device.commands.typedCall('RebootToBootloader', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/DeviceRecovery.ts

@@ -0,0 +1,41 @@
+import { RecoveryDevice } from '@onekeyfe/hd-transport/src/types/messages';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+
+export default class DeviceRecovery extends BaseMethod<RecoveryDevice> {
+  init() {
+    // 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/DeviceReset.ts

@@ -0,0 +1,43 @@
+import { ResetDevice } from '@onekeyfe/hd-transport/src/types/messages';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+
+export default class DeviceReset extends BaseMethod<ResetDevice> {
+  init() {
+    // 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/DeviceSettings.ts

@@ -0,0 +1,45 @@
+import { ApplySettings } from '@onekeyfe/hd-transport/src/types/messages';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+
+export default class DeviceSettings extends BaseMethod<ApplySettings> {
+  init() {
+    // 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: 'object' },
+      { name: 'experimentalFeatures', type: 'boolean' },
+    ]);
+
+    console.log('DeviceSettings payload', this.payload);
+
+    // 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,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('ApplySettings', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/DeviceUpdateReboot.ts

@@ -0,0 +1,13 @@
+import { BixinReboot } from '@onekeyfe/hd-transport/src/types/messages';
+import { BaseMethod } from './BaseMethod';
+
+// Upload hint Reboot BootLoader
+export default class DeviceUpdateReboot extends BaseMethod<BixinReboot> {
+  init() {}
+
+  async run() {
+    const res = await this.device.commands.typedCall('BixinReboot', 'Success');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/DeviceWipe.ts

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

package/src/api/EVMGetAddress.ts

@@ -0,0 +1,54 @@
+import { EthereumAddress, EthereumGetAddress } from '@onekeyfe/hd-transport/src/types/messages';
+import { UI_REQUEST } from '../constants/ui-request';
+import { validatePath } from './helpers/pathUtils';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+import { EVMGetAddressParams } from '../types/api/evmGetAddress';
+
+export default class EvmGetAddress extends BaseMethod<EthereumGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.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: EVMGetAddressParams) => {
+      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,
+      });
+    });
+  }
+
+  async run() {
+    const responses: EthereumAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('EthereumGetAddress', 'EthereumAddress', {
+        ...param,
+      });
+
+      responses.push(res.message);
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/EVMGetPublicKey.ts

@@ -0,0 +1,58 @@
+import { EthereumGetPublicKey, EthereumPublicKey } from '@onekeyfe/hd-transport/src/types/messages';
+import { UI_REQUEST } from '../constants/ui-request';
+import { validatePath } from './helpers/pathUtils';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+import { EVMGetPublicKeyParams } from '../types/api/evmGetPublicKey';
+
+export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKey[]> {
+  hasBundle = false;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.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: EVMGetPublicKeyParams) => {
+      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,
+      });
+    });
+  }
+
+  async run() {
+    const responses: EthereumPublicKey[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall(
+        'EthereumGetPublicKey',
+        'EthereumPublicKey',
+        {
+          ...param,
+        }
+      );
+
+      responses.push(res.message);
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}