@onekeyfe/hd-core 0.3.16 → 0.3.19

package/src/api/evm/latest/signTransaction.ts

@@ -0,0 +1,196 @@
+import {
+  EthereumSignTx,
+  EthereumSignTxEIP1559,
+  EthereumTxRequestOneKey,
+  MessageResponse,
+  TypedCall,
+} from '@onekeyfe/hd-transport';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EVMSignedTx, EVMTransaction, EVMTransactionEIP1559 } from '../../../types';
+import { cutString } from '../../helpers/stringUtils';
+import { stripHexStartZeroes } from '../../helpers/hexUtils';
+
+export const processTxRequest = async ({
+  typedCall,
+  request,
+  data,
+  chainId,
+  supportTrezor,
+}: {
+  typedCall: TypedCall;
+  request: EthereumTxRequestOneKey;
+  data: string;
+  chainId?: number | undefined;
+  supportTrezor?: boolean;
+}): Promise<EVMSignedTx> => {
+  if (!request.data_length) {
+    let 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.RuntimeError,
+        'processTxRequest: Unexpected request'
+      );
+    }
+
+    // if v is not 27 or 28, it is a legacy transaction
+    if (chainId && v <= 1) {
+      v += 2 * chainId + 35;
+    }
+
+    return Promise.resolve({
+      v: `0x${v.toString(16)}`,
+      r: `0x${r}`,
+      s: `0x${s}`,
+    });
+  }
+
+  const [first, rest] = cutString(data, request.data_length * 2);
+
+  let response: MessageResponse<'EthereumTxRequestOneKey'> | MessageResponse<'EthereumTxRequest'>;
+  if (supportTrezor) {
+    response = await typedCall('EthereumTxAck', 'EthereumTxRequest', {
+      data_chunk: first,
+    });
+  } else {
+    response = await typedCall('EthereumTxAckOneKey', 'EthereumTxRequestOneKey', {
+      data_chunk: first,
+    });
+  }
+
+  return processTxRequest({
+    typedCall,
+    request: response.message,
+    data: rest,
+    chainId,
+    supportTrezor,
+  });
+};
+
+const evmSignTx = async ({
+  typedCall,
+  addressN,
+  tx,
+  supportTrezor,
+}: {
+  typedCall: TypedCall;
+  addressN: number[];
+  tx: EVMTransaction;
+  supportTrezor?: boolean;
+}) => {
+  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,
+    };
+  }
+
+  let response;
+  if (supportTrezor) {
+    response = await typedCall('EthereumSignTx', 'EthereumTxRequest', message);
+  } else {
+    response = await typedCall('EthereumSignTxOneKey', 'EthereumTxRequestOneKey', message);
+  }
+
+  return processTxRequest({
+    typedCall,
+    request: response.message,
+    data: rest,
+    chainId,
+    supportTrezor,
+  });
+};
+
+const evmSignTxEip1559 = async ({
+  typedCall,
+  addressN,
+  tx,
+  supportTrezor,
+}: {
+  typedCall: TypedCall;
+  addressN: number[];
+  tx: EVMTransactionEIP1559;
+  supportTrezor?: boolean;
+}) => {
+  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,
+    })),
+  };
+
+  let response;
+  if (supportTrezor) {
+    response = await typedCall('EthereumSignTxEIP1559', 'EthereumTxRequest', message);
+  } else {
+    response = await typedCall('EthereumSignTxEIP1559OneKey', 'EthereumTxRequestOneKey', message);
+  }
+
+  return processTxRequest({ typedCall, request: response.message, data: rest, supportTrezor });
+};
+export const signTransaction = async ({
+  typedCall,
+  isEIP1559,
+  addressN,
+  tx,
+}: {
+  addressN: number[];
+  tx: EVMTransaction | EVMTransactionEIP1559;
+  isEIP1559: boolean;
+  typedCall: TypedCall;
+}) =>
+  isEIP1559
+    ? evmSignTxEip1559({ typedCall, addressN, tx: tx as EVMTransactionEIP1559 })
+    : evmSignTx({ typedCall, addressN, tx: tx as EVMTransaction });

