@ukeyfe/hardware-core 1.1.13

package/src/api/benfen/BenfenSignTransaction.ts

@@ -0,0 +1,104 @@
+import { BenfenSignTx, TypedCall, BenfenSignedTx, MessageType } from '@ukeyfe/hardware-transport';
+
+import { bytesToHex } from '@noble/hashes/utils';
+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 { TypedResponseMessage } from '../../device/DeviceCommands';
+
+export default class BenfenSignTransaction extends BaseMethod<BenfenSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+      { name: 'coinType', type: 'string', required: false },
+    ]);
+
+    const { path, rawTx, coinType } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx),
+      ...(coinType && {
+        coin_type: formatAnyHex(Buffer.from(coinType).toString('hex')),
+      }),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      pro: {
+        min: '4.12.0',
+      },
+      model_classic1s: {
+        min: '3.11.0',
+      },
+    };
+  }
+
+  chunkByteSize = 1024;
+
+  processTxRequest = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'BenfenSignedTx'> | TypedResponseMessage<'BenfenTxRequest'>,
+    data: Buffer,
+    offset = 0
+  ): Promise<BenfenSignedTx> => {
+    if (res.type === 'BenfenSignedTx') {
+      return res.message;
+    }
+
+    const { data_length } = res.message;
+
+    if (!data_length) {
+      // @ts-expect-error
+      return res.message;
+    }
+
+    const payload = data.subarray(offset, offset + data_length);
+    const newOffset = offset + payload.length;
+    const resourceAckParams = {
+      data_chunk: bytesToHex(new Uint8Array(payload)),
+    };
+
+    const response = await typedCall(
+      'BenfenTxAck',
+      ['BenfenSignedTx', 'BenfenTxRequest'] as unknown as keyof MessageType,
+      {
+        ...resourceAckParams,
+      }
+    );
+
+    return this.processTxRequest(
+      typedCall,
+      response as TypedResponseMessage<'BenfenSignedTx'> | TypedResponseMessage<'BenfenTxRequest'>,
+      data,
+      newOffset
+    );
+  };
+
+  async run() {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+    const offset = this.chunkByteSize;
+    const data = Buffer.from(this.params.raw_tx, 'hex');
+    this.params = {
+      address_n: this.params.address_n,
+      coin_type: this.params.coin_type,
+      raw_tx: '',
+      data_initial_chunk: bytesToHex(new Uint8Array(data.buffer).subarray(0, this.chunkByteSize)),
+      data_length: data.length,
+    };
+
+    const res = await typedCall('BenfenSignTx', ['BenfenSignedTx', 'BenfenTxRequest'], {
+      ...this.params,
+    });
+
+    return this.processTxRequest(typedCall, res, data, offset);
+  }
+}

package/src/api/benfen/normalize.ts

@@ -0,0 +1,51 @@
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
+import { blake2b } from '@noble/hashes/blake2b';
+import { sha256 } from '@noble/hashes/sha256';
+
+export const BENFEN_ADDRESS_LENGTH = 32;
+export const PUBLIC_KEY_SIZE = 32;
+
+export const SIGNATURE_SCHEME_TO_FLAG = {
+  ED25519: 0x00,
+};
+
+export function normalizeBenfenAddress(value: string, forceAdd0x = false): string {
+  let address = value.toLowerCase();
+  if (!forceAdd0x && address.startsWith('0x')) {
+    address = address.slice(2);
+  }
+  return `0x${address.padStart(BENFEN_ADDRESS_LENGTH * 2, '0')}`.toLowerCase();
+}
+
+export function publicKeyToAddress(publicKey: string) {
+  const tmp = new Uint8Array(PUBLIC_KEY_SIZE + 1);
+  tmp.set([SIGNATURE_SCHEME_TO_FLAG.ED25519]);
+  tmp.set(hexToBytes(publicKey), 1);
+
+  return normalizeBenfenAddress(
+    bytesToHex(blake2b(tmp, { dkLen: 32 })).slice(0, BENFEN_ADDRESS_LENGTH * 2)
+  );
+}
+
+/**
+ * 将十六进制地址转换为 BFC 格式地址
+ * @param hexAddress - 输入的十六进制地址（可以带有0x前缀）
+ * @returns BFC格式的地址，格式为：BFC + 64位地址 + 4位校验和
+ * @throws {Error} 当输入地址格式无效时
+ */
+export function hex2BfcAddress(hexAddress: string): string {
+  // 如果已经是BFC格式，直接返回
+  if (/^BFC/i.test(hexAddress)) {
+    return hexAddress;
+  }
+
+  // 移除0x前缀，补齐64位，转小写
+  const hex = hexAddress.replace(/^0x/, '').padStart(64, '0').toLowerCase();
+
+  // 使用SHA-256计算校验和
+  const hash = sha256(new TextEncoder().encode(hex));
+  const checksumHex = bytesToHex(hash).slice(0, 4);
+
+  // 返回BFC格式地址
+  return `BFC${hex}${checksumHex}`;
+}

