Solidity Openzeppelin VestingWallet合约

Solidity Openzeppelin VestingWallet合约

---

前言

VestingWallet合约用于实现对某个用户地址在一段时间内进行发放eth或erc20代币，发放的方式默认为线性释放，支持重写自定义的释放方式。

一、接口

FUNCTIONS
constructor(beneficiaryAddress, startTimestamp, durationSeconds)

receive()

beneficiary()

start()

duration()

released()

released(token)

release()

release(token)

vestedAmount(timestamp)

vestedAmount(token, timestamp)

_vestingSchedule(totalAllocation, timestamp)

EVENTS
EtherReleased(amount)

ERC20Released(token, amount)

二、Openzeppelin实现及注释

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (finance/VestingWallet.sol)
pragma solidity ^0.8.0;

import "../token/ERC20/utils/SafeERC20.sol";
import "../utils/Address.sol";
import "../utils/Context.sol";

/**
 * @title VestingWallet
 * @dev This contract handles the vesting of Eth and ERC20 tokens for a given beneficiary. Custody of multiple tokens
 * can be given to this contract, which will release the token to the beneficiary following a given vesting schedule.
 * The vesting schedule is customizable through the {vestedAmount} function.
 *
 * Any token transferred to this contract will follow the vesting schedule as if they were locked from the beginning.
 * Consequently, if the vesting has already started, any amount of tokens sent to this contract will (at least partly)
 * be immediately releasable.
 */
contract VestingWallet is Context {
    
    
    event EtherReleased(uint256 amount);
    event ERC20Released(address indexed token, uint256 amount);

    uint256 private _released; //已释放的eth数量
    mapping(address => uint256) private _erc20Released;//已释放的erc20代币数量
    address private immutable _beneficiary;//被发放地址
    uint64 private immutable _start;//发放开始时间
    uint64 private immutable _duration;//发放时间间隔

    /**构建函数时需要传入发放地址，开始时间及发放间隔
     * @dev Set the beneficiary, start timestamp and vesting duration of the vesting wallet.
     */
    constructor(
        address beneficiaryAddress,
        uint64 startTimestamp,
        uint64 durationSeconds
    ) payable {
    
    
        require(beneficiaryAddress != address(0), "VestingWallet: beneficiary is zero address");
        _beneficiary = beneficiaryAddress;
        _start = startTimestamp;
        _duration = durationSeconds;
    }

    /**
     * @dev The contract should be able to receive Eth.
     */
    receive() external payable virtual {
    
    }

    /**
     * @dev Getter for the beneficiary address.
     */
    function beneficiary() public view virtual returns (address) {
    
    
        return _beneficiary;
    }

    /**
     * @dev Getter for the start timestamp.
     */
    function start() public view virtual returns (uint256) {
    
    
        return _start;
    }

    /**
     * @dev Getter for the vesting duration.
     */
    function duration() public view virtual returns (uint256) {
    
    
        return _duration;
    }

    /**已释放数量
     * @dev Amount of eth already released
     */
    function released() public view virtual returns (uint256) {
    
    
        return _released;
    }

    /**
     * @dev Amount of token already released
     */
    function released(address token) public view virtual returns (uint256) {
    
    
        return _erc20Released[token];
    }

    /**剩余可释放数量
     * @dev Getter for the amount of releasable eth.
     */
    function releasable() public view virtual returns (uint256) {
    
    
        return vestedAmount(uint64(block.timestamp)) - released();
    }

    /**
     * @dev Getter for the amount of releasable `token` tokens. `token` should be the address of an
     * IERC20 contract.
     */
    function releasable(address token) public view virtual returns (uint256) {
    
    
        return vestedAmount(token, uint64(block.timestamp)) - released(token);
    }

    /**将当前可释放的eth份额发放给用户
     * @dev Release the native token (ether) that have already vested.
     *
     * Emits a {EtherReleased} event.
     */
    function release() public virtual {
    
    
        uint256 amount = releasable();
        _released += amount;
        emit EtherReleased(amount);
        Address.sendValue(payable(beneficiary()), amount);
    }

    /**将当前可释放的erc20份额发放给用户
     * @dev Release the tokens that have already vested.
     *
     * Emits a {ERC20Released} event.
     */
    function release(address token) public virtual {
    
    
        uint256 amount = releasable(token);
        _erc20Released[token] += amount;
        emit ERC20Released(token, amount);
        SafeERC20.safeTransfer(IERC20(token), beneficiary(), amount);
    }

    /**已发放的eth份额
     * @dev Calculates the amount of ether that has already vested. Default implementation is a linear vesting curve.
     */
    function vestedAmount(uint64 timestamp) public view virtual returns (uint256) {
    
    
        return _vestingSchedule(address(this).balance + released(), timestamp);
    }

    /**已发放的erc20份额
     * @dev Calculates the amount of tokens that has already vested. Default implementation is a linear vesting curve.
     */
    function vestedAmount(address token, uint64 timestamp) public view virtual returns (uint256) {
    
    
        return _vestingSchedule(IERC20(token).balanceOf(address(this)) + released(token), timestamp);
    }

    /**释放计划，默认线性释放
     * @dev Virtual implementation of the vesting formula. This returns the amount vested, as a function of time, for
     * an asset given its total historical allocation.
     */
    function _vestingSchedule(uint256 totalAllocation, uint64 timestamp) internal view virtual returns (uint256) {
    
    
        if (timestamp < start()) {
    
    
            return 0;
        } else if (timestamp > start() + duration()) {
    
    
            return totalAllocation;
        } else {
    
    
            return (totalAllocation * (timestamp - start())) / duration();
        }
    }
}