package/src/api/evm/latest/signTypedData.ts

@@ -0,0 +1,33 @@
+import { TypedCall } from '@onekeyfe/hd-transport';
+import { EthereumSignTypedDataMessage, EthereumSignTypedDataTypes } from '../../../types';
+
+export const signTypedData = async ({
+  typedCall,
+  addressN,
+  data,
+  metamaskV4Compat,
+  chainId,
+}: {
+  typedCall: TypedCall;
+  addressN: number[];
+  data: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>;
+  metamaskV4Compat: boolean;
+  chainId?: number;
+}) => {
+  const { primaryType }: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> = data;
+  return typedCall(
+    'EthereumSignTypedDataOneKey',
+    // @ts-ignore
+    [
+      'EthereumTypedDataStructRequestOneKey',
+      'EthereumTypedDataValueRequestOneKey',
+      'EthereumTypedDataSignatureOneKey',
+    ],
+    {
+      address_n: addressN,
+      primary_type: primaryType as string,
+      metamask_v4_compat: metamaskV4Compat,
+      chain_id: chainId,
+    }
+  );
+};

package/src/api/evm/latest/signTypedHash.ts

@@ -0,0 +1,44 @@
+import { MessageResponse, TypedCall } from '@onekeyfe/hd-transport';
+import semver from 'semver';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { Device } from '../../../device/Device';
+import { getDeviceFirmwareVersion, getDeviceType } from '../../../utils/deviceFeaturesUtils';
+
+export const signTypedHash = async ({
+  typedCall,
+  addressN,
+  device,
+  chainId,
+  domainHash,
+  messageHash,
+}: {
+  typedCall: TypedCall;
+  addressN: number[];
+  device: Device;
+  chainId: number;
+  domainHash: string;
+  messageHash: string | undefined;
+}): Promise<MessageResponse<'EthereumTypedDataSignatureOneKey'>> => {
+  const deviceType = getDeviceType(device.features);
+  if (deviceType === 'touch' || deviceType === 'pro') {
+    // Touch Pro Sign NestedArrays
+    const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+    const supportNestedArraysSignVersion = '4.2.0';
+
+    // 4.2.0 is the first version that supports nested arrays in signTypedData
+    if (semver.lt(currentVersion, supportNestedArraysSignVersion)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodNeedUpgradeFirmware,
+        `Device firmware version is too low, please update to ${supportNestedArraysSignVersion}`,
+        { current: currentVersion, require: supportNestedArraysSignVersion }
+      );
+    }
+  }
+
+  return typedCall('EthereumSignTypedHashOneKey', 'EthereumTypedDataSignatureOneKey', {
+    address_n: addressN,
+    domain_separator_hash: domainHash ?? '',
+    message_hash: messageHash,
+    chain_id: chainId,
+  });
+};

package/src/api/evm/latest/verifyMessage.ts

@@ -0,0 +1,15 @@
+import { EthereumVerifyMessageOneKey, Success, TypedCall } from '@onekeyfe/hd-transport';
+
+export default async function ({
+  typedCall,
+  params,
+}: {
+  typedCall: TypedCall;
+  params: EthereumVerifyMessageOneKey;
+}): Promise<Success> {
+  const res = await typedCall('EthereumVerifyMessageOneKey', 'Success', {
+    ...params,
+  });
+
+  return Promise.resolve(res.message);
+}

package/src/api/evm/legacyV1/getAddress.ts

@@ -0,0 +1,16 @@
+import { EthereumGetAddressOneKey, MessageResponse, TypedCall } from '@onekeyfe/hd-transport';
+
+export default async function ({
+  typedCall,
+  param,
+}: {
+  typedCall: TypedCall;
+  param: EthereumGetAddressOneKey;
+}): Promise<MessageResponse<'EthereumAddress'>> {
+  return typedCall('EthereumGetAddress', 'EthereumAddress', {
+    address_n: param.address_n,
+    show_display: param.show_display,
+    // @ts-ignore
+    chain_id: param.chain_id,
+  });
+}

package/src/api/evm/legacyV1/getPublicKey.ts

