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

package/src/api/evmTrezor/EVMSignTransaction.ts

@@ -1,83 +0,0 @@
-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,
-    });
-  }
-}

package/src/api/evmTrezor/EVMSignTypedData.ts

@@ -1,366 +0,0 @@
-import semver from 'semver';
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-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 { getDeviceFirmwareVersion, getDeviceType } from '../../utils';
-import {
-  DeviceModelToTypes,
-  type EthereumSignTypedDataMessage,
-  type EthereumSignTypedDataTypes,
-} from '../../types';
-import { signTypedHash as signTypedHashLegacyV1 } from './legacyV1/signTypedHash';
-import { signTypedData as signTypedDataLegacyV1 } from './legacyV1/signTypedData';
-import { encodeData, getFieldType, parseArrayType } from '../helpers/typeNameUtils';
-
-import type {
-  EthereumTypedDataSignature,
-  EthereumTypedDataStructAck,
-  MessageKey,
-  MessageResponse,
-  TypedCall,
-} from '@onekeyfe/hd-transport';
-
-export type EVMSignTypedDataParams = {
-  addressN: number[];
-  metamaskV4Compat: boolean;
-  data: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>;
-  domainHash?: string;
-  messageHash?: string;
-  chainId?: number;
-};
-
-export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams> {
-  init() {
-    this.checkDeviceId = true;
-    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-
-    validateParams(this.payload, [
-      { name: 'path', required: true },
-      { name: 'metamaskV4Compat', type: 'boolean' },
-      { name: 'data', type: 'object' },
-      { name: 'domainHash', type: 'hexString' },
-      { name: 'messageHash', type: 'hexString' },
-      { name: 'chainId', type: 'number' },
-    ]);
-
-    const { path, data, metamaskV4Compat, domainHash, messageHash, chainId } = this.payload;
-
-    const addressN = validatePath(path, 3);
-
-    this.params = {
-      addressN,
-      metamaskV4Compat,
-      data,
-      chainId,
-    };
-
-    if (domainHash) {
-      this.params.domainHash = formatAnyHex(domainHash);
-      if (messageHash) {
-        this.params.messageHash = formatAnyHex(messageHash);
-      } else if (!!data && (!data.primaryType || data.primaryType !== 'EIP712Domain')) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.CallMethodInvalidParameter,
-          'message_hash should only be empty when data.primaryType=EIP712Domain'
-        );
-      }
-    }
-  }
-
-  async handleSignTypedData({
-    typedCall,
-    signData,
-    response,
-  }: {
-    typedCall: TypedCall;
-    signData: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>;
-    response: MessageResponse<MessageKey>;
-  }) {
-    const {
-      types,
-      primaryType,
-      domain,
-      message,
-    }: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> = signData;
-
-    while (response.type === 'EthereumTypedDataStructRequest') {
-      // @ts-ignore
-      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 typedCall(
-        'EthereumTypedDataStructAck',
-        // @ts-ignore
-        [
-          'EthereumTypedDataStructRequest',
-          'EthereumTypedDataValueRequest',
-          'EthereumTypedDataSignature',
-        ],
-        dataStruckAck
-      );
-    }
-
-    while (response.type === 'EthereumTypedDataValueRequest') {
-      // @ts-ignore
-      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 as Record<string, unknown>)[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 typedCall(
-        'EthereumTypedDataValueAck',
-        // @ts-ignore
-        ['EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'],
-        {
-          value: encodedData,
-        }
-      );
-    }
-
-    if (response.type !== 'EthereumTypedDataSignature') {
-      throw ERRORS.TypedError('Runtime', 'Unexpected response type');
-    }
-
-    // @ts-ignore
-    const { address, signature }: EthereumTypedDataSignature = response.message;
-    return {
-      address,
-      signature,
-    };
-  }
-
-  async signTypedData() {
-    const { addressN, data, metamaskV4Compat, chainId } = this.params;
-
-    const response = await signTypedDataLegacyV1({
-      typedCall: this.device.commands.typedCall.bind(this.device.commands),
-      addressN,
-      data,
-      metamaskV4Compat,
-      chainId,
-    });
-
-    return this.handleSignTypedData({
-      typedCall: this.device.commands.typedCall.bind(this.device.commands),
-      signData: data,
-      response,
-    });
-  }
-
-  signTypedHash({
-    typedCall,
-    addressN,
-    domainHash,
-    messageHash,
-    chainId,
-  }: {
-    typedCall: TypedCall;
-    addressN: number[];
-    domainHash: string | undefined;
-    messageHash: string | undefined;
-    chainId: number | undefined;
-  }) {
-    if (!domainHash) throw ERRORS.TypedError('Runtime', 'domainHash is required');
-
-    return signTypedHashLegacyV1({
-      typedCall,
-      addressN,
-      chainId,
-      domainHash,
-      messageHash,
-      device: this.device,
-    });
-  }
-
-  getVersionRange() {
-    return {
-      model_mini: {
-        min: '2.1.9',
-      },
-    };
-  }
-
-  hasBiggerData(item: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>) {
-    const data = get(item.message, 'data', undefined) as string | undefined;
-    if (!data) return false;
-
-    let biggerLimit = 1024; // 1k
-
-    const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
-    const supportBiggerDataVersion = '4.4.0';
-
-    if (semver.gte(currentVersion, supportBiggerDataVersion)) {
-      biggerLimit = 1536; // 1.5k
-    }
-
-    const startIndex = data.startsWith('0x') ? 2 : 0;
-    return (data.length - startIndex) / 2 > biggerLimit;
-  }
-
-  hasNestedArrays(item: any): boolean {
-    if (!item) return false;
-
-    if (Array.isArray(item)) {
-      // item is an array
-      for (const element of item) {
-        if (Array.isArray(element)) {
-          // element is a nested array
-          return true;
-        }
-        if (typeof element === 'object' && element !== null) {
-          // element is an object, so check its properties recursively
-          if (this.hasNestedArrays(element)) {
-            return true;
-          }
-        }
-      }
-    } else if (typeof item === 'object' && item !== null) {
-      // item is an object, so check its properties recursively
-      // eslint-disable-next-line no-restricted-syntax
-      for (const property in item) {
-        if (this.hasNestedArrays(item[property])) {
-          return true;
-        }
-      }
-    }
-    // no nested arrays found
-    return false;
-  }
-
-  supportSignTyped() {
-    const deviceType = getDeviceType(this.device.features);
-    if (DeviceModelToTypes.model_mini.includes(deviceType)) {
-      const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
-      const supportSignTypedVersion = '2.2.0';
-
-      if (semver.lt(currentVersion, supportSignTypedVersion)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  async run() {
-    if (!this.device.features) {
-      throw ERRORS.TypedError(
-        'Device_InitializeFailed',
-        'Device initialization failed. Please try again.'
-      );
-    }
-
-    const { addressN, chainId } = this.params;
-
-    // For Classic、Mini device we use EthereumSignTypedData
-    const deviceType = getDeviceType(this.device.features);
-    if (DeviceModelToTypes.model_mini.includes(deviceType)) {
-      validateParams(this.params, [
-        { name: 'domainHash', type: 'hexString', required: true },
-        { name: 'messageHash', type: 'hexString', required: true },
-      ]);
-
-      const { domainHash, messageHash } = this.params;
-
-      let response;
-      if (this.supportSignTyped()) {
-        response = await this.signTypedHash({
-          typedCall: this.device.commands.typedCall.bind(this.device.commands),
-          addressN,
-          chainId,
-          domainHash,
-          messageHash,
-        });
-      } else {
-        response = await this.device.commands.typedCall(
-          'EthereumSignMessageEIP712',
-          'EthereumMessageSignature',
-          {
-            address_n: addressN,
-            domain_hash: domainHash ?? '',
-            message_hash: messageHash ?? '',
-          }
-        );
-      }
-
-      return Promise.resolve(response.message);
-    }
-
-    // Touch Pro Sign NestedArrays
-    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;
-
-      if (!domainHash) throw ERRORS.TypedError('Runtime', 'domainHash is required');
-
-      const response = await this.signTypedHash({
-        typedCall: this.device.commands.typedCall.bind(this.device.commands),
-        addressN,
-        chainId,
-        domainHash,
-        messageHash,
-      });
-
-      return Promise.resolve(response.message);
-    }
-
-    // For Touch、Pro we use EthereumSignTypedData
-    return this.signTypedData();
-  }
-}

package/src/api/evmTrezor/EVMVerifyMessage.ts

@@ -1,37 +0,0 @@
-import { UI_REQUEST } from '../../constants/ui-request';
-import { BaseMethod } from '../BaseMethod';
-import { validateParams } from '../helpers/paramsValidator';
-import { formatAnyHex } from '../helpers/hexUtils';
-import verifyMessageLegacyV1 from './legacyV1/verifyMessage';
-
-import type { EthereumVerifyMessageOneKey } from '@onekeyfe/hd-transport';
-
-export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessageOneKey> {
-  init() {
-    this.checkDeviceId = true;
-    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-
-    validateParams(this.payload, [
-      { name: 'address', type: 'string', required: true },
-      { name: 'messageHex', type: 'hexString', required: true },
-      { name: 'signature', type: 'hexString', required: true },
-      { name: 'chainId', type: 'number' },
-    ]);
-
-    const { address, messageHex, signature } = formatAnyHex(this.payload);
-
-    this.params = {
-      address,
-      message: messageHex,
-      signature,
-      chain_id: this.payload.chainId,
-    };
-  }
-
-  async run() {
-    return verifyMessageLegacyV1({
-      typedCall: this.device.commands.typedCall.bind(this.device.commands),
-      params: this.params,
-    });
-  }
-}

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

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

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

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

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

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

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

@@ -1,24 +0,0 @@
-import { evmSignTx, evmSignTxEip1559 } from '../../evm/latest/signTransaction';
-
-import type { TypedCall } from '@onekeyfe/hd-transport';
-import type { EVMTransaction, EVMTransactionEIP1559 } from '../../../types';
-
-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,
-        supportTrezor: true,
-      })
-    : evmSignTx({ typedCall, addressN, tx: tx as EVMTransaction, supportTrezor: true });

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