package/src/api/btc/BTCGetAddress.ts

@@ -0,0 +1,90 @@
+import { GetAddress } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { getScriptType, serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { BTCAddress, BTCGetAddressParams } from '../../types/api/btcGetAddress';
+import { getCoinInfo } from './helpers/btcParamsUtils';
+import { getBitcoinForkVersionRange } from './helpers/versionLimit';
+
+export default class BTCGetAddress extends BaseMethod<GetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = Object.prototype.hasOwnProperty.call(this.payload, 'bundle');
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+    payload.bundle.forEach((batch: BTCGetAddressParams) => {
+      const addressN = validatePath(batch.path, 1);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'coin', type: 'string' },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'multisig', type: 'object' },
+        { name: 'scriptType', type: 'string' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      const { multisig, coin } = batch;
+
+      let { scriptType } = batch;
+      if (!scriptType) {
+        scriptType = getScriptType(addressN);
+        if (scriptType === 'SPENDMULTISIG' && !multisig) {
+          scriptType = 'SPENDADDRESS';
+        }
+      }
+
+      const coinName = getCoinInfo(addressN, coin).name;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        coin_name: coinName,
+        multisig,
+        script_type: scriptType || 'SPENDADDRESS',
+      });
+    });
+  }
+
+  getVersionRange() {
+    return getBitcoinForkVersionRange(this.params.map(param => param.coin_name));
+  }
+
+  async run() {
+    const responses: BTCAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('GetAddress', 'Address', {
+        ...param,
+      });
+
+      const path = serializedPath(param.address_n);
+      responses.push({
+        path,
+        ...res.message,
+      });
+
+      this.postPreviousAddressMessage({
+        address: res.message.address,
+        path,
+      });
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/btc/BTCGetPublicKey.ts

@@ -0,0 +1,172 @@
+import type { GetPublicKey } from '@ukeyfe/hardware-transport';
+import { HardwareError, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { getScriptType, isTaprootPath, serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { BTCGetAddressParams } from '../../types/api/btcGetAddress';
+import { getCoinInfo } from './helpers/btcParamsUtils';
+import { BTCPublicKey } from '../../types/api/btcGetPublicKey';
+import { getBitcoinForkVersionRange } from './helpers/versionLimit';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+import { createExtendedPublicKey, getVersionBytes } from './helpers/xpubUtils';
+
+export default class BTCGetPublicKey extends BaseMethod<GetPublicKey[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = Object.prototype.hasOwnProperty.call(this.payload, 'bundle');
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+
+    payload.bundle.forEach((batch: BTCGetAddressParams) => {
+      const addressN = validatePath(batch.path, 1);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'coin', type: 'string' },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'scriptType', type: 'string' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      const { multisig, coin } = batch;
+
+      let { scriptType } = batch;
+      if (!scriptType) {
+        scriptType = getScriptType(addressN);
+        if (scriptType === 'SPENDMULTISIG' && !multisig) {
+          scriptType = 'SPENDADDRESS';
+        }
+      }
+
+      const coinName = getCoinInfo(addressN, coin).name;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        coin_name: coinName,
+        script_type: scriptType || 'SPENDADDRESS',
+      });
+    });
+  }
+
+  private isBtcNetwork(param: GetPublicKey) {
+    return param.coin_name === 'Testnet' || param.coin_name === 'Bitcoin';
+  }
+
+  getVersionRange() {
+    return getBitcoinForkVersionRange(this.params.map(param => param.coin_name));
+  }
+
+  async run() {
+    let responses: BTCPublicKey[] = [];
+
+    try {
+      const existsShowDisplay = this.params.some(param => param.show_display);
+      if (existsShowDisplay || !this.hasBundle) {
+        throw new Error('Goto getPublickey');
+      }
+
+      for (const param of this.params) {
+        const versionBytes = getVersionBytes(param.coin_name, param.script_type);
+        if (!versionBytes) {
+          throw new Error(
+            `Invalid coinName, not support generate xpub for scriptType: ${param.script_type}`
+          );
+        }
+      }
+
+      const res = await batchGetPublickeys(this.device, this.params, 'secp256k1', 0, {
+        includeNode: true,
+        ignoreCoinType: true,
+      });
+
+      if (!res?.hd_nodes || this.params.length !== res.hd_nodes.length) {
+        throw new Error('Invalid response from Publickeys');
+      }
+
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const node = res.hd_nodes[i];
+
+        const path = serializedPath(param.address_n);
+
+        const xpub = createExtendedPublicKey(node, param.coin_name, param.script_type);
+
+        const rootFingerprint = res.root_fingerprint;
+
+        let xpubSegwit = xpub;
+        if (this.isBtcNetwork(param) && isTaprootPath(param.address_n)) {
+          // wrap regular xpub into bitcoind native descriptor
+          const fingerprint = Number(rootFingerprint || 0)
+            .toString(16)
+            .padStart(8, '0');
+          const descriptorPath = `${fingerprint}${path.substring(1)}`;
+          xpubSegwit = `tr([${descriptorPath}]${xpub}/<0;1>/*)`;
+        }
+
+        responses.push({
+          path,
+          node,
+          xpub,
+          root_fingerprint: rootFingerprint,
+          xpubSegwit,
+        });
+      }
+    } catch (error) {
+      if (error instanceof HardwareError) {
+        const { errorCode } = error;
+        if (
+          errorCode === HardwareErrorCode.PinCancelled ||
+          errorCode === HardwareErrorCode.ActionCancelled ||
+          errorCode === HardwareErrorCode.ResponseUnexpectTypeError ||
+          errorCode === HardwareErrorCode.PinInvalid
+        ) {
+          throw error;
+        }
+      }
+
+      // clear responses
+      responses = [];
+
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+
+        const res = await this.device.commands.typedCall('GetPublicKey', 'PublicKey', {
+          ...param,
+        });
+
+        const response = {
+          path: serializedPath(param.address_n),
+          ...res.message,
+          xpubSegwit: res.message.xpub,
+        };
+
+        if (this.isBtcNetwork(param) && isTaprootPath(param.address_n)) {
+          // wrap regular xpub into bitcoind native descriptor
+          const fingerprint = Number(response.root_fingerprint || 0)
+            .toString(16)
+            .padStart(8, '0');
+          const descriptorPath = `${fingerprint}${response.path.substring(1)}`;
+          response.xpubSegwit = `tr([${descriptorPath}]${response.xpub}/<0;1>/*)`;
+        }
+
+        responses.push(response);
+      }
+    }
+
+    validateResult(responses, ['xpub'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/btc/BTCSignMessage.ts

@@ -0,0 +1,72 @@
+import { SignMessage } 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 { getCoinAndScriptType } from './helpers/btcParamsUtils';
+import { getBitcoinForkVersionRange } from './helpers/versionLimit';
+
+export default class BTCSignMessage extends BaseMethod<SignMessage> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'messageHex', type: 'hexString', required: true },
+      { name: 'coin', type: 'string' },
+      { name: 'noScriptType', type: 'boolean' },
+      { name: 'dAppSignType', type: 'string' },
+    ]);
+
+    const { path, messageHex, coin, noScriptType: _noScriptType, dAppSignType } = this.payload;
+
+    let noScriptType = _noScriptType;
+    let isBip322Simple = false;
+
+    const addressN = validatePath(path);
+
+    const { coinName, scriptType } = getCoinAndScriptType(addressN, coin, false);
+    let finalScriptType: undefined | typeof scriptType = scriptType;
+
+    if (dAppSignType === 'ecdsa' || dAppSignType === 'bip322-simple') {
+      if (dAppSignType === 'ecdsa') {
+        noScriptType = true;
+      } else {
+        isBip322Simple = true;
+        noScriptType = false;
+      }
+    } else {
+      finalScriptType = scriptType;
+    }
+
+    this.params = {
+      address_n: addressN,
+      message: formatAnyHex(messageHex),
+      coin_name: coinName,
+      script_type: finalScriptType,
+      no_script_type: noScriptType,
+      is_bip322_simple: isBip322Simple,
+    };
+  }
+
+  getVersionRange() {
+    if (this.payload.dAppSignType) {
+      return {
+        pro: {
+          min: '4.9.3',
+        },
+      };
+    }
+    return getBitcoinForkVersionRange([this.params.coin_name]);
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('SignMessage', 'MessageSignature', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/btc/BTCSignPsbt.ts

@@ -0,0 +1,63 @@
+import { SignPsbt } from '@ukeyfe/hardware-transport';
+import { HardwareErrorCode, TypedError, EDeviceType } from '@ukeyfe/hardware-shared';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+import { getCoinInfo } from './helpers/btcParamsUtils';
+import { getDeviceType } from '../../utils';
+
+export default class BTCSignPsbt extends BaseMethod<SignPsbt> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'psbt', type: 'hexString', required: true },
+      { name: 'coin', type: 'string' },
+    ]);
+
+    const { psbt, coin } = this.payload;
+
+    const coinInfo = getCoinInfo(undefined, coin);
+
+    this.params = {
+      psbt: formatAnyHex(psbt),
+      coin_name: coinInfo.name,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      pro: {
+        min: '4.9.3',
+      },
+      model_classic1s: {
+        min: '3.10.1',
+      },
+    };
+  }
+
+  async run() {
+    try {
+      const res = await this.device.commands.typedCall('SignPsbt', 'SignedPsbt', {
+        ...this.params,
+      });
+      return res.message;
+    } catch (error) {
+      const { message } = error;
+
+      const deviceType = getDeviceType(this.device.features);
+      if (
+        message.includes('PSBT parse failed') &&
+        (deviceType === EDeviceType.Classic1s || deviceType === EDeviceType.ClassicPure)
+      ) {
+        throw TypedError(HardwareErrorCode.BTCPsbtTooManyUtxos, 'PSBT too many utxos', {
+          count: 5,
+        });
+      }
+
+      throw error;
+    }
+  }
+}

