IronBank

1// SPDX-License-Identifier: GPL-3.0-or-later
2
3pragma solidity ^0.8.2;
4
5/**
6 * @dev Interface of the ERC20 standard as defined in the EIP.
7 */
8interface IERC20 {
9    function totalSupply() external view returns (uint256);
10    function decimals() external view returns (uint8);
11    function balanceOf(address account) external view returns (uint256);
12    function transfer(address recipient, uint256 amount) external returns (bool);
13    function allowance(address owner, address spender) external view returns (uint256);
14    function approve(address spender, uint256 amount) external returns (bool);
15    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
16    event Transfer(address indexed from, address indexed to, uint256 value);
17    event Approval(address indexed owner, address indexed spender, uint256 value);
18}
19
20/**
21 * @dev Interface of the ERC2612 standard as defined in the EIP.
22 *
23 * Adds the {permit} method, which can be used to change one's
24 * {IERC20-allowance} without having to send a transaction, by signing a
25 * message. This allows users to spend tokens without having to hold Ether.
26 *
27 * See https://eips.ethereum.org/EIPS/eip-2612.
28 */
29interface IERC2612 {
30
31    /**
32     * @dev Returns the current ERC2612 nonce for `owner`. This value must be
33     * included whenever a signature is generated for {permit}.
34     *
35     * Every successful call to {permit} increases ``owner``'s nonce by one. This
36     * prevents a signature from being used multiple times.
37     */
38    function nonces(address owner) external view returns (uint256);
39    function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
40    function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
41
42}
43
44/// @dev Wrapped ERC-20 v10 (AnyswapV3ERC20) is an ERC-20 ERC-20 wrapper. You can `deposit` ERC-20 and obtain an AnyswapV3ERC20 balance which can then be operated as an ERC-20 token. You can
45/// `withdraw` ERC-20 from AnyswapV3ERC20, which will then burn AnyswapV3ERC20 token in your wallet. The amount of AnyswapV3ERC20 token in any wallet is always identical to the
46/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
47interface IAnyswapV3ERC20 is IERC20, IERC2612 {
48
49    /// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
50    /// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
51    /// Emits {Approval} event.
52    /// Returns boolean value indicating whether operation succeeded.
53    /// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
54    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
55
56    /// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
57    /// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
58    /// A transfer to `address(0)` triggers an ERC-20 withdraw matching the sent AnyswapV3ERC20 token in favor of caller.
59    /// Emits {Transfer} event.
60    /// Returns boolean value indicating whether operation succeeded.
61    /// Requirements:
62    ///   - caller account must have at least `value` AnyswapV3ERC20 token.
63    /// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
64    function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
65}
66
67interface ITransferReceiver {
68    function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
69}
70
71interface IApprovalReceiver {
72    function onTokenApproval(address, uint, bytes calldata) external returns (bool);
73}
74
75library Address {
76    function isContract(address account) internal view returns (bool) {
77        bytes32 codehash;
78        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
79        // solhint-disable-next-line no-inline-assembly
80        assembly { codehash := extcodehash(account) }
81        return (codehash != 0x0 && codehash != accountHash);
82    }
83}
84
85library SafeERC20 {
86    using Address for address;
87
88    function safeTransfer(IERC20 token, address to, uint value) internal {
89        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
90    }
91
92    function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
93        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
94    }
95
96    function safeApprove(IERC20 token, address spender, uint value) internal {
97        require((value == 0) || (token.allowance(address(this), spender) == 0),
98            "SafeERC20: approve from non-zero to non-zero allowance"
99        );
100        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
101    }
102    function callOptionalReturn(IERC20 token, bytes memory data) private {
103        require(address(token).isContract(), "SafeERC20: call to non-contract");
104
105        // solhint-disable-next-line avoid-low-level-calls
106        (bool success, bytes memory returndata) = address(token).call(data);
107        require(success, "SafeERC20: low-level call failed");
108
109        if (returndata.length > 0) { // Return data is optional
110            // solhint-disable-next-line max-line-length
111            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
112        }
113    }
114}
115
116contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
117    using SafeERC20 for IERC20;
118    string public name;
119    string public symbol;
120    uint8  public immutable override decimals;
121
122    address public immutable underlying;
123
124    bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
125    bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
126    bytes32 public immutable DOMAIN_SEPARATOR;
127
128    /// @dev Records amount of AnyswapV3ERC20 token owned by account.
129    mapping (address => uint256) public override balanceOf;
130    uint256 private _totalSupply;
131
132    // init flag for setting immediate vault, needed for CREATE2 support
133    bool private _init;
134
135    // flag to enable/disable swapout vs vault.burn so multiple events are triggered
136    bool private _vaultOnly;
137
138    // configurable delay for timelock functions
139    uint public delay = 2*24*3600;
140
141
142    // set of minters, can be this bridge or other bridges
143    mapping(address => bool) public isMinter;
144    address[] public minters;
145
146    // primary controller of the token contract
147    address public vault;
148
149    address public pendingMinter;
150    uint public delayMinter;
151
152    address public pendingVault;
153    uint public delayVault;
154
155    modifier onlyAuth() {
156        require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
157        _;
158    }
159
160    modifier onlyVault() {
161        require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
162        _;
163    }
164
165    function owner() public view returns (address) {
166        return mpc();
167    }
168
169    function mpc() public view returns (address) {
170        if (block.timestamp >= delayVault) {
171            return pendingVault;
172        }
173        return vault;
174    }

JavaScript Tests