@onekeyfe/hd-core 0.0.1

package/src/api/EVMSignMessage.ts

@@ -0,0 +1,40 @@
+import { EthereumSignMessage } 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 { formatAnyHex } from './helpers/hexUtils';
+
+export default class EVMSignMessage extends BaseMethod<EthereumSignMessage> {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'messageHex', type: 'hexString', required: true },
+    ]);
+
+    const { path, messageHex } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      message: formatAnyHex(messageHex),
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'EthereumSignMessage',
+      'EthereumMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/EVMSignMessageEIP712.ts

@@ -0,0 +1,40 @@
+import { EthereumSignMessageEIP712 } 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 { formatAnyHex } from './helpers/hexUtils';
+
+export default class EVMSignMessageEIP712 extends BaseMethod<EthereumSignMessageEIP712> {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'domainHash', type: 'hexString', required: true },
+      { name: 'messageHash', type: 'hexString', required: true },
+    ]);
+
+    const { path, domainHash, messageHash } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      domain_hash: formatAnyHex(domainHash),
+      message_hash: formatAnyHex(messageHash),
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'EthereumSignMessageEIP712',
+      'EthereumMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/EVMSignTransaction.ts

@@ -0,0 +1,195 @@
+import {
+  EthereumSignTx,
+  EthereumSignTxEIP1559,
+  EthereumTxRequest,
+} from '@onekeyfe/hd-transport/src/types/messages';
+
+import { UI_REQUEST } from '../constants/ui-request';
+import { validatePath } from './helpers/pathUtils';
+import { BaseMethod } from './BaseMethod';
+import { SchemaParam, validateParams } from './helpers/paramsValidator';
+import {
+  EVMSignTransactionParams,
+  EVMTransaction,
+  EVMTransactionEIP1559,
+} from '../types/api/evmSignTransaction';
+import { cutString } from './helpers/stringUtils';
+import { formatAnyHex, stripHexStartZeroes } from './helpers/hexUtils';
+import { ERRORS } from '../constants';
+
+type EVMSignedTx = {
+  v: string;
+  r: string;
+  s: string;
+};
+
+export default class EVMSignTransaction extends BaseMethod {
+  addressN: number[] = [];
+
+  isEIP1559 = false;
+
+  formattedTx: EVMTransaction | EVMTransactionEIP1559 | undefined;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.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);
+  }
+
+  processTxRequest = async (
+    request: EthereumTxRequest,
+    data: string,
+    chain_id: number | undefined
+  ): Promise<EVMSignedTx> => {
+    if (!request.data_length) {
+      let v = request.signature_v;
+      const r = request.signature_r;
+      const s = request.signature_s;
+
+      if (!v || !r || !s) {
+        throw ERRORS.TypedError('Runtime', 'processTxRequest: Unexpected request');
+      }
+
+      // if v is not 27 or 28, it is a legacy transaction
+      if (chain_id && v <= 1) {
+        v += 2 * chain_id + 35;
+      }
+
+      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('EthereumTxAck', 'EthereumTxRequest', {
+      data_chunk: first,
+    });
+
+    return this.processTxRequest(response.message, rest, chain_id);
+  };
+
+  evmSignTx = async (addressN: number[], tx: EVMTransaction) => {
+    const { to, value, gasPrice, gasLimit, nonce, data, chainId, txType } = tx;
+
+    const length = data == null ? 0 : data.length / 2;
+
+    const [first, rest] = cutString(data, 1024 * 2);
+
+    let message: EthereumSignTx = {
+      address_n: addressN,
+      nonce: stripHexStartZeroes(nonce),
+      gas_price: stripHexStartZeroes(gasPrice),
+      gas_limit: stripHexStartZeroes(gasLimit),
+      to,
+      value: stripHexStartZeroes(value),
+      chain_id: chainId,
+    };
+
+    if (length !== 0) {
+      message = {
+        ...message,
+        data_length: length,
+        data_initial_chunk: first,
+      };
+    }
+
+    if (txType !== null) {
+      message = {
+        ...message,
+        tx_type: txType,
+      };
+    }
+
+    const response = await this.device.commands.typedCall(
+      'EthereumSignTx',
+      'EthereumTxRequest',
+      message
+    );
+
+    return this.processTxRequest(response.message, rest, chainId);
+  };
+
+  evmSignTxEip1559 = async (addressN: number[], tx: EVMTransactionEIP1559) => {
+    const {
+      to,
+      value,
+      gasLimit,
+      nonce,
+      data,
+      chainId,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      accessList,
+    } = tx;
+
+    const length = data == null ? 0 : data.length / 2;
+
+    const [first, rest] = cutString(data, 1024 * 2);
+
+    const message: EthereumSignTxEIP1559 = {
+      address_n: addressN,
+      nonce: stripHexStartZeroes(nonce),
+      max_gas_fee: stripHexStartZeroes(maxFeePerGas),
+      max_priority_fee: stripHexStartZeroes(maxPriorityFeePerGas),
+      gas_limit: stripHexStartZeroes(gasLimit),
+      to,
+      value: stripHexStartZeroes(value),
+      data_length: length,
+      data_initial_chunk: first,
+      chain_id: chainId,
+      access_list: (accessList || []).map(a => ({
+        address: a.address,
+        storage_keys: a.storageKeys,
+      })),
+    };
+
+    const response = await this.device.commands.typedCall(
+      'EthereumSignTxEIP1559',
+      'EthereumTxRequest',
+      message
+    );
+
+    return this.processTxRequest(response.message, rest, chainId);
+  };
+
+  async run() {
+    const { addressN, isEIP1559, formattedTx } = this;
+
+    const signedTx = await (isEIP1559
+      ? this.evmSignTxEip1559(addressN, formattedTx as EVMTransactionEIP1559)
+      : this.evmSignTx(addressN, formattedTx as EVMTransaction));
+
+    return Promise.resolve(signedTx);
+  }
+}