@@ -0,0 +1,16 @@
+import { EthereumGetPublicKeyOneKey, MessageResponse, TypedCall } from '@onekeyfe/hd-transport';
+
+export default async function ({
+  typedCall,
+  param,
+}: {
+  typedCall: TypedCall;
+  param: EthereumGetPublicKeyOneKey;
+}): Promise<MessageResponse<'EthereumPublicKey'>> {
+  return typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {
+    address_n: param.address_n,
+    show_display: param.show_display,
+    // @ts-ignore
+    chain_id: param.chain_id,
+  });
+}

package/src/api/evm/legacyV1/signMessage.ts

@@ -0,0 +1,22 @@
+import {
+  EthereumMessageSignature,
+  EthereumSignMessageOneKey,
+  TypedCall,
+} from '@onekeyfe/hd-transport';
+
+export default async function ({
+  typedCall,
+  params,
+}: {
+  typedCall: TypedCall;
+  params: EthereumSignMessageOneKey;
+}): Promise<EthereumMessageSignature> {
+  const res = await typedCall('EthereumSignMessage', 'EthereumMessageSignature', {
+    address_n: params.address_n,
+    message: params.message,
+    // @ts-ignore
+    chain_id: params.chain_id,
+  });
+
+  return Promise.resolve(res.message);
+}

package/src/api/evm/legacyV1/signTransaction.ts

@@ -0,0 +1,99 @@
+import { EthereumSignTx, EthereumSignTxEIP1559, TypedCall } from '@onekeyfe/hd-transport';
+import { EVMTransaction, EVMTransactionEIP1559 } from '../../../types';
+import { cutString } from '../../helpers/stringUtils';
+import { stripHexStartZeroes } from '../../helpers/hexUtils';
+import { processTxRequest } from '../latest/signTransaction';
+
+const evmSignTx = async (typedCall: TypedCall, 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 typedCall('EthereumSignTx', 'EthereumTxRequest', message);
+
+  return processTxRequest({ typedCall, request: response.message, data: rest, chainId });
+};
+
+const evmSignTxEip1559 = async (
+  typedCall: TypedCall,
+  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 typedCall('EthereumSignTxEIP1559', 'EthereumTxRequest', message);
+
+  return processTxRequest({ typedCall, request: response.message, data: rest });
+};
+export const signTransaction = async ({
+  typedCall,
+  isEIP1559,
+  addressN,
+  tx,
+}: {
+  addressN: number[];
+  tx: EVMTransaction | EVMTransactionEIP1559;
+  isEIP1559: boolean;
+  typedCall: TypedCall;
+}) =>
+  isEIP1559
+    ? evmSignTxEip1559(typedCall, addressN, tx as EVMTransactionEIP1559)
+    : evmSignTx(typedCall, addressN, tx as EVMTransaction);

package/src/api/evm/legacyV1/signTypedData.ts

@@ -0,0 +1,36 @@
+import { TypedCall } from '@onekeyfe/hd-transport';
+import { EthereumSignTypedDataMessage, EthereumSignTypedDataTypes } from '../../../types';
+
+export const signTypedData = async ({
+  typedCall,
+  addressN,
+  data,
+  metamaskV4Compat,
+  chainId,
+}: {
+  typedCall: TypedCall;
+  addressN: number[];
+  data: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>;
+  metamaskV4Compat: boolean;
+  chainId?: number;
+}) => {
+  const { primaryType }: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> = data;
+
+  const response = await typedCall(
+    'EthereumSignTypedData',
+    // @ts-ignore
+    [
+      'EthereumTypedDataStructRequest',
+      'EthereumTypedDataValueRequest',
+      'EthereumTypedDataSignature',
+    ],
+    {
+      address_n: addressN,
+      primary_type: primaryType as string,
+      metamask_v4_compat: metamaskV4Compat,
+      // @ts-ignore
+      chain_id: chainId,
+    }
+  );
+  return response;
+};

package/src/api/evm/legacyV1/signTypedHash.ts

