Yearn Finance V2

1contract yVault is ERC20, ERC20Detailed {
2    using SafeERC20 for IERC20;
3    using Address for address;
4    using SafeMath for uint256;
5​
6    IERC20 public token;
7​
8    uint256 public min = 9500;
9    uint256 public constant max = 10000;
10​
11    address public governance;
12    address public controller;
13​
14    constructor(address _token, address _controller)
15        public
16        ERC20Detailed(
17            string(abi.encodePacked("yearn ", ERC20Detailed(_token).name())),
18            string(abi.encodePacked("y", ERC20Detailed(_token).symbol())),
19            ERC20Detailed(_token).decimals()
20        )
21    {
22        token = IERC20(_token);
23        governance = msg.sender;
24        controller = _controller;
25    }
26​
27    function balance() public view returns (uint256) {
28        return token.balanceOf(address(this)).add(IController(controller).balanceOf(address(token)));
29    }
30​
31    function setMin(uint256 _min) external {
32        require(msg.sender == governance, "!governance");
33        min = _min;
34    }
35​
36    function setGovernance(address _governance) public {
37        require(msg.sender == governance, "!governance");
38        governance = _governance;
39    }
40​
41    function setController(address _controller) public {
42        require(msg.sender == governance, "!governance");
43        controller = _controller;
44    }
45​
46    / Custom logic in here for how much the vault allows to be borrowed
47    / Sets minimum required on-hand to keep small withdrawals cheap
48    function available() public view returns (uint256) {
49        return token.balanceOf(address(this)).mul(min).div(max);
50    }
51​
52    function earn() public {
53        uint256 _bal = available();
54        token.safeTransfer(controller, _bal);
55        IController(controller).earn(address(token), _bal);
56    }
57​
58    function depositAll() external {
59        deposit(token.balanceOf(msg.sender));
60    }
61​
62    function deposit(uint256 _amount) public {
63        uint256 _pool = balance();
64        uint256 _before = token.balanceOf(address(this));
65        token.safeTransferFrom(msg.sender, address(this), _amount);
66        uint256 _after = token.balanceOf(address(this));
67        _amount = _after.sub(_before); // Additional check for deflationary tokens
68        uint256 shares = 0;
69        if (totalSupply() == 0) {
70            shares = _amount;
71        } else {
72            shares = (_amount.mul(totalSupply())).div(_pool);
73        }
74        _mint(msg.sender, shares);
75    }
76​
77    function withdrawAll() external {
78        withdraw(balanceOf(msg.sender));
79    }
80​
81    // Used to swap any borrowed reserve over the debt limit to liquidate to 'token'
82    function harvest(address reserve, uint256 amount) external {
83        require(msg.sender == controller, "!controller");
84        require(reserve != address(token), "token");
85        IERC20(reserve).safeTransfer(controller, amount);
86    }
87​
88    // No rebalance implementation for lower fees and faster swaps
89    function withdraw(uint256 _shares) public {
90        uint256 r = (balance().mul(_shares)).div(totalSupply());
91        _burn(msg.sender, _shares);
92​
93        // Check balance
94        uint256 b = token.balanceOf(address(this));
95        if (b < r) {
96            uint256 _withdraw = r.sub(b);
97            IController(controller).withdraw(address(token), _withdraw);
98            uint256 _after = token.balanceOf(address(this));
99            uint256 _diff = _after.sub(b);
100            if (_diff < _withdraw) {
101                r = b.add(_diff);
102            }
103        }
104​
105        token.safeTransfer(msg.sender, r);
106    }
107​
108    function getPricePerFullShare() public view returns (uint256) {
109        return balance().mul(1e18).div(totalSupply());
110    }
111}

Solidity Contracts

JavaScript Tests