package/src/api/EVMSignTypedData.ts

@@ -0,0 +1,212 @@
+import {
+  EthereumTypedDataSignature,
+  EthereumTypedDataStructAck,
+  MessageKey,
+} 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 { formatAnyHex } from './helpers/hexUtils';
+import { ERRORS } from '../constants';
+import { encodeData, getFieldType, parseArrayType } from './helpers/typeNameUtils';
+import {
+  EthereumSignTypedDataMessage,
+  EthereumSignTypedDataTypes,
+} from '../types/api/evmSignTypedData';
+
+export type EVMSignTypedDataParams = {
+  addressN: number[];
+  metamaskV4Compat: boolean;
+  data: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>;
+  domainHash?: string;
+  messageHash?: string;
+};
+
+export default class EVMSignMessageEIP712 extends BaseMethod<EVMSignTypedDataParams> {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'metamaskV4Compat', type: 'boolean', required: true },
+      { name: 'data', type: 'object', required: true },
+      { name: 'domainHash', type: 'hexString' },
+      { name: 'messageHash', type: 'hexString' },
+    ]);
+
+    const { path, data, metamaskV4Compat, domainHash, messageHash } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      addressN,
+      metamaskV4Compat,
+      data,
+    };
+
+    if (domainHash) {
+      this.params.domainHash = formatAnyHex(domainHash);
+      if (messageHash) {
+        this.params.messageHash = formatAnyHex(messageHash);
+      } else if (!data.primaryType || data.primaryType !== 'EIP712Domain') {
+        throw ERRORS.TypedError(
+          'Method_InvalidParameter',
+          'message_hash should only be empty when data.primaryType=EIP712Domain'
+        );
+      }
+    }
+  }
+
+  // async signTypedData() {
+  //   const { commands } = this.device;
+  //   const { addressN, data, metamaskV4Compat } = this.params;
+
+  //   const {
+  //     types,
+  //     primaryType,
+  //     domain,
+  //     message,
+  //   }: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> = data;
+
+  //   let response = await commands.typedCall(
+  //     'EthereumSignTypedData',
+  //     // 'EthereumTypedDataStructRequest|EthereumTypedDataValueRequest|EthereumTypedDataSignature',
+  //     [
+  //       'EthereumTypedDataStructRequest',
+  //       'EthereumTypedDataValueRequest',
+  //       'EthereumTypedDataSignature',
+  //     ],
+  //     {
+  //       address_n: addressN,
+  //       primary_type: primaryType as string,
+  //       metamask_v4_compat: metamaskV4Compat,
+  //     }
+  //   );
+
+  //   while (response.type === 'EthereumTypedDataStructRequest') {
+  //     const { name: typeDefinitionName } = response.message;
+  //     const typeDefinition = types[typeDefinitionName];
+  //     if (typeDefinition === undefined) {
+  //       throw ERRORS.TypedError(
+  //         'Runtime',
+  //         `Type ${typeDefinitionName} was not defined in types object`
+  //       );
+  //     }
+
+  //     const dataStruckAck: EthereumTypedDataStructAck = {
+  //       members: typeDefinition.map(({ name, type: typeName }) => ({
+  //         name,
+  //         type: getFieldType(typeName, types),
+  //       })),
+  //     };
+
+  //     response = await commands.typedCall(
+  //       'EthereumTypedDataStructAck',
+  //       [
+  //         'EthereumTypedDataStructRequest',
+  //         'EthereumTypedDataValueRequest',
+  //         'EthereumTypedDataSignature',
+  //       ] as MessageKey[],
+  //       dataStruckAck
+  //     );
+  //   }
+
+  //   while (response.type === 'EthereumTypedDataValueRequest') {
+  //     const { member_path } = response.message;
+
+  //     let memberData;
+  //     let memberTypeName: string;
+
+  //     const [rootIndex, ...nestedMemberPath] = member_path;
+  //     switch (rootIndex) {
+  //       case 0:
+  //         memberData = domain;
+  //         memberTypeName = 'EIP712Domain';
+  //         break;
+  //       case 1:
+  //         memberData = message;
+  //         memberTypeName = primaryType as string;
+  //         break;
+  //       default:
+  //         throw ERRORS.TypedError('Runtime', 'Root index can only be 0 or 1');
+  //     }
+
+  //     for (const index of nestedMemberPath) {
+  //       if (Array.isArray(memberData)) {
+  //         memberTypeName = parseArrayType(memberTypeName).entryTypeName;
+  //         memberData = memberData[index];
+  //       } else if (typeof memberData === 'object' && memberData !== null) {
+  //         const memberTypeDefinition = types[memberTypeName][index];
+  //         memberTypeName = memberTypeDefinition.type;
+  //         memberData = memberData[memberTypeDefinition.name];
+  //       } else {
+  //         // TODO
+  //       }
+  //     }
+
+  //     let encodedData;
+  //     if (Array.isArray(memberData)) {
+  //       // Sending the length as uint16
+  //       encodedData = encodeData('uint16', memberData.length);
+  //     } else {
+  //       encodedData = encodeData(memberTypeName, memberData);
+  //     }
+
+  //     response = await commands.typedCall(
+  //       'EthereumTypedDataValueAck',
+  //       ['EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'] as MessageKey[],
+  //       {
+  //         value: encodedData,
+  //       }
+  //     );
+  //   }
+
+  //   if (response.type !== 'EthereumTypedDataSignature') {
+  //     throw ERRORS.TypedError('Runtime', 'Unexpected response type');
+  //   }
+
+  //   const { address, signature }: EthereumTypedDataSignature = response.message;
+  //   return {
+  //     address,
+  //     signature,
+  //   };
+  // }
+
+  async run() {
+    if (!this.device.features) {
+      throw ERRORS.TypedError(
+        'Device_InitializeFailed',
+        'Device initialization failed. Please try again.'
+      );
+    }
+
+    const { addressN } = this.params;
+
+    // For Classic、Mini device we use EthereumSignTypedData
+    if (this.device.features.model === '1') {
+      validateParams(this.params, [
+        { name: 'domainHash', type: 'hexString', required: true },
+        { name: 'messageHash', type: 'hexString' },
+      ]);
+
+      const { domainHash, messageHash } = this.params;
+
+      const response = await this.device.commands.typedCall(
+        'EthereumSignTypedHash',
+        'EthereumTypedDataSignature',
+        {
+          address_n: addressN,
+          domain_separator_hash: domainHash ?? '',
+          message_hash: messageHash,
+        }
+      );
+
+      return Promise.resolve(response.message);
+    }
+
+    // For Touch、Pro we use EthereumSignTypedData
+    // return this.signTypedData();
+    return Promise.resolve(ERRORS.TypedError('Runtime', 'Not implemented'));
+  }
+}

