@onetokenfe/hd-core 1.1.23

package/src/api/btc/helpers/signtxLegacy.ts

@@ -0,0 +1,227 @@
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import type {
+  TxAckResponse,
+  TxInputType,
+  TxOutputType,
+  TxRequest,
+  TxRequestSerializedType,
+  TypedCall,
+} from '@onetokenfe/hd-transport';
+import type {
+  RefTransaction,
+  SignedTransaction,
+  TransactionOptions,
+} from '../../../types/api/btcSignTransaction';
+
+type RefTxs = { [hash: string]: RefTransaction };
+type Props = {
+  typedCall: TypedCall;
+  txRequest: TxRequest;
+  refTxs: RefTxs;
+  inputs: TxInputType[];
+  outputs: TxOutputType[];
+  serializedTx: string[];
+  signatures: string[];
+};
+
+const requestPrevTxInfo = ({
+  txRequest: { request_type, details },
+  refTxs,
+}: Props): TxAckResponse => {
+  const { tx_hash } = details;
+  if (!tx_hash) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'requestPrevTxInfo: unknown details.tx_hash'
+    );
+  }
+  const tx = refTxs[tx_hash.toLowerCase()];
+  if (!tx) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`
+    );
+  }
+  if (!tx.bin_outputs) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`
+    );
+  }
+  if (request_type === 'TXINPUT') {
+    return { inputs: [tx.inputs[details.request_index]] };
+  }
+  if (request_type === 'TXOUTPUT') {
+    return { bin_outputs: [tx.bin_outputs[details.request_index]] };
+  }
+  if (request_type === 'TXEXTRADATA') {
+    if (typeof details.extra_data_len !== 'number') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'requestPrevTxInfo: Missing extra_data_len'
+      );
+    }
+    if (typeof details.extra_data_offset !== 'number') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'requestPrevTxInfo: Missing extra_data_offset'
+      );
+    }
+    if (typeof tx.extra_data !== 'string') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `requestPrevTxInfo: No extra data for transaction ${tx.hash}`
+      );
+    }
+    const data = tx.extra_data;
+    const dataLen = details.extra_data_len;
+    const dataOffset = details.extra_data_offset;
+    const extra_data = data.substring(dataOffset * 2, (dataOffset + dataLen) * 2);
+    return { extra_data };
+  }
+  if (request_type === 'TXMETA') {
+    const data = tx.extra_data;
+    const meta = {
+      version: tx.version,
+      lock_time: tx.lock_time,
+      inputs_cnt: tx.inputs.length,
+      outputs_cnt: tx.bin_outputs.length,
+      timestamp: tx.timestamp,
+      version_group_id: tx.version_group_id,
+      expiry: tx.expiry,
+      branch_id: tx.branch_id,
+    };
+
+    if (typeof data === 'string' && data.length !== 0) {
+      return {
+        ...meta,
+        extra_data_len: data.length / 2,
+      };
+    }
+    return meta;
+  }
+  throw ERRORS.TypedError(
+    HardwareErrorCode.RuntimeError,
+    `requestPrevTxInfo: Unknown request type: ${request_type}`
+  );
+};
+
+const requestSignedTxInfo = ({
+  txRequest: { request_type, details },
+  inputs,
+  outputs,
+}: Props): TxAckResponse => {
+  if (request_type === 'TXINPUT') {
+    return { inputs: [inputs[details.request_index]] };
+  }
+  if (request_type === 'TXOUTPUT') {
+    return { outputs: [outputs[details.request_index]] };
+  }
+  if (request_type === 'TXMETA') {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'requestSignedTxInfo: Cannot read TXMETA from signed transaction'
+    );
+  }
+  if (request_type === 'TXEXTRADATA') {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction'
+    );
+  }
+  throw ERRORS.TypedError(
+    HardwareErrorCode.RuntimeError,
+    `requestSignedTxInfo: Unknown request type: ${request_type}`
+  );
+};
+
+// requests information about a transaction
+// can be either signed transaction itself of prev transaction
+const requestTxAck = (props: Props) => {
+  const { tx_hash } = props.txRequest.details;
+  if (tx_hash) {
+    return requestPrevTxInfo(props);
+  }
+  return requestSignedTxInfo(props);
+};
+
+const saveTxSignatures = (
+  serializedTx: string[],
+  signatures: string[],
+  txRequest?: TxRequestSerializedType
+) => {
+  if (!txRequest) return;
+  const { signature_index, signature, serialized_tx } = txRequest;
+  if (serialized_tx) {
+    serializedTx.push(serialized_tx);
+  }
+  if (typeof signature_index === 'number') {
+    if (!signature) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'saveTxSignatures: Unexpected null in oneToken:TxRequestSerialized signature.'
+      );
+    }
+    signatures[signature_index] = signature;
+  }
+};
+
+const processTxRequest = async (
+  props: Props
+): Promise<{
+  signatures: string[];
+  serializedTx: string;
+}> => {
+  const { typedCall, txRequest, refTxs, inputs, outputs, serializedTx, signatures } = props;
+  saveTxSignatures(serializedTx, signatures, txRequest.serialized);
+  if (txRequest.request_type === 'TXFINISHED') {
+    return Promise.resolve({
+      signatures,
+      serializedTx: serializedTx.join(''),
+    });
+  }
+
+  const txAck = requestTxAck(props);
+  const { message } = await typedCall('TxAck', 'TxRequest', { tx: txAck });
+  return processTxRequest({
+    typedCall,
+    txRequest: message,
+    refTxs,
+    inputs,
+    outputs,
+    serializedTx,
+    signatures,
+  });
+};
+
+export default async (
+  typedCall: TypedCall,
+  inputs: TxInputType[],
+  outputs: TxOutputType[],
+  refTxsArray: RefTransaction[],
+  options: TransactionOptions,
+  coinName: string
+): Promise<SignedTransaction> => {
+  const refTxs: RefTxs = {};
+  refTxsArray.forEach(tx => {
+    refTxs[tx.hash.toLowerCase()] = tx;
+  });
+
+  const { message } = await typedCall('SignTx', 'TxRequest', {
+    ...options,
+    inputs_count: inputs.length,
+    outputs_count: outputs.length,
+    coin_name: coinName,
+  });
+
+  return processTxRequest({
+    typedCall,
+    txRequest: message,
+    refTxs,
+    inputs,
+    outputs,
+    serializedTx: [],
+    signatures: [],
+  });
+};

