PieDAO

1contract PV2SmartPool is IPV2SmartPool, PCToken, ReentryProtection {
2  using LibSafeApprove for IERC20;
3​
4  event TokensApproved();
5  event ControllerChanged(address indexed previousController, address indexed newController);
6  event PublicSwapSetterChanged(address indexed previousSetter, address indexed newSetter);
7  event TokenBinderChanged(address indexed previousTokenBinder, address indexed newTokenBinder);
8  event PublicSwapSet(address indexed setter, bool indexed value);
9  event SwapFeeSet(address indexed setter, uint256 newFee);
10  event CapChanged(address indexed setter, uint256 oldCap, uint256 newCap);
11  event CircuitBreakerTripped();
12  event JoinExitEnabledChanged(address indexed setter, bool oldValue, bool newValue);
13  event CircuitBreakerChanged(
14    address indexed _oldCircuitBreaker,
15    address indexed _newCircuitBreaker
16  );
17​
18  modifier ready() {
19    require(address(PBStorage.load().bPool) != address(0), "PV2SmartPool.ready: not ready");
20    _;
21  }
22​
23  modifier onlyController() {
24    require(
25      msg.sender == PBStorage.load().controller,
26      "PV2SmartPool.onlyController: not controller"
27    );
28    _;
29  }
30​
31  modifier onlyPublicSwapSetter() {
32    require(
33      msg.sender == PBStorage.load().publicSwapSetter,
34      "PV2SmartPool.onlyPublicSwapSetter: not public swap setter"
35    );
36    _;
37  }
38​
39  modifier onlyTokenBinder() {
40    require(
41      msg.sender == PBStorage.load().tokenBinder,
42      "PV2SmartPool.onlyTokenBinder: not token binder"
43    );
44    _;
45  }
46​
47  modifier onlyPublicSwap() {
48    require(
49      PBStorage.load().bPool.isPublicSwap(),
50      "PV2SmartPool.onlyPublicSwap: swapping not enabled"
51    );
52    _;
53  }
54​
55  modifier onlyCircuitBreaker() {
56    require(
57      msg.sender == P2Storage.load().circuitBreaker,
58      "PV2SmartPool.onlyCircuitBreaker: not circuit breaker"
59    );
60    _;
61  }
62​
63  modifier onlyJoinExitEnabled() {
64    require(
65      P2Storage.load().joinExitEnabled,
66      "PV2SmartPool.onlyJoinExitEnabled: join and exit not enabled"
67    );
68    _;
69  }
70​
71  modifier withinCap() {
72    _;
73    require(totalSupply() < PCSStorage.load().cap, "PV2SmartPool.withinCap: Cap limit reached");
74  }
75​
76  /**
77        @notice Initialises the contract
78        @param _bPool Address of the underlying balancer pool
79        @param _name Name for the smart pool token
80        @param _symbol Symbol for the smart pool token
81        @param _initialSupply Initial token supply to mint
82    */
83  function init(
84    address _bPool,
85    string calldata _name,
86    string calldata _symbol,
87    uint256 _initialSupply
88  ) external override {
89    PBStorage.StorageStruct storage s = PBStorage.load();
90    require(address(s.bPool) == address(0), "PV2SmartPool.init: already initialised");
91    require(_bPool != address(0), "PV2SmartPool.init: _bPool cannot be 0x00....000");
92    require(_initialSupply != 0, "PV2SmartPool.init: _initialSupply can not zero");
93    s.bPool = IBPool(_bPool);
94    s.controller = msg.sender;
95    s.publicSwapSetter = msg.sender;
96    s.tokenBinder = msg.sender;
97    PCStorage.load().name = _name;
98    PCStorage.load().symbol = _symbol;
99​
100    LibPoolToken._mint(msg.sender, _initialSupply);
101  }
102​
103  /**
104    @notice Sets approval to all tokens to the underlying balancer pool
105    @dev It uses this function to save on gas in joinPool
106  */
107  function approveTokens() public override noReentry {
108    IBPool bPool = PBStorage.load().bPool;
109    address[] memory tokens = bPool.getCurrentTokens();
110    for (uint256 i = 0; i < tokens.length; i++) {
111      IERC20(tokens[i]).safeApprove(address(bPool), uint256(-1));
112    }
113    emit TokensApproved();
114  }
115​
116  // POOL EXIT ------------------------------------------------
117​
118  /**
119        @notice Burns pool shares and sends back the underlying assets leaving some in the pool
120        @param _amount Amount of pool tokens to burn
121        @param _lossTokens Tokens skipped on redemption
122    */
123  function exitPoolTakingloss(uint256 _amount, address[] calldata _lossTokens)
124    external
125    override
126    ready
127    noReentry
128    onlyJoinExitEnabled
129  {
130    LibPoolEntryExit.exitPoolTakingloss(_amount, _lossTokens);
131  }
132​
133  /**
134        @notice Burns pool shares and sends back the underlying assets
135        @param _amount Amount of pool tokens to burn
136    */
137  function exitPool(uint256 _amount) external override ready noReentry onlyJoinExitEnabled {
138    LibPoolEntryExit.exitPool(_amount);
139  }
140​
141  /**
142    @notice Burn pool tokens and redeem underlying assets. With front running protection
143    @param _amount Amount of pool tokens to burn
144    @param _minAmountsOut Minimum amounts of underlying assets
145  */
146  function exitPool(uint256 _amount, uint256[] calldata _minAmountsOut)
147    external
148    override
149    ready
150    noReentry
151    onlyJoinExitEnabled
152  {
153    LibPoolEntryExit.exitPool(_amount, _minAmountsOut);
154  }
155​
156  /
157        @notice Exitswap single asset pool exit given pool amount in
158        @param _token Address of exit token
159        @param _poolAmountIn Amount of pool tokens sending to the pool
160        @return tokenAmountOut amount of exit tokens being withdrawn
161    */
162  function exitswapPoolAmountIn(
163    address _token,
164    uint256 _poolAmountIn,
165    uint256 _minAmountOut
166  )
167    external
168    override
169    ready
170    noReentry
171    onlyPublicSwap
172    onlyJoinExitEnabled
173    returns (uint256 tokenAmountOut)
174  {
175    return LibPoolEntryExit.exitswapPoolAmountIn(_token, _poolAmountIn, _minAmountOut);
176  }
177​
178  /*
179        @notice Exitswap single asset pool entry given token amount out
180        @param _token Address of exit token
181        @param _tokenAmountOut Amount of exit tokens
182        @return poolAmountIn amount of pool tokens being deposited
183    */
184  function exitswapExternAmountOut(
185    address _token,
186    uint256 _tokenAmountOut,
187    uint256 _maxPoolAmountIn
188  )

Solidity Contracts

JavaScript Tests