package/src/api/EVMVerifyMessage.ts

@@ -0,0 +1,33 @@
+import { EthereumVerifyMessage } 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';
+
+export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessage> {
+  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 },
+    ]);
+
+    const { address, messageHex, signature } = formatAnyHex(this.payload);
+
+    this.params = {
+      address,
+      message: messageHex,
+      signature,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('EthereumVerifyMessage', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/GetFeatures.ts

@@ -0,0 +1,12 @@
+import { UI_REQUEST } from '../constants/ui-request';
+import { BaseMethod } from './BaseMethod';
+
+export default class GetFeatures extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE, UI_REQUEST.BOOTLOADER];
+  }
+
+  run() {
+    return Promise.resolve(this.device.features);
+  }
+}

package/src/api/SearchDevices.ts

@@ -0,0 +1,40 @@
+import { BaseMethod } from './BaseMethod';
+import DeviceConnector from '../device/DeviceConnector';
+import TransportManager from '../data-manager/TransportManager';
+import { Device } from '../device/Device';
+import { DataManager } from '../data-manager';
+
+export default class SearchDevices extends BaseMethod {
+  connector?: DeviceConnector;
+
+  init() {
+    this.useDevice = false;
+  }
+
+  async run() {
+    await TransportManager.configure();
+    const deviceDiff = await this.connector?.enumerate();
+    const devicesDescriptor = deviceDiff?.descriptors ?? [];
+
+    const env = DataManager.getSettings('env');
+
+    /**
+     * No need to call features during Bluetooth scaning
+     * to avoid device pairing
+     */
+    if (env === 'react-native') {
+      return devicesDescriptor.map(device => ({ ...device, connectId: device.id }));
+    }
+
+    const devices = [];
+    for await (const descriptor of devicesDescriptor) {
+      const device = Device.fromDescriptor(descriptor);
+      device.deviceConnector = this.connector;
+      await device.connect();
+      await device.initialize();
+      await device.release();
+      devices.push(device);
+    }
+    return devices.map(device => device.toMessageObject());
+  }
+}