@@ -1,36 +0,0 @@
-import type { TypedCall } from '@onekeyfe/hd-transport';
-import type { 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 message = {
-    address_n: addressN,
-    primary_type: primaryType as string,
-    metamask_v4_compat: metamaskV4Compat,
-    chain_id: chainId,
-  };
-  const response = await typedCall(
-    'EthereumSignTypedData',
-    [
-      'EthereumTypedDataStructRequest',
-      'EthereumTypedDataValueRequest',
-      'EthereumTypedDataSignature',
-      'EthereumGnosisSafeTxRequest',
-    ],
-    message
-  );
-  return response;
-};

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

@@ -1,48 +0,0 @@
-import semver from 'semver';
-import { EDeviceType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import type { Device } from '../../../device/Device';
-import type { MessageResponse, TypedCall } from '@onekeyfe/hd-transport';
-
-export const signTypedHash = async ({
-  typedCall,
-  addressN,
-  device,
-  chainId,
-  domainHash,
-  messageHash,
-}: {
-  typedCall: TypedCall;
-  addressN: number[];
-  device: Device;
-  chainId: number | undefined;
-  domainHash: string;
-  messageHash: string | undefined;
-}): Promise<
-  | MessageResponse<'EthereumTypedDataSignature'>
-  | MessageResponse<'EthereumTypedDataSignatureOneKey'>
-> => {
-  const deviceType = device.getCurrentDeviceType();
-  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
-    // Touch Pro Sign NestedArrays
-    const currentVersion = device.getCurrentFirmwareVersionString() ?? '0.0.0';
-    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 }
-      );
-    }
-  }
-
-  const message = {
-    address_n: addressN,
-    domain_separator_hash: domainHash ?? '',
-    message_hash: messageHash,
-    chain_id: chainId,
-  };
-  return typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', message);
-};

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

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