package/src/api/btc/helpers/versionLimit.ts

@@ -0,0 +1,25 @@
+function isCoinNameInList(coinName: string, coinNames: (string | undefined)[]) {
+  for (let i = 0; i < coinNames.length; i++) {
+    const coin_name = coinNames[i];
+    if (coin_name?.toLowerCase() === coinName?.toLowerCase()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function getBitcoinForkVersionRange(params: (string | undefined)[]) {
+  if (isCoinNameInList('Neurai', params)) {
+    return {
+      model_mini: {
+        min: '3.7.0',
+      },
+      model_touch: {
+        min: '4.9.0',
+      },
+    };
+  }
+
+  // No version restrictions for other coins
+  return {};
+}

package/src/api/btc/helpers/xpubUtils.ts

@@ -0,0 +1,132 @@
+import { sha256 } from '@noble/hashes/sha256';
+
+import type { HDNodeType, InputScriptType } from '@onetokenfe/hd-transport';
+
+// 定义版本字节常量
+const VERSION_BYTES = {
+  // xpub - (SPENDADDRESS, SPENDMULTISIG)
+  XPUB: 0x0488b21e,
+  // ypub - (SPENDP2SHWITNESS)
+  YPUB: 0x049d7cb2,
+  // zpub - (SPENDWITNESS)
+  ZPUB: 0x04b24746,
+};
+
+export function getVersionBytes(
+  coinName: string,
+  scriptType?: InputScriptType
+): number | undefined {
+  if (coinName.toLowerCase() === 'bitcoin') {
+    switch (scriptType) {
+      case 'SPENDADDRESS':
+      case 'SPENDMULTISIG':
+        // 44、48
+        return VERSION_BYTES.XPUB;
+      case 'SPENDP2SHWITNESS':
+        // 49
+        return VERSION_BYTES.YPUB;
+      case 'SPENDWITNESS':
+        // 84
+        return VERSION_BYTES.ZPUB;
+      default:
+        // 86、10025
+        return VERSION_BYTES.XPUB;
+    }
+  } else if (coinName.toLowerCase() === 'litecoin') {
+    switch (scriptType) {
+      case 'SPENDADDRESS':
+      case 'SPENDMULTISIG':
+        // 44、48
+        return 0x019da462;
+      case 'SPENDP2SHWITNESS':
+        // 49
+        return 0x01b26ef6;
+      case 'SPENDWITNESS':
+        // 84
+        return 0x04b24746;
+      default:
+        // not support 86、10025 path
+        return undefined;
+    }
+  } else if (coinName.toLowerCase() === 'dogecoin') {
+    if (scriptType === 'SPENDADDRESS') {
+      // 44
+      return 0x02facafd;
+    }
+    if (scriptType === 'SPENDMULTISIG') {
+      // 48
+      return 0x0488b21e;
+    }
+    return undefined;
+  }
+  return undefined;
+}
+
+function base58Check(data: Buffer): string {
+  const checksum = sha256(sha256(new Uint8Array(data))).slice(0, 4);
+  const withChecksum = Buffer.concat([new Uint8Array(data), new Uint8Array(checksum)]);
+  const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+  let result = '';
+  let num = BigInt(`0x${withChecksum.toString('hex')}`);
+  const base = BigInt(58);
+
+  while (num > 0) {
+    const mod = Number(num % base);
+    num /= base;
+    result = ALPHABET[mod] + result;
+  }
+
+  // 处理前导零字节
+  for (let i = 0; i < withChecksum.length; i++) {
+    if (withChecksum[i] === 0) {
+      result = `1${result}`;
+    } else {
+      break;
+    }
+  }
+
+  return result;
+}
+
+function generateExtendedPublicKey(
+  coinName: string,
+  depth: number,
+  fingerprint: number,
+  childNum: number,
+  chainCode: string,
+  publicKey: string,
+  scriptType?: InputScriptType
+): string {
+  const versionBytes = getVersionBytes(coinName, scriptType);
+
+  if (!versionBytes) {
+    throw new Error(`Invalid coinName, not support generate xpub for scriptType: ${scriptType}`);
+  }
+
+  const buffer = Buffer.alloc(78);
+  buffer.writeUInt32BE(versionBytes, 0);
+  buffer.writeUInt8(depth, 4);
+  buffer.writeUInt32BE(fingerprint, 5);
+  buffer.writeUInt32BE(childNum, 9);
+  buffer.write(chainCode, 13, 'hex');
+  buffer.write(publicKey, 45, 'hex');
+
+  return base58Check(buffer);
+}
+
+export function createExtendedPublicKey(
+  node: HDNodeType,
+  coinName: string,
+  scriptType?: InputScriptType
+): string {
+  return generateExtendedPublicKey(
+    coinName,
+    node.depth,
+    node.fingerprint,
+    node.child_num,
+    node.chain_code,
+    node.public_key,
+    scriptType
+  );
+}

package/src/api/cardano/CardanoGetAddress.ts

@@ -0,0 +1,139 @@
+import { BaseMethod } from '../BaseMethod';
+import { PROTO } from '../../constants';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import {
+  addressParametersFromProto,
+  addressParametersToProto,
+  validateAddressParameters,
+} from './helper/addressParameters';
+import { serializedPath } from '../helpers/pathUtils';
+
+import type { CardanoAddress, CardanoGetAddressParams } from '../../types/api/cardanoGetAddress';
+import type { CardanoGetAddressMethodParams } from '../../types';
+
+export default class CardanoGetAddress extends BaseMethod<CardanoGetAddressParams[]> {
+  hasBundle?: boolean;
+
+  isCheck?: boolean;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    this.isCheck = this.hasBundle
+      ? !!this.payload?.bundle.every((i: CardanoGetAddressMethodParams) => !!i.isCheck)
+      : !!this.payload?.isCheck;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    this.params = payload.bundle.map((batch: any) => {
+      // validate incoming parameters for each batch
+      validateParams(batch, [
+        { name: 'addressParameters', type: 'object', required: true },
+        { name: 'networkId', type: 'number', required: true },
+        { name: 'protocolMagic', type: 'number', required: true },
+        { name: 'derivationType', type: 'number' },
+        { name: 'address', type: 'string' },
+        { name: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      validateAddressParameters(batch.addressParameters);
+
+      return {
+        address_parameters: addressParametersToProto(batch.addressParameters),
+        address: batch.address,
+        protocol_magic: batch.protocolMagic,
+        network_id: batch.networkId,
+        derivation_type:
+          typeof batch.derivationType !== 'undefined'
+            ? batch.derivationType
+            : PROTO.CardanoDerivationType.ICARUS,
+        show_display: typeof batch.showOnOneToken === 'boolean' ? !!batch.showOnOneToken : true,
+      };
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.0.0',
+      },
+      model_touch: {
+        min: '4.1.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: CardanoAddress[] = [];
+
+    for (const batch of this.params) {
+      const { address_parameters, protocol_magic, network_id, derivation_type, show_display } =
+        batch;
+      const response = await this.device.commands.typedCall('CardanoGetAddress', 'CardanoAddress', {
+        address_parameters,
+        protocol_magic,
+        network_id,
+        derivation_type,
+        show_display,
+      });
+
+      let xpub;
+      let stakeAddress;
+      if (address_parameters.address_type === PROTO.CardanoAddressType.BASE && !this.isCheck) {
+        const publicKeyRes = await this.device.commands.typedCall(
+          'CardanoGetPublicKey',
+          'CardanoPublicKey',
+          {
+            address_n: address_parameters.address_n.slice(0, 3),
+            derivation_type,
+            show_display: false,
+          }
+        );
+        xpub = publicKeyRes.message.xpub;
+
+        const stakeAddressRes = await this.device.commands.typedCall(
+          'CardanoGetAddress',
+          'CardanoAddress',
+          {
+            address_parameters: {
+              address_type: PROTO.CardanoAddressType.REWARD,
+              address_n: [],
+              address_n_staking: address_parameters.address_n_staking,
+            },
+            protocol_magic,
+            network_id,
+            derivation_type,
+            show_display: false,
+          }
+        );
+
+        stakeAddress = stakeAddressRes.message.address;
+      }
+
+      const path = serializedPath(batch.address_parameters.address_n);
+      responses.push({
+        addressParameters: addressParametersFromProto(batch.address_parameters),
+        protocolMagic: batch.protocol_magic,
+        networkId: batch.network_id,
+        serializedPath: path,
+        serializedStakingPath: serializedPath(batch.address_parameters.address_n_staking),
+        address: response.message.address,
+        xpub,
+        stakeAddress,
+      });
+
+      this.postPreviousAddressMessage({
+        path,
+        address: response.message.address,
+      });
+    }
+
+    validateResult(responses, ['serializedPath', 'serializedStakingPath', 'address'], {
+      expectedLength: this.params.length,
+    });
+
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/src/api/cardano/CardanoGetPublicKey.ts

@@ -0,0 +1,72 @@
+import { BaseMethod } from '../BaseMethod';
+import { PROTO } from '../../constants';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+
+import type { CardanoPublicKey, CardanoPublicKeyParams } from '../../types/api/cardanoGetPublicKey';
+
+export default class CardanoGetPublicKey extends BaseMethod<CardanoPublicKeyParams[]> {
+  hasBundle?: boolean;
+
+  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] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = payload.bundle.map((batch: any) => {
+      // validate incoming parameters for each batch
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'derivationType', type: 'number' },
+        { name: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const path = validatePath(batch.path, 3);
+      return {
+        address_n: path,
+        derivation_type:
+          typeof batch.derivationType !== 'undefined'
+            ? batch.derivationType
+            : PROTO.CardanoDerivationType.ICARUS,
+        show_display: typeof batch.showOnOneToken === 'boolean' ? batch.showOnOneToken : false,
+      };
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.0.0',
+      },
+      model_touch: {
+        min: '4.1.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: CardanoPublicKey[] = [];
+    const cmd = this.device.getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const batch = this.params[i];
+      const { message } = await cmd.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', batch);
+      responses.push({
+        path: batch.address_n,
+        serializedPath: serializedPath(batch.address_n),
+        xpub: message.xpub,
+        node: message.node,
+      });
+    }
+
+    validateResult(responses, ['xpub'], {
+      expectedLength: this.params.length,
+    });
+
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/src/api/cardano/CardanoSignMessage.ts

@@ -0,0 +1,73 @@
+import { BaseMethod } from '../BaseMethod';
+import { PROTO } from '../../constants';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateParams } from '../helpers/paramsValidator';
+import { validatePath } from '../helpers/pathUtils';
+
+import type { CardanoSignMessageParams } from '../../types/api/cardanoSignMessage';
+
+export default class CardanoSignMessage extends BaseMethod<CardanoSignMessageParams> {
+  hasBundle?: boolean;
+
+  isCheck?: boolean;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { payload } = this;
+    validateParams(payload, [
+      { name: 'path', type: 'string', required: true },
+      { name: 'message', type: 'string', required: true },
+      { name: 'derivationType', type: 'number' },
+      { name: 'networkId', type: 'number', required: true },
+      { name: 'addressType', type: 'number' },
+      { name: 'protocolMagic', type: 'number' },
+    ]);
+
+    const addressN = validatePath(payload.path, 3);
+
+    this.params = {
+      address_n: addressN,
+      message: payload.message,
+      derivation_type:
+        typeof payload.derivationType !== 'undefined'
+          ? payload.derivationType
+          : PROTO.CardanoDerivationType.ICARUS,
+      network_id: payload.networkId,
+      address_type: payload.addressType,
+      protocol_magic: payload.protocolMagic,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_touch: {
+        min: '4.10.0',
+      },
+    };
+  }
+
+  getAddressTypeVersionRange() {
+    return {
+      pro: {
+        min: '4.9.3',
+      },
+    };
+  }
+
+  async run() {
+    this.checkFeatureVersionLimit(
+      () => this.params.address_type !== null && this.params.address_type !== undefined,
+      () => this.getAddressTypeVersionRange()
+    );
+
+    const res = await this.device.commands.typedCall(
+      'CardanoSignMessage',
+      'CardanoMessageSignature',
+      this.params
+    );
+
+    return res.message;
+  }
+}