@onetokenfe/hd-core 1.1.23

package/src/api/dynex/DnxSignTransaction.ts

@@ -0,0 +1,126 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { stripHexPrefix } from '../helpers/hexUtils';
+
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type { DnxSignature } from '../../types';
+import type { DnxSignTx, TypedCall } from '@onetokenfe/hd-transport';
+
+export default class DnxSignTransaction extends BaseMethod<DnxSignTx> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { payload } = this;
+    // init params
+    const addressN = validatePath(payload.path, 3);
+
+    validateParams(payload, [
+      { name: 'path', required: true },
+      { name: 'inputs', type: 'array', required: true },
+      { name: 'toAddress', type: 'string', required: true },
+      { name: 'amount', required: true },
+      { name: 'fee', required: true },
+      { name: 'paymentIdHex', type: 'string' },
+    ]);
+
+    if (payload.paymentIdHex && stripHexPrefix(payload.paymentIdHex).length !== 64) {
+      throw new Error('Payment ID must be 32 bytes long');
+    }
+
+    this.params = {
+      address_n: addressN,
+      inputs_count: payload.inputs.length,
+      to_address: payload.toAddress,
+      amount: payload.amount,
+      fee: payload.fee,
+    };
+    if (payload.paymentIdHex) {
+      this.params.payment_id = stripHexPrefix(payload.paymentIdHex);
+    }
+  }
+
+  getVersionRange() {
+    return {
+      classic: {
+        min: '3.8.0',
+      },
+    };
+  }
+
+  async processTxRequest(
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'DnxInputRequest'>,
+    signature: Partial<DnxSignature>
+  ): Promise<DnxSignature> {
+    if (res.type === 'DnxInputRequest') {
+      const { inputs } = this.payload;
+      const { request_index, tx_key, computed_key_image } = res.message;
+
+      if (tx_key?.ephemeral_tx_sec_key && tx_key?.ephemeral_tx_pub_key) {
+        signature = {
+          ...signature,
+          txKey: {
+            ephemeralTxSecKey: tx_key.ephemeral_tx_sec_key,
+            ephemeralTxPubKey: tx_key.ephemeral_tx_pub_key,
+          },
+        };
+      }
+
+      if (computed_key_image?.key_image) {
+        signature = {
+          ...signature,
+          computedKeyImages: [...(signature.computedKeyImages ?? []), computed_key_image.key_image],
+        };
+      }
+
+      if (request_index) {
+        const input = inputs[request_index - 1];
+
+        const signRes = await typedCall('DnxInputAck', 'DnxInputRequest', {
+          prev_index: input.prevIndex,
+          global_index: input.globalIndex,
+          tx_pubkey: input.txPubkey,
+          prev_out_pubkey: input.prevOutPubkey,
+          amount: input.amount,
+        });
+
+        return this.processTxRequest(typedCall, signRes, signature);
+      }
+
+      const signRes = await typedCall('DnxRTSigsRequest', 'DnxSignedTx', {});
+
+      if (
+        signature.txKey == null ||
+        signature.txKey.ephemeralTxSecKey == null ||
+        signature.txKey.ephemeralTxPubKey == null
+      ) {
+        throw new Error('signatures or tx_key missing in response');
+      }
+
+      return {
+        path: serializedPath(this.params.address_n),
+        txKey: signature.txKey,
+        computedKeyImages: signature.computedKeyImages ?? [],
+        signatures: signRes.message.signatures,
+        outputKeys: signRes.message.output_keys,
+      };
+    }
+
+    throw new Error('Unexpected response');
+  }
+
+  async run() {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+
+    const res = await this.device.commands.typedCall('DnxSignTx', 'DnxInputRequest', {
+      ...this.params,
+    });
+
+    return this.processTxRequest(typedCall, res, {});
+  }
+}

package/src/api/evm/EVMGetAddress.ts

@@ -0,0 +1,88 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import TransportManager from '../../data-manager/TransportManager';
+import getAddressLegacyV1 from './legacyV1/getAddress';
+import getAddress from './latest/getAddress';
+
+import type { EVMAddress, EVMGetAddressParams } from '../../types';
+import type { EthereumGetAddressOneToken } from '@onetokenfe/hd-transport';
+
+export default class EvmGetAddress extends BaseMethod<EthereumGetAddressOneToken[]> {
+  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: 'showOnOneToken', type: 'boolean' },
+        { name: 'chainId', type: 'number' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+        chain_id: batch.chainId,
+      });
+    });
+  }
+
+  async getEvmAddress(param: EthereumGetAddressOneToken) {
+    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('EthereumGetAddressOneToken: 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,116 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+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';
+
+import type { EVMGetPublicKeyParams, EVMPublicKey } from '../../types';
+import type { EthereumGetPublicKey, EthereumGetPublicKeyOneToken } from '@onetokenfe/hd-transport';
+
+export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneToken[]> {
+  hasBundle = false;
+
+  confirmShowOnOneToken = false;
+
+  useBatch = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+
+    this.confirmShowOnOneToken = this.payload?.bundle?.some(
+      (item: EVMGetPublicKeyParams) => !!item.showOnOneToken
+    );
+
+    this.useBatch = !this.confirmShowOnOneToken && 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: 'showOnOneToken', type: 'boolean' },
+        { name: 'chainId', type: 'number' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+        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,49 @@
+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';
+
+import type { EthereumSignMessageOneToken } from '@onetokenfe/hd-transport';
+
+export default class EVMSignMessage extends BaseMethod<EthereumSignMessageOneToken> {
+  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,56 @@
+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 type { EthereumSignMessageEIP712 } from '@onetokenfe/hd-transport';
+
+/**
+ * @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,141 @@
+import { ERRORS } from '@onetokenfe/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 TransportManager from '../../data-manager/TransportManager';
+import { signTransaction } from './latest/signTransaction';
+import { signTransaction as signTransactionLegacyV1 } from './legacyV1/signTransaction';
+
+import type {
+  EVMSignTransactionParams,
+  EVMTransaction,
+  EVMTransactionEIP1559,
+  EVMTransactionEIP7702,
+} from '../../types';
+import type { SchemaParam } from '../helpers/paramsValidator';
+
+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,
+    });
+  }
+}