@@ -0,0 +1,48 @@
+import { MessageResponse, TypedCall } from '@onekeyfe/hd-transport';
+import semver from 'semver';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { Device } from '../../../device/Device';
+import { getDeviceFirmwareVersion, getDeviceType } from '../../../utils/deviceFeaturesUtils';
+
+export const signTypedHash = async ({
+  typedCall,
+  addressN,
+  device,
+  chainId,
+  domainHash,
+  messageHash,
+}: {
+  typedCall: TypedCall;
+  addressN: number[];
+  device: Device;
+  chainId: number;
+  domainHash: string;
+  messageHash: string | undefined;
+}): Promise<
+  | MessageResponse<'EthereumTypedDataSignature'>
+  | MessageResponse<'EthereumTypedDataSignatureOneKey'>
+> => {
+  const deviceType = getDeviceType(device.features);
+  if (deviceType === 'touch' || deviceType === 'pro') {
+    // Touch Pro Sign NestedArrays
+    const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+    const supportNestedArraysSignVersion = '4.2.0';
+
+    // 4.2.0 is the first version that supports nested arrays in signTypedData
+    if (semver.lt(currentVersion, supportNestedArraysSignVersion)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodNeedUpgradeFirmware,
+        `Device firmware version is too low, please update to ${supportNestedArraysSignVersion}`,
+        { current: currentVersion, require: supportNestedArraysSignVersion }
+      );
+    }
+  }
+
+  return typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', {
+    address_n: addressN,
+    domain_separator_hash: domainHash ?? '',
+    message_hash: messageHash,
+    // @ts-ignore
+    chain_id: chainId,
+  });
+};

package/src/api/evm/legacyV1/verifyMessage.ts

@@ -0,0 +1,19 @@
+import { EthereumVerifyMessageOneKey, Success, TypedCall } from '@onekeyfe/hd-transport';
+
+export default async function ({
+  typedCall,
+  params,
+}: {
+  typedCall: TypedCall;
+  params: EthereumVerifyMessageOneKey;
+}): Promise<Success> {
+  const res = await typedCall('EthereumVerifyMessage', 'Success', {
+    signature: params.signature,
+    message: params.message,
+    address: params.address,
+    // @ts-ignore
+    chain_id: params.chain_id,
+  });
+
+  return Promise.resolve(res.message);
+}

package/src/api/helpers/pathUtils.ts

@@ -6,6 +6,7 @@ import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 const HD_HARDENED = 0x80000000;
 export const toHardened = (n: number): number => (n | HD_HARDENED) >>> 0;
 export const fromHardened = (n: number): number => (n & ~HD_HARDENED) >>> 0;
+export const getSlip44ByPath = (path: number[]) => fromHardened(path[1]);
 
 const PATH_NOT_VALID = ERRORS.TypedError(
   HardwareErrorCode.CallMethodInvalidParameter,

package/src/core/index.ts

@@ -21,18 +21,18 @@ import { findMethod } from '../api/utils';
 import { DataManager } from '../data-manager';
 import { enableLog, getLogger, LoggerNames, setLoggerPostMessage, wait } from '../utils';
 import {
+  CORE_EVENT,
   CoreMessage,
+  createDeviceMessage,
   createResponseMessage,
+  createUiMessage,
   DEVICE,
   IFRAME,
   IFrameCallMessage,
-  CORE_EVENT,
   UI_REQUEST,
   UI_RESPONSE,
   UiPromise,
   UiPromiseResponse,
-  createUiMessage,
-  createDeviceMessage,
 } from '../events';
 import type { BaseMethod } from '../api/BaseMethod';
 import type { ConnectSettings, KnownDevice } from '../types';
@@ -232,7 +232,7 @@ export const callAPI = async (message: CoreMessage) => {
 
       // reconfigure messages
       if (_deviceList) {
-        await TransportManager.reconfigure(device.getFirmwareVersion());
+        await TransportManager.reconfigure(device.features);
       }
 
       // Check to see if it is safe to use Passphrase
@@ -409,6 +409,7 @@ function initDeviceForBle(method: BaseMethod) {
  * If the Bluetooth connection times out, retry 6 times
  */
 let bleTimeoutRetry = 0;
+
 async function connectDeviceForBle(method: BaseMethod, device: Device) {
   try {
     await device.acquire();