Badger Finance

1contract BadgerBridgeAdapter is OwnableUpgradeable, ReentrancyGuardUpgradeable {
2    using SafeMathUpgradeable for uint256;
3    using SafeERC20 for IERC20;
4​
5    IERC20 public renBTC;
6    IERC20 public wBTC;
7​
8    // RenVM gateway registry.
9    IGatewayRegistry public registry;
10    // Swap router that handles swap routing optimizations.
11    ISwapStrategyRouter public router;
12​
13    event RecoverStuck(uint256 amount, uint256 fee);
14    event Mint(uint256 renbtc_minted, uint256 wbtc_swapped, uint256 fee);
15    event Burn(uint256 renbtc_burned, uint256 wbtc_transferred, uint256 fee);
16    event SwapError(bytes error);
17​
18    address public rewards;
19    address public governance;
20​
21    uint256 public mintFeeBps;
22    uint256 public burnFeeBps;
23    uint256 private percentageFeeRewardsBps;
24    uint256 private percentageFeeGovernanceBps;
25​
26    uint256 public constant MAX_BPS = 10000;
27​
28    mapping(address => bool) public approvedVaults;
29​
30    // Configurable permissionless curve lp token wrapper.
31    address curveTokenWrapper;
32​
33    // Make struct for mint args, otherwise too many local vars (stack too deep).
34    struct MintArguments {
35        uint256 _mintAmount;
36        uint256 _mintAmountMinusFee;
37        uint256 _fee;
38        uint256 _slippage;
39        address _vault;
40        address _user;
41        address _token;
42    }
43​
44    function initialize(
45        address _governance,
46        address _rewards,
47        address _registry,
48        address _router,
49        address _wbtc,
50        uint256[4] memory _feeConfig
51    ) public initializer {
52        __Ownable_init();
53        __ReentrancyGuard_init();
54​
55        require(_governance != address(0x0), "must set governance address");
56        require(_rewards != address(0x0), "must set rewards address");
57        require(_registry != address(0x0), "must set registry address");
58        require(_router != address(0x0), "must set router address");
59        require(_wbtc != address(0x0), "must set wBTC address");
60​
61        governance = _governance;
62        rewards = _rewards;
63​
64        registry = IGatewayRegistry(_registry);
65        router = ISwapStrategyRouter(_router);
66        renBTC = registry.getTokenBySymbol("BTC");
67        wBTC = IERC20(_wbtc);
68​
69        mintFeeBps = _feeConfig[0];
70        burnFeeBps = _feeConfig[1];
71        percentageFeeRewardsBps = _feeConfig[2];
72        percentageFeeGovernanceBps = _feeConfig[3];
73    }
74​
75    function version() external pure returns (string memory) {
76        return "1.1";
77    }
78​
79    // NB: This recovery fn only works for the BTC gateway (hardcoded and only one supported in this adapter).
80    function recoverStuck(
81        // encoded user args
82        bytes calldata encoded,
83        // darkdnode args
84        uint256 _amount,
85        bytes32 _nHash,
86        bytes calldata _sig
87    ) external nonReentrant {
88        // Ensure sender matches sender of original tx.
89        uint256 start = encoded.length - 32;
90        address sender = abi.decode(encoded[start:], (address));
91        require(sender == msg.sender);
92​
93        bytes32 pHash = keccak256(encoded);
94        uint256 _mintAmount = registry.getGatewayBySymbol("BTC").mint(pHash, _amount, _nHash, _sig);
95        uint256 _fee = _processFee(renBTC, _mintAmount, mintFeeBps);
96​
97        emit RecoverStuck(_mintAmount, _fee);
98​
99        renBTC.safeTransfer(msg.sender, _mintAmount.sub(_fee));
100    }
101​
102    function mint(
103        // user args
104        address _token, // either renBTC or wBTC
105        uint256 _slippage,
106        address _user,
107        address _vault,
108        / darknode args
109        uint256 _amount,
110        bytes32 _nHash,
111        bytes calldata _sig
112    ) external nonReentrant {
113        require(_token == address(renBTC) || _token == address(wBTC), "invalid token address");
114​
115        / Mint renBTC tokens
116        bytes32 pHash = keccak256(abi.encode(_token, _slippage, _user, _vault));
117        uint256 mintAmount = registry.getGatewayBySymbol("BTC").mint(pHash, _amount, _nHash, _sig);
118​
119        require(mintAmount > 0, "zero mint amount");
120​
121        uint256 fee = _processFee(renBTC, mintAmount, mintFeeBps);
122        uint256 mintAmountMinusFee = mintAmount.sub(fee);
123​
124        MintArguments memory args = MintArguments(mintAmount, mintAmountMinusFee, fee, _slippage, _vault, _user, _token);
125        bool success = mintAdapter(args);
126​
127        if (!success) {
128            renBTC.safeTransfer(_user, mintAmountMinusFee);
129        }
130    }
131​
132    function burn(
133        // user args
134        address _token, // either renBTC or wBTC
135        address _vault,
136        uint256 _slippage,
137        bytes calldata _btcDestination,
138        uint256 _amount
139    ) external nonReentrant {
140        require(_token == address(renBTC) || _token == address(wBTC), "invalid token address");
141        require(!(_vault != address(0) && !approvedVaults[_vault]), "Vault not approved");
142​
143        bool isVault = _vault != address(0);
144        bool isRenBTC = _token == address(renBTC);
145        IERC20 token = isRenBTC ? renBTC : wBTC;
146        uint256 startBalanceRenBTC = renBTC.balanceOf(address(this));
147        uint256 startBalanceWBTC = wBTC.balanceOf(address(this));
148​
149        // Vaults can require up to two levels of unwrapping.
150        if (isVault) {
151            // First level of unwrapping for sett tokens.
152            IERC20(_vault).safeTransferFrom(msg.sender, address(this), _amount);
153            IERC20 vaultToken = IBridgeVault(_vault).token();
154​
155            uint256 beforeBalance = vaultToken.balanceOf(address(this));
156            IBridgeVault(_vault).withdraw(IERC20(_vault).balanceOf(address(this)));
157            uint256 balance = vaultToken.balanceOf(address(this)).sub(beforeBalance);
158​
159            // If the vault token does not match requested burn token, then we need to further unwrap
160            // vault token (e.g. withdrawing from crv sett gets us crv lp tokens which need to be unwrapped to renbtc).
161            if (address(vaultToken) != _token) {
162                vaultToken.safeTransfer(curveTokenWrapper, balance);
163                ICurveTokenWrapper(curveTokenWrapper).unwrap(_vault);
164            }
165        } else {
166            token.safeTransferFrom(msg.sender, address(this), _amount);
167        }
168​
169        uint256 wbtcTransferred = wBTC.balanceOf(address(this)).sub(startBalanceWBTC);
170​
171        if (!isRenBTC) {
172            _swapWBTCForRenBTC(wbtcTransferred, _slippage);
173        }
174​
175        uint256 toBurnAmount = renBTC.balanceOf(address(this)).sub(startBalanceRenBTC);
176        uint256 fee = _processFee(renBTC, toBurnAmount, burnFeeBps);
177​
178        uint256 burnAmount = registry.getGatewayBySymbol("BTC").burn(_btcDestination, toBurnAmount.sub(fee));
179​
180        emit Burn(burnAmount, wbtcTransferred, fee);
181    }
182​
183    function mintAdapter(MintArguments memory args) internal returns (bool) {
184        if (args._vault != address(0) && !approvedVaults[args._vault]) {
185            return false;
186        }
187​
188        uint256 wbtcExchanged;
189        bool isVault = args._vault != address(0);
190        bool isRenBTC = args._token == address(renBTC);
191        IERC20 token = isRenBTC ? renBTC : wBTC;
192        
193if (!isRenBTC) {
194            // Try and swap and transfer wbtc if token wbtc specified.
195            uint256 startBalance = token.balanceOf(address(this));
196            if (!_swapRenBTCForWBTC(args._mintAmountMinusFee, args._slippage)) {
197                return false;
198            }
199            uint256 endBalance = token.balanceOf(address(this));
200            wbtcExchanged = endBalance.sub(startBalance);
201        }
202​
203        emit Mint(args._mintAmount, wbtcExchanged, args._fee);
204​
205        uint256 amount = isRenBTC ? args._mintAmountMinusFee : wbtcExchanged;
206​
207​

Solidity Contracts

JavaScript Tests