package/src/api/btc/BTCSignTransaction.ts

@@ -0,0 +1,147 @@
+import { TxInputType, TxOutputType } from '@ukeyfe/hardware-transport';
+
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { getOutputScriptType, isSegwitPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import {
+  AccountAddresses,
+  BTCSignTransactionParams,
+  RefTransaction,
+  TransactionOptions,
+} from '../../types/api/btcSignTransaction';
+import signtx from './helpers/signtx';
+import signtxLegacy from './helpers/signtxLegacy';
+import { getCoinInfo } from './helpers/btcParamsUtils';
+import { getBitcoinForkVersionRange } from './helpers/versionLimit';
+
+type Params = {
+  inputs: TxInputType[];
+  outputs: TxOutputType[];
+  refTxs: RefTransaction[];
+  addresses?: AccountAddresses;
+  options: TransactionOptions;
+  coinName: string;
+};
+export default class BTCSignTransaction extends BaseMethod<Params> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'coin', type: 'string', required: true },
+      { name: 'inputs', type: 'array', required: true },
+      { name: 'outputs', type: 'array', required: true },
+      { name: 'refTxs', type: 'array', required: true, allowEmpty: true },
+      { name: 'locktime', type: 'number' },
+      { name: 'version', type: 'number' },
+      { name: 'expiry', type: 'number' },
+      { name: 'overwintered', type: 'boolean' },
+      { name: 'versionGroupId', type: 'number' },
+      { name: 'branchId', type: 'number' },
+      { name: 'timestamp', type: 'number' },
+    ]);
+
+    this.payload.refTxs.forEach((tx: RefTransaction) => {
+      validateParams(tx, [
+        { name: 'hash', type: 'hexString', required: true },
+        { name: 'inputs', type: 'array', required: true },
+        { name: 'bin_outputs', type: 'array', required: !Array.isArray(tx.outputs) },
+        { name: 'outputs', type: 'array' },
+        { name: 'version', type: 'number', required: true },
+        { name: 'lock_time', type: 'number', required: true },
+        { name: 'extra_data', type: 'string' },
+        { name: 'timestamp', type: 'number' },
+        { name: 'version_group_id', type: 'number' },
+      ]);
+    });
+
+    this.payload.inputs.forEach((input: any) => {
+      validatePath(input.address_n);
+      const useAmount = isSegwitPath(input.address_n);
+      validateParams(input, [
+        { name: 'prev_hash', type: 'hexString', required: true },
+        { name: 'prev_index', type: 'number', required: true },
+        { name: 'script_type', type: 'string' },
+        { name: 'amount', type: 'string', required: useAmount },
+        { name: 'sequence', type: 'number' },
+        { name: 'multisig', type: 'object' },
+      ]);
+    });
+
+    this.payload.outputs.forEach((output: any) => {
+      validateParams(output, [
+        { name: 'address_n', type: 'array' },
+        { name: 'address', type: 'string' },
+        { name: 'amount', type: 'string' },
+        { name: 'op_return_data', type: 'string' },
+        { name: 'multisig', type: 'object' },
+      ]);
+
+      if (
+        Object.prototype.hasOwnProperty.call(output, 'address_n') &&
+        Object.prototype.hasOwnProperty.call(output, 'address')
+      ) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.CallMethodInvalidParameter,
+          'Cannot use address and address_n in one output'
+        );
+      }
+
+      if (output.address_n) {
+        const scriptType = getOutputScriptType(output.address_n);
+        if (output.script_type !== scriptType)
+          throw ERRORS.TypedError(
+            HardwareErrorCode.CallMethodInvalidParameter,
+            `Output change script_type should be set to ${scriptType}`
+          );
+      }
+    });
+
+    const { inputs, outputs, refTxs, account, coin } = this.payload as BTCSignTransactionParams;
+
+    const coinName = getCoinInfo(undefined, coin).name;
+
+    this.params = {
+      inputs,
+      outputs,
+      refTxs,
+      addresses: account ? account.addresses : undefined,
+      options: {
+        lock_time: this.payload.locktime,
+        timestamp: this.payload.timestamp,
+        version: this.payload.version,
+        expiry: this.payload.expiry,
+        overwintered: this.payload.overwintered,
+        version_group_id: this.payload.versionGroupId,
+        branch_id: this.payload.branchId,
+      },
+      coinName,
+    };
+  }
+
+  getVersionRange() {
+    return getBitcoinForkVersionRange([this.params.coinName]);
+  }
+
+  async run() {
+    const { device, params } = this;
+
+    const useLegacySignProcess = device.unavailableCapabilities.replaceTransaction;
+
+    const { refTxs } = params;
+
+    const signTxMethod = !useLegacySignProcess ? signtx : signtxLegacy;
+    const response = await signTxMethod(
+      device.commands.typedCall.bind(device.commands),
+      params.inputs,
+      params.outputs,
+      refTxs,
+      params.options,
+      params.coinName
+    );
+
+    return response;
+  }
+}