Balancer V2

1// This program is free software: you can redistribute it and/or modify
2// it under the terms of the GNU General Public License as published by
3// the Free Software Foundation, either version 3 of the License, or
4// (at your option) any later version.
5
6// This program is distributed in the hope that it will be useful,
7// but WITHOUT ANY WARRANTY; without even the implied warranty of
8// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
9// GNU General Public License for more details.
10
11// You should have received a copy of the GNU General Public License
12// along with this program.  If not, see <http://www.gnu.org/licenses/>.
13
14pragma solidity 0.5.12;
15
16import "./BToken.sol";
17import "./BMath.sol";
18
19contract BPool is BBronze, BToken, BMath {
20
21    struct Record {
22        bool bound;   // is token bound to pool
23        uint index;   // private
24        uint denorm;  // denormalized weight
25        uint balance;
26    }
27
28    event LOG_SWAP(
29        address indexed caller,
30        address indexed tokenIn,
31        address indexed tokenOut,
32        uint256         tokenAmountIn,
33        uint256         tokenAmountOut
34    );
35
36    event LOG_JOIN(
37        address indexed caller,
38        address indexed tokenIn,
39        uint256         tokenAmountIn
40    );
41
42    event LOG_EXIT(
43        address indexed caller,
44        address indexed tokenOut,
45        uint256         tokenAmountOut
46    );
47
48    event LOG_CALL(
49        bytes4  indexed sig,
50        address indexed caller,
51        bytes           data
52    ) anonymous;
53
54    modifier _logs_() {
55        emit LOG_CALL(msg.sig, msg.sender, msg.data);
56        _;
57    }
58
59    modifier _lock_() {
60        require(!_mutex, "ERR_REENTRY");
61        _mutex = true;
62        _;
63        _mutex = false;
64    }
65
66    modifier _viewlock_() {
67        require(!_mutex, "ERR_REENTRY");
68        _;
69    }
70
71    bool private _mutex;
72
73    address private _factory;    // BFactory address to push token exitFee to
74    address private _controller; // has CONTROL role
75    bool private _publicSwap; // true if PUBLIC can call SWAP functions
76
77    // `setSwapFee` and `finalize` require CONTROL
78    // `finalize` sets `PUBLIC can SWAP`, `PUBLIC can JOIN`
79    uint private _swapFee;
80    bool private _finalized;
81
82    address[] private _tokens;
83    mapping(address=>Record) private  _records;
84    uint private _totalWeight;
85
86    constructor() public {
87        _controller = msg.sender;
88        _factory = msg.sender;
89        _swapFee = MIN_FEE;
90        _publicSwap = false;
91        _finalized = false;
92    }
93
94    function isPublicSwap()
95        external view
96        returns (bool)
97    {
98        return _publicSwap;
99    }
100
101    function isFinalized()
102        external view
103        returns (bool)
104    {
105        return _finalized;
106    }
107
108    function isBound(address t)
109        external view
110        returns (bool)
111    {
112        return _records[t].bound;
113    }
114
115    function getNumTokens()
116        external view
117        returns (uint) 
118    {
119        return _tokens.length;
120    }
121
122    function getCurrentTokens()
123        external view _viewlock_
124        returns (address[] memory tokens)
125    {
126        return _tokens;
127    }
128
129    function getFinalTokens()
130        external view
131        _viewlock_
132        returns (address[] memory tokens)
133    {
134        require(_finalized, "ERR_NOT_FINALIZED");
135        return _tokens;
136    }
137
138    function getDenormalizedWeight(address token)
139        external view
140        _viewlock_
141        returns (uint)
142    {
143
144        require(_records[token].bound, "ERR_NOT_BOUND");
145        return _records[token].denorm;
146    }
147
148    function getTotalDenormalizedWeight()
149        external view
150        _viewlock_
151        returns (uint)
152    {
153        return _totalWeight;
154    }
155
156    function getNormalizedWeight(address token)
157        external view
158        _viewlock_
159        returns (uint)
160    {
161
162        require(_records[token].bound, "ERR_NOT_BOUND");
163        uint denorm = _records[token].denorm;
164        return bdiv(denorm, _totalWeight);
165    }
166
167    function getBalance(address token)
168        external view
169        _viewlock_
170        returns (uint)
171    {
172
173        require(_records[token].bound, "ERR_NOT_BOUND");
174        return _records[token].balance;
175    }
176
177    function getSwapFee()
178        external view
179        _viewlock_
180        returns (uint)
181    {
182        return _swapFee;
183    }
184
185    function getController()
186        external view
187        _viewlock_
188        returns (address)
189    {
190        return _controller;
191    }
192
193    function setSwapFee(uint swapFee)
194        external
195        _logs_
196        _lock_
197    { 
198        require(!_finalized, "ERR_IS_FINALIZED");
199        require(msg.sender == _controller, "ERR_NOT_CONTROLLER");
200        require(swapFee >= MIN_FEE, "ERR_MIN_FEE");
201        require(swapFee <= MAX_FEE, "ERR_MAX_FEE");
202        _swapFee = swapFee;
203    }
204
205    function setController(address manager)
206        external
207        _logs_
208        _lock_
209    {
210        require(msg.sender == _controller, "ERR_NOT_CONTROLLER");
211        _controller = manager;
212    }
213
214    function setPublicSwap(bool public_)
215        external
216        _logs_
217        _lock_
218    {
219        require(!_finalized, "ERR_IS_FINALIZED");
220        require(msg.sender == _controller, "ERR_NOT_CONTROLLER");
221        _publicSwap = public_;
222    }
223
224    function finalize()
225        external
226        _logs_
227        _lock_
228    {
229        require(msg.sender == _controller, "ERR_NOT_CONTROLLER");
230        require(!_finalized, "ERR_IS_FINALIZED");
231        require(_tokens.length >= MIN_BOUND_TOKENS, "ERR_MIN_TOKENS");
232
233        _finalized = true;
234        _publicSwap = true;
235
236        _mintPoolShare(INIT_POOL_SUPPLY);
237        _pushPoolShare(msg.sender, INIT_POOL_SUPPLY);
238    }