ERC-7144: 具有交易验证步骤的 ERC-20

interface IERC7144 {

    struct TransferValidation {
        // 所有者的地址。
        address from;
        // 接收者的地址。
        address to;
        // Token 数量。
        uint256 amount;
        // 是否是有效的转移。
        bool valid;
    }

    struct ApprovalValidation {
        // 所有者的地址。
        address owner;
        // 消费者的地址。
        address spender;
        // 批准的 Token 数量。
        uint256 amount;
        // 是否是有效的批准。
        bool valid;
    }

    /**
     * @dev 当请求新的转移验证时发出。
     */
    event ValidateTransfer(address indexed from, address indexed to, uint256 amount, uint256 indexed transferValidationId);

    /**
    * @dev 当请求新的批准验证时发出。
    */
    event ValidateApproval(address indexed owner, address indexed spender, uint256 amount, uint256 indexed approvalValidationId);

    /**
     * @dev 如果此合约是验证器 ERC20，则返回 true。
     */
    function isValidatorContract() external view returns (bool);

    /**
     * @dev 使用转移 ID 返回转移验证结构体。
     *
     */
    function transferValidation(uint256 transferId) external view returns (TransferValidation memory);

    /**
    * @dev 使用批准 ID 返回批准验证结构体。
    *
    */
    function approvalValidation(uint256 approvalId) external view returns (ApprovalValidation memory);

    /**
     * @dev 返回创建的转移验证的总量。
     *
     */
    function totalTransferValidations() external view returns (uint256);

    /**
     * @dev 返回创建的转移验证的总量。
     *
     */
    function totalApprovalValidations() external view returns (uint256);
}

// SPDX-License-Identifier: CC0-1.0

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./IERC7144.sol";

/**
 * @dev ERC7144 的实现
 */
contract ERC7144 is IERC7144, ERC20 {

    // 从转移 ID 到转移验证的映射
    mapping(uint256 => TransferValidation) private _transferValidations;

    // 从批准 ID 到批准验证的映射
    mapping(uint256 => ApprovalValidation) private _approvalValidations;

    // 转移验证的总数
    uint256 private _totalTransferValidations;

    // 批准验证的总数
    uint256 private _totalApprovalValidations;

    /**
     * @dev 通过设置 Token 集合的 `name` 和 `symbol` 来初始化合约。
     */
    constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_){
    }

    /**
    * @dev 如果此合约是验证器 ERC721，则返回 true。
    */
    function isValidatorContract() public pure returns (bool) {
        return true;
    }

    /**
     * @dev 使用转移 ID 返回转移验证结构体。
     *
     */
    function transferValidation(uint256 transferId) public view override returns (TransferValidation memory) {
        require(transferId < _totalTransferValidations, "ERC7144: 无效的转移 ID");
        TransferValidation memory v = _transferValidation(transferId);

        return v;
    }

    /**
     * @dev 使用批准 ID 返回批准验证结构体。
     *
     */
    function approvalValidation(uint256 approvalId) public view override returns (ApprovalValidation memory) {
        require(approvalId < _totalApprovalValidations, "ERC7144: 无效的批准 ID");
        ApprovalValidation memory v = _approvalValidation(approvalId);

        return v;
    }

    /**
     * @dev 返回创建的转移验证的总量。
     *
     */
    function totalTransferValidations() public view override returns (uint256) {
        return _totalTransferValidations;
    }

    /**
     * @dev 返回创建的批准验证的总量。
     *
     */
    function totalApprovalValidations() public view override returns (uint256) {
        return _totalApprovalValidations;
    }

    /**
     * @dev 返回 `transferId` 的转移验证。如果转移不存在，则不会恢复
     */
    function _transferValidation(uint256 transferId) internal view virtual returns (TransferValidation memory) {
        return _transferValidations[transferId];
    }

    /**
     * @dev 返回 `approvalId` 的批准验证。如果转移不存在，则不会恢复
     */
    function _approvalValidation(uint256 approvalId) internal view virtual returns (ApprovalValidation memory) {
        return _approvalValidations[approvalId];
    }

    /**
     * @dev 使用转移 ID 验证转移。
     *
     */
    function _validateTransfer(uint256 transferId) internal virtual {
        TransferValidation memory v = transferValidation(transferId);
        require(!v.valid, "ERC721V: 转移已验证");

        super._transfer(v.from, v.to, v.amount);

        _transferValidations[transferId].valid = true;
    }

    /**
     * @dev 使用批准 ID 验证批准。
     *
     */
    function _validateApproval(uint256 approvalId) internal virtual {
        ApprovalValidation memory v = approvalValidation(approvalId);
        require(!v.valid, "ERC7144: 批准已验证");

        super._approve(v.owner, v.spender, v.amount);

        _approvalValidations[approvalId].valid = true;
    }

    /**
     * @dev 创建从 `from` 到 `to` 的 `tokenId` 的转移请求。
     *
     * 要求：
     *
     * - `from` 不能为零地址。
     * - `to` 不能为零地址。
     *
     * 发出 {ValidateTransfer} 事件。
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        require(from != address(0), "ERC7144: 从零地址转移");
        require(to != address(0), "ERC7144: 转移到零地址");

        if(_msgSender() == from) {
            TransferValidation memory v;

            v.from = from;
            v.to = to;
            v.amount = amount;

            _transferValidations[_totalTransferValidations] = v;

            emit ValidateTransfer(from, to, amount, _totalTransferValidations);

            _totalTransferValidations++;
        } else {
            super._transfer(from, to, amount);
        }
    }

    /**
     * @dev 创建从 `owner` 操作 `amount` 的批准请求
     *
     * 发出 {ValidateApproval} 事件。
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual override {
        require(owner != address(0), "ERC7144: 从零地址批准");
        require(spender != address(0), "ERC7144: 批准到零地址");

        ApprovalValidation memory v;

        v.owner = owner;
        v.spender = spender;
        v.amount = amount;

        _approvalValidations[_totalApprovalValidations] = v;

        emit ValidateApproval(v.owner, spender, amount, _totalApprovalValidations);

        _totalApprovalValidations++;
    }
}