@ukeyfe/hardware-core 1.1.13

package/src/api/evm/EVMGetAddress.ts

@@ -0,0 +1,87 @@
+import { EthereumGetAddressUKey } 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 { EVMAddress, EVMGetAddressParams } from '../../types';
+import TransportManager from '../../data-manager/TransportManager';
+import getAddressLegacyV1 from './legacyV1/getAddress';
+import getAddress from './latest/getAddress';
+
+export default class EvmGetAddress extends BaseMethod<EthereumGetAddressUKey[]> {
+  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: EVMGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'chainId', type: 'number' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        chain_id: batch.chainId,
+      });
+    });
+  }
+
+  async getEvmAddress(param: EthereumGetAddressUKey) {
+    if (TransportManager.getMessageVersion() === 'v1') {
+      return getAddressLegacyV1({
+        typedCall: this.device.commands.typedCall.bind(this.device.commands),
+        param,
+      });
+    }
+
+    return getAddress({
+      typedCall: this.device.commands.typedCall.bind(this.device.commands),
+      param,
+    });
+  }
+
+  async run() {
+    const responses: EVMAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.getEvmAddress(param);
+
+      const { address } = res.message;
+
+      if (!address) {
+        throw new Error('EthereumGetAddressUKey: address is undefined');
+      }
+
+      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]);
+  }
+}

package/src/api/evm/EVMGetPublicKey.ts

@@ -0,0 +1,115 @@
+import { EthereumGetPublicKey, EthereumGetPublicKeyUKey } 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 { EVMGetPublicKeyParams, EVMPublicKey } from '../../types';
+import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
+import TransportManager from '../../data-manager/TransportManager';
+import getPublicKey from './latest/getPublicKey';
+import getPublicKeyLegacyV1 from './legacyV1/getPublicKey';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+
+export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyUKey[]> {
+  hasBundle = false;
+
+  confirmShowOnUKey = false;
+
+  useBatch = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+
+    this.confirmShowOnUKey = this.payload?.bundle?.some(
+      (item: EVMGetPublicKeyParams) => !!item.showOnOneKey
+    );
+
+    this.useBatch = !this.confirmShowOnUKey && this.hasBundle && this.payload.useBatch;
+
+    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: EVMGetPublicKeyParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'chainId', type: 'number' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        chain_id: batch.chainId,
+      });
+    });
+  }
+
+  getEvmPublicKey(param: EthereumGetPublicKey) {
+    if (TransportManager.getMessageVersion() === 'v1') {
+      return getPublicKeyLegacyV1({
+        typedCall: this.device.commands.typedCall.bind(this.device.commands),
+        param,
+      });
+    }
+
+    return getPublicKey({
+      typedCall: this.device.commands.typedCall.bind(this.device.commands),
+      param,
+    });
+  }
+
+  async run() {
+    const responses: EVMPublicKey[] = [];
+
+    if (this.useBatch && supportBatchPublicKey(this.device?.features)) {
+      try {
+        const res = await batchGetPublickeys(this.device, this.params, 'secp256k1', 60, {
+          includeNode: false,
+          ignoreCoinType: true,
+        });
+        const result = res.public_keys.map((publicKey: string, index: number) => ({
+          path: serializedPath((this.params as unknown as any[])[index].address_n),
+          pub: publicKey,
+          publicKey,
+        }));
+
+        validateResult(result, ['pub'], {
+          expectedLength: this.params.length,
+        });
+        return await Promise.resolve(result);
+      } catch (e) {
+        // ignore error, fallback to single get public key
+      }
+    }
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.getEvmPublicKey(param);
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        pub: res.message.node.public_key,
+        publicKey: res.message.node.public_key,
+        ...res.message,
+      });
+    }
+
+    validateResult(responses, ['pub'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/evm/EVMSignMessage.ts

@@ -0,0 +1,48 @@
+import { EthereumSignMessageUKey } from '@ukeyfe/hardware-transport';
+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 TransportManager from '../../data-manager/TransportManager';
+import signMessage from './latest/signMessage';
+import signMessageLegacyV1 from './legacyV1/signMessage';
+
+export default class EVMSignMessage extends BaseMethod<EthereumSignMessageUKey> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'messageHex', type: 'hexString', required: true },
+      { name: 'chainId', type: 'number' },
+    ]);
+
+    const { path, messageHex, chainId } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      message: formatAnyHex(messageHex),
+      chain_id: chainId,
+    };
+  }
+
+  async run() {
+    if (TransportManager.getMessageVersion() === 'v1') {
+      return signMessageLegacyV1({
+        typedCall: this.device.commands.typedCall.bind(this.device.commands),
+        params: this.params,
+      });
+    }
+
+    return signMessage({
+      typedCall: this.device.commands.typedCall.bind(this.device.commands),
+      params: this.params,
+    });
+  }
+}

