Solidity-ERC20代币的锁仓与释放-1

此篇文章主要介绍如何部署一个ERC20代币，和写一个智能合约的锁仓 ，释放功能，最后通过合约去管理，这些Token的流通。

主要的实现思路步骤如下：

1.   先部署ERC20Token

2.   编写Solidity合约锁仓和释放的业务功能模块

3.   把部署的ERC20Token转到锁仓的智能合约

一. 部署ERC20Token

主要实现思路 

•   打开Remix
•   编写ERC20标准合约
•   点击发布部署

1.打开网页版Remix

2.编写ERC2合约并且发布 （此合约是通过mint无限增发的模式）

 两个合约代码，一个是interface ERC20接口用来定义标准， 第二个合约就是具体的实现合约，转账，查询，消耗等功能。(ERC20标准合约代码)

// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)pragma solidity ^0.8.0;/** * @dev Interface of the ERC20 standard as defined in the EIP. */interface IERC20 {    /**     * @dev Returns the amount of tokens in existence.     */    function totalSupply() external view returns (uint256);    /**     * @dev Returns the amount of tokens owned by `account`.     */    function balanceOf(address account) external view returns (uint256);    /**     * @dev Moves `amount` tokens from the caller\'s account to `recipient`.     *     * Returns a boolean value indicating whether the operation succeeded.     *     * Emits a {Transfer} event.     */    function transfer(address recipient, uint256 amount) external returns (bool);    /**     * @dev Returns the remaining number of tokens that `spender` will be     * allowed to spend on behalf of `owner` through {transferFrom}. This is     * zero by default.     *     * This value changes when {approve} or {transferFrom} are called.     */    function allowance(address owner, address spender) external view returns (uint256);    /**     * @dev Sets `amount` as the allowance of `spender` over the caller\'s tokens.     *     * Returns a boolean value indicating whether the operation succeeded.     *     * IMPORTANT: Beware that changing an allowance with this method brings the risk     * that someone may use both the old and the new allowance by unfortunate     * transaction ordering. One possible solution to mitigate this race     * condition is to first reduce the spender\'s allowance to 0 and set the     * desired value afterwards:     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729     *     * Emits an {Approval} event.     */    function approve(address spender, uint256 amount) external returns (bool);    /**     * @dev Moves `amount` tokens from `sender` to `recipient` using the     * allowance mechanism. `amount` is then deducted from the caller\'s     * allowance.     *     * Returns a boolean value indicating whether the operation succeeded.     *     * Emits a {Transfer} event.     */    function transferFrom(        address sender,        address recipient,        uint256 amount    ) external returns (bool);    /**     * @dev Emitted when `value` tokens are moved from one account (`from`) to     * another (`to`).     *     * Note that `value` may be zero.     */    event Transfer(address indexed from, address indexed to, uint256 value);    /**     * @dev Emitted when the allowance of a `spender` for an `owner` is set by     * a call to {approve}. `value` is the new allowance.     */    event Approval(address indexed owner, address indexed spender, uint256 value);}

