Multichain.org

1// SPDX-License-Identifier: GPL-3.0-or-later
2
3pragma solidity ^0.8.10;
4
5import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
6import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
7import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
8
9
10library TokenOperation {
11    using Address for address;
12
13    function safeMint(
14        address token,
15        address to,
16        uint256 value
17    ) internal {
18        // mint(address,uint256)
19        _callOptionalReturn(token, abi.encodeWithSelector(0x40c10f19, to, value));
20    }
21
22    function safeBurnAny(
23        address token,
24        address from,
25        uint256 value
26    ) internal {
27        // burn(address,uint256)
28        _callOptionalReturn(token, abi.encodeWithSelector(0x9dc29fac, from, value));
29    }
30
31    function safeBurnSelf(
32        address token,
33        uint256 value
34    ) internal {
35        // burn(uint256)
36        _callOptionalReturn(token, abi.encodeWithSelector(0x42966c68, msg.sender, value));
37    }
38
39    function safeBurnFrom(
40        address token,
41        address from,
42        uint256 value
43    ) internal {
44        // burnFrom(address,uint256)
45        _callOptionalReturn(token, abi.encodeWithSelector(0x79cc6790, from, value));
46    }
47
48    function _callOptionalReturn(address token, bytes memory data) private {
49        bytes memory returndata = token.functionCall(data, "TokenOperation: low-level call failed");
50        if (returndata.length > 0) {
51            // Return data is optional
52            require(abi.decode(returndata, (bool)), "TokenOperation: did not succeed");
53        }
54    }
55}
56
57interface IBridge {
58    function Swapin(bytes32 txhash, address account, uint256 amount) external returns (bool);
59    function Swapout(uint256 amount, address bindaddr) external returns (bool);
60
61    event LogSwapin(bytes32 indexed txhash, address indexed account, uint256 amount);
62    event LogSwapout(address indexed account, address indexed bindaddr, uint256 amount);
63}
64
65interface IRouter {
66    function mint(address to, uint256 amount) external returns (bool);
67    function burn(address from, uint256 amount) external returns (bool);
68}
69
70contract MintBurnWrapper is AccessControlEnumerable, IBridge, IRouter {
71    using SafeERC20 for IERC20;
72
73    struct Supply {
74        uint256 max; // single limit of each mint
75        uint256 cap; // total limit of all mint
76        uint256 total; // total minted minus burned
77    }
78
79    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
80
81    mapping(address => Supply) public minterSupply;
82    uint256 public totalMintCap; // total mint cap
83    uint256 public totalMinted; // total minted amount
84
85    enum TokenType {
86        MintBurnAny,  // mint and burn(address from, uint256 amount), don't need approve
87        MintBurnFrom, // mint and burnFrom(address from, uint256 amount), need approve
88        MintBurnSelf, // mint and burn(uint256 amount), call transferFrom first, need approve
89        Transfer      // transfer and transferFrom, need approve
90    }
91
92    address public immutable token; // the target token this contract is wrapping
93    TokenType public immutable tokenType;
94
95    bool public allMintPaused; // pause all mint calling
96    bool public allBurnPaused; // pause all burn calling
97    mapping(address => bool) public mintPaused; // pause specify minters' mint calling
98    mapping(address => bool) public burnPaused; // pause specify minters' burn calling
99
100    constructor(address _token, TokenType _tokenType, uint256 _totalMintCap, address _admin) {
101        require(_token != address(0), "zero token address");
102        require(_admin != address(0), "zero admin address");
103        token = _token;
104        tokenType = _tokenType;
105        totalMintCap = _totalMintCap;
106        _grantRole(DEFAULT_ADMIN_ROLE, _admin);
107    }
108
109    function owner() external view returns (address) {
110        return getRoleMember(DEFAULT_ADMIN_ROLE, 0);
111    }
112
113    function _mint(address to, uint256 amount) internal {
114        require(to != address(this), "forbid mint to address(this)");
115        require(!allMintPaused && !mintPaused[msg.sender], "mint paused");
116        Supply storage s = minterSupply[msg.sender];
117        require(amount <= s.max, "minter max exceeded");
118        s.total += amount;
119        require(s.total <= s.cap, "minter cap exceeded");
120        totalMinted += amount;
121        require(totalMinted <= totalMintCap, "total mint cap exceeded");
122
123        if (tokenType == TokenType.Transfer) {
124            IERC20(token).safeTransfer(to, amount);
125        } else {
126            TokenOperation.safeMint(token, to, amount);
127        }
128    }
129
130    function _burn(address from, uint256 amount) internal {
131        require(from != address(this), "forbid burn from address(this)");
132        require(!allBurnPaused && !burnPaused[msg.sender], "burn paused");
133        Supply storage s = minterSupply[msg.sender];
134        require(s.total >= amount, "minter burn amount exceeded");
135        s.total -= amount;
136        require(totalMinted >= amount, "total burn amount exceeded");
137        totalMinted -= amount;
138
139        if (tokenType == TokenType.Transfer) {
140            IERC20(token).safeTransferFrom(from, address(this), amount);
141        } else if (tokenType == TokenType.MintBurnAny) {
142            TokenOperation.safeBurnAny(token, from, amount);
143        } else if (tokenType == TokenType.MintBurnFrom) {
144            TokenOperation.safeBurnFrom(token, from, amount);
145        } else if (tokenType == TokenType.MintBurnSelf) {
146            IERC20(token).safeTransferFrom(from, address(this), amount);
147            TokenOperation.safeBurnSelf(token, amount);
148        }
149    }
150
151    // impl IRouter `mint`
152    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) returns (bool) {
153        _mint(to, amount);
154        return true;
155    }
156
157    // impl IRouter `burn`
158    function burn(address from, uint256 amount) external onlyRole(MINTER_ROLE) returns (bool) {
159        _burn(from, amount);
160        return true;
161    }
162
163    // impl IBridge `Swapin`
164    function Swapin(bytes32 txhash, address account, uint256 amount) external onlyRole(MINTER_ROLE) returns (bool) {
165        _mint(account, amount);
166        emit LogSwapin(txhash, account, amount);
167        return true;
168    }
169
170    // impl IBridge `Swapout`
171    function Swapout(uint256 amount, address bindaddr) public returns (bool) {
172        require(bindaddr != address(0), "zero bind address");
173        _burn(msg.sender, amount);
174        emit LogSwapout(msg.sender, bindaddr, amount);
175        return true;
176    }
177
178    function setTotalMintCap(uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
179        totalMintCap = cap;
180    }
181
182    function addMinter(address minter, uint256 cap, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
183        _grantRole(MINTER_ROLE, minter);
184        minterSupply[minter].cap = cap;
185        minterSupply[minter].max = max;
186        mintPaused[minter] = false;
187        burnPaused[minter] = false;
188    }
189
190    function removeMinter(address minter) external onlyRole(DEFAULT_ADMIN_ROLE) {
191        _revokeRole(MINTER_ROLE, minter);
192        minterSupply[minter].cap = 0;
193        minterSupply[minter].max = 0;
194    }
195
196    function setMinterCap(address minter, uint256 cap) external onlyRole(DEFAULT_ADMIN_ROLE) {
197        require(hasRole(MINTER_ROLE, minter), "not minter");
198        minterSupply[minter].cap = cap;
199    }
200
201    function setMinterMax(address minter, uint256 max) external onlyRole(DEFAULT_ADMIN_ROLE) {
202        require(hasRole(MINTER_ROLE, minter), "not minter");
203        minterSupply[minter].max = max;
204    }
205
206    function setMinterTotal(address minter, uint256 total) external onlyRole(DEFAULT_ADMIN_ROLE) {
207        minterSupply[minter].total = total;
208    }
209
210    function setAllMintPaused(bool paused) external onlyRole(DEFAULT_ADMIN_ROLE) {
211        allMintPaused = paused;
212    }
213
214    function setAllBurnPaused(bool paused) external onlyRole(DEFAULT_ADMIN_ROLE) {
215        allBurnPaused = paused;
216    }
217
218    function setAllMintAndBurnPaused(bool paused) external onlyRole(DEFAULT_ADMIN_ROLE) {
219        allMintPaused = paused;
220        allBurnPaused = paused;
221    }
222
223    function setMintPaused(address minter, bool paused) external onlyRole(DEFAULT_ADMIN_ROLE) {
224        require(hasRole(MINTER_ROLE, minter), "not minter");
225        mintPaused[minter] = paused;
226    }
227
228    function setBurnPaused(address minter, bool paused) external onlyRole(DEFAULT_ADMIN_ROLE) {
229        require(hasRole(MINTER_ROLE, minter), "not minter");
230        burnPaused[minter] = paused;
231    }
232
233    function setMintAndBurnPaused(address minter, bool paused) external onlyRole(DEFAULT_ADMIN_ROLE) {
234        require(hasRole(MINTER_ROLE, minter), "not minter");
235        mintPaused[minter] = paused;
236        burnPaused[minter] = paused;
237    }
238}
239

JavaScript Tests