package/src/api/evm/EVMSignMessageEIP712.ts

@@ -0,0 +1,55 @@
+import { EthereumSignMessageEIP712 } from '@ukeyfe/hardware-transport';
+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';
+
+/**
+ * @deprecated Use EVMSignTypedData instead.
+ */
+export default class EVMSignMessageEIP712 extends BaseMethod<EthereumSignMessageEIP712> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'domainHash', type: 'hexString', required: true },
+      { name: 'messageHash', type: 'hexString', required: true },
+    ]);
+
+    const { path, domainHash, messageHash } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      domain_hash: formatAnyHex(domainHash),
+      message_hash: formatAnyHex(messageHash),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.1.9',
+      },
+      model_classic1s: {
+        min: '3.14.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'EthereumSignMessageEIP712',
+      'EthereumMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/evm/EVMSignTransaction.ts

@@ -0,0 +1,138 @@
+import { ERRORS } from '@ukeyfe/hardware-shared';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { SchemaParam, validateParams } from '../helpers/paramsValidator';
+import {
+  EVMSignTransactionParams,
+  EVMTransaction,
+  EVMTransactionEIP1559,
+  EVMTransactionEIP7702,
+} 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[] = [];
+
+  isEIP1559 = false;
+
+  isEIP7702 = false;
+
+  formattedTx: EVMTransaction | EVMTransactionEIP1559 | EVMTransactionEIP7702 | undefined;
+
+  /**
+   * Check if transaction has EIP7702 authorization list
+   * Following ethereumjs pattern for type detection
+   */
+  private hasEIP7702Features(tx: EVMSignTransactionParams['transaction']): boolean {
+    const authList = (tx as EVMTransactionEIP7702).authorizationList;
+    return !!(authList && Array.isArray(authList) && authList.length > 0);
+  }
+
+  /**
+   * Check if transaction has EIP1559 fee market features
+   * Both maxFeePerGas and maxPriorityFeePerGas must be present
+   */
+  private hasEIP1559Features(tx: EVMSignTransactionParams['transaction']): boolean {
+    return !!(tx.maxFeePerGas && tx.maxPriorityFeePerGas);
+  }
+
+  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;
+
+    // Transaction type detection based on distinctive features
+    // Following ethereumjs pattern: check most specific features first
+
+    // EIP7702: Has authorizationList (extends EIP1559)
+    this.isEIP7702 = this.hasEIP7702Features(tx);
+
+    // EIP1559: Has EIP1559 fee fields but no authorizationList (extends EIP2930)
+    this.isEIP1559 = this.hasEIP1559Features(tx) && !this.isEIP7702;
+
+    // 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.isEIP7702) {
+      schema.push({ name: 'maxFeePerGas', type: 'hexString', required: true });
+      schema.push({ name: 'maxPriorityFeePerGas', type: 'hexString', required: true });
+      schema.push({ name: 'authorizationList', type: 'array', required: true });
+    } else 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.isEIP7702) {
+      return {
+        model_classic1s: {
+          min: '3.13.0',
+        },
+        pro: {
+          min: '4.16.0',
+        },
+      };
+    }
+    if (this.isEIP1559) {
+      return {
+        model_mini: {
+          min: '2.1.11',
+        },
+      };
+    }
+    return {
+      model_mini: {
+        min: '1.0.0',
+      },
+    };
+  }
+
+  async run() {
+    const { addressN, isEIP1559, isEIP7702, formattedTx } = this;
+
+    if (formattedTx == null) throw ERRORS.TypedError('Runtime', 'formattedTx is not set');
+
+    if (TransportManager.getMessageVersion() === 'v1') {
+      return signTransactionLegacyV1({
+        typedCall: this.device.commands.typedCall.bind(this.device.commands),
+        addressN,
+        tx: formattedTx,
+        isEIP1559,
+        isEIP7702,
+      });
+    }
+
+    return signTransaction({
+      typedCall: this.device.commands.typedCall.bind(this.device.commands),
+      addressN,
+      tx: formattedTx,
+      isEIP1559,
+      isEIP7702,
+    });
+  }
+}