写在前面
最近在入门web3，在学习的过程中，发现以太坊上的ERC20协议挺有意思的，打算产出篇文章来好好总结一下，这个ERC20到底是个啥。本文需要搭配我在B站发布的视频一起配套食用喔
开始
首先我们需要先到ERC20官网上查看具体信息。下面是我从官网上抽出的ERC20的核心代码
// Events
// 记录_from账户给_to账户转账_value个Token
event Transfer(address indexed _from, address indexed _to, uint256 _value)
// 记录_owner账户给_spender账户授权了_value个Token
event Approval(address indexed _owner, address indexed _spender, uint256 _value)
// Functions
// 返回Token的名字，类似比特币中的BitCoin
function name() public view returns (string)
// 返回Token的简称，类似比特币中的BTC
function symbol() public view reutrns (string)
// 返回Token的精度
function decimals() public view returns (uint8)
// 返回Token的总供应量
function totalSupply() public view returns (uint256)
// 返回_owner账户中有多少个Token
function balanceOf(address _owner) publiv view returns (uint256 balance)
// 调用者将_value个Token转给_to账户
function transfer(address _to, uint256 _value) public returns (bool success)
// 将_from账户_value个Token转给_to账户
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
// 调用者将_value个Token授权给_spender使用
function approval(address _spender, uint256 _value) public returns (bool success)
// 返回_owner账户授权多少个Token给_spender账户
function allowance(address _owner, address _spender) public view returns (uint256 remaining)
这是官方定义的关于ERC20的规范，这个其实我们用得不是很多，在实际开发过程中，我们都是用的openzeppelin合约安全库。接下来我们就看看openzeppelin是怎么实现的吧。
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
// 这是一个标准的ERC20协议
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
// 保存address有多少Token
mapping(address => uint256) private _balances;
// 第一个address授权给第二个address多少个Token
mapping(address => mapping(address => uint256)) private _allowances;
// Token的总供应量
uint256 private _totalSupply;
// Token的名字
string private _name;
// Token的简称
string private _symbol;
// 构造函数，传入Token的名字和简称
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
// 返回Token的名字
function name() public view virtual override returns (string memory) {
return _name;
}
// 返回Token的简称
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
// 返回Token小数点后位数
function decimals() public view virtual override returns (uint8) {
return 18;
}
// 返回Token的总供应量
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
// 返回account的Token余额
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
// msg.sender给to转amount个Token
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender(); // _msgSender函数是在Context合约中定义的，这里需要注意合约和合约之间的调用关系
_transfer(owner, to, amount); // 真正实现转帐逻辑
return true;
}
// 查询owner给spender授权了多少个Token
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
// msg.sneder给sender授权使用他的amount个Token
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount); // 真正实现授权逻辑
return true;
}
// 把from的amount个Token转给to
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
// msg.sender继续追加授权addedValue个Token给spender
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
// msg.sender减少授权subtractedValue个Token给spender
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
// 把from中amount个Token转给to
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address"); // from不能是一个非法的地址
require(to != address(0), "ERC20: transfer to the zero address");// to不能是一个非法的地址
_beforeTokenTransfer(from, to, amount); // 钩子函数，目前未实现
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); // amount必须小于等于from账上的资产
unchecked {
_balances[from] = fromBalance - amount;
// Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount); // 记录日志事件
_afterTokenTransfer(from, to, amount); // 钩子函数
}
// 追加Token的供应量
// 默认Token供应量只有0
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
// 燃烧供应量
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;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
// 把owner的amount个Token授权给spender使用
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);
}
// 把owner授权给spender的Token减去amount个
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
// 两个钩子函数，目前没有实现，可以自己内部实现
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
