@onekeyfe/hd-core 0.3.16 → 0.3.19

package/src/api/evm/EVMSignTransaction.ts

@@ -1,18 +1,13 @@
-import { EthereumSignTx, EthereumSignTxEIP1559, EthereumTxRequest } from '@onekeyfe/hd-transport';
-
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { ERRORS } from '@onekeyfe/hd-shared';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { SchemaParam, validateParams } from '../helpers/paramsValidator';
-import {
-  EVMSignedTx,
-  EVMSignTransactionParams,
-  EVMTransaction,
-  EVMTransactionEIP1559,
-} from '../../types/api/evmSignTransaction';
-import { cutString } from '../helpers/stringUtils';
-import { formatAnyHex, stripHexStartZeroes } from '../helpers/hexUtils';
+import { EVMSignTransactionParams, EVMTransaction, EVMTransactionEIP1559 } from '../../types';
+import { formatAnyHex } from '../helpers/hexUtils';
+import TransportManager from '../../data-manager/TransportManager';
+import { signTransaction } from './latest/signTransaction';
+import { signTransaction as signTransactionLegacyV1 } from './legacyV1/signTransaction';
 
 export default class EVMSignTransaction extends BaseMethod {
   addressN: number[] = [];
@@ -57,127 +52,6 @@ export default class EVMSignTransaction extends BaseMethod {
     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 == 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 (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);
-  };
-
   getVersionRange() {
     if (this.isEIP1559) {
       return {
@@ -196,10 +70,22 @@ export default class EVMSignTransaction extends BaseMethod {
   async run() {
     const { addressN, isEIP1559, formattedTx } = this;
 
-    const signedTx = await (isEIP1559
-      ? this.evmSignTxEip1559(addressN, formattedTx as EVMTransactionEIP1559)
-      : this.evmSignTx(addressN, formattedTx as EVMTransaction));
+    if (formattedTx == null) throw ERRORS.TypedError('Runtime', 'formattedTx is not set');
 
-    return Promise.resolve(signedTx);
+    if (TransportManager.getMessageVersion() === 'v1') {
+      return signTransactionLegacyV1({
+        typedCall: this.device.commands.typedCall.bind(this.device.commands),
+        addressN,
+        tx: formattedTx,
+        isEIP1559,
+      });
+    }
+
+    return signTransaction({
+      typedCall: this.device.commands.typedCall.bind(this.device.commands),
+      addressN,
+      tx: formattedTx,
+      isEIP1559,
+    });
   }
 }

package/src/api/evm/EVMSignTypedData.ts

@@ -1,20 +1,26 @@
 import semver from 'semver';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import type {
+import {
   EthereumTypedDataSignature,
   EthereumTypedDataStructAck,
+  MessageKey,
+  MessageResponse,
+  TypedCall,
 } from '@onekeyfe/hd-transport';
+import { get } from 'lodash';
 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 { encodeData, getFieldType, parseArrayType } from '../helpers/typeNameUtils';
 import { getDeviceFirmwareVersion, getDeviceType } from '../../utils/deviceFeaturesUtils';
-import type {
-  EthereumSignTypedDataMessage,
-  EthereumSignTypedDataTypes,
-} from '../../types/api/evmSignTypedData';
+import type { EthereumSignTypedDataMessage, EthereumSignTypedDataTypes } from '../../types';
+import TransportManager from '../../data-manager/TransportManager';
+import { signTypedHash as signTypedHashLegacyV1 } from './legacyV1/signTypedHash';
+import { signTypedHash } from './latest/signTypedHash';
+import { signTypedData as signTypedDataLegacyV1 } from './legacyV1/signTypedData';
+import { signTypedData } from './latest/signTypedData';
+import { encodeData, getFieldType, parseArrayType } from '../helpers/typeNameUtils';
 
 export type EVMSignTypedDataParams = {
   addressN: number[];
@@ -63,33 +69,29 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
     }
   }
 
-  async signTypedData() {
-    const { commands } = this.device;
-    const { addressN, data, metamaskV4Compat, chainId } = this.params;
-
+  async handleSignTypedData({
+    typedCall,
+    signData,
+    response,
+    supportTrezor,
+  }: {
+    typedCall: TypedCall;
+    signData: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>;
+    response: MessageResponse<MessageKey>;
+    supportTrezor: boolean;
+  }) {
     const {
       types,
       primaryType,
       domain,
       message,
-    }: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> = data;
-
-    let response = await commands.typedCall(
-      'EthereumSignTypedData',
-      [
-        'EthereumTypedDataStructRequest',
-        'EthereumTypedDataValueRequest',
-        'EthereumTypedDataSignature',
-      ],
-      {
-        address_n: addressN,
-        primary_type: primaryType as string,
-        metamask_v4_compat: metamaskV4Compat,
-        chain_id: chainId,
-      }
-    );
+    }: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> = signData;
 
-    while (response.type === 'EthereumTypedDataStructRequest') {
+    while (
+      response.type === 'EthereumTypedDataStructRequest' ||
+      response.type === 'EthereumTypedDataStructRequestOneKey'
+    ) {
+      // @ts-ignore
       const { name: typeDefinitionName } = response.message;
       const typeDefinition = types[typeDefinitionName];
       if (typeDefinition === undefined) {
@@ -106,18 +108,36 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
         })),
       };
 
-      response = await commands.typedCall(
-        'EthereumTypedDataStructAck',
-        [
-          'EthereumTypedDataStructRequest',
-          'EthereumTypedDataValueRequest',
-          'EthereumTypedDataSignature',
-        ],
-        dataStruckAck
-      );
+      if (supportTrezor) {
+        response = await typedCall(
+          'EthereumTypedDataStructAck',
+          // @ts-ignore
+          [
+            'EthereumTypedDataStructRequest',
+            'EthereumTypedDataValueRequest',
+            'EthereumTypedDataSignature',
+          ],
+          dataStruckAck
+        );
+      } else {
+        response = await typedCall(
+          'EthereumTypedDataStructAckOneKey',
+          // @ts-ignore
+          [
+            'EthereumTypedDataStructRequestOneKey',
+            'EthereumTypedDataValueRequestOneKey',
+            'EthereumTypedDataSignatureOneKey',
+          ],
+          dataStruckAck
+        );
+      }
     }
 
-    while (response.type === 'EthereumTypedDataValueRequest') {
+    while (
+      response.type === 'EthereumTypedDataValueRequest' ||
+      response.type === 'EthereumTypedDataValueRequestOneKey'
+    ) {
+      // @ts-ignore
       const { member_path } = response.message;
 
       let memberData;
@@ -158,19 +178,35 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
         encodedData = encodeData(memberTypeName, memberData);
       }
 
-      response = await commands.typedCall(
-        'EthereumTypedDataValueAck',
-        ['EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'],
-        {
-          value: encodedData,
-        }
-      );
+      if (supportTrezor) {
+        response = await typedCall(
+          'EthereumTypedDataValueAck',
+          // @ts-ignore
+          ['EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'],
+          {
+            value: encodedData,
+          }
+        );
+      } else {
+        response = await typedCall(
+          'EthereumTypedDataValueAckOneKey',
+          // @ts-ignore
+          ['EthereumTypedDataValueRequestOneKey', 'EthereumTypedDataSignatureOneKey'],
+          {
+            value: encodedData,
+          }
+        );
+      }
     }
 
-    if (response.type !== 'EthereumTypedDataSignature') {
+    if (
+      response.type !== 'EthereumTypedDataSignature' &&
+      response.type !== 'EthereumTypedDataSignatureOneKey'
+    ) {
       throw ERRORS.TypedError('Runtime', 'Unexpected response type');
     }
 
+    // @ts-ignore
     const { address, signature }: EthereumTypedDataSignature = response.message;
     return {
       address,
@@ -178,6 +214,84 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
     };
   }
 
+  async signTypedData() {
+    const { addressN, data, metamaskV4Compat, chainId } = this.params;
+
+    let supportTrezor = false;
+    let response: MessageResponse<MessageKey>;
+    switch (TransportManager.getMessageVersion()) {
+      case 'v1':
+        supportTrezor = true;
+        response = await signTypedDataLegacyV1({
+          typedCall: this.device.commands.typedCall.bind(this.device.commands),
+          addressN,
+          data,
+          metamaskV4Compat,
+          chainId,
+        });
+        break;
+
+      case 'latest':
+      default:
+        supportTrezor = false;
+        response = await signTypedData({
+          typedCall: this.device.commands.typedCall.bind(this.device.commands),
+          addressN,
+          data,
+          metamaskV4Compat,
+          chainId,
+        });
+        break;
+    }
+
+    return this.handleSignTypedData({
+      typedCall: this.device.commands.typedCall.bind(this.device.commands),
+      signData: data,
+      response,
+      supportTrezor,
+    });
+  }
+
+  signTypedHash({
+    typedCall,
+    addressN,
+    chainId,
+    domainHash,
+    messageHash,
+  }: {
+    typedCall: TypedCall;
+    addressN: number[];
+    chainId: number | undefined;
+    domainHash: string | undefined;
+    messageHash: string | undefined;
+  }) {
+    if (!domainHash) throw ERRORS.TypedError('Runtime', 'domainHash is required');
+    if (!chainId) throw ERRORS.TypedError('Runtime', 'chainId is required');
+
+    switch (TransportManager.getMessageVersion()) {
+      case 'v1':
+        return signTypedHashLegacyV1({
+          typedCall,
+          addressN,
+          domainHash,
+          messageHash,
+          chainId,
+          device: this.device,
+        });
+
+      case 'latest':
+      default:
+        return signTypedHash({
+          typedCall,
+          addressN,
+          domainHash,
+          messageHash,
+          chainId,
+          device: this.device,
+        });
+    }
+  }
+
   getVersionRange() {
     return {
       model_mini: {
@@ -186,6 +300,21 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
     };
   }
 
+  hasBiggerData(item: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>) {
+    const data = get(item.message, 'data', undefined) as string | undefined;
+    if (!data) return false;
+
+    let biggerLimit = 1536; // 1.5k
+    const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+    const supportSignTypedVersion = '4.4.0';
+
+    if (semver.lt(currentVersion, supportSignTypedVersion)) {
+      biggerLimit = 1024; // 1k
+    }
+
+    return data.replace('0x', '').length > biggerLimit;
+  }
+
   hasNestedArrays(item: any): boolean {
     if (!item) return false;
 
@@ -252,16 +381,13 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
       let response;
       if (this.supportSignTyped()) {
-        response = await this.device.commands.typedCall(
-          'EthereumSignTypedHash',
-          'EthereumTypedDataSignature',
-          {
-            address_n: addressN,
-            domain_separator_hash: domainHash ?? '',
-            message_hash: messageHash,
-            chain_id: chainId,
-          }
-        );
+        response = await this.signTypedHash({
+          typedCall: this.device.commands.typedCall.bind(this.device.commands),
+          addressN,
+          domainHash,
+          messageHash,
+          chainId,
+        });
       } else {
         response = await this.device.commands.typedCall(
           'EthereumSignMessageEIP712',
@@ -278,38 +404,26 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
     }
 
     // Touch Pro Sign NestedArrays
-    const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
-    if (this.hasNestedArrays(this.params.data)) {
-      const supportNestedArraysSignVersion = '4.2.0';
-
-      // 4.2.0 is the first version that supports nested arrays in signTypedData
-      if (semver.gte(currentVersion, supportNestedArraysSignVersion)) {
-        validateParams(this.params, [
-          { name: 'domainHash', type: 'hexString', required: true },
-          { name: 'messageHash', type: 'hexString', required: true },
-        ]);
+    if (this.hasNestedArrays(this.params.data) || this.hasBiggerData(this.params.data)) {
+      validateParams(this.params, [
+        { name: 'domainHash', type: 'hexString', required: true },
+        { name: 'messageHash', type: 'hexString', required: true },
+      ]);
 
-        const { domainHash, messageHash } = this.params;
+      const { domainHash, messageHash } = this.params;
 
-        const response = await this.device.commands.typedCall(
-          'EthereumSignTypedHash',
-          'EthereumTypedDataSignature',
-          {
-            address_n: addressN,
-            domain_separator_hash: domainHash ?? '',
-            message_hash: messageHash,
-            chain_id: chainId,
-          }
-        );
+      if (!domainHash) throw ERRORS.TypedError('Runtime', 'domainHash is required');
+      if (!chainId) throw ERRORS.TypedError('Runtime', 'chainId is required');
 
-        return Promise.resolve(response.message);
-      }
+      const response = await this.signTypedHash({
+        typedCall: this.device.commands.typedCall.bind(this.device.commands),
+        addressN,
+        domainHash,
+        messageHash,
+        chainId,
+      });
 
-      throw ERRORS.TypedError(
-        HardwareErrorCode.CallMethodNeedUpgradeFirmware,
-        `Device firmware version is too low, please update to ${supportNestedArraysSignVersion}`,
-        { current: currentVersion, require: supportNestedArraysSignVersion }
-      );
+      return Promise.resolve(response.message);
     }
 
     // For Touch、Pro we use EthereumSignTypedData

package/src/api/evm/EVMVerifyMessage.ts

@@ -1,10 +1,13 @@
-import { EthereumVerifyMessage } from '@onekeyfe/hd-transport';
+import { EthereumVerifyMessageOneKey } from '@onekeyfe/hd-transport';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
+import TransportManager from '../../data-manager/TransportManager';
+import verifyMessageLegacyV1 from './legacyV1/verifyMessage';
+import verifyMessage from './latest/verifyMessage';
 
-export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessage> {
+export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessageOneKey> {
   init() {
     this.checkDeviceId = true;
     this.notAllowDeviceMode = [...this.notAllowDeviceMode, UI_REQUEST.INITIALIZE];
@@ -27,10 +30,16 @@ export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessage> {
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('EthereumVerifyMessage', 'Success', {
-      ...this.params,
-    });
+    if (TransportManager.getMessageVersion() === 'v1') {
+      return verifyMessageLegacyV1({
+        typedCall: this.device.commands.typedCall.bind(this.device.commands),
+        params: this.params,
+      });
+    }
 
-    return Promise.resolve(res.message);
+    return verifyMessage({
+      typedCall: this.device.commands.typedCall.bind(this.device.commands),
+      params: this.params,
+    });
   }
 }

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

@@ -0,0 +1,13 @@
+import { EthereumGetAddressOneKey, MessageResponse, TypedCall } from '@onekeyfe/hd-transport';
+
+export default async function ({
+  typedCall,
+  param,
+}: {
+  typedCall: TypedCall;
+  param: EthereumGetAddressOneKey;
+}): Promise<MessageResponse<'EthereumAddressOneKey'>> {
+  return typedCall('EthereumGetAddressOneKey', 'EthereumAddressOneKey', {
+    ...param,
+  });
+}

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

@@ -0,0 +1,13 @@
+import { EthereumGetPublicKeyOneKey, MessageResponse, TypedCall } from '@onekeyfe/hd-transport';
+
+export default async function ({
+  typedCall,
+  param,
+}: {
+  typedCall: TypedCall;
+  param: EthereumGetPublicKeyOneKey;
+}): Promise<MessageResponse<'EthereumPublicKeyOneKey'>> {
+  return typedCall('EthereumGetPublicKeyOneKey', 'EthereumPublicKeyOneKey', {
+    ...param,
+  });
+}

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

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