X2Y2: 必须修改的中心化NFT挂单奖励机制

  • 33357
  • 更新于 2022-03-08 12:29
  • 阅读 1819

X2Y2: 必须修改的中心化NFT挂单奖励机制

原文发布在 https://github.com/33357/smartcontract-apps这是一个面向中文社区，分析市面上智能合约应用的架构与实现的仓库。欢迎关注开源知识项目！

X2Y2: 必须修改的中心化NFT挂单奖励机制

X2Y2 的爆发与沉没

2022年2月15日，X2Y2 正式开启空投、NFT挂单奖励和质押挖矿，随后的十几天内其币价一泻千里。最低到0.25 u/X2Y2，相比最高点跌了90%以上。直到官方宣布修改NFT挂单奖励，大幅减少产出，币价才重新稳定在0.35 u/X2Y2左右。

中心化 NFT 挂单奖励是不可持续的

X2Y2 币价的下跌是多重因素的共同作用，其相比 OpenSea 新创的交易手续费返还 X2Y2 持有者和 NFT 挂单奖励是具有相当程度先进性的。但是我认为：中心化、不透明、无法预测的 NFT 挂单奖励机制在区块链乃至整个 Web3 世界都是不可持续的，主要问题有以下几点：

  • NFT挂单奖励算法会被随意修改，用户无法做长期决策（之前团队为了稳定币价修改算法的决策值得肯定，但严重削弱了挂单用户对项目的信任）。
  • 用户无法对挂单奖励进行预测，因此无法对是否挂单做理性决策（具体来说就是无法在挂单之前对挂单奖励做预测，这会导致很多人要么抱着赌一把的心态来挂单，要么抱着不信任的态度走人）。
  • 团队有持币跑路的风险（区块链世界里代码才是法律，甚至高于法律，达到了物理规则的高度。团队跑路的成本和收益相比不值一提，因此永远不要高估人性）。

之前我在项目方群里讨论这个问题时，有很多人认为 NFT 挂单奖励对 NFT 挂单者是一种 “恩惠”，而不是一种商业模式：你在 OpenSea 挂单啥都没有，来这里还有可能获得奖励，因此中心化的 NFT 挂单奖励机制的这些弊病是没有问题的。我觉得如果真是这样，那么这个项目就不足以对 OpenSea 在商业模式上进行创新，而大多数用户没有足够多确定的利益是懒得去换平台的。

如何设计去中心化的 NFT 挂单奖励

这是一个区块链技术方向的社群，因此讨论不会仅涉及于提出问题而没有解决方案。在去中心化的代币奖励方面，早有前人为我们指明了一条道路，那就是目前普遍用于代币质押的挖矿奖励算法（篇幅所限，我就不去解释这个算法了）。我们只需要知道，这个算法实现了随时间和质押代币数量成正比的奖励。在个条件下，时间是不需要改变的，而 NFT 不是代币。因此只要实现从 NFT 到代币的转换，就完全可以实现去中心化的 NFT 挂单奖励。

  • 这是一个简单的算法，使用挂单价格作为唯一参数，实现从 NFT 到代币的转换

    // 最大价格
