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

package/src/api/emmc/EmmcFileRead.ts

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

package/src/api/emmc/EmmcFileWrite.ts

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

package/src/api/emmc/EmmcFixPermission.ts

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

package/src/api/emmc/EmmcPathInfo.ts

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

package/src/api/eos/EosGetPublicKey.ts

@@ -0,0 +1,26 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+
+import type { EosGetPublicKey as HardwareEosGetPublicKey } from '@onekeyfe/hd-transport';
+
+export default class EosGetPublicKey extends BaseMethod<HardwareEosGetPublicKey> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // init params
+    this.params = {
+      address_n: validatePath(this.payload.path, 3),
+      show_display: this.payload.showOnOneKey ?? true,
+    };
+  }
+
+  async run() {
+    return this.device.commands.typedCall('EosGetPublicKey', 'EosPublicKey', {
+      ...this.params,
+    });
+  }
+}

package/src/api/eos/EosSignTx.ts

@@ -0,0 +1,40 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+
+import type { EosSignTx as HardwareEosSignTx } from '@onekeyfe/hd-transport';
+
+export default class EosSignTx extends BaseMethod<HardwareEosSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { path } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      chain_id: this.payload.chain_id,
+      header: this.payload.header,
+      num_actions: this.payload.num_actions,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.5.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('EosSignTx', 'EosTxActionRequest', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/evmTrezor/EVMGetAddress.ts

@@ -0,0 +1,75 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import getAddressLegacyV1 from './legacyV1/getAddress';
+
+import type { EVMAddress, EVMGetAddressParams } from '../../types';
+import type { EthereumGetAddressOneKey } from '@onekeyfe/hd-transport';
+
+export default class EvmGetAddress extends BaseMethod<EthereumGetAddressOneKey[]> {
+  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: EVMGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'chainId', type: 'number' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        chain_id: batch.chainId,
+      });
+    });
+  }
+
+  async getEvmAddress(param: EthereumGetAddressOneKey) {
+    return getAddressLegacyV1({
+      typedCall: this.device.commands.typedCall.bind(this.device.commands),
+      param,
+    });
+  }
+
+  async run() {
+    const responses: EVMAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.getEvmAddress(param);
+
+      const { address } = res.message;
+
+      if (!address) {
+        throw new Error('EthereumGetAddress: address is undefined');
+      }
+
+      const result = {
+        path: serializedPath(param.address_n),
+        address,
+      };
+      responses.push(result);
+      this.postPreviousAddressMessage(result);
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/evmTrezor/EVMGetPublicKey.ts

@@ -0,0 +1,106 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { batchGetPublickeys, supportBatchPublicKeyByDevice } from '../helpers/batchGetPublickeys';
+import getPublicKeyLegacyV1 from './legacyV1/getPublicKey';
+
+import type { EVMGetPublicKeyParams, EVMPublicKey } from '../../types';
+import type { EthereumGetPublicKey, EthereumGetPublicKeyOneKey } from '@onekeyfe/hd-transport';
+
+export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneKey[]> {
+  hasBundle = false;
+
+  confirmShowOnOneKey = false;
+
+  useBatch = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+
+    this.confirmShowOnOneKey = this.payload?.bundle?.some(
+      (item: EVMGetPublicKeyParams) => !!item.showOnOneKey
+    );
+
+    this.useBatch = !this.confirmShowOnOneKey && this.hasBundle && this.payload.useBatch;
+
+    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' },
+        { name: 'chainId', type: 'number' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        chain_id: batch.chainId,
+      });
+    });
+  }
+
+  getEvmPublicKey(param: EthereumGetPublicKey) {
+    return getPublicKeyLegacyV1({
+      typedCall: this.device.commands.typedCall.bind(this.device.commands),
+      param,
+    });
+  }
+
+  async run() {
+    const responses: EVMPublicKey[] = [];
+
+    if (this.useBatch && supportBatchPublicKeyByDevice(this.device)) {
+      try {
+        const res = await batchGetPublickeys(this.device, this.params, 'secp256k1', 60, {
+          includeNode: false,
+          ignoreCoinType: true,
+        });
+        const result = res.public_keys.map((publicKey: string, index: number) => ({
+          path: serializedPath((this.params as unknown as any[])[index].address_n),
+          pub: publicKey,
+          publicKey,
+        }));
+
+        validateResult(result, ['pub'], {
+          expectedLength: this.params.length,
+        });
+        return await Promise.resolve(result);
+      } catch (e) {
+        // ignore error, fallback to single get public key
+      }
+    }
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.getEvmPublicKey(param);
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        pub: res.message.node.public_key,
+        publicKey: res.message.node.public_key,
+        ...res.message,
+      });
+    }
+
+    validateResult(responses, ['pub'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/evmTrezor/EVMSignMessage.ts

@@ -0,0 +1,40 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+import signMessageLegacyV1 from './legacyV1/signMessage';
+
+import type { EthereumSignMessageOneKey } from '@onekeyfe/hd-transport';
+
+export default class EVMSignMessage extends BaseMethod<EthereumSignMessageOneKey> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'messageHex', type: 'hexString', required: true },
+      { name: 'chainId', type: 'number' },
+    ]);
+
+    const { path, messageHex, chainId } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      message: formatAnyHex(messageHex),
+      chain_id: chainId,
+    };
+  }
+
+  async run() {
+    return signMessageLegacyV1({
+      typedCall: this.device.commands.typedCall.bind(this.device.commands),
+      params: this.params,
+    });
+  }
+}

