ERC-7246: Encumber - 分割所有权和保证

/**
 * @dev ERC-7246 标准的接口。
 */
interface IERC7246{
    /**
     * @dev 当从 `owner` 到 `taker` encumber 了 `amount` 个 token 时触发。
     */
    event Encumber(address indexed owner, address indexed taker, uint amount);

    /**
     * @dev 当 `taker` 对 `owner` 的 encumber 减少了 `amount` 时触发。
     */
    event Release(address indexed owner, address indexed taker, uint amount);

    /**
     * @dev 返回 `owner` 拥有的当前被 encumber 的 token 总量。
     * 必须永远不超过 `balanceOf(owner)`
     *
     * 任何会将 balanceOf(owner) 减少到 encumberedBalanceOf(owner) 以下的函数都必须 revert
     */
    function encumberedBalanceOf(address owner) external returns (uint);

    /**
     * @dev 返回 `owner` encumber 给 `taker` 的 token 数量。
     *
     * 当 `owner` 或另一个被允许的账户调用 {encumber} 或 {encumberFrom} 时，这个值会增加。
     * 当 `taker` 调用 {release} 和 {transferFrom} 时，这个值会减少。
     */
    function encumbrances(address owner, address taker) external returns (uint);

    /**
     * @dev 将调用者 encumber 给 `taker` 的 token 数量增加 `amount`。
     * 授予 `taker` 一种保证的权利，可以通过使用 `transferFrom` 从调用者的余额中转移 `amount`。
     *
     * 如果调用者没有 `amount` 个可用的 token（例如，如果 `balanceOf(caller) - encumbrances(caller) < amount`），则必须 revert。
     *
     * 触发一个 {Encumber} 事件。
     */
    function encumber(address taker, uint amount) external;

    /**
     * @dev 将 `owner` encumber 给 `taker` 的 token 数量增加 `amount`。
     * 授予 `taker` 一种保证的权利，可以通过使用 transferFrom 从 `owner` 处转移 `amount`
     *
     * 除非所有者账户通过某种机制故意授权了消息的发送者，否则该函数应该 revert。
     *
     * 如果 `owner` 没有 `amount` 个可用的 token（例如，如果 `balanceOf(owner) - encumbrances(owner) < amount`），则必须 revert。
     *
     * 触发一个 {Encumber} 事件。
     */
    function encumberFrom(address owner, address taker, uint amount) external;

    /**
     * @dev 将从 `owner` 到调用者的 encumber 的 token 数量减少 `amount`
     *
     * 触发一个 {Release} 事件。
     */
    function release(address owner, uint amount) external;


    /**
     * @dev 用于读取地址的未 encumber 余额的便捷函数。
     * 可以简单地实现为 `balanceOf(owner) - encumberedBalanceOf(owner)`
     */
    function availableBalanceOf(address owner) public view returns (uint);
}

// 一个通过阻止转移来实现 encumber 接口的 erc-20 token。

pragma solidity ^0.8.0;
import {ERC20} from "../lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
import { IERC7246 } from "./IERC7246.sol";

contract EncumberableERC20 is ERC20, IERC7246 {
    // Owner -> Taker -> 可以被拿走的金额
    mapping (address => mapping (address => uint)) public encumbrances;

    // token 所有者的 encumber 余额。对于一个用户来说，encumberedBalance 必须不超过 balanceOf
    // 请注意，这意味着重新调整 token 存在减少和违反此协议的风险
    mapping (address => uint) public encumberedBalanceOf;

    address public minter;

    constructor(string memory name, string memory symbol) ERC20(name, symbol) {
        minter = msg.sender;
    }

    function mint(address recipient, uint amount) public {
        require(msg.sender == minter, "only minter");
        _mint(recipient, amount);
    }

    function encumber(address taker, uint amount) external {
        _encumber(msg.sender, taker, amount);
    }

    function encumberFrom(address owner, address taker, uint amount) external {
        require(allowance(owner, msg.sender) >= amount);
       _encumber(owner, taker, amount);
    }

    function release(address owner, uint amount) external {
        _release(owner, msg.sender, amount);
    }

    // 如果使余额和 encumber 更接近相等，则必须检查
    function availableBalanceOf(address a) public view returns (uint) {
        return (balanceOf(a) - encumberedBalanceOf[a]);
    }

    function _encumber(address owner, address taker, uint amount) private {
        require(availableBalanceOf(owner) >= amount, "insufficient balance");
        encumbrances[owner][taker] += amount;
        encumberedBalanceOf[owner] += amount;
        emit Encumber(owner, taker, amount);
    }

    function _release(address owner, address taker, uint amount) private {
        if (encumbrances[owner][taker] < amount) {
          amount = encumbrances[owner][taker];
        }
        encumbrances[owner][taker] -= amount;
        encumberedBalanceOf[owner] -= amount;
        emit Release(owner, taker, amount);
    }

    function transfer(address dst, uint amount) public override returns (bool) {
        // 检查但不花费 encumber
        require(availableBalanceOf(msg.sender) >= amount, "insufficient balance");
        _transfer(msg.sender, dst, amount);
        return true;
    }

    function transferFrom(address src, address dst, uint amount) public override returns (bool) {
        uint encumberedToTaker = encumbrances[src][msg.sender];
        bool exceedsEncumbrance = amount > encumberedToTaker;
        if (exceedsEncumbrance)  {
            uint excessAmount = amount - encumberedToTaker;

            // 检查是否存在足够的 enencumber token 以从授权中支出
           require(availableBalanceOf(src) >= excessAmount, "insufficient balance");

           // 超过 Encumber，所以花费所有
            _spendEncumbrance(src, msg.sender, encumberedToTaker);

            _spendAllowance(src, dst, excessAmount);
        } else {
            _spendEncumbrance(src, msg.sender, amount);
        }

        _transfer(src, dst, amount);
        return true;
    }

    function _spendEncumbrance(address owner, address taker, uint256 amount) internal virtual {
        uint256 currentEncumbrance = encumbrances[owner][taker];
        require(currentEncumbrance >= amount, "insufficient encumbrance");
        uint newEncumbrance = currentEncumbrance - amount;
        encumbrances[owner][taker] = newEncumbrance;
        encumberedBalanceOf[owner] -= amount;
    }
}