花式发币法之发行各类 ERC20 代币

Blue
更新于 2024-01-22 10:40
阅读 6131

在Web3的世界中，我们会接触到许许多多的token，如ERC20标准的token，即同质化代币，就是我们常说的在交易所可交易的虚拟货币，还有如ERC721，即非同质化代币，也是我们熟知的NFT，这篇文章主要给大家讲讲如何使用Solidity发行各类的ERC20代币。

> 在`Web3`的世界中，我们会接触到许许多多的`token`，如`ERC20`标准的`token`，即同质化代币，就是我们常说的在交易所可交易的虚拟货币，还有如`ERC721`，即非同质化代币，也是我们熟知的`NFT`，这篇文章主要给大家讲讲如何使用`Solidity`发行各类的`ERC20`代币。

下面的各类花式发币法是参考了 [崔棉大师的花式发币法](https://www.youtube.com/playlist?list=PLV16oVzL15MSC_H7BzeqstW4zSJ4sm-tM)，不过其中的`Solidity`版本和`OpenZeppelin`都使用了最新版本`Solidity 8`和`OpenZeppelin 5`，写法也都有相应的变化。

### 一、发行固定总量的`ERC20`代币

`ERC20FixedSupply.sol:`
```
// SPDX-License-Identifier: MIT 
pragma solidity >=0.8.0;

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

// 固定总量代币
contract ERC20FixedSupply is ERC20 {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 totalSupply // 发行总量
    ) ERC20(name, symbol) {
        _mint(msg.sender, totalSupply);
    }
}
```

固定总量代币即在发行时就发行全部到指定账户，这里是会把全部币增发到合约部署人账户里。后期该币也不能再次增发。

### 二、发行可销毁的`ERC20`代币

`ERC20WithBurnable.sol:`
```
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";

// 可销毁代币
contract ERC20WithBurnable is ERC20, ERC20Burnable {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 initialSupply // 初始发行总量
    ) ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
    }
}
```

可销毁代币可以在发行之后，通过调用`burn(uint256 amount)`方法来销毁自己手上的代币。

### 三、发行可增发的`ERC20`代币

`ERC20WithMintable.sol:`
```
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

// 可增发代币
contract ERC20WithMintable is ERC20, Ownable {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 initialSupply // 初始发行总量
    ) ERC20(name, symbol) Ownable(msg.sender) {
        _mint(msg.sender, initialSupply);
    }

function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}
```

可增发代币可以在发行之后，`owner`也随时可以调用`mint(address to, uint256 amount)`进行代币的增发。

### 四、通过角色权限控制的可增发`ERC20`代币

`ERC20WithMintableByAccess.sol:`
```
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

// 通过角色控制的可增发代币
contract ERC20WithMintableByAccess is ERC20, AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");

constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 initialSupply // 初始发行总量
    ) ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(MINTER_ROLE, msg.sender);
    }

function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
        _mint(to, amount);
    }
}
```

普通的可增发代币，一般只有`owner`才有增发的权限，如果我们想要让多个属于该角色的账号都有增发权限，就可以使用`OpenZeppelin`提供的角色权限控制合约，其他如销毁权限等也可这样控制。

### 五、发行有上限总量的`ERC20`代币

`ERC20WithCapped.sol:`
```
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

// 有封顶上限总量的代币
contract ERC20WithCapped is ERC20Capped, Ownable {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 initialSupply, // 初始发行总量
        uint256 cap // 上限总量
    ) ERC20(name, symbol) ERC20Capped(cap) Ownable(msg.sender) {
        _mint(msg.sender, initialSupply);
    }

function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}
```

有封顶上限总量代币一般是在可增发代币的基础上，设置一个总供应量上限，当达到这个上限时不允许再继续增发。

### 六、发行可暂停的`ERC20`代币

`ERC20WithPausable.sol:`
```
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

// 可暂停代币
contract ERC20WithPausable is ERC20, ERC20Pausable, Ownable {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 initialSupply // 初始发行总量
    ) ERC20(name, symbol) Ownable(msg.sender) {
        _mint(msg.sender, initialSupply);
    }

function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }

function pause() public onlyOwner {
        _pause();
    }

function unpause() public onlyOwner {
        _unpause();
    }

function _update(
        address from,
        address to,
        uint256 value
    ) internal override(ERC20, ERC20Pausable) {
        super._update(from, to, value);
    }
}
```

可暂停代币可以让`owner`通过调用`pause()`方法来暂停代币的所有交易功能(如增发、销毁、转移等)。

### 七、可锁仓的`ERC20`代币

可锁仓的`ERC20`代币需要我们在发行一个普通`ERC20`代币的合约情况下，再发行一个锁仓合约，通过把`ERC20`代币发送到锁仓合约进行锁仓，再由锁仓合约去控制解锁的时间和解锁的代币数量，最后会把解锁的代币发送给一个受益者(一般是锁仓的人或合约的部署人)。

这里我以最开始部署的固定总量代币和锁仓合约来演示可锁仓的`ERC20`代币

`ERC20FixedSupply.sol:`
```
// SPDX-License-Identifier: MIT 
pragma solidity >=0.8.0;

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

`ERC20WithVesting.sol:`
```
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/finance/VestingWallet.sol";

// 锁仓合约
contract ERC20WithVesting is VestingWallet {
    constructor(
        address beneficiary, // 受益人
        uint64 startTimestamp, // 开始解锁时间戳(秒)
        uint64 durationSeconds // 持续解锁时间(秒)
    ) VestingWallet(beneficiary, startTimestamp, durationSeconds) {}
}
```

部署完成这两个合约后，调用`ERC20FixedSupply`的`transfer`方法发送代币给`ERC20WithVesting`锁仓合约，锁仓合约会根据我们部署时给构造函数设置的受益人、开始时间、持续时间自动解锁代币，有解锁代币时，我们调用`ERC20WithVesting`的`release`方法就可把解锁的代币发送给受益人。

### 八、`ERC20`代币水龙头

代币水龙头也是基于普通`ERC20`代币合约的情况下，再发行一个水龙头合约，我们在`ERC20`代币合约中发送代币给水龙头合约，水龙头合约去控制每次给用户是否发放代币及发送代币的数量等。

`ERC20FixedSupply.sol:`
```
// SPDX-License-Identifier: MIT 
pragma solidity >=0.8.0;

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

`ERC20Faucet.sol:`
```
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

// ERC20代币的水龙头合约
contract Faucet {
    uint256 public amountAllowed = 100; // 每次可领的代币数
    address public tokenContract; // token合约地址
    mapping(address => bool) public requestedAddress; // 领取过代币的地址

// SendToken事件
    event SendToken(address indexed Receiver, uint256 indexed Amount);

// 部署时设定ERC20合约地址
    constructor(address _tokenContract) {
        tokenContract = _tokenContract;
    }

// 用户领取代币函数
    function requestToken() external {
        require(
            requestedAddress[msg.sender] == false,
            "Can't Request Multiple Times!"
        );
        ERC20 token = ERC20(tokenContract); // 创建合约对象
        require(
            token.balanceOf(address(this)) >= amountAllowed,
            "Faucet Empty!"
        );

token.transfer(msg.sender, amountAllowed); // 发送token
        requestedAddress[msg.sender] = true; // 记录领取地址

emit SendToken(msg.sender, amountAllowed); // 记录SendTOken事件
    }
}
```

部署完这两个合约后，先通过`ERC20`代币合约`transfer`代币到水龙头合约，然后其他用户就可以从水龙头合约去领取代币了，这里我们实现是每个用户只能领取一次，也可以实现为每个用户24小时只能领取一次，改一下判定是否领取的逻辑就行。

### 九、`ERC20`代币空投

代币空投也是需要在普通`ERC20`代币的基础上部署一个空投合约，通过在`ERC20`代币`approve`给空投合约可以转移的权限，然后空投合约去处理空投的逻辑。

`ERC20FixedSupply.sol:`
```
// SPDX-License-Identifier: MIT 
pragma solidity >=0.8.0;

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

`ERC20Airdrop.sol:`
```
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

// 空投合约
contract ERC20Airdrop {
    function multiTransferToken(
        address _token,
        address[] calldata _addresses,
        uint256[] calldata _amounts
    ) external {
        require(
            _addresses.length == _amounts.length,
            "Lengths of Addresses and Amounts NOT EQUAL"
        );
        ERC20 token = ERC20(_token);
        uint256 _amountSum = getSum(_amounts);
        require(
            token.allowance(msg.sender, address(this)) >= _amountSum,
            "Need Approve ERC20 token"
        );

for (uint8 i = 0; i < _addresses.length; i++) {
            token.transferFrom(msg.sender, _addresses[i], _amounts[i]);
        }
    }

// 数组求和函数
    function getSum(uint256[] calldata _arr) public pure returns (uint256 sum) {
        for (uint256 i = 0; i < _arr.length; i++) sum = sum + _arr[i];
    }
}
```

部署完这两个合约后，首先通过在`ERC20`代币合约中`approve`给空投合约可以转移代币的权限及代币数量，最后调用空投合约的`multiTransferToken(address _token, address[] calldata _addresses, uint256[] calldata _amounts)`，通过传入`ERC20`代币地址、空投的地址数组、地址对应空投的代币数来实现空投的逻辑。

### 十、`ERC20`代币之`WETH`

`WETH`是`ETH`通过智能合约包装的版本，我们常见的`WETH`、`WBTC`、`WBNB`都是对区块链原生代币通过智能合约包装的版本，因为如以太坊链原生代币`ETH`本身是不符合`ERC20`标准的，`WETH`可以包装后可以使`ETH`用于如`DAPP`，或跨链等。

`ERC20WETH.sol:`
```
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

contract WETH is ERC20{
    // 事件：存款和取款
    event  Deposit(address indexed dst, uint wad);
    event  Withdrawal(address indexed src, uint wad);

// 构造函数，初始化ERC20的名字和代号
    constructor() ERC20("WETH", "WETH"){
    }

// 回调函数，当用户往WETH合约转ETH时，会触发deposit()函数
    fallback() external payable {
        deposit();
    }
    // 回调函数，当用户往WETH合约转ETH时，会触发deposit()函数
    receive() external payable {
        deposit();
    }

// 存款函数，当用户存入ETH时，给他铸造等量的WETH
    function deposit() public payable {
        _mint(msg.sender, msg.value);
        emit Deposit(msg.sender, msg.value);
    }

// 提款函数，用户销毁WETH，取回等量的ETH
    function withdraw(uint amount) public {
        require(balanceOf(msg.sender) >= amount);
        _burn(msg.sender, amount);
        payable(msg.sender).transfer(amount);
        emit Withdrawal(msg.sender, amount);
    }
}
```

使用一个智能合约，用户在转入`ETH`时给他生成等量的`WETH`，用户在取款`ETH`时给他销毁等量的`WETH`，实现对`ETH`的包装。

> 到此我们就完成了常见的`ERC20`代币的发行，希望小伙伴给我多点赞、收藏哦~

在Web3的世界中，我们会接触到许许多多的token，如ERC20标准的token，即同质化代币，就是我们常说的在交易所可交易的虚拟货币，还有如ERC721，即非同质化代币，也是我们熟知的NFT，这篇文章主要给大家讲讲如何使用Solidity发行各类的ERC20代币。

下面的各类花式发币法是参考了崔棉大师的花式发币法，不过其中的Solidity版本和OpenZeppelin都使用了最新版本Solidity 8和OpenZeppelin 5，写法也都有相应的变化。

一、发行固定总量的`ERC20`代币

ERC20FixedSupply.sol:

// SPDX-License-Identifier: MIT 
pragma solidity >=0.8.0;

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

// 固定总量代币
contract ERC20FixedSupply is ERC20 {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 totalSupply // 发行总量
    ) ERC20(name, symbol) {
        _mint(msg.sender, totalSupply);
    }
}

固定总量代币即在发行时就发行全部到指定账户，这里是会把全部币增发到合约部署人账户里。后期该币也不能再次增发。

二、发行可销毁的`ERC20`代币

ERC20WithBurnable.sol:

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";

// 可销毁代币
contract ERC20WithBurnable is ERC20, ERC20Burnable {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 initialSupply // 初始发行总量
    ) ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
    }
}

可销毁代币可以在发行之后，通过调用burn(uint256 amount)方法来销毁自己手上的代币。

三、发行可增发的`ERC20`代币

ERC20WithMintable.sol:

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

// 可增发代币
contract ERC20WithMintable is ERC20, Ownable {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 initialSupply // 初始发行总量
    ) ERC20(name, symbol) Ownable(msg.sender) {
        _mint(msg.sender, initialSupply);
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}

可增发代币可以在发行之后，owner也随时可以调用mint(address to, uint256 amount)进行代币的增发。

四、通过角色权限控制的可增发`ERC20`代币

ERC20WithMintableByAccess.sol:

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

// 通过角色控制的可增发代币
contract ERC20WithMintableByAccess is ERC20, AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");

    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 initialSupply // 初始发行总量
    ) ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(MINTER_ROLE, msg.sender);
    }

    function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
        _mint(to, amount);
    }
}

普通的可增发代币，一般只有owner才有增发的权限，如果我们想要让多个属于该角色的账号都有增发权限，就可以使用OpenZeppelin提供的角色权限控制合约，其他如销毁权限等也可这样控制。

五、发行有上限总量的`ERC20`代币

ERC20WithCapped.sol:

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

// 有封顶上限总量的代币
contract ERC20WithCapped is ERC20Capped, Ownable {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 initialSupply, // 初始发行总量
        uint256 cap // 上限总量
    ) ERC20(name, symbol) ERC20Capped(cap) Ownable(msg.sender) {
        _mint(msg.sender, initialSupply);
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}

有封顶上限总量代币一般是在可增发代币的基础上，设置一个总供应量上限，当达到这个上限时不允许再继续增发。

六、发行可暂停的`ERC20`代币

ERC20WithPausable.sol:

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

// 可暂停代币
contract ERC20WithPausable is ERC20, ERC20Pausable, Ownable {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 initialSupply // 初始发行总量
    ) ERC20(name, symbol) Ownable(msg.sender) {
        _mint(msg.sender, initialSupply);
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    function _update(
        address from,
        address to,
        uint256 value
    ) internal override(ERC20, ERC20Pausable) {
        super._update(from, to, value);
    }
}

可暂停代币可以让owner通过调用pause()方法来暂停代币的所有交易功能(如增发、销毁、转移等)。

七、可锁仓的`ERC20`代币

可锁仓的ERC20代币需要我们在发行一个普通ERC20代币的合约情况下，再发行一个锁仓合约，通过把ERC20代币发送到锁仓合约进行锁仓，再由锁仓合约去控制解锁的时间和解锁的代币数量，最后会把解锁的代币发送给一个受益者(一般是锁仓的人或合约的部署人)。

这里我以最开始部署的固定总量代币和锁仓合约来演示可锁仓的ERC20代币

ERC20FixedSupply.sol:

// SPDX-License-Identifier: MIT 
pragma solidity >=0.8.0;

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

// 固定总量代币
contract ERC20FixedSupply is ERC20 {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 totalSupply // 发行总量
    ) ERC20(name, symbol) {
        _mint(msg.sender, totalSupply);
    }
}

ERC20WithVesting.sol:

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "@openzeppelin/contracts/finance/VestingWallet.sol";

// 锁仓合约
contract ERC20WithVesting is VestingWallet {
    constructor(
        address beneficiary, // 受益人
        uint64 startTimestamp, // 开始解锁时间戳(秒)
        uint64 durationSeconds // 持续解锁时间(秒)
    ) VestingWallet(beneficiary, startTimestamp, durationSeconds) {}
}

部署完成这两个合约后，调用ERC20FixedSupply的transfer方法发送代币给ERC20WithVesting锁仓合约，锁仓合约会根据我们部署时给构造函数设置的受益人、开始时间、持续时间自动解锁代币，有解锁代币时，我们调用ERC20WithVesting的release方法就可把解锁的代币发送给受益人。

八、`ERC20`代币水龙头

代币水龙头也是基于普通ERC20代币合约的情况下，再发行一个水龙头合约，我们在ERC20代币合约中发送代币给水龙头合约，水龙头合约去控制每次给用户是否发放代币及发送代币的数量等。

ERC20FixedSupply.sol:

// SPDX-License-Identifier: MIT 
pragma solidity >=0.8.0;

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

// 固定总量代币
contract ERC20FixedSupply is ERC20 {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 totalSupply // 发行总量
    ) ERC20(name, symbol) {
        _mint(msg.sender, totalSupply);
    }
}

ERC20Faucet.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

// ERC20代币的水龙头合约
contract Faucet {
    uint256 public amountAllowed = 100; // 每次可领的代币数
    address public tokenContract; // token合约地址
    mapping(address => bool) public requestedAddress; // 领取过代币的地址

    // SendToken事件
    event SendToken(address indexed Receiver, uint256 indexed Amount);

    // 部署时设定ERC20合约地址
    constructor(address _tokenContract) {
        tokenContract = _tokenContract;
    }

    // 用户领取代币函数
    function requestToken() external {
        require(
            requestedAddress[msg.sender] == false,
            "Can't Request Multiple Times!"
        );
        ERC20 token = ERC20(tokenContract); // 创建合约对象
        require(
            token.balanceOf(address(this)) >= amountAllowed,
            "Faucet Empty!"
        );

        token.transfer(msg.sender, amountAllowed); // 发送token
        requestedAddress[msg.sender] = true; // 记录领取地址

        emit SendToken(msg.sender, amountAllowed); // 记录SendTOken事件
    }
}

部署完这两个合约后，先通过ERC20代币合约transfer代币到水龙头合约，然后其他用户就可以从水龙头合约去领取代币了，这里我们实现是每个用户只能领取一次，也可以实现为每个用户24小时只能领取一次，改一下判定是否领取的逻辑就行。

九、`ERC20`代币空投

代币空投也是需要在普通ERC20代币的基础上部署一个空投合约，通过在ERC20代币approve给空投合约可以转移的权限，然后空投合约去处理空投的逻辑。

ERC20FixedSupply.sol:

// SPDX-License-Identifier: MIT 
pragma solidity >=0.8.0;

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

// 固定总量代币
contract ERC20FixedSupply is ERC20 {
    constructor(
        string memory name, // 代币名称
        string memory symbol, // 代币缩写
        uint256 totalSupply // 发行总量
    ) ERC20(name, symbol) {
        _mint(msg.sender, totalSupply);
    }
}

ERC20Airdrop.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

// 空投合约
contract ERC20Airdrop {
    function multiTransferToken(
        address _token,
        address[] calldata _addresses,
        uint256[] calldata _amounts
    ) external {
        require(
            _addresses.length == _amounts.length,
            "Lengths of Addresses and Amounts NOT EQUAL"
        );
        ERC20 token = ERC20(_token);
        uint256 _amountSum = getSum(_amounts);
        require(
            token.allowance(msg.sender, address(this)) >= _amountSum,
            "Need Approve ERC20 token"
        );

        for (uint8 i = 0; i &lt; _addresses.length; i++) {
            token.transferFrom(msg.sender, _addresses[i], _amounts[i]);
        }
    }

    // 数组求和函数
    function getSum(uint256[] calldata _arr) public pure returns (uint256 sum) {
        for (uint256 i = 0; i &lt; _arr.length; i++) sum = sum + _arr[i];
    }
}

部署完这两个合约后，首先通过在ERC20代币合约中approve给空投合约可以转移代币的权限及代币数量，最后调用空投合约的multiTransferToken(address _token, address[] calldata _addresses, uint256[] calldata _amounts)，通过传入ERC20代币地址、空投的地址数组、地址对应空投的代币数来实现空投的逻辑。

十、`ERC20`代币之`WETH`

WETH是ETH通过智能合约包装的版本，我们常见的WETH、WBTC、WBNB都是对区块链原生代币通过智能合约包装的版本，因为如以太坊链原生代币ETH本身是不符合ERC20标准的，WETH可以包装后可以使ETH用于如DAPP，或跨链等。

ERC20WETH.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

contract WETH is ERC20{
    // 事件：存款和取款
    event  Deposit(address indexed dst, uint wad);
    event  Withdrawal(address indexed src, uint wad);

    // 构造函数，初始化ERC20的名字和代号
    constructor() ERC20("WETH", "WETH"){
    }

    // 回调函数，当用户往WETH合约转ETH时，会触发deposit()函数
    fallback() external payable {
        deposit();
    }
    // 回调函数，当用户往WETH合约转ETH时，会触发deposit()函数
    receive() external payable {
        deposit();
    }

    // 存款函数，当用户存入ETH时，给他铸造等量的WETH
    function deposit() public payable {
        _mint(msg.sender, msg.value);
        emit Deposit(msg.sender, msg.value);
    }

    // 提款函数，用户销毁WETH，取回等量的ETH
    function withdraw(uint amount) public {
        require(balanceOf(msg.sender) >= amount);
        _burn(msg.sender, amount);
        payable(msg.sender).transfer(amount);
        emit Withdrawal(msg.sender, amount);
    }
}

使用一个智能合约，用户在转入ETH时给他生成等量的WETH，用户在取款ETH时给他销毁等量的WETH，实现对ETH的包装。

到此我们就完成了常见的ERC20代币的发行，希望小伙伴给我多点赞、收藏哦~

原创
学分: 125
分类: Web3应用
标签: Solidity ERC20

本文参与登链社区写作激励计划，好文好收益，欢迎正在阅读的你也加入。

花式发币法之发行各类 ERC20 代币

一、发行固定总量的`ERC20`代币

二、发行可销毁的`ERC20`代币

三、发行可增发的`ERC20`代币

四、通过角色权限控制的可增发`ERC20`代币

五、发行有上限总量的`ERC20`代币

六、发行可暂停的`ERC20`代币

七、可锁仓的`ERC20`代币

八、`ERC20`代币水龙头

九、`ERC20`代币空投

十、`ERC20`代币之`WETH`

0 条评论

文章目录

花式发币法之发行各类 ERC20 代币

一、发行固定总量的ERC20代币

二、发行可销毁的ERC20代币

三、发行可增发的ERC20代币

四、通过角色权限控制的可增发ERC20代币

五、发行有上限总量的ERC20代币

六、发行可暂停的ERC20代币

七、可锁仓的ERC20代币

八、ERC20代币水龙头

九、ERC20代币空投

十、ERC20代币之WETH

0 条评论

文章目录

一、发行固定总量的`ERC20`代币

二、发行可销毁的`ERC20`代币

三、发行可增发的`ERC20`代币

四、通过角色权限控制的可增发`ERC20`代币

五、发行有上限总量的`ERC20`代币

六、发行可暂停的`ERC20`代币

七、可锁仓的`ERC20`代币

八、`ERC20`代币水龙头

九、`ERC20`代币空投

十、`ERC20`代币之`WETH`