package/src/api/helpers/bigNumberUtils.ts

@@ -0,0 +1,58 @@
+import BigNumber from 'bignumber.js';
+import { ERRORS } from '../../constants';
+
+/**
+ * Converts a number to a two's complement representation.
+ *
+ * E.g. -128 would be 0x80 in two's complement, while 127 would be 0x7F.
+ *
+ * BigNumber.js has no built-in function, unlike https://www.npmjs.com/package/bn.js
+ */
+export const twosComplement = (number: BigNumber, bytes: number): BigNumber => {
+  if (bytes < 1 || bytes > 32) {
+    throw ERRORS.TypedError('Runtime', 'Int byte size must be between 1 and 32 (8 and 256 bits)');
+  }
+  // Determine value range
+  const minValue = new BigNumber(2).exponentiatedBy(bytes * 8 - 1).negated();
+  const maxValue = minValue.negated().minus(1);
+
+  const bigNumber = new BigNumber(number);
+
+  if (bigNumber.isGreaterThan(maxValue) || bigNumber.isLessThan(minValue)) {
+    throw ERRORS.TypedError(
+      'Runtime',
+      `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`
+    );
+  }
+
+  if (bigNumber.isPositive()) {
+    return bigNumber;
+  }
+  return bigNumber.minus(minValue).minus(minValue);
+};
+
+export const intToHex = (
+  number: number | BigNumber | string,
+  bytes: number,
+  signed: boolean
+): string => {
+  let bigNumber = new BigNumber(number);
+  if (signed) {
+    bigNumber = twosComplement(bigNumber, bytes);
+  }
+  if (bigNumber.isNegative()) {
+    throw ERRORS.TypedError(
+      'Runtime',
+      `Cannot convert negative number to unsigned interger: ${number.toString()}`
+    );
+  }
+  const hex = bigNumber.toString(16);
+  const hexChars = bytes * 2;
+  if (hex.length > hexChars) {
+    throw ERRORS.TypedError(
+      'Runtime',
+      `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`
+    );
+  }
+  return hex.padStart(bytes * 2, '0');
+};