openchain-sdk-yxl-ts/lib/operation/ctp10Token.js

OpenChain SDK for browser

import errors from '../exception/index.js';

/**
 * CTP10代币操作相关的方法集合
 * 这些方法将被混入到 Operation 类中
 */
class CTP10TokenOperations {
  /**
   * 验证代币金额
   * @private
   * @param {string|number} amount - 代币金额
   * @returns {boolean} 是否有效
   */
  _isValidTokenAmount(amount) {
    try {
      const numAmount = Number(amount);
      return !isNaN(numAmount) && numAmount > 0;
    } catch {
      return false;
    }
  }

  /**
   * 验证地址相等性
   * @private
   * @param {string} address1 - 第一个地址
   * @param {string} address2 - 第二个地址
   * @returns {Object} 验证结果
   */
  _validateAddressEquality(address1, address2) {
    if (address1 && address2 === address1) {
      return {
        valid: false,
        error: errors.SOURCEADDRESS_EQUAL_DESTADDRESS_ERROR
      };
    }
    return { valid: true };
  }

  /**
   * CTP10代币发行操作
   * @param {Object} args - 发行参数
   * @param {string} [args.sourceAddress] - 源地址
   * @param {string|number} args.initBalance - 初始余额
   * @param {string} args.name - 代币名称
   * @param {string} args.symbol - 代币符号
   * @param {number} args.decimals - 小数位数
   * @param {string|number} args.supply - 发行总量
   * @param {string} [args.metadata] - 元数据
   * @returns {Object} 操作结果
   */
  ctp10TokenIssueOperation(args) {
    console.log('ctp10TokenIssueOperation args:', args);
    try {
      if (Array.isArray(args) || typeof args !== 'object' || args === null) {
        return this._responseError(errors.INVALID_ARGUMENTS);
      }

      const schema = {
        sourceAddress: {
          required: false,
          address: true,
        },
        initBalance: {
          required: true,
          numeric: true,
        },
        name: {
          required: true,
          string: true,
        },
        symbol: {
          required: true,
          string: true,
        },
        decimals: {
          required: true,
          numeric: true,
        },
        totalSupply: {
          required: true,
          numeric: true,
        },
        metadata: {
          required: false,
          string: true,
        },
      };

      const validation = this._validate(args, schema);
      console.log('Validation result:', validation); // Add this line for debugging validatio
      if (!validation.tag) {
        return this._responseError(errors[validation.msg]);
      }

      return this._responseData({
        operation: {
          type: 'ctp10TokenIssue',
          data: this._sanitizeOperationData(args),
        },
      });
    } catch (err) {
      console.error('Error in ctp10TokenIssueOperation:', err);
      throw err;
    }
  }

  /**
   * CTP10代币转移操作
   * @param {Object} args - 转移参数
   * @param {string} [args.sourceAddress] - 源地址
   * @param {string} args.contractAddress - 合约地址
   * @param {string} args.destAddress - 目标地址
   * @param {string|number} args.amount - 转移金额
   * @param {string} [args.metadata] - 元数据
   * @returns {Object} 操作结果
   */
  ctp10TokenTransferOperation(args) {
    try {
      if (Array.isArray(args) || typeof args !== 'object' || args === null) {
        return this._responseError(errors.INVALID_ARGUMENTS);
      }

      const schema = {
        sourceAddress: {
          required: false,
          address: true,
        },
        contractAddress: {
          required: true,
          address: true,
        },
        destAddress: {
          required: true,
          address: true,
        },
        amount: {
          required: true,
          numeric: true,
        },
        metadata: {
          required: false,
          string: true,
        },
      };

      const validation = this._validate(args, schema);
      if (!validation.tag) {
        return this._responseError(errors[validation.msg]);
      }

      const addressValidation = this._validateAddressEquality(
        args.sourceAddress,
        args.destAddress
      );
      if (!addressValidation.valid) {
        return this._responseError(addressValidation.error);
      }

      return this._responseData({
        operation: {
          type: 'ctp10TokenTransfer',
          data: this._sanitizeOperationData(args),
        },
      });
    } catch (err) {
      console.error('Error in ctp10TokenTransferOperation:', err);
      throw err;
    }
  }

  /**
   * CTP10代币授权操作
   * @param {Object} args - 授权参数
   * @param {string} [args.sourceAddress] - 源地址
   * @param {string} args.contractAddress - 合约地址
   * @param {string} args.spender - 授权地址
   * @param {string|number} args.amount - 授权金额
   * @param {string} [args.metadata] - 元数据
   * @returns {Object} 操作结果
   */
  ctp10TokenApproveOperation(args) {
    try {
      if (Array.isArray(args) || typeof args !== 'object' || args === null) {
        return this._responseError(errors.INVALID_ARGUMENTS);
      }

      const schema = {
        sourceAddress: {
          required: false,
          address: true,
        },
        contractAddress: {
          required: true,
          address: true,
        },
        spender: {
          required: true,
          address: true,
        },
        amount: {
          required: true,
          numeric: true,
        },
        metadata: {
          required: false,
          string: true,
        },
      };

      const validation = this._validate(args, schema);
      if (!validation.tag) {
        return this._responseError(errors[validation.msg]);
      }

      return this._responseData({
        operation: {
          type: 'ctp10TokenApprove',
          data: this._sanitizeOperationData(args),
        },
      });
    } catch (err) {
      console.error('Error in ctp10TokenApproveOperation:', err);
      throw err;
    }
  }