// SPDX-License-Identifier: MIT// OpenZeppelin Contracts v4.4.0 (token/ERC20/ERC20.sol)pragma solidity ^0.8.0;import \"./IERC20.sol\";contract ERC20 is  IERC20  {    mapping(address => uint256) private _balances;    mapping(address => mapping(address => uint256)) private _allowances;    uint256 private _totalSupply;    string private _name;    string private _symbol;    address _owner;     /**     * @dev Sets the values for {name} and {symbol}.     *     * The default value of {decimals} is 18. To select a different value for     * {decimals} you should overload it.     *     * All two of these values are immutable: they can only be set once during     * construction.     */    constructor(string memory name_, string memory symbol_) {        _name = name_;        _symbol = symbol_;        _owner=msg.sender;    }    /**     * @dev Returns the name of the token.     */    function name() public view virtual   returns (string memory) {        return _name;    }    /**     * @dev Returns the symbol of the token, usually a shorter version of the     * name.     */    function symbol() public view virtual   returns (string memory) {        return _symbol;    }    /**     * @dev Returns the number of decimals used to get its user representation.     * For example, if `decimals` equals `2`, a balance of `505` tokens should     * be displayed to a user as `5.05` (`505 / 10 ** 2`).     *     * Tokens usually opt for a value of 18, imitating the relationship between     * Ether and Wei. This is the value {ERC20} uses, unless this function is     * overridden;     *     * NOTE: This information is only used for _display_ purposes: it in     * no way affects any of the arithmetic of the contract, including     * {IERC20-balanceOf} and {IERC20-transfer}.     */    function decimals() public view virtual   returns (uint8) {        return 18;    }    /**     * @dev See {IERC20-totalSupply}.     */    function totalSupply() public view virtual override returns (uint256) {        return _totalSupply;    }    /**     * @dev See {IERC20-balanceOf}.     */    function balanceOf(address account) public view virtual override returns (uint256) {        return _balances[account];    }    /**     * @dev See {IERC20-transfer}.     *     * Requirements:     *     * - `recipient` cannot be the zero address.     * - the caller must have a balance of at least `amount`.     */    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {        _transfer(msg.sender, recipient, amount);        return true;    }    /**     * @dev See {IERC20-allowance}.     */    function allowance(address owner, address spender) public view virtual override returns (uint256) {        return _allowances[owner][spender];    }    /**     * @dev See {IERC20-approve}.     *     * Requirements:     *     * - `spender` cannot be the zero address.     */    function approve(address spender, uint256 amount) public virtual override returns (bool) {        _approve(msg.sender, spender, amount);        return true;    }    /**     * @dev See {IERC20-transferFrom}.     *     * Emits an {Approval} event indicating the updated allowance. This is not     * required by the EIP. See the note at the beginning of {ERC20}.     *     * Requirements:     *     * - `sender` and `recipient` cannot be the zero address.     * - `sender` must have a balance of at least `amount`.     * - the caller must have allowance for ``sender``\'s tokens of at least     * `amount`.     */    function transferFrom(        address sender,        address recipient,        uint256 amount    ) public virtual override returns (bool) {        _transfer(sender, recipient, amount);        uint256 currentAllowance = _allowances[sender][msg.sender];        require(currentAllowance >= amount, \"ERC20: transfer amount exceeds allowance\");        unchecked {            _approve(sender, msg.sender, currentAllowance - amount);        }        return true;    }    /**     * @dev Atomically increases the allowance granted to `spender` by the caller.     *     * This is an alternative to {approve} that can be used as a mitigation for     * problems described in {IERC20-approve}.     *     * Emits an {Approval} event indicating the updated allowance.     *     * Requirements:     *     * - `spender` cannot be the zero address.     */    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {        _approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);        return true;    }    /**     * @dev Atomically decreases the allowance granted to `spender` by the caller.     *     * This is an alternative to {approve} that can be used as a mitigation for     * problems described in {IERC20-approve}.     *     * Emits an {Approval} event indicating the updated allowance.     *     * Requirements:     *     * - `spender` cannot be the zero address.     * - `spender` must have allowance for the caller of at least     * `subtractedValue`.     */    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {        uint256 currentAllowance = _allowances[msg.sender][spender];        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");        unchecked {            _approve(msg.sender, spender, currentAllowance - subtractedValue);        }        return true;    }    /**     * @dev Moves `amount` of tokens from `sender` to `recipient`.     *     * This internal function is equivalent to {transfer}, and can be used to     * e.g. implement automatic token fees, slashing mechanisms, etc.     *     * Emits a {Transfer} event.     *     * Requirements:     *     * - `sender` cannot be the zero address.     * - `recipient` cannot be the zero address.     * - `sender` must have a balance of at least `amount`.     */    function _transfer(        address sender,        address recipient,        uint256 amount    ) internal virtual {        require(sender != address(0), \"ERC20: transfer from the zero address\");        require(recipient != address(0), \"ERC20: transfer to the zero address\");        _beforeTokenTransfer(sender, recipient, amount);        uint256 senderBalance = _balances[sender];        require(senderBalance >= amount, \"ERC20: transfer amount exceeds balance\");        unchecked {            _balances[sender] = senderBalance - amount;        }        _balances[recipient] += amount;        emit Transfer(sender, recipient, amount);        _afterTokenTransfer(sender, recipient, amount);    }    modifier onlyowner{        require(msg.sender==_owner);        _;    }    /** @dev Creates `amount` tokens and assigns them to `account`, increasing     * the total supply.     *     * Emits a {Transfer} event with `from` set to the zero address.     *     * Requirements:     *     * - `account` cannot be the zero address.     */    function _mint(address account, uint256 amount) public virtual onlyowner {        require(account != address(0), \"ERC20: mint to the zero address\");        _beforeTokenTransfer(address(0), account, amount);        _totalSupply += amount;        _balances[account] += amount;        emit Transfer(address(0), account, amount);        _afterTokenTransfer(address(0), account, amount);    }    /**     * @dev Destroys `amount` tokens from `account`, reducing the     * total supply.     *     * Emits a {Transfer} event with `to` set to the zero address.     *     * Requirements:     *     * - `account` cannot be the zero address.     * - `account` must have at least `amount` tokens.     */    function _burn(address account, uint256 amount) internal virtual {        require(account != address(0), \"ERC20: burn from the zero address\");        _beforeTokenTransfer(account, address(0), amount);        uint256 accountBalance = _balances[account];        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");        unchecked {            _balances[account] = accountBalance - amount;        }        _totalSupply -= amount;        emit Transfer(account, address(0), amount);        _afterTokenTransfer(account, address(0), amount);    }    /**     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.     *     * This internal function is equivalent to `approve`, and can be used to     * e.g. set automatic allowances for certain subsystems, etc.     *     * Emits an {Approval} event.     *     * Requirements:     *     * - `owner` cannot be the zero address.     * - `spender` cannot be the zero address.     */    function _approve(        address owner,        address spender,        uint256 amount    ) internal virtual {        require(owner != address(0), \"ERC20: approve from the zero address\");        require(spender != address(0), \"ERC20: approve to the zero address\");        _allowances[owner][spender] = amount;        emit Approval(owner, spender, amount);    }    /**     * @dev Hook that is called before any transfer of tokens. This includes     * minting and burning.     *     * Calling conditions:     *     * - when `from` and `to` are both non-zero, `amount` of ``from``\'s tokens     * will be transferred to `to`.     * - when `from` is zero, `amount` tokens will be minted for `to`.     * - when `to` is zero, `amount` of ``from``\'s tokens will be burned.     * - `from` and `to` are never both zero.     *     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].     */    function _beforeTokenTransfer(        address from,        address to,        uint256 amount    ) internal virtual {}    /**     * @dev Hook that is called after any transfer of tokens. This includes     * minting and burning.     *     * Calling conditions:     *     * - when `from` and `to` are both non-zero, `amount` of ``from``\'s tokens     * has been transferred to `to`.     * - when `from` is zero, `amount` tokens have been minted for `to`.     * - when `to` is zero, `amount` of ``from``\'s tokens have been burned.     * - `from` and `to` are never both zero.     *     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].     */    function _afterTokenTransfer(        address from,        address to,        uint256 amount    ) internal virtual {}}

编写成功后

3.第三步

点击左上角的–Complie编译合约–编译通过后点击–左上角的DEPLOY部署自己的ERC20合约，在这里要注意先链接好自己的钱包地址，并且里面有测试代币等，最后点击部署即可完成全部操作。部署成功之后还需要自己手动初始化合约，例如代币的名词等。

跟着上面的步骤既可完成我们锁仓的合约第一步，下一篇更新锁仓合约。