Bancor V3

1// SPDX-License-Identifier: SEE LICENSE IN LICENSE
2pragma solidity 0.8.13;
3
4import { Address } from "@openzeppelin/contracts/utils/Address.sol";
5import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
6import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
7import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
8import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
9
10import { ITokenGovernance } from "@bancor/token-governance/contracts/ITokenGovernance.sol";
11
12import { IVault, ROLE_ASSET_MANAGER } from "./interfaces/IVault.sol";
13import { Upgradeable } from "../utility/Upgradeable.sol";
14import { IERC20Burnable } from "../token/interfaces/IERC20Burnable.sol";
15import { Token } from "../token/Token.sol";
16import { TokenLibrary } from "../token/TokenLibrary.sol";
17
18import { Utils, AccessDenied, NotPayable, InvalidToken } from "../utility/Utils.sol";
19
20abstract contract Vault is IVault, Upgradeable, PausableUpgradeable, ReentrancyGuardUpgradeable, Utils {
21    using Address for address payable;
22    using SafeERC20 for IERC20;
23    using TokenLibrary for Token;
24
25    // the address of the BNT token
26    IERC20 internal immutable _bnt;
27
28    // the address of the BNT token governance
29    ITokenGovernance internal immutable _bntGovernance;
30
31    // the address of the VBNT token
32    IERC20 internal immutable _vbnt;
33
34    // the address of the VBNT token governance
35    ITokenGovernance internal immutable _vbntGovernance;
36
37    // solhint-disable func-name-mixedcase
38
39    /**
40     * @dev a "virtual" constructor that is only used to set immutable state variables
41     */
42    constructor(ITokenGovernance initBNTGovernance, ITokenGovernance initVBNTGovernance)
43        validAddress(address(initBNTGovernance))
44        validAddress(address(initVBNTGovernance))
45    {
46        _bntGovernance = initBNTGovernance;
47        _bnt = initBNTGovernance.token();
48        _vbntGovernance = initVBNTGovernance;
49        _vbnt = initVBNTGovernance.token();
50    }
51
52    /**
53     * @dev initializes the contract and its parents
54     */
55    function __Vault_init() internal onlyInitializing {
56        __Upgradeable_init();
57        __Pausable_init();
58        __ReentrancyGuard_init();
59
60        __Vault_init_unchained();
61    }
62
63    /**
64     * @dev performs contract-specific initialization
65     */
66    function __Vault_init_unchained() internal onlyInitializing {}
67
68    // solhint-enable func-name-mixedcase
69
70    /**
71     * @dev returns the asset manager role
72     */
73    function roleAssetManager() external pure returns (bytes32) {
74        return ROLE_ASSET_MANAGER;
75    }
76
77    // allows execution only by an authorized operation
78    modifier whenAuthorized(
79        address caller,
80        Token token,
81        address payable target,
82        uint256 amount
83    ) {
84        if (!isAuthorizedWithdrawal(caller, token, target, amount)) {
85            revert AccessDenied();
86        }
87
88        _;
89    }
90
91    /**
92     * @dev returns whether withdrawals are currently paused
93     */
94    function isPaused() external view returns (bool) {
95        return paused();
96    }
97
98    /**
99     * @dev pauses withdrawals
100     *
101     * requirements:
102     *
103     * - the caller must have the ROLE_ADMIN privileges
104     */
105    function pause() external onlyAdmin {
106        _pause();
107    }
108
109    /**
110     * @dev unpauses withdrawals
111     *
112     * requirements:
113     *
114     * - the caller must have the ROLE_ADMIN privileges
115     */
116    function unpause() external onlyAdmin {
117        _unpause();
118    }
119
120    /**
121     * @inheritdoc IVault
122     */
123    function withdrawFunds(
124        Token token,
125        address payable target,
126        uint256 amount
127    )
128        external
129        override
130        validAddress(target)
131        nonReentrant
132        whenNotPaused
133        whenAuthorized(msg.sender, token, target, amount)
134    {
135        if (amount == 0) {
136            return;
137        }
138
139        if (token.isNative()) {
140            // using a regular transfer here would revert due to exceeding the 2300 gas limit which is why we're using
141            // call instead (via sendValue), which the 2300 gas limit does not apply for
142            target.sendValue(amount);
143        } else {
144            token.safeTransfer(target, amount);
145        }
146
147        emit FundsWithdrawn({ token: token, caller: msg.sender, target: target, amount: amount });
148    }
149
150    /**
151     * @inheritdoc IVault
152     */
153    function burn(Token token, uint256 amount)
154        external
155        nonReentrant
156        whenNotPaused
157        whenAuthorized(msg.sender, token, payable(address(0)), amount)
158    {
159        if (amount == 0) {
160            return;
161        }
162
163        if (token.isNative()) {
164            revert InvalidToken();
165        }
166
167        // allow vaults to burn BNT and VBNT via their respective token governance modules
168        if (token.isEqual(_bnt)) {
169            _bntGovernance.burn(amount);
170        } else if (token.isEqual(_vbnt)) {
171            _vbntGovernance.burn(amount);
172        } else {
173            IERC20Burnable(address(token)).burn(amount);
174        }
175
176        emit FundsBurned({ token: token, caller: msg.sender, amount: amount });
177    }
178
179    /**
180     * @dev returns whether the given caller is allowed access to the given token
181     */
182    function isAuthorizedWithdrawal(
183        address caller,
184        Token token,
185        address target,
186        uint256 amount
187    ) internal view virtual returns (bool);
188
189    /**
190     * @inheritdoc IVault
191     */
192    function isPayable() public view virtual returns (bool);
193
194    /**
195     * @dev authorize the contract to receive the native token
196     *
197     * requirements:
198     *
199     * - isPayable must return true
200     */
201    receive() external payable {
202        if (!isPayable()) {
203            revert NotPayable();
204        }
205    }
206}

JavaScript Tests