openchain-sdk-yxl-ts/lib/util/index.js

OpenChain SDK for browser

import BigNumber from 'bignumber.js';
import long from 'long';
import CommonUtil from '../common/util.js';

class Util extends CommonUtil {
  constructor(options = {}) {
    super(options);
    
    // 确保使用 new 关键字调用
    if (!(this instanceof Util)) {
      return new Util(options);
    }
  }

  /**
   * 检查对象是否为 BigNumber 实例
   * @param {*} object - 要检查的对象
   * @returns {boolean} - 是否为 BigNumber 实例
   */
  isBigNumber(object) {
    return object instanceof BigNumber;
  }

  /**
   * 将输入转换为 BigNumber 实例
   * @param {string|number|BigNumber} data - 要转换的数据
   * @returns {BigNumber|null} - 转换结果
   */
  toBigNumber(data) {
    try {
      return new BigNumber(data);
    } catch {
      return null;
    }
  }

  /**
   * 将 UTF-8 字符串转换为十六进制字符串
   * @param {string} str - 要转换的 UTF-8 字符串
   * @returns {string|null} - 转换后的十六进制字符串，转换失败时返回 null
   */
  utfToHex(str) {
    if (typeof str !== 'string') {
      return null;
    }
  
    return Buffer.from(str, 'utf8').toString('hex');
  }
  
  /**
   * 将十六进制字符串转换为 UTF-8 字符串
   * @param {string} str - 要转换的十六进制字符串
   * @returns {string|null} - 转换后的 UTF-8 字符串，转换失败时返回 null
   */
  hexToUtf(str) {
    if (typeof str !== 'string' ||
        str === '' ||
        !this._isHexString(str)) {
      return null;
    }
  
    return Buffer.from(str, 'hex').toString('utf8');
  }

  /**
   * 将操作数转换为 OPC
   * @param {string|number} op - 操作数
   * @returns {string} - 转换后的 OPC 值
   */
  opToOpc(op) {
    if (!this._isAvailableOp(op)) {
      return '';
    }
    try {
      const oneOpc = new BigNumber(10).pow(8);
      return new BigNumber(op).times(oneOpc).toString();
    } catch {
      return '';
    }
  }

  /**
   * 将 OPC 转换为操作数
   * @param {string|number} opc - OPC 值
   * @returns {string} - 转换后的操作数
   */
  opcToOp(opc) {
    if (!this._isAvailableValue(opc)) {
      return '';
    }
    try {
      const oneOpc = new BigNumber(10).pow(8);
      return new BigNumber(opc).dividedBy(oneOpc).toString();
    } catch {
      return '';
    }
  }

  /**
   * 根据小数位数计算单位值
   * @param {string|number} amount - 数量
   * @param {string|number} decimals - 小数位数
   * @returns {string|false} - 计算结果或失败标志
   */
  unitWithDecimals(amount, decimals) {
    if (!/^\d+$/.test(amount) || !/^\d+$/.test(decimals)) {
      return false;
    }

    try {
      const amountBN = new BigNumber(amount);
      const decimalsBN = new BigNumber(10).pow(decimals);
      const result = amountBN.times(decimalsBN);

      if (result.isGreaterThanOrEqualTo(0) && 
          result.isLessThanOrEqualTo(long.MAX_VALUE.toString())) {
        return result.toString();
      }
      return false;
    } catch {
      return false;
    }
  }

  /**
   * 批量处理工具方法
   * @param {Array} items - 要处理的项目数组
   * @param {Function} processor - 处理函数
   * @returns {Promise<Array>} - 处理结果
   */
  async batchProcess(items, processor) {
    return this._batchProcess(items, processor);
  }
}

export default Util;