  /**
   * CTP10代币授权转移操作
   * @param {Object} args - 授权转移参数
   * @param {string} [args.sourceAddress] - 源地址
   * @param {string} args.contractAddress - 合约地址
   * @param {string} args.from - 转出地址
   * @param {string} args.to - 转入地址
   * @param {string|number} args.amount - 转移金额
   * @param {string} [args.metadata] - 元数据
   * @returns {Object} 操作结果
   */
  ctp10TokenTransferFromOperation(args) {
    try {
      if (Array.isArray(args) || typeof args !== 'object' || args === null) {
        return this._responseError(errors.INVALID_ARGUMENTS);
      }

      const schema = {
        sourceAddress: {
          required: false,
          address: true,
        },
        contractAddress: {
          required: true,
          address: true,
        },
        from: {
          required: true,
          address: true,
        },
        to: {
          required: true,
          address: true,
        },
        amount: {
          required: true,
          numeric: true,
        },
        metadata: {
          required: false,
          string: true,
        },
      };

      const validation = this._validate(args, schema);
      if (!validation.tag) {
        return this._responseError(errors[validation.msg]);
      }

      return this._responseData({
        operation: {
          type: 'ctp10TokenTransferFrom',
          data: this._sanitizeOperationData(args),
        },
      });
    } catch (err) {
      console.error('Error in ctp10TokenTransferFromOperation:', err);
      throw err;
    }
  }

  /**
   * CTP10代币分配操作
   * @param {Object} args - 分配参数
   * @param {string} [args.sourceAddress] - 源地址
   * @param {string} args.contractAddress - 合约地址
   * @param {string} args.destAddress - 目标地址
   * @param {string|number} args.amount - 分配金额
   * @param {string} [args.metadata] - 元数据
   * @returns {Object} 操作结果
   */
  ctp10TokenAssignOperation(args) {
    try {
      if (Array.isArray(args) || typeof args !== 'object' || args === null) {
        return this._responseError(errors.INVALID_ARGUMENTS);
      }

      const schema = {
        sourceAddress: {
          required: false,
          address: true,
        },
        contractAddress: {
          required: true,
          address: true,
        },
        destAddress: {
          required: true,
          address: true,
        },
        amount: {
          required: true,
          numeric: true,
        },
        metadata: {
          required: false,
          string: true,
        },
      };

      const validation = this._validate(args, schema);
      if (!validation.tag) {
        return this._responseError(errors[validation.msg]);
      }

      return this._responseData({
        operation: {
          type: 'ctp10TokenAssign',
          data: this._sanitizeOperationData(args),
        },
      });
    } catch (err) {
      console.error('Error in ctp10TokenAssignOperation:', err);
      throw err;
    }
  }

  /**
   * CTP10代币更改所有者操作
   * @param {Object} args - 更改所有者参数
   * @param {string} [args.sourceAddress] - 源地址
   * @param {string} args.contractAddress - 合约地址
   * @param {string} args.tokenOwner - 新所有者地址
   * @param {string} [args.metadata] - 元数据
   * @returns {Object} 操作结果
   */
  ctp10TokenChangeOwnerOperation(args) {
    try {
      if (Array.isArray(args) || typeof args !== 'object' || args === null) {
        return this._responseError(errors.INVALID_ARGUMENTS);
      }

      const schema = {
        sourceAddress: {
          required: false,
          address: true,
        },
        contractAddress: {
          required: true,
          address: true,
        },
        tokenOwner: {
          required: true,
          address: true,
        },
        metadata: {
          required: false,
          string: true,
        },
      };

      const validation = this._validate(args, schema);
      if (!validation.tag) {
        return this._responseError(errors[validation.msg]);
      }

      return this._responseData({
        operation: {
          type: 'ctp10TokenChangeOwner',
          data: this._sanitizeOperationData(args),
        },
      });
    } catch (err) {
      console.error('Error in ctp10TokenChangeOwnerOperation:', err);
      throw err;
    }
  }

  /**
   * 清理操作数据，移除未定义的字段
   * @private
   * @param {Object} data - 原始数据
   * @returns {Object} 清理后的数据
   */
  _sanitizeOperationData(data) {
    return Object.entries(data).reduce((acc, [key, value]) => {
      if (value !== undefined && value !== null) {
        acc[key] = value;
      }
      return acc;
    }, {});
  }
}

// 导出操作方法
export default {
  ctp10TokenIssueOperation: CTP10TokenOperations.prototype.ctp10TokenIssueOperation,
  ctp10TokenTransferOperation: CTP10TokenOperations.prototype.ctp10TokenTransferOperation,
  ctp10TokenApproveOperation: CTP10TokenOperations.prototype.ctp10TokenApproveOperation,
  ctp10TokenTransferFromOperation: CTP10TokenOperations.prototype.ctp10TokenTransferFromOperation,
  ctp10TokenAssignOperation: CTP10TokenOperations.prototype.ctp10TokenAssignOperation,
  ctp10TokenChangeOwnerOperation: CTP10TokenOperations.prototype.ctp10TokenChangeOwnerOperation,
  _isValidTokenAmount: CTP10TokenOperations.prototype._isValidTokenAmount,
  _validateAddressEquality: CTP10TokenOperations.prototype._validateAddressEquality,
  _sanitizeOperationData: CTP10TokenOperations.prototype._sanitizeOperationData,
};