Compare text

Find the difference between two text files

Real-time editor

Hide unchanged lines

Disable line wrap

Layout

Diff precision

Syntax highlighting

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

BPool.sol

Created 6 years agoDiff never expires

111 removals

Lines
Total
Removed

Characters
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

740 lines

167 additions

Lines
Total
Added

Characters
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

791 lines

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with this program. If not, see <http://www.gnu.org/licenses/>.

pragma solidity 0.5.12;

import "./BToken.sol";

import "./BMath.sol";

contract BPool is BBronze, BToken, BMath {

struct Record {

bool bound; // is token bound to pool

uint index; // private

uint denorm; // denormalized weight

uint balance;

}

event LOG_SWAP(

address indexed caller,

address indexed tokenIn,

address indexed tokenOut,

uint256 tokenAmountIn,

uint256 tokenAmountOut

uint256 tokenAmountOut,

uint256 reservesAmount

);

event LOG_JOIN(

address indexed caller,

address indexed tokenIn,

uint256 tokenAmountIn

uint256 tokenAmountIn,

uint256 reservesAmount

);

event LOG_EXIT(

address indexed caller,

address indexed tokenOut,

uint256 tokenAmountOut,

uint256 reservesAmount

);

event LOG_DRAIN_RESERVES(

address indexed caller,

address indexed tokenOut,

uint256 tokenAmountOut

);

event LOG_ADD_RESERVES(

address indexed token,

uint256 reservesAmount

);

event LOG_CALL(

bytes4 indexed sig,

address indexed caller,

bytes data

) anonymous;

modifier _logs_() {

emit LOG_CALL(msg.sig, msg.sender, msg.data);

}

modifier _lock_() {

require(!_mutex, "ERR_REENTRY");

require(!_mutex);

_mutex = true;

_mutex = false;

}

modifier _viewlock_() {

require(!_mutex, "ERR_REENTRY");

require(!_mutex);

}

bool private _mutex;

address private _factory; // BFactory address to push token exitFee to

address private _controller; // has CONTROL role

bool private _publicSwap; // true if PUBLIC can call SWAP functions

// `setSwapFee` and `finalize` require CONTROL

// `finalize` sets `PUBLIC can SWAP`, `PUBLIC can JOIN`

uint private _swapFee;

uint private _reservesRatio;

bool private _finalized;

address[] private _tokens;

mapping(address=>Record) private _records;

mapping(address=>uint) public totalReserves;

uint private _totalWeight;

constructor() public {

_controller = msg.sender;

_factory = msg.sender;

_swapFee = MIN_FEE;

_reservesRatio = DEFAULT_RESERVES_RATIO;

_publicSwap = false;

_finalized = false;

}

function isPublicSwap()

external view

returns (bool)

{

return _publicSwap;

}

function isFinalized()

external view

returns (bool)

{

return _finalized;

}

function isBound(address t)

external view

returns (bool)

{

return _records[t].bound;

}

function getNumTokens()

external view

returns (uint)

{

return _tokens.length;

}

function getCurrentTokens()

external view _viewlock_

returns (address[] memory tokens)

{

return _tokens;

}

function getFinalTokens()

external view

_viewlock_

returns (address[] memory tokens)

{

require(_finalized, "ERR_NOT_FINALIZED");

require(_finalized);

return _tokens;

}

function getDenormalizedWeight(address token)

external view

_viewlock_

returns (uint)

{

require(_records[token].bound, "ERR_NOT_BOUND");

require(_records[token].bound);

return _records[token].denorm;

}

function getTotalDenormalizedWeight()

external view

_viewlock_

returns (uint)

{

return _totalWeight;

}

function getNormalizedWeight(address token)

external view

_viewlock_

returns (uint)

{

require(_records[token].bound, "ERR_NOT_BOUND");

require(_records[token].bound);

uint denorm = _records[token].denorm;

return bdiv(denorm, _totalWeight);

}

function getBalance(address token)

external view

_viewlock_

returns (uint)

{

require(_records[token].bound, "ERR_NOT_BOUND");

require(_records[token].bound);

return _records[token].balance;

}

function getSwapFee()

external view

_viewlock_

returns (uint)

{

return _swapFee;

}

function getReservesRatio()

external view

_viewlock_

returns (uint)

{

return _reservesRatio;

}

function getController()

external view

_viewlock_

returns (address)

{

return _controller;

}

function setSwapFee(uint swapFee)

external

_logs_

_lock_

{

require(!_finalized, "ERR_IS_FINALIZED");

require(!_finalized);

require(msg.sender == _controller, "ERR_NOT_CONTROLLER");

require(msg.sender == _controller);

require(swapFee >= MIN_FEE, "ERR_MIN_FEE");

require(swapFee >= MIN_FEE);

require(swapFee <= MAX_FEE, "ERR_MAX_FEE");

require(swapFee <= MAX_FEE);

_swapFee = swapFee;

}

function setReservesRatio(uint reservesRatio)

external

_logs_

_lock_

{

require(!_finalized);

require(msg.sender == _controller);

require(reservesRatio <= BONE);

require(reservesRatio >= DEFAULT_RESERVES_RATIO);

_reservesRatio = reservesRatio;

}

function setController(address manager)

external

_logs_

_lock_

{

require(msg.sender == _controller, "ERR_NOT_CONTROLLER");

require(msg.sender == _controller);

_controller = manager;

}

function setPublicSwap(bool public_)

external

_logs_

_lock_

{

require(!_finalized, "ERR_IS_FINALIZED");

require(!_finalized);

require(msg.sender == _controller, "ERR_NOT_CONTROLLER");

require(msg.sender == _controller);

_publicSwap = public_;

}

function finalize()

external

_logs_

_lock_

{

require(msg.sender == _controller, "ERR_NOT_CONTROLLER");

require(msg.sender == _controller);

require(!_finalized, "ERR_IS_FINALIZED");

require(!_finalized);

require(_tokens.length >= MIN_BOUND_TOKENS, "ERR_MIN_TOKENS");

require(_tokens.length >= MIN_BOUND_TOKENS);

_finalized = true;

_publicSwap = true;

_mintPoolShare(INIT_POOL_SUPPLY);

_pushPoolShare(msg.sender, INIT_POOL_SUPPLY);

}

function bind(address token, uint balance, uint denorm)

external

_logs_

// _lock_ Bind does not lock because it jumps to `rebind`, which does

{

require(msg.sender == _controller, "ERR_NOT_CONTROLLER");

require(msg.sender == _controller);

require(!_records[token].bound, "ERR_IS_BOUND");

require(!_records[token].bound);

require(!_finalized, "ERR_IS_FINALIZED");

require(!_finalized);

require(_tokens.length < MAX_BOUND_TOKENS, "ERR_MAX_TOKENS");

require(_tokens.length < MAX_BOUND_TOKENS);

_records[token] = Record({

bound: true,

index: _tokens.length,

denorm: 0, // balance and denorm will be validated

balance: 0 // and set by `rebind`

});

_tokens.push(token);

rebind(token, balance, denorm);

}

function rebind(address token, uint balance, uint denorm)

public

_logs_

_lock_

{

require(msg.sender == _controller, "ERR_NOT_CONTROLLER");

require(msg.sender == _controller);

require(_records[token].bound, "ERR_NOT_BOUND");

require(_records[token].bound);

require(!_finalized, "ERR_IS_FINALIZED");

require(!_finalized);

require(denorm >= MIN_WEIGHT, "ERR_MIN_WEIGHT");

require(denorm >= MIN_WEIGHT);

require(denorm <= MAX_WEIGHT, "ERR_MAX_WEIGHT");

require(denorm <= MAX_WEIGHT);

require(balance >= MIN_BALANCE, "ERR_MIN_BALANCE");

require(balance >= MIN_BALANCE);

// Adjust the denorm and totalWeight

uint oldWeight = _records[token].denorm;

if (denorm > oldWeight) {

_totalWeight = badd(_totalWeight, bsub(denorm, oldWeight));

require(_totalWeight <= MAX_TOTAL_WEIGHT, "ERR_MAX_TOTAL_WEIGHT");

require(_totalWeight <= MAX_TOTAL_WEIGHT);

} else if (denorm < oldWeight) {

_totalWeight = bsub(_totalWeight, bsub(oldWeight, denorm));

}

_records[token].denorm = denorm;

// Adjust the balance record and actual token balance

uint oldBalance = _records[token].balance;

_records[token].balance = balance;

if (balance > oldBalance) {

_pullUnderlying(token, msg.sender, bsub(balance, oldBalance));

} else if (balance < oldBalance) {

// In this case liquidity is being withdrawn, so charge EXIT_FEE

uint tokenBalanceWithdrawn = bsub(oldBalance, balance);

uint tokenExitFee = bmul(tokenBalanceWithdrawn, EXIT_FEE);

_pushUnderlying(token, msg.sender, bsub(tokenBalanceWithdrawn, tokenExitFee));

_pushUnderlying(token, _factory, tokenExitFee);

}

function unbind(address token)

external

_logs_

_lock_

{

require(msg.sender == _controller, "ERR_NOT_CONTROLLER");

require(msg.sender == _controller);

require(_records[token].bound, "ERR_NOT_BOUND");

require(_records[token].bound);

require(!_finalized, "ERR_IS_FINALIZED");

require(!_finalized);

uint tokenBalance = _records[token].balance;

uint tokenExitFee = bmul(tokenBalance, EXIT_FEE);

_totalWeight = bsub(_totalWeight, _records[token].denorm);

// Swap the token-to-unbind with the last token,

// then delete the last token

uint index = _records[token].index;

uint last = _tokens.length - 1;

_tokens[index] = _tokens[last];

_records[_tokens[index]].index = index;

_tokens.pop();

_records[token] = Record({

bound: false,

index: 0,

denorm: 0,

balance: 0

});

_pushUnderlying(token, msg.sender, bsub(tokenBalance, tokenExitFee));

_pushUnderlying(token, _factory, tokenExitFee);

}

// Absorb any tokens that have been sent to this contract into the pool

function gulp(address token)

external

_logs_

_lock_

{

require(_records[token].bound, "ERR_NOT_BOUND");

require(_records[token].bound);

_records[token].balance = IERC20(token).balanceOf(address(this));

uint erc20Balance = IERC20(token).balanceOf(address(this));

uint reserves = totalReserves[token];

// `_records[token].balance` should be equaled to `bsub(erc20Balance, reserves)` unless there are extra

// tokens transferred to this pool without calling `joinxxx`.

require(_records[token].balance <= bsub(erc20Balance, reserves));

_records[token].balance = bsub(erc20Balance, reserves);

}

function seize(address token, uint amount)

external

_logs_

_lock_

{

require(msg.sender == _controller);

require(!_records[token].bound);

uint bal = IERC20(token).balanceOf(address(this));

require(amount <= bal);

_pushUnderlying(token, msg.sender, amount);

}

function getSpotPrice(address tokenIn, address tokenOut)

external view

_viewlock_

returns (uint spotPrice)

{

require(_records[tokenIn].bound, "ERR_NOT_BOUND");

require(_records[tokenOut].bound, "ERR_NOT_BOUND");

Record storage inRecord = _records[tokenIn];

Record storage outRecord = _records[tokenOut];

return calcSpotPrice(inRecord.balance, inRecord.denorm, outRecord.balance, outRecord.denorm, _swapFee);

}

function getSpotPriceSansFee(address tokenIn, address tokenOut)

external view

_viewlock_

returns (uint spotPrice)

{

require(_records[tokenIn].bound, "ERR_NOT_BOUND");

require(_records[tokenOut].bound, "ERR_NOT_BOUND");

Record storage inRecord = _records[tokenIn];

Record storage outRecord = _records[tokenOut];

return calcSpotPrice(inRecord.balance, inRecord.denorm, outRecord.balance, outRecord.denorm, 0);

}

function joinPool(uint poolAmountOut, uint[] calldata maxAmountsIn)

external

_logs_

_lock_

{

require(_finalized, "ERR_NOT_FINALIZED");

uint poolTotal = totalSupply();

uint ratio = bdiv(poolAmountOut, poolTotal);

require(ratio != 0, "ERR_MATH_APPROX");

for (uint i = 0; i < _tokens.length; i++) {

address t = _tokens[i];

uint bal = _records[t].balance;

uint tokenAmountIn = bmul(ratio, bal);

require(tokenAmountIn != 0, "ERR_MATH_APPROX");

require(tokenAmountIn <= maxAmountsIn[i], "ERR_LIMIT_IN");

_records[t].balance = badd(_records[t].balance, tokenAmountIn);

emit LOG_JOIN(msg.sender, t, tokenAmountIn);

emit LOG_JOIN(msg.sender, t, tokenAmountIn, 0);

_pullUnderlying(t, msg.sender, tokenAmountIn);

}

_mintPoolShare(poolAmountOut);

_pushPoolShare(msg.sender, poolAmountOut);

}

function exitPool(uint poolAmountIn, uint[] calldata minAmountsOut)

external

_logs_

_lock_

{

require(_finalized, "ERR_NOT_FINALIZED");

uint poolTotal = totalSupply();

uint exitFee = bmul(poolAmountIn, EXIT_FEE);

uint pAiAfterExitFee = bsub(poolAmountIn, exitFee);

uint ratio = bdiv(pAiAfterExitFee, poolTotal);

require(ratio != 0, "ERR_MATH_APPROX");

_pullPoolShare(msg.sender, poolAmountIn);

_pushPoolShare(_factory, exitFee);

_burnPoolShare(pAiAfterExitFee);

for (uint i = 0; i < _tokens.length; i++) {

address t = _tokens[i];

uint bal = _records[t].balance;

uint tokenAmountOut = bmul(ratio, bal);

require(tokenAmountOut != 0, "ERR_MATH_APPROX");

require(tokenAmountOut >= minAmountsOut[i], "ERR_LIMIT_OUT");

_records[t].balance = bsub(_records[t].balance, tokenAmountOut);

emit LOG_EXIT(msg.sender, t, tokenAmountOut);

emit LOG_EXIT(msg.sender, t, tokenAmountOut, 0);

_pushUnderlying(t, msg.sender, tokenAmountOut);

}

function swapExactAmountIn(

address tokenIn,

uint tokenAmountIn,

address tokenOut,

uint minAmountOut,

uint maxPrice

)

external

_logs_

_lock_

returns (uint tokenAmountOut, uint spotPriceAfter)

{

require(_records[tokenIn].bound, "ERR_NOT_BOUND");

require(_records[tokenOut].bound, "ERR_NOT_BOUND");

require(_publicSwap, "ERR_SWAP_NOT_PUBLIC");

Record storage inRecord = _records[address(tokenIn)];

Record storage outRecord = _records[address(tokenOut)];

require(tokenAmountIn <= bmul(inRecord.balance, MAX_IN_RATIO), "ERR_MAX_IN_RATIO");

uint spotPriceBefore = calcSpotPrice(

inRecord.balance,

inRecord.denorm,

outRecord.balance,

outRecord.denorm,

_swapFee

);

require(spotPriceBefore <= maxPrice, "ERR_BAD_LIMIT_PRICE");

tokenAmountOut = calcOutGivenIn(

uint tokenInFee;

inRecord.balance,

(tokenAmountOut, tokenInFee) = calcOutGivenIn(

inRecord.denorm,

inRecord.balance,

outRecord.balance,

inRecord.denorm,

outRecord.denorm,

outRecord.balance,

tokenAmountIn,

outRecord.denorm,

_swapFee

tokenAmountIn,

);

_swapFee

);

require(tokenAmountOut >= minAmountOut, "ERR_LIMIT_OUT");

inRecord.balance = badd(inRecord.balance, tokenAmountIn);

uint reserves = calcReservesFromFee(tokenInFee, _reservesRatio);

// Subtract `reserves`.

inRecord.balance = bsub(badd(inRecord.balance, tokenAmountIn), reserves);

outRecord.balance = bsub(outRecord.balance, tokenAmountOut);

spotPriceAfter = calcSpotPrice(

inRecord.balance,

inRecord.denorm,

outRecord.balance,

outRecord.denorm,

_swapFee

);

require(spotPriceAfter >= spotPriceBefore, "ERR_MATH_APPROX");

require(spotPriceAfter <= maxPrice, "ERR_LIMIT_PRICE");

require(spotPriceBefore <= bdiv(tokenAmountIn, tokenAmountOut), "ERR_MATH_APPROX");

emit LOG_SWAP(msg.sender, tokenIn, tokenOut, tokenAmountIn, tokenAmountOut);

emit LOG_SWAP(msg.sender, tokenIn, tokenOut, tokenAmountIn, tokenAmountOut, reserves);

totalReserves[address(tokenIn)] = badd(totalReserves[address(tokenIn)], reserves);

emit LOG_ADD_RESERVES(address(tokenIn), reserves);

_pullUnderlying(tokenIn, msg.sender, tokenAmountIn);

_pushUnderlying(tokenOut, msg.sender, tokenAmountOut);

return (tokenAmountOut, spotPriceAfter);

}

function swapExactAmountOut(

address tokenIn,

uint maxAmountIn,

address tokenOut,

uint tokenAmountOut,

uint maxPrice

)

external

_logs_

_lock_

returns (uint tokenAmountIn, uint spotPriceAfter)

{

require(_records[tokenIn].bound, "ERR_NOT_BOUND");

require(_records[tokenOut].bound, "ERR_NOT_BOUND");

require(_publicSwap, "ERR_SWAP_NOT_PUBLIC");

Record storage inRecord = _records[address(tokenIn)];

Record storage outRecord = _records[address(tokenOut)];

require(tokenAmountOut <= bmul(outRecord.balance, MAX_OUT_RATIO), "ERR_MAX_OUT_RATIO");

uint spotPriceBefore = calcSpotPrice(

inRecord.balance,

inRecord.denorm,

outRecord.balance,

outRecord.denorm,

_swapFee

);

require(spotPriceBefore <= maxPrice, "ERR_BAD_LIMIT_PRICE");

tokenAmountIn = calcInGivenOut(

uint tokenInFee;

inRecord.balance,

(tokenAmountIn, tokenInFee) = calcInGivenOut(

inRecord.denorm,

inRecord.balance,

outRecord.balance,

inRecord.denorm,

outRecord.denorm,

outRecord.balance,

tokenAmountOut,

outRecord.denorm,

_swapFee

tokenAmountOut,

);

_swapFee

);

require(tokenAmountIn <= maxAmountIn, "ERR_LIMIT_IN");

inRecord.balance = badd(inRecord.balance, tokenAmountIn);

uint reserves = calcReservesFromFee(

tokenInFee,

_reservesRatio

);

// Subtract `reserves` which is reserved for admin.

inRecord.balance = bsub(badd(inRecord.balance, tokenAmountIn), reserves);

outRecord.balance = bsub(outRecord.balance, tokenAmountOut);

spotPriceAfter = calcSpotPrice(

inRecord.balance,

inRecord.denorm,

outRecord.balance,

outRecord.denorm,

_swapFee

);

require(spotPriceAfter >= spotPriceBefore, "ERR_MATH_APPROX");

require(spotPriceAfter <= maxPrice, "ERR_LIMIT_PRICE");

require(spotPriceBefore <= bdiv(tokenAmountIn, tokenAmountOut), "ERR_MATH_APPROX");

emit LOG_SWAP(msg.sender, tokenIn, tokenOut, tokenAmountIn, tokenAmountOut);

emit LOG_SWAP(msg.sender, tokenIn, tokenOut, tokenAmountIn, tokenAmountOut, reserves);

totalReserves[address(tokenIn)] = badd(totalReserves[address(tokenIn)], reserves);

emit LOG_ADD_RESERVES(address(tokenIn), reserves);

_pullUnderlying(tokenIn, msg.sender, tokenAmountIn);

_pushUnderlying(tokenOut, msg.sender, tokenAmountOut);

return (tokenAmountIn, spotPriceAfter);

}

function joinswapExternAmountIn(address tokenIn, uint tokenAmountIn, uint minPoolAmountOut)

external

_logs_

_lock_

returns (uint poolAmountOut)

{

require(_finalized, "ERR_NOT_FINALIZED");

require(_records[tokenIn].bound, "ERR_NOT_BOUND");

require(tokenAmountIn <= bmul(_records[tokenIn].balance, MAX_IN_RATIO), "ERR_MAX_IN_RATIO");

Record storage inRecord = _records[tokenIn];

poolAmountOut = calcPoolOutGivenSingleIn(

uint reserves;

(poolAmountOut, reserves) = calcPoolOutGivenSingleIn(

inRecord.balance,

inRecord.denorm,

_totalSupply,

_totalWeight,

tokenAmountIn,

_swapFee

_swapFee,

_reservesRatio

);

require(poolAmountOut >= minPoolAmountOut, "ERR_LIMIT_OUT");

inRecord.balance = badd(inRecord.balance, tokenAmountIn);

inRecord.balance = bsub(badd(inRecord.balance, tokenAmountIn), reserves);

emit LOG_JOIN(msg.sender, tokenIn, tokenAmountIn);

emit LOG_JOIN(msg.sender, tokenIn, tokenAmountIn, reserves);

totalReserves[address(tokenIn)] = badd(totalReserves[address(tokenIn)], reserves);

emit LOG_ADD_RESERVES(address(tokenIn), reserves);

_mintPoolShare(poolAmountOut);

_pushPoolShare(msg.sender, poolAmountOut);

_pullUnderlying(tokenIn, msg.sender, tokenAmountIn);

return poolAmountOut;

}

function joinswapPoolAmountOut(address tokenIn, uint poolAmountOut, uint maxAmountIn)

external

_logs_

_lock_

returns (uint tokenAmountIn)

{

require(_finalized, "ERR_NOT_FINALIZED");

require(_records[tokenIn].bound, "ERR_NOT_BOUND");

Record storage inRecord = _records[tokenIn];

tokenAmountIn = calcSingleInGivenPoolOut(

inRecord.balance,

inRecord.denorm,

_totalSupply,

_totalWeight,

poolAmountOut,

_swapFee

);

require(tokenAmountIn != 0, "ERR_MATH_APPROX");

require(tokenAmountIn <= maxAmountIn, "ERR_LIMIT_IN");

require(tokenAmountIn <= bmul(_records[tokenIn].balance, MAX_IN_RATIO), "ERR_MAX_IN_RATIO");

inRecord.balance = badd(inRecord.balance, tokenAmountIn);

uint tokenAmountInZeroFee = calcSingleInGivenPoolOut(

inRecord.balance,

inRecord.denorm,

_totalSupply,

_totalWeight,

poolAmountOut,

);

uint reserves = calcReserves(

tokenAmountIn,

tokenAmountInZeroFee,

_reservesRatio

);

emit LOG_JOIN(msg.sender, tokenIn, tokenAmountIn);

inRecord.balance = bsub(badd(inRecord.balance, tokenAmountIn), reserves);

emit LOG_JOIN(msg.sender, tokenIn, tokenAmountIn, reserves);

totalReserves[address(tokenIn)] = badd(totalReserves[address(tokenIn)], reserves);

emit LOG_ADD_RESERVES(address(tokenIn), reserves);

_mintPoolShare(poolAmountOut);

_pushPoolShare(msg.sender, poolAmountOut);

_pullUnderlying(tokenIn, msg.sender, tokenAmountIn);

return tokenAmountIn;

}

function exitswapPoolAmountIn(address tokenOut, uint poolAmountIn, uint minAmountOut)

external

_logs_

_lock_

returns (uint tokenAmountOut)

{

require(_finalized, "ERR_NOT_FINALIZED");

require(_records[tokenOut].bound, "ERR_NOT_BOUND");

Record storage outRecord = _records[tokenOut];

tokenAmountOut = calcSingleOutGivenPoolIn(

outRecord.balance,

outRecord.denorm,

_totalSupply,

_totalWeight,

poolAmountIn,

_swapFee

);

require(tokenAmountOut >= minAmountOut, "ERR_LIMIT_OUT");

require(tokenAmountOut <= bmul(_records[tokenOut].balance, MAX_OUT_RATIO), "ERR_MAX_OUT_RATIO");

outRecord.balance = bsub(outRecord.balance, tokenAmountOut);

uint tokenAmountOutZeroFee = calcSingleOutGivenPoolIn(

outRecord.balance,

outRecord.denorm,

_totalSupply,

_totalWeight,

poolAmountIn,

);

uint reserves = calcReserves(

tokenAmountOutZeroFee,

tokenAmountOut,

_reservesRatio

);

outRecord.balance = bsub(bsub(outRecord.balance, tokenAmountOut), reserves);

uint exitFee = bmul(poolAmountIn, EXIT_FEE);

emit LOG_EXIT(msg.sender, tokenOut, tokenAmountOut);

emit LOG_EXIT(msg.sender, tokenOut, tokenAmountOut, reserves);

totalReserves[address(tokenOut)] = badd(totalReserves[address(tokenOut)], reserves);

emit LOG_ADD_RESERVES(address(tokenOut), reserves);

_pullPoolShare(msg.sender, poolAmountIn);

_burnPoolShare(bsub(poolAmountIn, exitFee));

_pushPoolShare(_factory, exitFee);

_pushUnderlying(tokenOut, msg.sender, tokenAmountOut);

return tokenAmountOut;

}

function exitswapExternAmountOut(address tokenOut, uint tokenAmountOut, uint maxPoolAmountIn)

external

_logs_

_lock_

returns (uint poolAmountIn)

{

require(_finalized, "ERR_NOT_FINALIZED");

require(_records[tokenOut].bound, "ERR_NOT_BOUND");

require(tokenAmountOut <= bmul(_records[tokenOut].balance, MAX_OUT_RATIO), "ERR_MAX_OUT_RATIO");

Record storage outRecord = _records[tokenOut];

poolAmountIn = calcPoolInGivenSingleOut(

uint reserves;

(poolAmountIn, reserves) = calcPoolInGivenSingleOut(

outRecord.balance,

outRecord.denorm,

_totalSupply,

_totalWeight,

tokenAmountOut,

_swapFee

);

require(poolAmountIn != 0, "ERR_MATH_APPROX");

require(poolAmountIn <= maxPoolAmountIn, "ERR_LIMIT_IN");

outRecord.balance = bsub(outRecord.balance, tokenAmountOut);

uint exitFee = bmul(poolAmountIn, EXIT_FEE);

emit LOG_EXIT(msg.sender, tokenOut, tokenAmountOut);

_pullPoolShare(msg.sender, poolAmountIn);

_burnPoolShare(bsub(poolAmountIn, exitFee));

_pushPoolShare(_factory, exitFee);

_pushUnderlying(tokenOut, msg.sender, tokenAmountOut);

return poolAmountIn;

}

// ==

// 'Underlying' token-manipulation functions make external calls but are NOT locked

// You must `_lock_` or otherwise ensure reentry-safety

function _pullUnderlying(address erc20, address from, uint amount)

internal

{

bool xfer = IERC20(erc20).transferFrom(from, address(this), amount);

require(xfer, "ERR_ERC20_FALSE");

}

function _pushUnderlying(address erc20, address to, uint amount)

internal

{

bool xfer = IERC20(erc20).transfer(to, amount);

require(xfer, "ERR_ERC20_FALSE");

}

function _pullPoolShare(address from, uint amount)

internal

{

_pull(from, amount);

}

function _pushPoolShare(address to, uint amount)

internal

{

_push(to, amount);

}

function _mintPoolShare(uint amount)

internal

{

_mint(amount);

}

function _burnPoolShare(uint amount)

internal

{

_burn(amount);

}

Saved diffs

Original text

Open file

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity 0.5.12;

import "./BToken.sol";
import "./BMath.sol";

contract BPool is BBronze, BToken, BMath {

struct Record {
        bool bound;   // is token bound to pool
        uint index;   // private
        uint denorm;  // denormalized weight
        uint balance;
    }

event LOG_SWAP(
        address indexed caller,
        address indexed tokenIn,
        address indexed tokenOut,
        uint256         tokenAmountIn,
        uint256         tokenAmountOut
    );

event LOG_JOIN(
        address indexed caller,
        address indexed tokenIn,
        uint256         tokenAmountIn
    );

event LOG_EXIT(
        address indexed caller,
        address indexed tokenOut,
        uint256         tokenAmountOut
    );

event LOG_CALL(
        bytes4  indexed sig,
        address indexed caller,
        bytes           data
    ) anonymous;

modifier _logs_() {
        emit LOG_CALL(msg.sig, msg.sender, msg.data);
        _;
    }

modifier _lock_() {
        require(!_mutex, "ERR_REENTRY");
        _mutex = true;
        _;
        _mutex = false;
    }

modifier _viewlock_() {
        require(!_mutex, "ERR_REENTRY");
        _;
    }

bool private _mutex;

address private _factory;    // BFactory address to push token exitFee to
    address private _controller; // has CONTROL role
    bool private _publicSwap; // true if PUBLIC can call SWAP functions

// `setSwapFee` and `finalize` require CONTROL
    // `finalize` sets `PUBLIC can SWAP`, `PUBLIC can JOIN`
    uint private _swapFee;
    bool private _finalized;

address[] private _tokens;
    mapping(address=>Record) private  _records;
    uint private _totalWeight;

constructor() public {
        _controller = msg.sender;
        _factory = msg.sender;
        _swapFee = MIN_FEE;
        _publicSwap = false;
        _finalized = false;
    }

function isPublicSwap()
        external view
        returns (bool)
    {
        return _publicSwap;
    }

function isFinalized()
        external view
        returns (bool)
    {
        return _finalized;
    }

function isBound(address t)
        external view
        returns (bool)
    {
        return _records[t].bound;
    }

function getNumTokens()
        external view
        returns (uint) 
    {
        return _tokens.length;
    }

function getCurrentTokens()
        external view _viewlock_
        returns (address[] memory tokens)
    {
        return _tokens;
    }

function getFinalTokens()
        external view
        _viewlock_
        returns (address[] memory tokens)
    {
        require(_finalized, "ERR_NOT_FINALIZED");
        return _tokens;
    }

function getDenormalizedWeight(address token)
        external view
        _viewlock_
        returns (uint)
    {

require(_records[token].bound, "ERR_NOT_BOUND");
        return _records[token].denorm;
    }

function getTotalDenormalizedWeight()
        external view
        _viewlock_
        returns (uint)
    {
        return _totalWeight;
    }

function getNormalizedWeight(address token)
        external view
        _viewlock_
        returns (uint)
    {

require(_records[token].bound, "ERR_NOT_BOUND");
        uint denorm = _records[token].denorm;
        return bdiv(denorm, _totalWeight);
    }

function getBalance(address token)
        external view
        _viewlock_
        returns (uint)
    {

require(_records[token].bound, "ERR_NOT_BOUND");
        return _records[token].balance;
    }

function getSwapFee()
        external view
        _viewlock_
        returns (uint)
    {
        return _swapFee;
    }

function getController()
        external view
        _viewlock_
        returns (address)
    {
        return _controller;
    }

function setSwapFee(uint swapFee)
        external
        _logs_
        _lock_
    { 
        require(!_finalized, "ERR_IS_FINALIZED");
        require(msg.sender == _controller, "ERR_NOT_CONTROLLER");
        require(swapFee >= MIN_FEE, "ERR_MIN_FEE");
        require(swapFee <= MAX_FEE, "ERR_MAX_FEE");
        _swapFee = swapFee;
    }

function setController(address manager)
        external
        _logs_
        _lock_
    {
        require(msg.sender == _controller, "ERR_NOT_CONTROLLER");
        _controller = manager;
    }

function setPublicSwap(bool public_)
        external
        _logs_
        _lock_
    {
        require(!_finalized, "ERR_IS_FINALIZED");
        require(msg.sender == _controller, "ERR_NOT_CONTROLLER");
        _publicSwap = public_;
    }

function finalize()
        external
        _logs_
        _lock_
    {
        require(msg.sender == _controller, "ERR_NOT_CONTROLLER");
        require(!_finalized, "ERR_IS_FINALIZED");
        require(_tokens.length >= MIN_BOUND_TOKENS, "ERR_MIN_TOKENS");

_finalized = true;
        _publicSwap = true;

_mintPoolShare(INIT_POOL_SUPPLY);
        _pushPoolShare(msg.sender, INIT_POOL_SUPPLY);
    }

function bind(address token, uint balance, uint denorm)
        external
        _logs_
        // _lock_  Bind does not lock because it jumps to `rebind`, which does
    {
        require(msg.sender == _controller, "ERR_NOT_CONTROLLER");
        require(!_records[token].bound, "ERR_IS_BOUND");
        require(!_finalized, "ERR_IS_FINALIZED");

require(_tokens.length < MAX_BOUND_TOKENS, "ERR_MAX_TOKENS");

_records[token] = Record({
            bound: true,
            index: _tokens.length,
            denorm: 0,    // balance and denorm will be validated
            balance: 0   // and set by `rebind`
        });
        _tokens.push(token);
        rebind(token, balance, denorm);
    }

function rebind(address token, uint balance, uint denorm)
        public
        _logs_
        _lock_
    {

require(msg.sender == _controller, "ERR_NOT_CONTROLLER");
        require(_records[token].bound, "ERR_NOT_BOUND");
        require(!_finalized, "ERR_IS_FINALIZED");

require(denorm >= MIN_WEIGHT, "ERR_MIN_WEIGHT");
        require(denorm <= MAX_WEIGHT, "ERR_MAX_WEIGHT");
        require(balance >= MIN_BALANCE, "ERR_MIN_BALANCE");

// Adjust the denorm and totalWeight
        uint oldWeight = _records[token].denorm;
        if (denorm > oldWeight) {
            _totalWeight = badd(_totalWeight, bsub(denorm, oldWeight));
            require(_totalWeight <= MAX_TOTAL_WEIGHT, "ERR_MAX_TOTAL_WEIGHT");
        } else if (denorm < oldWeight) {
            _totalWeight = bsub(_totalWeight, bsub(oldWeight, denorm));
        }        
        _records[token].denorm = denorm;

// Adjust the balance record and actual token balance
        uint oldBalance = _records[token].balance;
        _records[token].balance = balance;
        if (balance > oldBalance) {
            _pullUnderlying(token, msg.sender, bsub(balance, oldBalance));
        } else if (balance < oldBalance) {
            // In this case liquidity is being withdrawn, so charge EXIT_FEE
            uint tokenBalanceWithdrawn = bsub(oldBalance, balance);
            uint tokenExitFee = bmul(tokenBalanceWithdrawn, EXIT_FEE);
            _pushUnderlying(token, msg.sender, bsub(tokenBalanceWithdrawn, tokenExitFee));
            _pushUnderlying(token, _factory, tokenExitFee);
        }
    }

function unbind(address token)
        external
        _logs_
        _lock_
    {

require(msg.sender == _controller, "ERR_NOT_CONTROLLER");
        require(_records[token].bound, "ERR_NOT_BOUND");
        require(!_finalized, "ERR_IS_FINALIZED");

uint tokenBalance = _records[token].balance;
        uint tokenExitFee = bmul(tokenBalance, EXIT_FEE);

_totalWeight = bsub(_totalWeight, _records[token].denorm);

// Swap the token-to-unbind with the last token,
        // then delete the last token
        uint index = _records[token].index;
        uint last = _tokens.length - 1;
        _tokens[index] = _tokens[last];
        _records[_tokens[index]].index = index;
        _tokens.pop();
        _records[token] = Record({
            bound: false,
            index: 0,
            denorm: 0,
            balance: 0
        });

_pushUnderlying(token, msg.sender, bsub(tokenBalance, tokenExitFee));
        _pushUnderlying(token, _factory, tokenExitFee);
    }

// Absorb any tokens that have been sent to this contract into the pool
    function gulp(address token)
        external
        _logs_
        _lock_
    {
        require(_records[token].bound, "ERR_NOT_BOUND");
        _records[token].balance = IERC20(token).balanceOf(address(this));
    }

function getSpotPrice(address tokenIn, address tokenOut)
        external view
        _viewlock_
        returns (uint spotPrice)
    {
        require(_records[tokenIn].bound, "ERR_NOT_BOUND");
        require(_records[tokenOut].bound, "ERR_NOT_BOUND");
        Record storage inRecord = _records[tokenIn];
        Record storage outRecord = _records[tokenOut];
        return calcSpotPrice(inRecord.balance, inRecord.denorm, outRecord.balance, outRecord.denorm, _swapFee);
    }

function getSpotPriceSansFee(address tokenIn, address tokenOut)
        external view
        _viewlock_
        returns (uint spotPrice)
    {
        require(_records[tokenIn].bound, "ERR_NOT_BOUND");
        require(_records[tokenOut].bound, "ERR_NOT_BOUND");
        Record storage inRecord = _records[tokenIn];
        Record storage outRecord = _records[tokenOut];
        return calcSpotPrice(inRecord.balance, inRecord.denorm, outRecord.balance, outRecord.denorm, 0);
    }

function joinPool(uint poolAmountOut, uint[] calldata maxAmountsIn)
        external
        _logs_
        _lock_
    {
        require(_finalized, "ERR_NOT_FINALIZED");

uint poolTotal = totalSupply();
        uint ratio = bdiv(poolAmountOut, poolTotal);
        require(ratio != 0, "ERR_MATH_APPROX");

for (uint i = 0; i < _tokens.length; i++) {
            address t = _tokens[i];
            uint bal = _records[t].balance;
            uint tokenAmountIn = bmul(ratio, bal);
            require(tokenAmountIn != 0, "ERR_MATH_APPROX");
            require(tokenAmountIn <= maxAmountsIn[i], "ERR_LIMIT_IN");
            _records[t].balance = badd(_records[t].balance, tokenAmountIn);
            emit LOG_JOIN(msg.sender, t, tokenAmountIn);
            _pullUnderlying(t, msg.sender, tokenAmountIn);
        }
        _mintPoolShare(poolAmountOut);
        _pushPoolShare(msg.sender, poolAmountOut);
    }

function exitPool(uint poolAmountIn, uint[] calldata minAmountsOut)
        external
        _logs_
        _lock_
    {
        require(_finalized, "ERR_NOT_FINALIZED");

uint poolTotal = totalSupply();
        uint exitFee = bmul(poolAmountIn, EXIT_FEE);
        uint pAiAfterExitFee = bsub(poolAmountIn, exitFee);
        uint ratio = bdiv(pAiAfterExitFee, poolTotal);
        require(ratio != 0, "ERR_MATH_APPROX");

_pullPoolShare(msg.sender, poolAmountIn);
        _pushPoolShare(_factory, exitFee);
        _burnPoolShare(pAiAfterExitFee);

for (uint i = 0; i < _tokens.length; i++) {
            address t = _tokens[i];
            uint bal = _records[t].balance;
            uint tokenAmountOut = bmul(ratio, bal);
            require(tokenAmountOut != 0, "ERR_MATH_APPROX");
            require(tokenAmountOut >= minAmountsOut[i], "ERR_LIMIT_OUT");
            _records[t].balance = bsub(_records[t].balance, tokenAmountOut);
            emit LOG_EXIT(msg.sender, t, tokenAmountOut);
            _pushUnderlying(t, msg.sender, tokenAmountOut);
        }

}

function swapExactAmountIn(
        address tokenIn,
        uint tokenAmountIn,
        address tokenOut,
        uint minAmountOut,
        uint maxPrice
    )
        external
        _logs_
        _lock_
        returns (uint tokenAmountOut, uint spotPriceAfter)
    {

require(_records[tokenIn].bound, "ERR_NOT_BOUND");
        require(_records[tokenOut].bound, "ERR_NOT_BOUND");
        require(_publicSwap, "ERR_SWAP_NOT_PUBLIC");

Record storage inRecord = _records[address(tokenIn)];
        Record storage outRecord = _records[address(tokenOut)];

require(tokenAmountIn <= bmul(inRecord.balance, MAX_IN_RATIO), "ERR_MAX_IN_RATIO");

uint spotPriceBefore = calcSpotPrice(
                                    inRecord.balance,
                                    inRecord.denorm,
                                    outRecord.balance,
                                    outRecord.denorm,
                                    _swapFee
                                );
        require(spotPriceBefore <= maxPrice, "ERR_BAD_LIMIT_PRICE");

tokenAmountOut = calcOutGivenIn(
                            inRecord.balance,
                            inRecord.denorm,
                            outRecord.balance,
                            outRecord.denorm,
                            tokenAmountIn,
                            _swapFee
                        );
        require(tokenAmountOut >= minAmountOut, "ERR_LIMIT_OUT");

inRecord.balance = badd(inRecord.balance, tokenAmountIn);
        outRecord.balance = bsub(outRecord.balance, tokenAmountOut);

spotPriceAfter = calcSpotPrice(
                                inRecord.balance,
                                inRecord.denorm,
                                outRecord.balance,
                                outRecord.denorm,
                                _swapFee
                            );
        require(spotPriceAfter >= spotPriceBefore, "ERR_MATH_APPROX");     
        require(spotPriceAfter <= maxPrice, "ERR_LIMIT_PRICE");
        require(spotPriceBefore <= bdiv(tokenAmountIn, tokenAmountOut), "ERR_MATH_APPROX");

emit LOG_SWAP(msg.sender, tokenIn, tokenOut, tokenAmountIn, tokenAmountOut);

_pullUnderlying(tokenIn, msg.sender, tokenAmountIn);
        _pushUnderlying(tokenOut, msg.sender, tokenAmountOut);

return (tokenAmountOut, spotPriceAfter);
    }

function swapExactAmountOut(
        address tokenIn,
        uint maxAmountIn,
        address tokenOut,
        uint tokenAmountOut,
        uint maxPrice
    )
        external
        _logs_
        _lock_ 
        returns (uint tokenAmountIn, uint spotPriceAfter)
    {
        require(_records[tokenIn].bound, "ERR_NOT_BOUND");
        require(_records[tokenOut].bound, "ERR_NOT_BOUND");
        require(_publicSwap, "ERR_SWAP_NOT_PUBLIC");

Record storage inRecord = _records[address(tokenIn)];
        Record storage outRecord = _records[address(tokenOut)];

require(tokenAmountOut <= bmul(outRecord.balance, MAX_OUT_RATIO), "ERR_MAX_OUT_RATIO");

tokenAmountIn = calcInGivenOut(
                            inRecord.balance,
                            inRecord.denorm,
                            outRecord.balance,
                            outRecord.denorm,
                            tokenAmountOut,
                            _swapFee
                        );
        require(tokenAmountIn <= maxAmountIn, "ERR_LIMIT_IN");

inRecord.balance = badd(inRecord.balance, tokenAmountIn);
        outRecord.balance = bsub(outRecord.balance, tokenAmountOut);

spotPriceAfter = calcSpotPrice(
                                inRecord.balance,
                                inRecord.denorm,
                                outRecord.balance,
                                outRecord.denorm,
                                _swapFee
                            );
        require(spotPriceAfter >= spotPriceBefore, "ERR_MATH_APPROX");
        require(spotPriceAfter <= maxPrice, "ERR_LIMIT_PRICE");
        require(spotPriceBefore <= bdiv(tokenAmountIn, tokenAmountOut), "ERR_MATH_APPROX");

emit LOG_SWAP(msg.sender, tokenIn, tokenOut, tokenAmountIn, tokenAmountOut);

_pullUnderlying(tokenIn, msg.sender, tokenAmountIn);
        _pushUnderlying(tokenOut, msg.sender, tokenAmountOut);

return (tokenAmountIn, spotPriceAfter);
    }

function joinswapExternAmountIn(address tokenIn, uint tokenAmountIn, uint minPoolAmountOut)
        external
        _logs_
        _lock_
        returns (uint poolAmountOut)

{        
        require(_finalized, "ERR_NOT_FINALIZED");
        require(_records[tokenIn].bound, "ERR_NOT_BOUND");
        require(tokenAmountIn <= bmul(_records[tokenIn].balance, MAX_IN_RATIO), "ERR_MAX_IN_RATIO");

Record storage inRecord = _records[tokenIn];

poolAmountOut = calcPoolOutGivenSingleIn(
                            inRecord.balance,
                            inRecord.denorm,
                            _totalSupply,
                            _totalWeight,
                            tokenAmountIn,
                            _swapFee
                        );

require(poolAmountOut >= minPoolAmountOut, "ERR_LIMIT_OUT");

inRecord.balance = badd(inRecord.balance, tokenAmountIn);

emit LOG_JOIN(msg.sender, tokenIn, tokenAmountIn);

_mintPoolShare(poolAmountOut);
        _pushPoolShare(msg.sender, poolAmountOut);
        _pullUnderlying(tokenIn, msg.sender, tokenAmountIn);

return poolAmountOut;
    }

function joinswapPoolAmountOut(address tokenIn, uint poolAmountOut, uint maxAmountIn)
        external
        _logs_
        _lock_
        returns (uint tokenAmountIn)
    {
        require(_finalized, "ERR_NOT_FINALIZED");
        require(_records[tokenIn].bound, "ERR_NOT_BOUND");

Record storage inRecord = _records[tokenIn];

tokenAmountIn = calcSingleInGivenPoolOut(
                            inRecord.balance,
                            inRecord.denorm,
                            _totalSupply,
                            _totalWeight,
                            poolAmountOut,
                            _swapFee
                        );

require(tokenAmountIn != 0, "ERR_MATH_APPROX");
        require(tokenAmountIn <= maxAmountIn, "ERR_LIMIT_IN");
        
        require(tokenAmountIn <= bmul(_records[tokenIn].balance, MAX_IN_RATIO), "ERR_MAX_IN_RATIO");

inRecord.balance = badd(inRecord.balance, tokenAmountIn);

emit LOG_JOIN(msg.sender, tokenIn, tokenAmountIn);

_mintPoolShare(poolAmountOut);
        _pushPoolShare(msg.sender, poolAmountOut);
        _pullUnderlying(tokenIn, msg.sender, tokenAmountIn);

return tokenAmountIn;
    }

function exitswapPoolAmountIn(address tokenOut, uint poolAmountIn, uint minAmountOut)
        external
        _logs_
        _lock_
        returns (uint tokenAmountOut)
    {
        require(_finalized, "ERR_NOT_FINALIZED");
        require(_records[tokenOut].bound, "ERR_NOT_BOUND");

Record storage outRecord = _records[tokenOut];

tokenAmountOut = calcSingleOutGivenPoolIn(
                            outRecord.balance,
                            outRecord.denorm,
                            _totalSupply,
                            _totalWeight,
                            poolAmountIn,
                            _swapFee
                        );

require(tokenAmountOut >= minAmountOut, "ERR_LIMIT_OUT");
        
        require(tokenAmountOut <= bmul(_records[tokenOut].balance, MAX_OUT_RATIO), "ERR_MAX_OUT_RATIO");

outRecord.balance = bsub(outRecord.balance, tokenAmountOut);

uint exitFee = bmul(poolAmountIn, EXIT_FEE);

emit LOG_EXIT(msg.sender, tokenOut, tokenAmountOut);

_pullPoolShare(msg.sender, poolAmountIn);
        _burnPoolShare(bsub(poolAmountIn, exitFee));
        _pushPoolShare(_factory, exitFee);
        _pushUnderlying(tokenOut, msg.sender, tokenAmountOut);

return tokenAmountOut;
    }

function exitswapExternAmountOut(address tokenOut, uint tokenAmountOut, uint maxPoolAmountIn)
        external
        _logs_
        _lock_
        returns (uint poolAmountIn)
    {
        require(_finalized, "ERR_NOT_FINALIZED");
        require(_records[tokenOut].bound, "ERR_NOT_BOUND");
        require(tokenAmountOut <= bmul(_records[tokenOut].balance, MAX_OUT_RATIO), "ERR_MAX_OUT_RATIO");

Record storage outRecord = _records[tokenOut];

poolAmountIn = calcPoolInGivenSingleOut(
                            outRecord.balance,
                            outRecord.denorm,
                            _totalSupply,
                            _totalWeight,
                            tokenAmountOut,
                            _swapFee
                        );

require(poolAmountIn != 0, "ERR_MATH_APPROX");
        require(poolAmountIn <= maxPoolAmountIn, "ERR_LIMIT_IN");

outRecord.balance = bsub(outRecord.balance, tokenAmountOut);

uint exitFee = bmul(poolAmountIn, EXIT_FEE);

emit LOG_EXIT(msg.sender, tokenOut, tokenAmountOut);

return poolAmountIn;
    }

// ==
    // 'Underlying' token-manipulation functions make external calls but are NOT locked
    // You must `_lock_` or otherwise ensure reentry-safety

function _pullUnderlying(address erc20, address from, uint amount)
        internal
    {
        bool xfer = IERC20(erc20).transferFrom(from, address(this), amount);
        require(xfer, "ERR_ERC20_FALSE");
    }

function _pushUnderlying(address erc20, address to, uint amount)
        internal
    {
        bool xfer = IERC20(erc20).transfer(to, amount);
        require(xfer, "ERR_ERC20_FALSE");
    }

function _pullPoolShare(address from, uint amount)
        internal
    {
        _pull(from, amount);
    }

function _pushPoolShare(address to, uint amount)
        internal
    {
        _push(to, amount);
    }

function _mintPoolShare(uint amount)
        internal
    {
        _mint(amount);
    }

function _burnPoolShare(uint amount)
        internal
    {
        _burn(amount);
    }

}

Changed text

Open file

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity 0.5.12;

import "./BToken.sol";
import "./BMath.sol";

contract BPool is BBronze, BToken, BMath {

struct Record {
        bool bound;   // is token bound to pool
        uint index;   // private
        uint denorm;  // denormalized weight
        uint balance;
    }

event LOG_SWAP(
        address indexed caller,
        address indexed tokenIn,
        address indexed tokenOut,
        uint256         tokenAmountIn,
        uint256         tokenAmountOut,
        uint256         reservesAmount
    );

event LOG_JOIN(
        address indexed caller,
        address indexed tokenIn,
        uint256         tokenAmountIn,
        uint256         reservesAmount
    );

event LOG_EXIT(
        address indexed caller,
        address indexed tokenOut,
        uint256         tokenAmountOut,
        uint256         reservesAmount
    );

event LOG_DRAIN_RESERVES(
        address indexed caller,
        address indexed tokenOut,
        uint256         tokenAmountOut
    );

event LOG_ADD_RESERVES(
        address indexed token,
        uint256         reservesAmount
    );

event LOG_CALL(
        bytes4  indexed sig,
        address indexed caller,
        bytes           data
    ) anonymous;

modifier _logs_() {
        emit LOG_CALL(msg.sig, msg.sender, msg.data);
        _;
    }

modifier _lock_() {
        require(!_mutex);
        _mutex = true;
        _;
        _mutex = false;
    }

modifier _viewlock_() {
        require(!_mutex);
        _;
    }

bool private _mutex;

address private _factory;    // BFactory address to push token exitFee to
    address private _controller; // has CONTROL role
    bool private _publicSwap; // true if PUBLIC can call SWAP functions

// `setSwapFee` and `finalize` require CONTROL
    // `finalize` sets `PUBLIC can SWAP`, `PUBLIC can JOIN`
    uint private _swapFee;
    uint private _reservesRatio;
    bool private _finalized;

address[] private _tokens;
    mapping(address=>Record) private  _records;
    mapping(address=>uint) public totalReserves;

uint private _totalWeight;

constructor() public {
        _controller = msg.sender;
        _factory = msg.sender;
        _swapFee = MIN_FEE;
        _reservesRatio = DEFAULT_RESERVES_RATIO;
        _publicSwap = false;
        _finalized = false;
    }

function isPublicSwap()
        external view
        returns (bool)
    {
        return _publicSwap;
    }

function isFinalized()
        external view
        returns (bool)
    {
        return _finalized;
    }

function isBound(address t)
        external view
        returns (bool)
    {
        return _records[t].bound;
    }

function getNumTokens()
        external view
        returns (uint)
    {
        return _tokens.length;
    }

function getCurrentTokens()
        external view _viewlock_
        returns (address[] memory tokens)
    {
        return _tokens;
    }

function getFinalTokens()
        external view
        _viewlock_
        returns (address[] memory tokens)
    {
        require(_finalized);
        return _tokens;
    }

function getDenormalizedWeight(address token)
        external view
        _viewlock_
        returns (uint)
    {

require(_records[token].bound);
        return _records[token].denorm;
    }

function getTotalDenormalizedWeight()
        external view
        _viewlock_
        returns (uint)
    {
        return _totalWeight;
    }

function getNormalizedWeight(address token)
        external view
        _viewlock_
        returns (uint)
    {

require(_records[token].bound);
        uint denorm = _records[token].denorm;
        return bdiv(denorm, _totalWeight);
    }

function getBalance(address token)
        external view
        _viewlock_
        returns (uint)
    {

require(_records[token].bound);
        return _records[token].balance;
    }

function getSwapFee()
        external view
        _viewlock_
        returns (uint)
    {
        return _swapFee;
    }

function getReservesRatio()
        external view
        _viewlock_
        returns (uint)
    {
        return _reservesRatio;
    }

function getController()
        external view
        _viewlock_
        returns (address)
    {
        return _controller;
    }

function setSwapFee(uint swapFee)
        external
        _logs_
        _lock_
    {
        require(!_finalized);
        require(msg.sender == _controller);
        require(swapFee >= MIN_FEE);
        require(swapFee <= MAX_FEE);
        _swapFee = swapFee;
    }

function setReservesRatio(uint reservesRatio)
        external
        _logs_
        _lock_
    {
        require(!_finalized);
        require(msg.sender == _controller);
        require(reservesRatio <= BONE);
        require(reservesRatio >= DEFAULT_RESERVES_RATIO);
        _reservesRatio = reservesRatio;
    }

function setController(address manager)
        external
        _logs_
        _lock_
    {
        require(msg.sender == _controller);
        _controller = manager;
    }

function setPublicSwap(bool public_)
        external
        _logs_
        _lock_
    {
        require(!_finalized);
        require(msg.sender == _controller);
        _publicSwap = public_;
    }

function finalize()
        external
        _logs_
        _lock_
    {
        require(msg.sender == _controller);
        require(!_finalized);
        require(_tokens.length >= MIN_BOUND_TOKENS);

_finalized = true;
        _publicSwap = true;

_mintPoolShare(INIT_POOL_SUPPLY);
        _pushPoolShare(msg.sender, INIT_POOL_SUPPLY);
    }

function bind(address token, uint balance, uint denorm)
        external
        _logs_
        // _lock_  Bind does not lock because it jumps to `rebind`, which does
    {
        require(msg.sender == _controller);
        require(!_records[token].bound);
        require(!_finalized);

require(_tokens.length < MAX_BOUND_TOKENS);

function rebind(address token, uint balance, uint denorm)
        public
        _logs_
        _lock_
    {

require(msg.sender == _controller);
        require(_records[token].bound);
        require(!_finalized);

require(denorm >= MIN_WEIGHT);
        require(denorm <= MAX_WEIGHT);
        require(balance >= MIN_BALANCE);

// Adjust the denorm and totalWeight
        uint oldWeight = _records[token].denorm;
        if (denorm > oldWeight) {
            _totalWeight = badd(_totalWeight, bsub(denorm, oldWeight));
            require(_totalWeight <= MAX_TOTAL_WEIGHT);
        } else if (denorm < oldWeight) {
            _totalWeight = bsub(_totalWeight, bsub(oldWeight, denorm));
        }
        _records[token].denorm = denorm;

function unbind(address token)
        external
        _logs_
        _lock_
    {

require(msg.sender == _controller);
        require(_records[token].bound);
        require(!_finalized);

uint tokenBalance = _records[token].balance;
        uint tokenExitFee = bmul(tokenBalance, EXIT_FEE);

_totalWeight = bsub(_totalWeight, _records[token].denorm);

_pushUnderlying(token, msg.sender, bsub(tokenBalance, tokenExitFee));
        _pushUnderlying(token, _factory, tokenExitFee);
    }

// Absorb any tokens that have been sent to this contract into the pool
    function gulp(address token)
        external
        _logs_
        _lock_
    {
        require(_records[token].bound);
        uint erc20Balance = IERC20(token).balanceOf(address(this));
        uint reserves = totalReserves[token];
        // `_records[token].balance` should be equaled to `bsub(erc20Balance, reserves)` unless there are extra
        // tokens transferred to this pool without calling `joinxxx`.
        require(_records[token].balance <= bsub(erc20Balance, reserves));
        _records[token].balance = bsub(erc20Balance, reserves);
    }

function seize(address token, uint amount)
        external
        _logs_
        _lock_
    {
        require(msg.sender == _controller);
        require(!_records[token].bound);

uint bal = IERC20(token).balanceOf(address(this));
        require(amount <= bal);

_pushUnderlying(token, msg.sender, amount);
    }

function joinPool(uint poolAmountOut, uint[] calldata maxAmountsIn)
        external
        _logs_
        _lock_
    {
        require(_finalized, "ERR_NOT_FINALIZED");

uint poolTotal = totalSupply();
        uint ratio = bdiv(poolAmountOut, poolTotal);
        require(ratio != 0, "ERR_MATH_APPROX");

for (uint i = 0; i < _tokens.length; i++) {
            address t = _tokens[i];
            uint bal = _records[t].balance;
            uint tokenAmountIn = bmul(ratio, bal);
            require(tokenAmountIn != 0, "ERR_MATH_APPROX");
            require(tokenAmountIn <= maxAmountsIn[i], "ERR_LIMIT_IN");
            _records[t].balance = badd(_records[t].balance, tokenAmountIn);
            emit LOG_JOIN(msg.sender, t, tokenAmountIn, 0);
            _pullUnderlying(t, msg.sender, tokenAmountIn);
        }
        _mintPoolShare(poolAmountOut);
        _pushPoolShare(msg.sender, poolAmountOut);
    }

function exitPool(uint poolAmountIn, uint[] calldata minAmountsOut)
        external
        _logs_
        _lock_
    {
        require(_finalized, "ERR_NOT_FINALIZED");

_pullPoolShare(msg.sender, poolAmountIn);
        _pushPoolShare(_factory, exitFee);
        _burnPoolShare(pAiAfterExitFee);

for (uint i = 0; i < _tokens.length; i++) {
            address t = _tokens[i];
            uint bal = _records[t].balance;
            uint tokenAmountOut = bmul(ratio, bal);
            require(tokenAmountOut != 0, "ERR_MATH_APPROX");
            require(tokenAmountOut >= minAmountsOut[i], "ERR_LIMIT_OUT");
            _records[t].balance = bsub(_records[t].balance, tokenAmountOut);
            emit LOG_EXIT(msg.sender, t, tokenAmountOut, 0);
            _pushUnderlying(t, msg.sender, tokenAmountOut);
        }

}

require(_records[tokenIn].bound, "ERR_NOT_BOUND");
        require(_records[tokenOut].bound, "ERR_NOT_BOUND");
        require(_publicSwap, "ERR_SWAP_NOT_PUBLIC");

Record storage inRecord = _records[address(tokenIn)];
        Record storage outRecord = _records[address(tokenOut)];

require(tokenAmountIn <= bmul(inRecord.balance, MAX_IN_RATIO), "ERR_MAX_IN_RATIO");

uint tokenInFee;
        (tokenAmountOut, tokenInFee) = calcOutGivenIn(
                                            inRecord.balance,
                                            inRecord.denorm,
                                            outRecord.balance,
                                            outRecord.denorm,
                                            tokenAmountIn,
                                            _swapFee
                                        );
        require(tokenAmountOut >= minAmountOut, "ERR_LIMIT_OUT");

uint reserves = calcReservesFromFee(tokenInFee, _reservesRatio);

// Subtract `reserves`.
        inRecord.balance = bsub(badd(inRecord.balance, tokenAmountIn), reserves);
        outRecord.balance = bsub(outRecord.balance, tokenAmountOut);

spotPriceAfter = calcSpotPrice(
                                inRecord.balance,
                                inRecord.denorm,
                                outRecord.balance,
                                outRecord.denorm,
                                _swapFee
                            );
        require(spotPriceAfter >= spotPriceBefore, "ERR_MATH_APPROX");
        require(spotPriceAfter <= maxPrice, "ERR_LIMIT_PRICE");
        require(spotPriceBefore <= bdiv(tokenAmountIn, tokenAmountOut), "ERR_MATH_APPROX");

emit LOG_SWAP(msg.sender, tokenIn, tokenOut, tokenAmountIn, tokenAmountOut, reserves);

totalReserves[address(tokenIn)] = badd(totalReserves[address(tokenIn)], reserves);
        emit LOG_ADD_RESERVES(address(tokenIn), reserves);

_pullUnderlying(tokenIn, msg.sender, tokenAmountIn);
        _pushUnderlying(tokenOut, msg.sender, tokenAmountOut);

return (tokenAmountOut, spotPriceAfter);
    }

function swapExactAmountOut(
        address tokenIn,
        uint maxAmountIn,
        address tokenOut,
        uint tokenAmountOut,
        uint maxPrice
    )
        external
        _logs_
        _lock_
        returns (uint tokenAmountIn, uint spotPriceAfter)
    {
        require(_records[tokenIn].bound, "ERR_NOT_BOUND");
        require(_records[tokenOut].bound, "ERR_NOT_BOUND");
        require(_publicSwap, "ERR_SWAP_NOT_PUBLIC");

Record storage inRecord = _records[address(tokenIn)];
        Record storage outRecord = _records[address(tokenOut)];

require(tokenAmountOut <= bmul(outRecord.balance, MAX_OUT_RATIO), "ERR_MAX_OUT_RATIO");

uint tokenInFee;
        (tokenAmountIn, tokenInFee) = calcInGivenOut(
                                            inRecord.balance,
                                            inRecord.denorm,
                                            outRecord.balance,
                                            outRecord.denorm,
                                            tokenAmountOut,
                                            _swapFee
                                        );
        require(tokenAmountIn <= maxAmountIn, "ERR_LIMIT_IN");

uint reserves = calcReservesFromFee(
            tokenInFee,
            _reservesRatio
        );

// Subtract `reserves` which is reserved for admin.
        inRecord.balance = bsub(badd(inRecord.balance, tokenAmountIn), reserves);
        outRecord.balance = bsub(outRecord.balance, tokenAmountOut);

spotPriceAfter = calcSpotPrice(
                                inRecord.balance,
                                inRecord.denorm,
                                outRecord.balance,
                                outRecord.denorm,
                                _swapFee
                            );
        require(spotPriceAfter >= spotPriceBefore, "ERR_MATH_APPROX");
        require(spotPriceAfter <= maxPrice, "ERR_LIMIT_PRICE");
        require(spotPriceBefore <= bdiv(tokenAmountIn, tokenAmountOut), "ERR_MATH_APPROX");

emit LOG_SWAP(msg.sender, tokenIn, tokenOut, tokenAmountIn, tokenAmountOut, reserves);

totalReserves[address(tokenIn)] = badd(totalReserves[address(tokenIn)], reserves);
        emit LOG_ADD_RESERVES(address(tokenIn), reserves);

_pullUnderlying(tokenIn, msg.sender, tokenAmountIn);
        _pushUnderlying(tokenOut, msg.sender, tokenAmountOut);

return (tokenAmountIn, spotPriceAfter);
    }

function joinswapExternAmountIn(address tokenIn, uint tokenAmountIn, uint minPoolAmountOut)
        external
        _logs_
        _lock_
        returns (uint poolAmountOut)

{
        require(_finalized, "ERR_NOT_FINALIZED");
        require(_records[tokenIn].bound, "ERR_NOT_BOUND");
        require(tokenAmountIn <= bmul(_records[tokenIn].balance, MAX_IN_RATIO), "ERR_MAX_IN_RATIO");

Record storage inRecord = _records[tokenIn];

uint reserves;
        (poolAmountOut, reserves) = calcPoolOutGivenSingleIn(
                            inRecord.balance,
                            inRecord.denorm,
                            _totalSupply,
                            _totalWeight,
                            tokenAmountIn,
                            _swapFee,
                            _reservesRatio
                        );

require(poolAmountOut >= minPoolAmountOut, "ERR_LIMIT_OUT");

inRecord.balance = bsub(badd(inRecord.balance, tokenAmountIn), reserves);

emit LOG_JOIN(msg.sender, tokenIn, tokenAmountIn, reserves);

totalReserves[address(tokenIn)] = badd(totalReserves[address(tokenIn)], reserves);
        emit LOG_ADD_RESERVES(address(tokenIn), reserves);

_mintPoolShare(poolAmountOut);
        _pushPoolShare(msg.sender, poolAmountOut);
        _pullUnderlying(tokenIn, msg.sender, tokenAmountIn);

return poolAmountOut;
    }

Record storage inRecord = _records[tokenIn];

require(tokenAmountIn != 0, "ERR_MATH_APPROX");
        require(tokenAmountIn <= maxAmountIn, "ERR_LIMIT_IN");

require(tokenAmountIn <= bmul(_records[tokenIn].balance, MAX_IN_RATIO), "ERR_MAX_IN_RATIO");

uint tokenAmountInZeroFee = calcSingleInGivenPoolOut(
            inRecord.balance,
            inRecord.denorm,
            _totalSupply,
            _totalWeight,
            poolAmountOut,
            0
        );
        uint reserves = calcReserves(
            tokenAmountIn,
            tokenAmountInZeroFee,
            _reservesRatio
        );

inRecord.balance = bsub(badd(inRecord.balance, tokenAmountIn), reserves);

emit LOG_JOIN(msg.sender, tokenIn, tokenAmountIn, reserves);

totalReserves[address(tokenIn)] = badd(totalReserves[address(tokenIn)], reserves);
        emit LOG_ADD_RESERVES(address(tokenIn), reserves);

_mintPoolShare(poolAmountOut);
        _pushPoolShare(msg.sender, poolAmountOut);
        _pullUnderlying(tokenIn, msg.sender, tokenAmountIn);

return tokenAmountIn;
    }

Record storage outRecord = _records[tokenOut];

require(tokenAmountOut >= minAmountOut, "ERR_LIMIT_OUT");

require(tokenAmountOut <= bmul(_records[tokenOut].balance, MAX_OUT_RATIO), "ERR_MAX_OUT_RATIO");

uint tokenAmountOutZeroFee = calcSingleOutGivenPoolIn(
            outRecord.balance,
            outRecord.denorm,
            _totalSupply,
            _totalWeight,
            poolAmountIn,
            0
        );
        uint reserves = calcReserves(
            tokenAmountOutZeroFee,
            tokenAmountOut,
            _reservesRatio
        );

outRecord.balance = bsub(bsub(outRecord.balance, tokenAmountOut), reserves);

uint exitFee = bmul(poolAmountIn, EXIT_FEE);

emit LOG_EXIT(msg.sender, tokenOut, tokenAmountOut, reserves);

totalReserves[address(tokenOut)] = badd(totalReserves[address(tokenOut)], reserves);
        emit LOG_ADD_RESERVES(address(tokenOut), reserves);

return tokenAmountOut;
    }

Record storage outRecord = _records[tokenOut];

uint reserves;
        (poolAmountIn, reserves) = calcPoolInGivenSingleOut(
                            outRecord.balance,
                            outRecord.denorm,
                            _totalSupply,
                            _totalWeight,
                            tokenAmountOut,
                            _swapFee,
                            _reservesRatio
                        );

require(poolAmountIn != 0, "ERR_MATH_APPROX");
        require(poolAmountIn <= maxPoolAmountIn, "ERR_LIMIT_IN");

outRecord.balance = bsub(bsub(outRecord.balance, tokenAmountOut), reserves);

uint exitFee = bmul(poolAmountIn, EXIT_FEE);

emit LOG_EXIT(msg.sender, tokenOut, tokenAmountOut, reserves);

totalReserves[address(tokenOut)] = badd(totalReserves[address(tokenOut)], reserves);
        emit LOG_ADD_RESERVES(address(tokenOut), reserves);

return poolAmountIn;
    }

function drainTotalReserves(address reservesAddress)
        external
        _logs_
        _lock_
    {
        require(msg.sender == _factory);

for (uint i = 0; i < _tokens.length; i++) {
            address t = _tokens[i];
            uint tokenAmountOut = totalReserves[t];
            totalReserves[t] = 0;
            emit LOG_DRAIN_RESERVES(reservesAddress, t, tokenAmountOut);
            _pushUnderlying(t, reservesAddress, tokenAmountOut);
        }
    }

// ==
    // 'Underlying' token-manipulation functions make external calls but are NOT locked
    // You must `_lock_` or otherwise ensure reentry-safety

function _pushUnderlying(address erc20, address to, uint amount)
        internal
    {
        bool xfer = IERC20(erc20).transfer(to, amount);
        require(xfer, "ERR_ERC20_FALSE");
    }

function _pullPoolShare(address from, uint amount)
        internal
    {
        _pull(from, amount);
    }

function _pushPoolShare(address to, uint amount)
        internal
    {
        _push(to, amount);
    }

function _mintPoolShare(uint amount)
        internal
    {
        _mint(amount);
    }

function _burnPoolShare(uint amount)
        internal
    {
        _burn(amount);
    }

}