package/src/api/evmTrezor/EVMSignTransaction.ts

@@ -0,0 +1,83 @@
+import { ERRORS } from '@onekeyfe/hd-shared';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+import { signTransaction as signTransactionLegacyV1 } from './legacyV1/signTransaction';
+
+import type { EVMSignTransactionParams, EVMTransaction, EVMTransactionEIP1559 } from '../../types';
+import type { SchemaParam } from '../helpers/paramsValidator';
+
+export default class EVMSignTransaction extends BaseMethod {
+  addressN: number[] = [];
+
+  isEIP1559 = false;
+
+  formattedTx: EVMTransaction | EVMTransactionEIP1559 | undefined;
+
+  init() {
+    this.checkDeviceId = true;
+    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: EVMSignTransactionParams['transaction'] = transaction;
+
+    this.isEIP1559 = !!tx.maxFeePerGas && !!tx.maxPriorityFeePerGas;
+
+    // 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: 'nonce', type: 'hexString', required: true },
+      { name: 'chainId', type: 'number', required: true },
+      { name: 'data', type: 'hexString' },
+    ];
+    if (this.isEIP1559) {
+      schema.push({ name: 'maxFeePerGas', type: 'hexString', required: true });
+      schema.push({ name: 'maxPriorityFeePerGas', type: 'hexString', required: true });
+    } else {
+      schema.push({ name: 'gasPrice', type: 'hexString', required: true });
+      schema.push({ name: 'txType', type: 'number' });
+    }
+    validateParams(tx, schema);
+
+    this.formattedTx = formatAnyHex(tx);
+  }
+
+  getVersionRange() {
+    if (this.isEIP1559) {
+      return {
+        model_mini: {
+          min: '2.1.11',
+        },
+      };
+    }
+    return {
+      model_mini: {
+        min: '1.0.0',
+      },
+    };
+  }
+
+  async run() {
+    const { addressN, isEIP1559, formattedTx } = this;
+
+    if (formattedTx == null) throw ERRORS.TypedError('Runtime', 'formattedTx is not set');
+
+    return signTransactionLegacyV1({
+      typedCall: this.device.commands.typedCall.bind(this.device.commands),
+      addressN,
+      tx: formattedTx,
+      isEIP1559,
+    });
+  }
+}