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

package/src/api/evmTrezor/EVMSignTypedData.ts

@@ -0,0 +1,366 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,48 @@
+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

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

package/src/api/extensionMethodNames.ts

@@ -0,0 +1,88 @@
+export const TEST_API_METHOD_NAMES = [
+  'btcGetOwnershipId',
+  'btcGetOwnershipProof',
+  'btcAuthorizeCoinJoin',
+  'cryptoBatchGetPublickeys',
+  'cryptoCipherKeyValue',
+  'cryptoCosiCommit',
+  'cryptoCosiSign',
+  'cryptoGetECDHSessionKey',
+  'cryptoSignIdentity',
+  'evmGetAddressTrezor',
+  'evmGetPublicKeyTrezor',
+  'evmSignMessageTrezor',
+  'evmSignTransactionTrezor',
+  'evmSignTypedDataTrezor',
+  'evmVerifyMessageTrezor',
+  'nemDecryptMessage',
+  'deviceSpiFlashWrite',
+  'deviceSpiFlashRead',
+  'deviceInfoSettings',
+  'deviceGetInfo',
+  'deviceReadSEPublicCert',
+  'deviceWriteSEPrivateKey',
+  'deviceWriteSEPublicCert',
+  'deviceSESignMessage',
+  'devicePing',
+  'deviceGetEntropy',
+  'deviceGetFirmwareHash',
+  'deviceUnlockPath',
+  'deviceSdProtect',
+  'deviceChangeWipeCode',
+  'deviceEndSession',
+  'deviceLoad',
+  'deviceDoPreauthorized',
+  'deviceCancelAuthorization',
+  'emmcDirList',
+  'emmcDirMake',
+  'emmcDirRemove',
+  'emmcFileDelete',
+  'emmcFileRead',
+  'emmcFileWrite',
+  'emmcFixPermission',
+  'emmcPathInfo',
+  'debugLinkDecision',
+  'debugLinkEraseSdCard',
+  'debugLinkFlashErase',
+  'debugLinkGetState',
+  'debugLinkMemoryRead',
+  'debugLinkMemoryWrite',
+  'debugLinkRecordScreen',
+  'debugLinkReseedRandom',
+  'debugLinkStop',
+  'debugLinkWatchLayout',
+  'firmwareErase',
+  'firmwareEraseEx',
+  'firmwareUpdateEmmcTest',
+  'firmwareUploadTest',
+  'reboot',
+  'selfTest',
+  'tezosGetAddress',
+  'tezosGetPublicKey',
+  'tezosSignTx',
+  'moneroGetAddress',
+  'moneroGetWatchKey',
+  'eosGetPublicKey',
+  'eosSignTx',
+  'binanceGetAddress',
+  'binanceGetPublicKey',
+  'binanceSignTx',
+  'webAuthnAddResidentCredential',
+  'webAuthnListResidentCredentials',
+  'webAuthnRemoveResidentCredential',
+  'getPublicKeyMultiple',
+  'listResDir',
+  'nftWriteData',
+  'nftWriteInfo',
+  'readSEPublicKey',
+  'resourceUpdate',
+  'bixinBackupDevice',
+  'bixinLoadDevice',
+  'bixinMessageSE',
+  'bixinVerifyDeviceRequest',
+] as const;
+
+export const FACTORY_API_METHOD_NAMES = [
+  'deviceProvisionFactoryInfo',
+  'deviceWriteFactoryCertificate',
+] as const;

package/src/api/factoryMethods.ts

@@ -0,0 +1,2 @@
+export { default as deviceProvisionFactoryInfo } from './protocol-v2/DeviceFactoryInfoSet';
+export { default as deviceWriteFactoryCertificate } from './protocol-v2/DeviceFactoryCertificateWrite';