@ukeyfe/hardware-core 1.1.13

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

@@ -0,0 +1,301 @@
+import {
+  EthereumAuthorizationSignature,
+  EthereumSignTx,
+  EthereumSignTxEIP1559,
+  EthereumSignTxEIP7702UKey,
+  EthereumTxRequest,
+  EthereumTxRequestUKey,
+  MessageResponse,
+  TypedCall,
+} from '@ukeyfe/hardware-transport';
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import {
+  EVMSignedTx,
+  EVMTransaction,
+  EVMTransactionEIP1559,
+  EVMTransactionEIP7702,
+} from '../../../types';
+import { cutString } from '../../helpers/stringUtils';
+import { stripHexStartZeroes, addHexPrefix } from '../../helpers/hexUtils';
+
+export const processTxRequest = async ({
+  typedCall,
+  request,
+  data,
+  chainId,
+  supportTrezor,
+}: {
+  typedCall: TypedCall;
+  request: EthereumTxRequestUKey | EthereumTxRequest;
+  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;
+    const authorizationSignatures =
+      'authorization_signatures' in request ? request.authorization_signatures : undefined;
+
+    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;
+    }
+
+    const result: any = {
+      v: `0x${v.toString(16)}`,
+      r: `0x${r}`,
+      s: `0x${s}`,
+    };
+
+    // Add authorization signatures for EIP7702 transactions with flattened yParity,r,s structure
+    if (authorizationSignatures && authorizationSignatures.length > 0) {
+      result.authorizationSignatures = authorizationSignatures.map(
+        (sig: EthereumAuthorizationSignature) => ({
+          yParity: sig.y_parity,
+          r: sig.r,
+          s: sig.s,
+        })
+      );
+    }
+
+    return Promise.resolve(result);
+  }
+
+  const [first, rest] = cutString(data, request.data_length * 2);
+
+  let response: MessageResponse<'EthereumTxRequestUKey'> | MessageResponse<'EthereumTxRequest'>;
+  if (supportTrezor) {
+    response = await typedCall('EthereumTxAck', 'EthereumTxRequest', {
+      data_chunk: first,
+    });
+  } else {
+    response = await typedCall('EthereumTxAckUKey', 'EthereumTxRequestUKey', {
+      data_chunk: first,
+    });
+  }
+
+  return processTxRequest({
+    typedCall,
+    request: response.message,
+    data: rest,
+    chainId,
+    supportTrezor,
+  });
+};
+
+export 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('EthereumSignTxUKey', 'EthereumTxRequestUKey', message);
+  }
+
+  return processTxRequest({
+    typedCall,
+    request: response.message,
+    data: rest,
+    chainId,
+    supportTrezor,
+  });
+};
+
+export 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('EthereumSignTxEIP1559UKey', 'EthereumTxRequestUKey', message);
+  }
+
+  return processTxRequest({ typedCall, request: response.message, data: rest, supportTrezor });
+};
+
+export const evmSignTxEip7702 = async ({
+  typedCall,
+  addressN,
+  tx,
+  supportTrezor,
+}: {
+  typedCall: TypedCall;
+  addressN: number[];
+  tx: EVMTransactionEIP7702;
+  supportTrezor?: boolean;
+}) => {
+  const {
+    to,
+    value,
+    gasLimit,
+    nonce,
+    data,
+    chainId,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    accessList,
+    authorizationList,
+  } = tx;
+
+  const length = data == null ? 0 : data.length / 2;
+
+  const [first, rest] = cutString(data, 1024 * 2);
+
+  const message: EthereumSignTxEIP7702UKey = {
+    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,
+    })),
+    authorization_list: authorizationList.map(auth => ({
+      address_n: auth.addressN || [],
+      chain_id: auth.chainId,
+      address: addHexPrefix(auth.address),
+      nonce: stripHexStartZeroes(auth.nonce),
+      signature:
+        auth.yParity !== undefined && auth.r && auth.s
+          ? {
+              y_parity: auth.yParity,
+              r: auth.r,
+              s: auth.s,
+            }
+          : undefined,
+    })),
+  };
+
+  let response;
+  if (supportTrezor) {
+    // Note: Trezor doesn't support EIP7702 yet, this is for future compatibility
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'EIP7702 not supported by Trezor');
+  } else {
+    response = await typedCall('EthereumSignTxEIP7702UKey', 'EthereumTxRequestUKey', message);
+  }
+
+  return processTxRequest({
+    typedCall,
+    request: response.message,
+    data: rest,
+    supportTrezor,
+  });
+};
+
+export const signTransaction = async ({
+  typedCall,
+  isEIP1559,
+  isEIP7702,
+  addressN,
+  tx,
+}: {
+  addressN: number[];
+  tx: EVMTransaction | EVMTransactionEIP1559 | EVMTransactionEIP7702;
+  isEIP1559: boolean;
+  isEIP7702?: boolean;
+  typedCall: TypedCall;
+}) => {
+  if (isEIP7702) {
+    return evmSignTxEip7702({ typedCall, addressN, tx: tx as EVMTransactionEIP7702 });
+  }
+  return 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,34 @@
+import { TypedCall } from '@ukeyfe/hardware-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(
+    'EthereumSignTypedDataUKey',
+    // @ts-ignore
+    [
+      'EthereumTypedDataStructRequestUKey',
+      'EthereumTypedDataValueRequestUKey',
+      'EthereumTypedDataSignatureUKey',
+      'EthereumGnosisSafeTxRequest',
+    ],
+    {
+      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 '@ukeyfe/hardware-transport';
+import semver from 'semver';
+import { EDeviceType, ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { Device } from '../../../device/Device';
+import { getDeviceFirmwareVersion, getDeviceType } from '../../../utils';
+
+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<'EthereumTypedDataSignatureUKey'>> => {
+  const deviceType = getDeviceType(device.features);
+  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.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('EthereumSignTypedHashUKey', 'EthereumTypedDataSignatureUKey', {
+    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 { EthereumVerifyMessageUKey, Success, TypedCall } from '@ukeyfe/hardware-transport';
+
+export default async function ({
+  typedCall,
+  params,
+}: {
+  typedCall: TypedCall;
+  params: EthereumVerifyMessageUKey;
+}): Promise<Success> {
+  const res = await typedCall('EthereumVerifyMessageUKey', 'Success', {
+    ...params,
+  });
+
+  return Promise.resolve(res.message);
+}

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

@@ -0,0 +1,16 @@
+import { EthereumGetAddressUKey, MessageResponse, TypedCall } from '@ukeyfe/hardware-transport';
+
+export default async function ({
+  typedCall,
+  param,
+}: {
+  typedCall: TypedCall;
+  param: EthereumGetAddressUKey;
+}): 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 { EthereumGetPublicKeyUKey, MessageResponse, TypedCall } from '@ukeyfe/hardware-transport';
+
+export default async function ({
+  typedCall,
+  param,
+}: {
+  typedCall: TypedCall;
+  param: EthereumGetPublicKeyUKey;
+}): 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,
+  EthereumSignMessageUKey,
+  TypedCall,
+} from '@ukeyfe/hardware-transport';
+
+export default async function ({
+  typedCall,
+  params,
+}: {
+  typedCall: TypedCall;
+  params: EthereumSignMessageUKey;
+}): 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,36 @@
+import { TypedCall } from '@ukeyfe/hardware-transport';
+import { EVMTransaction, EVMTransactionEIP1559, EVMTransactionEIP7702 } from '../../../types';
+import { evmSignTx, evmSignTxEip1559, evmSignTxEip7702 } from '../latest/signTransaction';
+
+export const signTransaction = async ({
+  typedCall,
+  isEIP1559,
+  isEIP7702,
+  addressN,
+  tx,
+}: {
+  addressN: number[];
+  tx: EVMTransaction | EVMTransactionEIP1559 | EVMTransactionEIP7702;
+  isEIP1559: boolean;
+  isEIP7702: boolean;
+  typedCall: TypedCall;
+}) => {
+  if (isEIP7702) {
+    return evmSignTxEip7702({
+      typedCall,
+      addressN,
+      tx: tx as EVMTransactionEIP7702,
+      supportTrezor: true,
+    });
+  }
+  if (isEIP1559) {
+    return evmSignTxEip1559({
+      typedCall,
+      addressN,
+      tx: tx as EVMTransactionEIP1559,
+      supportTrezor: true,
+    });
+  }
+
+  return evmSignTx({ typedCall, addressN, tx: tx as EVMTransaction, supportTrezor: true });
+};

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

@@ -0,0 +1,37 @@
+import { TypedCall } from '@ukeyfe/hardware-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',
+      'EthereumGnosisSafeTxRequest',
+    ],
+    {
+      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 '@ukeyfe/hardware-transport';
+import semver from 'semver';
+import { EDeviceType, ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { Device } from '../../../device/Device';
+import { getDeviceFirmwareVersion, getDeviceType } from '../../../utils';
+
+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<'EthereumTypedDataSignatureUKey'>
+> => {
+  const deviceType = getDeviceType(device.features);
+  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.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 { EthereumVerifyMessageUKey, Success, TypedCall } from '@ukeyfe/hardware-transport';
+
+export default async function ({
+  typedCall,
+  params,
+}: {
+  typedCall: TypedCall;
+  params: EthereumVerifyMessageUKey;
+}): 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/filecoin/FilecoinGetAddress.ts

@@ -0,0 +1,79 @@
+import { FilecoinGetAddress as HardwareFilecoinGetAddress } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { FilecoinAddress, FilecoinGetAddressParams } from '../../types';
+
+export default class FilecoinGetAddress extends BaseMethod<HardwareFilecoinGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: FilecoinGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'isTestnet', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        testnet: batch.isTestnet,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.10.0',
+      },
+      model_touch: {
+        min: '3.5.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: FilecoinAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('FilecoinGetAddress', 'FilecoinAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        address,
+      };
+      responses.push(result);
+      this.postPreviousAddressMessage(result);
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}