区块链学习笔记之RealWorld体验赛——TransferFrom

//SPDX-License-Identifier: UNLICENSEDpragma solidity ^0.6.6;abstract contract Context {    function _msgSender() internal view virtual returns (address payable) {        return msg.sender;    }    function _msgData() internal view virtual returns (bytes memory) {        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691        return msg.data;    }}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);    function transfer(address recipient, 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 sender,        address recipient,        uint256 amount    ) external returns (bool);    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    );}library SafeMath {    function add(uint256 a, uint256 b) internal pure returns (uint256) {        uint256 c = a + b;        require(c >= a, "SafeMath: addition overflow");        return c;    }    function sub(uint256 a, uint256 b) internal pure returns (uint256) {        return sub(a, b, "SafeMath: subtraction overflow");    }    function sub(        uint256 a,        uint256 b,        string memory errorMessage    ) internal pure returns (uint256) {        require(b <= a, errorMessage);        uint256 c = a - b;        return c;    }    function mul(uint256 a, uint256 b) internal pure returns (uint256) {        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the        // benefit is lost if 'b' is also tested.        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522        if (a == 0) {            return 0;        }        uint256 c = a * b;        require(c / a == b, "SafeMath: multiplication overflow");        return c;    }    function div(uint256 a, uint256 b) internal pure returns (uint256) {        return div(a, b, "SafeMath: division by zero");    }    function div(        uint256 a,        uint256 b,        string memory errorMessage    ) internal pure returns (uint256) {        require(b > 0, errorMessage);        uint256 c = a / b;        // assert(a == b * c + a % b); // There is no case in which this doesn't hold        return c;    }    function mod(uint256 a, uint256 b) internal pure returns (uint256) {        return mod(a, b, "SafeMath: modulo by zero");    }    function mod(        uint256 a,        uint256 b,        string memory errorMessage    ) internal pure returns (uint256) {        require(b != 0, errorMessage);        return a % b;    }}contract ERC20 is Context, IERC20 {    using SafeMath for uint256;    mapping(address => uint256) private _balances;    mapping(address => mapping(address => uint256)) private _allowances;    uint256 private _totalSupply;    string private _name;    string private _symbol;    uint8 private _decimals;    constructor(string memory name, string memory symbol) public {        _name = name;        _symbol = symbol;        _decimals = 18;    }    /**     * @dev Returns the name of the token.     */    function name() public view returns (string memory) {        return _name;    }    function symbol() public view returns (string memory) {        return _symbol;    }    function decimals() public view returns (uint8) {        return _decimals;    }    /**     * @dev See {IERC20-totalSupply}.     */    function totalSupply() public view override returns (uint256) {        return _totalSupply;    }    /**     * @dev See {IERC20-balanceOf}.     */    function balanceOf(address account) public view override returns (uint256) {        return _balances[account];    }    function transfer(address recipient, uint256 amount)        public        virtual        override        returns (bool){        _transfer(_msgSender(), recipient, amount);        return true;    }    function allowance(address owner, address spender)        public        view        virtual        override        returns (uint256){        return _allowances[owner][spender];    }    function approve(address spender, uint256 amount)        public        virtual        override        returns (bool){        _approve(_msgSender(), spender, amount);        return true;    }    function transferFrom(        address sender,        address recipient,        uint256 amount    ) public virtual override returns (bool) {        _transfer(sender, recipient, amount);        _approve(            sender,            _msgSender(),            _allowances[sender][_msgSender()].sub(                amount,                "ERC20: transfer amount exceeds allowance"            )        );        return true;    }    function increaseAllowance(address spender, uint256 addedValue)        public        virtual        returns (bool){        _approve(            _msgSender(),            spender,            _allowances[_msgSender()][spender].add(addedValue)        );        return true;    }    function decreaseAllowance(address spender, uint256 subtractedValue)        public        virtual        returns (bool){        _approve(            _msgSender(),            spender,            _allowances[_msgSender()][spender].sub(                subtractedValue,                "ERC20: decreased allowance below zero"            )        );        return true;    }    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");        _balances[sender] = _balances[sender] - amount;        _balances[recipient] = _balances[recipient] + amount;        emit Transfer(sender, recipient, amount);    }    function _mint(address account, uint256 amount) internal virtual {        require(account != address(0), "ERC20: mint to the zero address");        _totalSupply = _totalSupply.add(amount);        _balances[account] = _balances[account].add(amount);        emit Transfer(address(0), account, amount);    }    function _burn(address account, uint256 amount) internal virtual {        require(account != address(0), "ERC20: burn from the zero address");        _balances[account] = _balances[account].sub(            amount,            "ERC20: burn amount exceeds balance"        );        _totalSupply = _totalSupply.sub(amount);        emit Transfer(account, address(0), amount);    }    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);    }    function _setupDecimals(uint8 decimals_) internal {        _decimals = decimals_;    }}contract Ownable is Context {    address private _owner;    event OwnershipTransferred(        address indexed previousOwner,        address indexed newOwner    );    constructor() internal {        address msgSender = _msgSender();        _owner = msgSender;        emit OwnershipTransferred(address(0), msgSender);    }    function owner() public view returns (address) {        return _owner;    }    modifier onlyOwner() {        require(_owner == _msgSender(), "Ownable: caller is not the owner");        _;    }    function renounceOwnership() public virtual onlyOwner {        emit OwnershipTransferred(_owner, address(0));        _owner = address(0);    }    function transferOwnership(address newOwner) public virtual onlyOwner {        require(            newOwner != address(0),            "Ownable: new owner is the zero address"        );        emit OwnershipTransferred(_owner, newOwner);        _owner = newOwner;    }}contract FishmenToken is ERC20("FishmenToken", "FMT"), Ownable {    function mint(address _to, uint256 _amount) public onlyOwner {        _mint(_to, _amount);    }    function burn(address _from, uint256 _amount) public {        _burn(_from, _amount);    }}