@onetokenfe/hd-core 1.1.23

package/src/api/benfen/BenfenSignTransaction.ts

@@ -0,0 +1,105 @@
+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 { BenfenSignTx, BenfenSignedTx, MessageType, TypedCall } from '@onetokenfe/hd-transport';
+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,91 @@
+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 { getCoinInfo } from './helpers/btcParamsUtils';
+import { getBitcoinForkVersionRange } from './helpers/versionLimit';
+
+import type { BTCAddress, BTCGetAddressParams } from '../../types/api/btcGetAddress';
+import type { GetAddress } from '@onetokenfe/hd-transport';
+
+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: 'showOnOneToken', type: 'boolean' },
+        { name: 'multisig', type: 'object' },
+        { name: 'scriptType', type: 'string' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? 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: showOnOneToken,
+        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,174 @@
+import { HardwareError, HardwareErrorCode } from '@onetokenfe/hd-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 { getCoinInfo } from './helpers/btcParamsUtils';
+import { getBitcoinForkVersionRange } from './helpers/versionLimit';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+import { createExtendedPublicKey, getVersionBytes } from './helpers/xpubUtils';
+
+import type { BTCPublicKey } from '../../types/api/btcGetPublicKey';
+import type { BTCGetAddressParams } from '../../types/api/btcGetAddress';
+import type { GetPublicKey } from '@onetokenfe/hd-transport';
+
+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: 'showOnOneToken', type: 'boolean' },
+        { name: 'scriptType', type: 'string' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? 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: showOnOneToken,
+        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,73 @@
+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';
+
+import type { SignMessage } from '@onetokenfe/hd-transport';
+
+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,65 @@
+import { EDeviceType, HardwareErrorCode, TypedError } from '@onetokenfe/hd-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';
+
+import type { SignPsbt } from '@onetokenfe/hd-transport';
+
+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;
+    }
+  }
+}