uint256 constant MAX_PRICE = 10**26;
// 最小价格
uint256 constant MIN_PRICE = 10**10;
// 预估分数
function predictPoint(uint256 price) public pure override returns (uint256) {
  // 价格不能超过范围
  require(price <= MAX_PRICE && price >= MIN_PRICE, "NFT: price is too high or too low");
  // 计算分数
  return (MAX_PRICE * MIN_PRICE) / price;
}

    在这里，我把从 NFT 到代币的转换过程抽象为给每个 NFT 打分的过程。NFT 作为非同质化代币，想要准确地给每个 NFT 打分，只有从挂单价格入手：价格越高的 NFT 其分数越低。

    • 在这里我们可以演算一下：如果一共有10个 NFT，其价格分别是 1、2、3、4、5、6、7、8、9、10 ETH，那么打分的情况会是什么？

    • point1: (10**26 * 10**10) / 10**18 = 10**18

    • point2: (10**26 * 10**10) / (2 * 10**18) = 10**18 / 2

    • point3: (10**26 * 10**10) / (3 * 10**18) = 10**18 / 3

    • point4: (10**26 * 10**10) / (4 * 10**18) = 10**18 / 4

    • point5: (10**26 * 10**10) / (5 * 10**18) = 10**18 / 5

    • point6: (10**26 * 10**10) / (6 * 10**18) = 10**18 / 6

    • point7: (10**26 * 10**10) / (7 * 10**18) = 10**18 / 7

    • point8: (10**26 * 10**10) / (8 * 10**18) = 10**18 / 8

    • point9: (10**26 * 10**10) / (9 * 10**18) = 10**18 / 9

    • point10: (10**26 * 10**10) / (10 * 10**18) = 10**18 / 10

    point 总数为 10**18 * (7381/2520)，每个 NFT 代币可以分到奖励的份额如下：

    • token1: 2520/7381
    • token2: 1260/7381
    • token3: 840/7381
    • token4: 630/7381
    • token5: 504/7381
    • token6: 420/7381
    • token7: 360/7381
    • token8: 315/7381
    • token9: 280/7381
    • token10: 252/7381

    可以看到，随着 NFT 挂单价格的升高，其分数会下降，奖励份额也会下降。

    一般而言NFT的挂单价格不会如此平均，一般会呈现中间多，两头少的“橄榄球”形状，这意味着挂单价格低的用户会拥有比这个演算更多的奖励。

  • 对于不同类型的NFT，需要给予不同的挂单奖励。

    由于不同类型的 NFT 之间价格差异巨大，因此不可能对所有种类的 NFT 给予相同的奖励池。实际上每种 NFT 的奖励池额度需要单独计算，对此又可以衍生出好几种不同的算法：

    • 使用中心化的算法

    实际上目前 X2Y2 就是使用的这种算法，其效果只能说是差强人意。

    • 使用去中心化的算法

    可以使用每种 NFT 的交易手续费作为参数，对奖励额度在链上进行动态调整。我预计是可行的，但是在没有手续费时，项目如何启动是一个问题。

    • 使用 DAO 进行管理

    对上述的方案进行中和，使用 DAO 让社区成员投票决定给某种 NFT 多少奖励池。这种方案依赖良好的社群用户。

  • 对挂单奖励进行预测

    经典的挖矿奖励算法已经实现了对奖励的预测，还可以计算 APY。由于 NFT 难确定标准的市场价格，因此我估计只能在用户输入挂单价格后，预测每天获得多少奖励。

  • 对挂买单进行奖励

    实际上对上述的挂单 NFT 奖励算法反过来，就可以对挂 NFT 买单进行奖励。也许可以借此做出一个 NFT 的公允市场价。

  • 目前的问题

    • 这套方案里挂单需要上链，改价格也需要上链，因此和 OpenSea 目前的模式并不完全兼容。
    • 挂单需要将 NFT 的所有权转移到合约，因此不能同时挂在 OpenSea 上。

总结

X2Y2 在 OpenSea 的基础上进行了创新，却无法给 OpenSea 用户足够的利益让他们改换门庭。但无论如何，OpenSea 再不改革把自己的利益分享出来，下个四年就看不到它的身影了。

  • 目前实现的代码，有很多问题，并不完善

    //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.12;

import "./interfaces/INFT.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract NFT is INFT, ReentrancyGuard {
  using SafeERC20 for IERC20;

  mapping(address => uint256) blockMint;

  mapping(address => uint256) totalPoint;

  mapping(address => uint256) perPointMinted;

  mapping(address => uint256) lastUpdateBlock;

  mapping(address => mapping(uint256 => uint256)) tokenPoint;

  mapping(address => mapping(uint256 => address)) tokenOwner;

  mapping(address => mapping(uint256 => uint256)) tokenPrice;

  mapping(address => mapping(uint256 => uint256)) tokenMinted;

  mapping(address => mapping(uint256 => uint256)) tokenPerPointPaid;

  uint256 constant MAX_PRICE = 10**26;

  uint256 constant MIN_PRICE = 10**10;

  uint256 fee = 200;

  address feeTo;

  constructor() {}

  /* ================ UTIL FUNCTIONS ================ */

  function safeTransferETH(address to, uint256 value) internal {
      (bool success, ) = to.call{value: value}(new bytes(0));
      require(success, "NFT: ETH transfer failed");
  }

  function perPointMint(address nft) internal view returns (uint256) {
      if (totalPoint[nft] != 0) {
          return perPointMinted[nft] + ((block.number - lastUpdateBlock[nft]) * blockMint[nft]) / totalPoint[nft];
      } else {
          return perPointMinted[nft];
      }
  }

  modifier _updateMint(address nft, uint256 tokenId) {
      if (block.number > lastUpdateBlock[nft]) {
          perPointMinted[nft] = perPointMint(nft);
          lastUpdateBlock[nft] = block.number;
      }
      if (totalPoint[nft] != 0) {
          tokenMinted[nft][tokenId] = tokenMint(nft, tokenId);
      }
      tokenPerPointPaid[nft][tokenId] = perPointMinted[nft];
      _;
  }

  /* ================ VIEW FUNCTIONS ================ */

  function predictPoint(uint256 price) public pure override returns (uint256) {
      require(price <= MAX_PRICE && price >= MIN_PRICE, "NFT: price is too high or too low");
      return (MAX_PRICE * MIN_PRICE) / price;
  }

  function tokenMint(address nft, uint256 tokenId) public view override returns (uint256) {
      return
          tokenMinted[nft][tokenId] +
          (tokenPoint[nft][tokenId] * (perPointMint(nft) - tokenPerPointPaid[nft][tokenId]));
  }

  /* ================ TRANSACTION FUNCTIONS ================ */

  function list(
      address nft,
      uint256 tokenId,
      uint256 price
  ) external override nonReentrant {
      tokenPoint[nft][tokenId] = predictPoint(price);
      totalPoint[nft] += tokenPoint[nft][tokenId];
      tokenPrice[nft][tokenId] = price;
      tokenOwner[nft][tokenId] = msg.sender;
      IERC721(nft).safeTransferFrom(msg.sender, address(this), tokenId);
  }

  function unList(address nft, uint256 tokenId) external override nonReentrant {
      require(tokenOwner[nft][tokenId] == msg.sender, "NFT: sender not owner");
      require(IERC721(nft).ownerOf(tokenId) == address(this), "NFT: this not owner");
      totalPoint[nft] -= tokenPoint[nft][tokenId];
      tokenPoint[nft][tokenId] = 0;
      tokenOwner[nft][tokenId] = address(0);
      tokenPrice[nft][tokenId] = 0;
      IERC721(nft).safeTransferFrom(address(this), msg.sender, tokenId);
  }

  function rePrice(
      address nft,
      uint256 tokenId,
      uint256 price
  ) external override nonReentrant {
      require(tokenOwner[nft][tokenId] == msg.sender, "NFT: sender not owner");
      require(IERC721(nft).ownerOf(tokenId) == address(this), "NFT: this not owner");
      totalPoint[nft] -= tokenPoint[nft][tokenId];
      tokenPoint[nft][tokenId] = predictPoint(price);
      totalPoint[nft] += tokenPoint[nft][tokenId];
      tokenPrice[nft][tokenId] = price;
  }

  function buy(address nft, uint256 tokenId) external payable override nonReentrant {
      require(msg.value >= tokenPrice[nft][tokenId], "NFT: price is too low");
      require(IERC721(nft).ownerOf(tokenId) == address(this), "NFT: this not owner");
      uint256 feeAmount = (tokenPrice[nft][tokenId] * fee) / 10000;
      totalPoint[nft] -= tokenPoint[nft][tokenId];
      tokenPoint[nft][tokenId] = 0;
      tokenOwner[nft][tokenId] = address(0);
      safeTransferETH(feeTo, feeAmount);
      safeTransferETH(tokenOwner[nft][tokenId], tokenPrice[nft][tokenId] - feeAmount);
      tokenPrice[nft][tokenId] = 0;
      IERC721(nft).safeTransferFrom(address(this), msg.sender, tokenId);
      if (address(this).balance > 0) {
          safeTransferETH(msg.sender, address(this).balance);
      }
  }

  /* ================ ADMIN FUNCTIONS ================ */

  function setBlockMint(address nft, uint256 newBlockMint) external {
      blockMint[nft] = newBlockMint;
  }

  function setFee(uint256 newFee) external {
      fee = newFee;
  }

  function setFeeTo(address newFeeTo) external {
      feeTo = newFeeTo;
  }
}
点赞 1
收藏 0
分享
本文参与登链社区写作激励计划 ，好文好收益，欢迎正在阅读的你也加入。

你可能感兴趣的文章

相关问题

0 条评论

请先 登录 后评论
33357
33357
0x1f24...fa59
传播区块链技术，躺赢未来人生

33357

如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！