Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

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

BMath.sol

Created 5 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

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

272 lines

Lines
Total
Added

Words
Total
Added

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

299 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 "./BNum.sol";

contract BMath is BBronze, BConst, BNum {

/**********************************************************************************************

// calcSpotPrice //

// sP = spotPrice //

// bI = tokenBalanceIn ( bI / wI ) 1 //

// bO = tokenBalanceOut sP = ----------- * ---------- //

// wI = tokenWeightIn ( bO / wO ) ( 1 - sF ) //

// wO = tokenWeightOut //

// sF = swapFee //

**********************************************************************************************/

function calcSpotPrice(

uint tokenBalanceIn,

uint tokenWeightIn,

uint tokenBalanceOut,

uint tokenWeightOut,

uint swapFee

)

public pure

returns (uint spotPrice)

{

uint numer = bdiv(tokenBalanceIn, tokenWeightIn);

uint denom = bdiv(tokenBalanceOut, tokenWeightOut);

uint ratio = bdiv(numer, denom);

uint scale = bdiv(BONE, bsub(BONE, swapFee));

return (spotPrice = bmul(ratio, scale));

}

/**********************************************************************************************

// calcOutGivenIn //

// aO = tokenAmountOut //

// bO = tokenBalanceOut //

// bI = tokenBalanceIn / / bI \ (wI / wO) \ //

// aI = tokenAmountIn aO = bO * | 1 - | -------------------------- | ^ | //

// wI = tokenWeightIn \ \ ( bI + ( aI * ( 1 - sF )) / / //

// wO = tokenWeightOut //

// sF = swapFee //

**********************************************************************************************/

function calcOutGivenIn(

uint tokenBalanceIn,

uint tokenWeightIn,

uint tokenBalanceOut,

uint tokenWeightOut,

uint tokenAmountIn,

uint swapFee

)

public pure

returns (uint tokenAmountOut)

returns (uint tokenAmountOut, uint tokenInFee)

{

uint weightRatio = bdiv(tokenWeightIn, tokenWeightOut);

uint adjustedIn = bsub(BONE, swapFee);

adjustedIn = bmul(tokenAmountIn, adjustedIn);

uint y = bdiv(tokenBalanceIn, badd(tokenBalanceIn, adjustedIn));

uint foo = bpow(y, weightRatio);

uint bar = bsub(BONE, foo);

tokenAmountOut = bmul(tokenBalanceOut, bar);

return tokenAmountOut;

tokenInFee = bsub(tokenAmountIn, adjustedIn);

return (tokenAmountOut, tokenInFee);

}

/**********************************************************************************************

// calcInGivenOut //

// aI = tokenAmountIn //

// bO = tokenBalanceOut / / bO \ (wO / wI) \ //

// bI = tokenBalanceIn bI * | | ------------ | ^ - 1 | //

// aO = tokenAmountOut aI = \ \ ( bO - aO ) / / //

// wI = tokenWeightIn -------------------------------------------- //

// wO = tokenWeightOut ( 1 - sF ) //

// sF = swapFee //

**********************************************************************************************/

function calcInGivenOut(

uint tokenBalanceIn,

uint tokenWeightIn,

uint tokenBalanceOut,

uint tokenWeightOut,

uint tokenAmountOut,

uint swapFee

)

public pure

returns (uint tokenAmountIn)

returns (uint tokenAmountIn, uint tokenInFee)

{

uint weightRatio = bdiv(tokenWeightOut, tokenWeightIn);

uint diff = bsub(tokenBalanceOut, tokenAmountOut);

uint y = bdiv(tokenBalanceOut, diff);

uint foo = bpow(y, weightRatio);

foo = bsub(foo, BONE);

foo = bmul(tokenBalanceIn, foo);

tokenAmountIn = bsub(BONE, swapFee);

tokenAmountIn = bdiv(bmul(tokenBalanceIn, foo), tokenAmountIn);

tokenAmountIn = bdiv(foo, tokenAmountIn);

return tokenAmountIn;

tokenInFee = bdiv(foo, BONE);

tokenInFee = bsub(tokenAmountIn, tokenInFee);

return (tokenAmountIn, tokenInFee);

}

/**********************************************************************************************

// calcPoolOutGivenSingleIn //

// pAo = poolAmountOut / \ //

// tAi = tokenAmountIn /// / // wI \ \\ \ wI \ //

// wI = tokenWeightIn //| tAi *| 1 - || 1 - -- | * sF || + tBi \ -- \ //

// tW = totalWeight pAo=|| \ \ \\ tW / // | ^ tW | * pS - pS //

// tBi = tokenBalanceIn \\ ------------------------------------- / / //

// pS = poolSupply \\ tBi / / //

// sF = swapFee \ / //

**********************************************************************************************/

function calcPoolOutGivenSingleIn(

uint tokenBalanceIn,

uint tokenWeightIn,

uint poolSupply,

uint totalWeight,

uint tokenAmountIn,

uint swapFee

uint swapFee,

uint reservesRatio

)

public pure

returns (uint poolAmountOut)

returns (uint poolAmountOut, uint reserves)

{

// Charge the trading fee for the proportion of tokenAi

/// which is implicitly traded to the other pool tokens.

// That proportion is (1- weightTokenIn)

// tokenAiAfterFee = tAi * (1 - (1-weightTi) * poolFee);

uint normalizedWeight = bdiv(tokenWeightIn, totalWeight);

uint zaz = bmul(bsub(BONE, normalizedWeight), swapFee);

// Exact fee portion of `tokenAmountIn`, i.e. (1- Wt)

uint zaz = bmul(bsub(BONE, normalizedWeight), swapFee);

uint tokenAmountInAfterFee = bmul(tokenAmountIn, bsub(BONE, zaz));

reserves = calcReserves(tokenAmountIn, tokenAmountInAfterFee, reservesRatio);

uint newTokenBalanceIn = badd(tokenBalanceIn, tokenAmountInAfterFee);

uint tokenInRatio = bdiv(newTokenBalanceIn, tokenBalanceIn);

// uint newPoolSupply = (ratioTi ^ weightTi) * poolSupply;

uint poolRatio = bpow(tokenInRatio, normalizedWeight);

uint newPoolSupply = bmul(poolRatio, poolSupply);

poolAmountOut = bsub(newPoolSupply, poolSupply);

return poolAmountOut;

return (poolAmountOut, reserves);

}

/**********************************************************************************************

// calcSingleInGivenPoolOut //

// tAi = tokenAmountIn //(pS + pAo)\ / 1 \\ //

// pS = poolSupply || --------- | ^ | --------- || * bI - bI //

// pAo = poolAmountOut \\ pS / \(wI / tW)// //

// bI = balanceIn tAi = -------------------------------------------- //

// wI = weightIn / wI \ //

// tW = totalWeight | 1 - ---- | * sF //

// sF = swapFee \ tW / //

**********************************************************************************************/

function calcSingleInGivenPoolOut(

uint tokenBalanceIn,

uint tokenWeightIn,

uint poolSupply,

uint totalWeight,

uint poolAmountOut,

uint swapFee

)

public pure

returns (uint tokenAmountIn)

{

uint normalizedWeight = bdiv(tokenWeightIn, totalWeight);

uint newPoolSupply = badd(poolSupply, poolAmountOut);

uint poolRatio = bdiv(newPoolSupply, poolSupply);

//uint newBalTi = poolRatio^(1/weightTi) * balTi;

uint boo = bdiv(BONE, normalizedWeight);

uint tokenInRatio = bpow(poolRatio, boo);

uint newTokenBalanceIn = bmul(tokenInRatio, tokenBalanceIn);

uint tokenAmountInAfterFee = bsub(newTokenBalanceIn, tokenBalanceIn);

// Do reverse order of fees charged in joinswap_ExternAmountIn, this way

// ``` pAo == joinswap_ExternAmountIn(Ti, joinswap_PoolAmountOut(pAo, Ti)) ```

//uint tAi = tAiAfterFee / (1 - (1-weightTi) * swapFee) ;

uint zar = bmul(bsub(BONE, normalizedWeight), swapFee);

tokenAmountIn = bdiv(tokenAmountInAfterFee, bsub(BONE, zar));

return tokenAmountIn;

}

/**********************************************************************************************

// calcSingleOutGivenPoolIn //

// tAo = tokenAmountOut / / \\ //

// bO = tokenBalanceOut / // pS - (pAi * (1 - eF)) \ / 1 \ \\ //

// pAi = poolAmountIn | bO - || ----------------------- | ^ | --------- | * b0 || //

// ps = poolSupply \ \\ pS / \(wO / tW)/ // //

// wI = tokenWeightIn tAo = \ \ // //

// tW = totalWeight / / wO \ \ //

// sF = swapFee * | 1 - | 1 - ---- | * sF | //

// eF = exitFee \ \ tW / / //

**********************************************************************************************/

function calcSingleOutGivenPoolIn(

uint tokenBalanceOut,

uint tokenWeightOut,

uint poolSupply,

uint totalWeight,

uint poolAmountIn,

uint swapFee

)

public pure

returns (uint tokenAmountOut)

{

uint normalizedWeight = bdiv(tokenWeightOut, totalWeight);

// charge exit fee on the pool token side

// pAiAfterExitFee = pAi*(1-exitFee)

uint poolAmountInAfterExitFee = bmul(poolAmountIn, bsub(BONE, EXIT_FEE));

uint newPoolSupply = bsub(poolSupply, poolAmountInAfterExitFee);

uint poolRatio = bdiv(newPoolSupply, poolSupply);

// newBalTo = poolRatio^(1/weightTo) * balTo;

uint tokenOutRatio = bpow(poolRatio, bdiv(BONE, normalizedWeight));

uint newTokenBalanceOut = bmul(tokenOutRatio, tokenBalanceOut);

uint tokenAmountOutBeforeSwapFee = bsub(tokenBalanceOut, newTokenBalanceOut);

// charge swap fee on the output token side

//uint tAo = tAoBeforeSwapFee * (1 - (1-weightTo) * swapFee)

uint zaz = bmul(bsub(BONE, normalizedWeight), swapFee);

tokenAmountOut = bmul(tokenAmountOutBeforeSwapFee, bsub(BONE, zaz));

return tokenAmountOut;

}

/**********************************************************************************************

// calcPoolInGivenSingleOut //

// pAi = poolAmountIn // / tAo \\ / wO \ \ //

// bO = tokenBalanceOut // | bO - -------------------------- |\ | ---- | \ //

// tAo = tokenAmountOut pS - || \ 1 - ((1 - (tO / tW)) * sF)/ | ^ \ tW / * pS | //

// ps = poolSupply \\ -----------------------------------/ / //

// wO = tokenWeightOut pAi = \\ bO / / //

// tW = totalWeight ------------------------------------------------------------- //

// sF = swapFee ( 1 - eF ) //

// eF = exitFee //

**********************************************************************************************/

function calcPoolInGivenSingleOut(

uint tokenBalanceOut,

uint tokenWeightOut,

uint poolSupply,

uint totalWeight,

uint tokenAmountOut,

uint swapFee

uint swapFee,

uint reservesRatio

)

public pure

returns (uint poolAmountIn)

returns (uint poolAmountIn, uint reserves)

{

// charge swap fee on the output token side

uint normalizedWeight = bdiv(tokenWeightOut, totalWeight);

//uint tAoBeforeSwapFee = tAo / (1 - (1-weightTo) * swapFee) ;

uint zar = bmul(bsub(BONE, normalizedWeight), swapFee);

uint zoo = bsub(BONE, normalizedWeight);

uint zar = bmul(zoo, swapFee);

uint tokenAmountOutBeforeSwapFee = bdiv(tokenAmountOut, bsub(BONE, zar));

reserves = calcReserves(tokenAmountOutBeforeSwapFee, tokenAmountOut, reservesRatio);

uint newTokenBalanceOut = bsub(tokenBalanceOut, tokenAmountOutBeforeSwapFee);

uint tokenOutRatio = bdiv(newTokenBalanceOut, tokenBalanceOut);

//uint newPoolSupply = (ratioTo ^ weightTo) * poolSupply;

uint poolRatio = bpow(tokenOutRatio, normalizedWeight);

uint newPoolSupply = bmul(poolRatio, poolSupply);

uint poolAmountInAfterExitFee = bsub(poolSupply, newPoolSupply);

// charge exit fee on the pool token side

// pAi = pAiAfterExitFee/(1-exitFee)

poolAmountIn = bdiv(poolAmountInAfterExitFee, bsub(BONE, EXIT_FEE));

return poolAmountIn;

return (poolAmountIn, reserves);

}

// `swapFeeAndReserves = amountWithFee - amountWithoutFee` is the swap fee in balancer.

// We divide `swapFeeAndReserves` into halves, `actualSwapFee` and `reserves`.

// `reserves` goes to the admin and `actualSwapFee` still goes to the liquidity

// providers.

function calcReserves(uint amountWithFee, uint amountWithoutFee, uint reservesRatio)

internal pure

returns (uint reserves)

{

require(amountWithFee >= amountWithoutFee, "ERR_MATH_APPROX");

require(reservesRatio <= BONE, "ERR_INVALID_RESERVE");

uint swapFeeAndReserves = bsub(amountWithFee, amountWithoutFee);

reserves = bmul(swapFeeAndReserves, reservesRatio);

require(swapFeeAndReserves >= reserves, "ERR_MATH_APPROX");

}

function calcReservesFromFee(uint fee, uint reservesRatio)

internal pure

returns (uint reserves)

{

require(reservesRatio <= BONE, "ERR_INVALID_RESERVE");

reserves = bmul(fee, reservesRatio);

}

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 "./BNum.sol";

contract BMath is BBronze, BConst, BNum {
    /**********************************************************************************************
    // calcSpotPrice                                                                             //
    // sP = spotPrice                                                                            //
    // bI = tokenBalanceIn                ( bI / wI )         1                                  //
    // bO = tokenBalanceOut         sP =  -----------  *  ----------                             //
    // wI = tokenWeightIn                 ( bO / wO )     ( 1 - sF )                             //
    // wO = tokenWeightOut                                                                       //
    // sF = swapFee                                                                              //
    **********************************************************************************************/
    function calcSpotPrice(
        uint tokenBalanceIn,
        uint tokenWeightIn,
        uint tokenBalanceOut,
        uint tokenWeightOut,
        uint swapFee
    )
        public pure
        returns (uint spotPrice)
    {
        uint numer = bdiv(tokenBalanceIn, tokenWeightIn);
        uint denom = bdiv(tokenBalanceOut, tokenWeightOut);
        uint ratio = bdiv(numer, denom);
        uint scale = bdiv(BONE, bsub(BONE, swapFee));
        return  (spotPrice = bmul(ratio, scale));
    }

/**********************************************************************************************
    // calcOutGivenIn                                                                            //
    // aO = tokenAmountOut                                                                       //
    // bO = tokenBalanceOut                                                                      //
    // bI = tokenBalanceIn              /      /            bI             \    (wI / wO) \      //
    // aI = tokenAmountIn    aO = bO * |  1 - | --------------------------  | ^            |     //
    // wI = tokenWeightIn               \      \ ( bI + ( aI * ( 1 - sF )) /              /      //
    // wO = tokenWeightOut                                                                       //
    // sF = swapFee                                                                              //
    **********************************************************************************************/
    function calcOutGivenIn(
        uint tokenBalanceIn,
        uint tokenWeightIn,
        uint tokenBalanceOut,
        uint tokenWeightOut,
        uint tokenAmountIn,
        uint swapFee
    )
        public pure
        returns (uint tokenAmountOut)
    {
        uint weightRatio = bdiv(tokenWeightIn, tokenWeightOut);
        uint adjustedIn = bsub(BONE, swapFee);
        adjustedIn = bmul(tokenAmountIn, adjustedIn);
        uint y = bdiv(tokenBalanceIn, badd(tokenBalanceIn, adjustedIn));
        uint foo = bpow(y, weightRatio);
        uint bar = bsub(BONE, foo);
        tokenAmountOut = bmul(tokenBalanceOut, bar);
        return tokenAmountOut;
    }

/**********************************************************************************************
    // calcInGivenOut                                                                            //
    // aI = tokenAmountIn                                                                        //
    // bO = tokenBalanceOut               /  /     bO      \    (wO / wI)      \                 //
    // bI = tokenBalanceIn          bI * |  | ------------  | ^            - 1  |                //
    // aO = tokenAmountOut    aI =        \  \ ( bO - aO ) /                   /                 //
    // wI = tokenWeightIn           --------------------------------------------                 //
    // wO = tokenWeightOut                          ( 1 - sF )                                   //
    // sF = swapFee                                                                              //
    **********************************************************************************************/
    function calcInGivenOut(
        uint tokenBalanceIn,
        uint tokenWeightIn,
        uint tokenBalanceOut,
        uint tokenWeightOut,
        uint tokenAmountOut,
        uint swapFee
    )
        public pure
        returns (uint tokenAmountIn)
    {
        uint weightRatio = bdiv(tokenWeightOut, tokenWeightIn);
        uint diff = bsub(tokenBalanceOut, tokenAmountOut);
        uint y = bdiv(tokenBalanceOut, diff);
        uint foo = bpow(y, weightRatio);
        foo = bsub(foo, BONE);
        tokenAmountIn = bsub(BONE, swapFee);
        tokenAmountIn = bdiv(bmul(tokenBalanceIn, foo), tokenAmountIn);
        return tokenAmountIn;
    }

/**********************************************************************************************
    // calcPoolOutGivenSingleIn                                                                  //
    // pAo = poolAmountOut         /                                              \              //
    // tAi = tokenAmountIn        ///      /     //    wI \      \\       \     wI \             //
    // wI = tokenWeightIn        //| tAi *| 1 - || 1 - --  | * sF || + tBi \    --  \            //
    // tW = totalWeight     pAo=||  \      \     \\    tW /      //         | ^ tW   | * pS - pS //
    // tBi = tokenBalanceIn      \\  ------------------------------------- /        /            //
    // pS = poolSupply            \\                    tBi               /        /             //
    // sF = swapFee                \                                              /              //
    **********************************************************************************************/
    function calcPoolOutGivenSingleIn(
        uint tokenBalanceIn,
        uint tokenWeightIn,
        uint poolSupply,
        uint totalWeight,
        uint tokenAmountIn,
        uint swapFee
    )
        public pure
        returns (uint poolAmountOut)
    {
        // Charge the trading fee for the proportion of tokenAi
        ///  which is implicitly traded to the other pool tokens.
        // That proportion is (1- weightTokenIn)
        // tokenAiAfterFee = tAi * (1 - (1-weightTi) * poolFee);
        uint normalizedWeight = bdiv(tokenWeightIn, totalWeight);
        uint zaz = bmul(bsub(BONE, normalizedWeight), swapFee); 
        uint tokenAmountInAfterFee = bmul(tokenAmountIn, bsub(BONE, zaz));

uint newTokenBalanceIn = badd(tokenBalanceIn, tokenAmountInAfterFee);
        uint tokenInRatio = bdiv(newTokenBalanceIn, tokenBalanceIn);

// uint newPoolSupply = (ratioTi ^ weightTi) * poolSupply;
        uint poolRatio = bpow(tokenInRatio, normalizedWeight);
        uint newPoolSupply = bmul(poolRatio, poolSupply);
        poolAmountOut = bsub(newPoolSupply, poolSupply);
        return poolAmountOut;
    }

/**********************************************************************************************
    // calcSingleInGivenPoolOut                                                                  //
    // tAi = tokenAmountIn              //(pS + pAo)\     /    1    \\                           //
    // pS = poolSupply                 || ---------  | ^ | --------- || * bI - bI                //
    // pAo = poolAmountOut              \\    pS    /     \(wI / tW)//                           //
    // bI = balanceIn          tAi =  --------------------------------------------               //
    // wI = weightIn                              /      wI  \                                   //
    // tW = totalWeight                          |  1 - ----  |  * sF                            //
    // sF = swapFee                               \      tW  /                                   //
    **********************************************************************************************/
    function calcSingleInGivenPoolOut(
        uint tokenBalanceIn,
        uint tokenWeightIn,
        uint poolSupply,
        uint totalWeight,
        uint poolAmountOut,
        uint swapFee
    )
        public pure
        returns (uint tokenAmountIn)
    {
        uint normalizedWeight = bdiv(tokenWeightIn, totalWeight);
        uint newPoolSupply = badd(poolSupply, poolAmountOut);
        uint poolRatio = bdiv(newPoolSupply, poolSupply);
      
        //uint newBalTi = poolRatio^(1/weightTi) * balTi;
        uint boo = bdiv(BONE, normalizedWeight); 
        uint tokenInRatio = bpow(poolRatio, boo);
        uint newTokenBalanceIn = bmul(tokenInRatio, tokenBalanceIn);
        uint tokenAmountInAfterFee = bsub(newTokenBalanceIn, tokenBalanceIn);
        // Do reverse order of fees charged in joinswap_ExternAmountIn, this way 
        //     ``` pAo == joinswap_ExternAmountIn(Ti, joinswap_PoolAmountOut(pAo, Ti)) ```
        //uint tAi = tAiAfterFee / (1 - (1-weightTi) * swapFee) ;
        uint zar = bmul(bsub(BONE, normalizedWeight), swapFee);
        tokenAmountIn = bdiv(tokenAmountInAfterFee, bsub(BONE, zar));
        return tokenAmountIn;
    }

/**********************************************************************************************
    // calcSingleOutGivenPoolIn                                                                  //
    // tAo = tokenAmountOut            /      /                                             \\   //
    // bO = tokenBalanceOut           /      // pS - (pAi * (1 - eF)) \     /    1    \      \\  //
    // pAi = poolAmountIn            | bO - || ----------------------- | ^ | --------- | * b0 || //
    // ps = poolSupply                \      \\          pS           /     \(wO / tW)/      //  //
    // wI = tokenWeightIn      tAo =   \      \                                             //   //
    // tW = totalWeight                    /     /      wO \       \                             //
    // sF = swapFee                    *  | 1 - |  1 - ---- | * sF  |                            //
    // eF = exitFee                        \     \      tW /       /                             //
    **********************************************************************************************/
    function calcSingleOutGivenPoolIn(
        uint tokenBalanceOut,
        uint tokenWeightOut,
        uint poolSupply,
        uint totalWeight,
        uint poolAmountIn,
        uint swapFee
    )
        public pure
        returns (uint tokenAmountOut)
    {
        uint normalizedWeight = bdiv(tokenWeightOut, totalWeight);
        // charge exit fee on the pool token side
        // pAiAfterExitFee = pAi*(1-exitFee)
        uint poolAmountInAfterExitFee = bmul(poolAmountIn, bsub(BONE, EXIT_FEE));
        uint newPoolSupply = bsub(poolSupply, poolAmountInAfterExitFee);
        uint poolRatio = bdiv(newPoolSupply, poolSupply);
     
        // newBalTo = poolRatio^(1/weightTo) * balTo;
        uint tokenOutRatio = bpow(poolRatio, bdiv(BONE, normalizedWeight));
        uint newTokenBalanceOut = bmul(tokenOutRatio, tokenBalanceOut);

uint tokenAmountOutBeforeSwapFee = bsub(tokenBalanceOut, newTokenBalanceOut);

// charge swap fee on the output token side 
        //uint tAo = tAoBeforeSwapFee * (1 - (1-weightTo) * swapFee)
        uint zaz = bmul(bsub(BONE, normalizedWeight), swapFee); 
        tokenAmountOut = bmul(tokenAmountOutBeforeSwapFee, bsub(BONE, zaz));
        return tokenAmountOut;
    }

/**********************************************************************************************
    // calcPoolInGivenSingleOut                                                                  //
    // pAi = poolAmountIn               // /               tAo             \\     / wO \     \   //
    // bO = tokenBalanceOut            // | bO - -------------------------- |\   | ---- |     \  //
    // tAo = tokenAmountOut      pS - ||   \     1 - ((1 - (tO / tW)) * sF)/  | ^ \ tW /  * pS | //
    // ps = poolSupply                 \\ -----------------------------------/                /  //
    // wO = tokenWeightOut  pAi =       \\               bO                 /                /   //
    // tW = totalWeight           -------------------------------------------------------------  //
    // sF = swapFee                                        ( 1 - eF )                            //
    // eF = exitFee                                                                              //
    **********************************************************************************************/
    function calcPoolInGivenSingleOut(
        uint tokenBalanceOut,
        uint tokenWeightOut,
        uint poolSupply,
        uint totalWeight,
        uint tokenAmountOut,
        uint swapFee
    )
        public pure
        returns (uint poolAmountIn)
    {

// charge swap fee on the output token side 
        uint normalizedWeight = bdiv(tokenWeightOut, totalWeight);
        //uint tAoBeforeSwapFee = tAo / (1 - (1-weightTo) * swapFee) ;
        uint zoo = bsub(BONE, normalizedWeight);
        uint zar = bmul(zoo, swapFee); 
        uint tokenAmountOutBeforeSwapFee = bdiv(tokenAmountOut, bsub(BONE, zar));

uint newTokenBalanceOut = bsub(tokenBalanceOut, tokenAmountOutBeforeSwapFee);
        uint tokenOutRatio = bdiv(newTokenBalanceOut, tokenBalanceOut);

//uint newPoolSupply = (ratioTo ^ weightTo) * poolSupply;
        uint poolRatio = bpow(tokenOutRatio, normalizedWeight);
        uint newPoolSupply = bmul(poolRatio, poolSupply);
        uint poolAmountInAfterExitFee = bsub(poolSupply, newPoolSupply);

// charge exit fee on the pool token side
        // pAi = pAiAfterExitFee/(1-exitFee)
        poolAmountIn = bdiv(poolAmountInAfterExitFee, bsub(BONE, EXIT_FEE));
        return poolAmountIn;
    }

}

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 "./BNum.sol";

/**********************************************************************************************
    // calcOutGivenIn                                                                            //
    // aO = tokenAmountOut                                                                       //
    // bO = tokenBalanceOut                                                                      //
    // bI = tokenBalanceIn              /      /            bI             \    (wI / wO) \      //
    // aI = tokenAmountIn    aO = bO * |  1 - | --------------------------  | ^            |     //
    // wI = tokenWeightIn               \      \ ( bI + ( aI * ( 1 - sF )) /              /      //
    // wO = tokenWeightOut                                                                       //
    // sF = swapFee                                                                              //
    **********************************************************************************************/
    function calcOutGivenIn(
        uint tokenBalanceIn,
        uint tokenWeightIn,
        uint tokenBalanceOut,
        uint tokenWeightOut,
        uint tokenAmountIn,
        uint swapFee
    )
        public pure
        returns (uint tokenAmountOut, uint tokenInFee)
    {
        uint weightRatio = bdiv(tokenWeightIn, tokenWeightOut);
        uint adjustedIn = bsub(BONE, swapFee);
        adjustedIn = bmul(tokenAmountIn, adjustedIn);
        uint y = bdiv(tokenBalanceIn, badd(tokenBalanceIn, adjustedIn));
        uint foo = bpow(y, weightRatio);
        uint bar = bsub(BONE, foo);
        tokenAmountOut = bmul(tokenBalanceOut, bar);
        tokenInFee = bsub(tokenAmountIn, adjustedIn);
        return (tokenAmountOut, tokenInFee);
    }

/**********************************************************************************************
    // calcInGivenOut                                                                            //
    // aI = tokenAmountIn                                                                        //
    // bO = tokenBalanceOut               /  /     bO      \    (wO / wI)      \                 //
    // bI = tokenBalanceIn          bI * |  | ------------  | ^            - 1  |                //
    // aO = tokenAmountOut    aI =        \  \ ( bO - aO ) /                   /                 //
    // wI = tokenWeightIn           --------------------------------------------                 //
    // wO = tokenWeightOut                          ( 1 - sF )                                   //
    // sF = swapFee                                                                              //
    **********************************************************************************************/
    function calcInGivenOut(
        uint tokenBalanceIn,
        uint tokenWeightIn,
        uint tokenBalanceOut,
        uint tokenWeightOut,
        uint tokenAmountOut,
        uint swapFee
    )
        public pure
        returns (uint tokenAmountIn, uint tokenInFee)
    {
        uint weightRatio = bdiv(tokenWeightOut, tokenWeightIn);
        uint diff = bsub(tokenBalanceOut, tokenAmountOut);
        uint y = bdiv(tokenBalanceOut, diff);
        uint foo = bpow(y, weightRatio);
        foo = bsub(foo, BONE);
        foo = bmul(tokenBalanceIn, foo);
        tokenAmountIn = bsub(BONE, swapFee);
        tokenAmountIn = bdiv(foo, tokenAmountIn);
        tokenInFee = bdiv(foo, BONE);
        tokenInFee = bsub(tokenAmountIn, tokenInFee);
        return (tokenAmountIn, tokenInFee);
    }

/**********************************************************************************************
    // calcPoolOutGivenSingleIn                                                                  //
    // pAo = poolAmountOut         /                                              \              //
    // tAi = tokenAmountIn        ///      /     //    wI \      \\       \     wI \             //
    // wI = tokenWeightIn        //| tAi *| 1 - || 1 - --  | * sF || + tBi \    --  \            //
    // tW = totalWeight     pAo=||  \      \     \\    tW /      //         | ^ tW   | * pS - pS //
    // tBi = tokenBalanceIn      \\  ------------------------------------- /        /            //
    // pS = poolSupply            \\                    tBi               /        /             //
    // sF = swapFee                \                                              /              //
    **********************************************************************************************/
    function calcPoolOutGivenSingleIn(
        uint tokenBalanceIn,
        uint tokenWeightIn,
        uint poolSupply,
        uint totalWeight,
        uint tokenAmountIn,
        uint swapFee,
        uint reservesRatio
    )
        public pure
        returns (uint poolAmountOut, uint reserves)
    {
        // Charge the trading fee for the proportion of tokenAi
        ///  which is implicitly traded to the other pool tokens.
        // That proportion is (1- weightTokenIn)
        // tokenAiAfterFee = tAi * (1 - (1-weightTi) * poolFee);
        uint normalizedWeight = bdiv(tokenWeightIn, totalWeight);
        // Exact fee portion of `tokenAmountIn`, i.e. (1- Wt)
        uint zaz = bmul(bsub(BONE, normalizedWeight), swapFee);
        uint tokenAmountInAfterFee = bmul(tokenAmountIn, bsub(BONE, zaz));

reserves = calcReserves(tokenAmountIn, tokenAmountInAfterFee, reservesRatio);
        uint newTokenBalanceIn = badd(tokenBalanceIn, tokenAmountInAfterFee);
        uint tokenInRatio = bdiv(newTokenBalanceIn, tokenBalanceIn);

//uint newBalTi = poolRatio^(1/weightTi) * balTi;
        uint boo = bdiv(BONE, normalizedWeight);
        uint tokenInRatio = bpow(poolRatio, boo);
        uint newTokenBalanceIn = bmul(tokenInRatio, tokenBalanceIn);
        uint tokenAmountInAfterFee = bsub(newTokenBalanceIn, tokenBalanceIn);
        // Do reverse order of fees charged in joinswap_ExternAmountIn, this way
        //     ``` pAo == joinswap_ExternAmountIn(Ti, joinswap_PoolAmountOut(pAo, Ti)) ```
        //uint tAi = tAiAfterFee / (1 - (1-weightTi) * swapFee) ;
        uint zar = bmul(bsub(BONE, normalizedWeight), swapFee);
        tokenAmountIn = bdiv(tokenAmountInAfterFee, bsub(BONE, zar));
        return tokenAmountIn;
    }

// newBalTo = poolRatio^(1/weightTo) * balTo;
        uint tokenOutRatio = bpow(poolRatio, bdiv(BONE, normalizedWeight));
        uint newTokenBalanceOut = bmul(tokenOutRatio, tokenBalanceOut);

uint tokenAmountOutBeforeSwapFee = bsub(tokenBalanceOut, newTokenBalanceOut);

// charge swap fee on the output token side
        //uint tAo = tAoBeforeSwapFee * (1 - (1-weightTo) * swapFee)
        uint zaz = bmul(bsub(BONE, normalizedWeight), swapFee);
        tokenAmountOut = bmul(tokenAmountOutBeforeSwapFee, bsub(BONE, zaz));
        return tokenAmountOut;
    }

/**********************************************************************************************
    // calcPoolInGivenSingleOut                                                                  //
    // pAi = poolAmountIn               // /               tAo             \\     / wO \     \   //
    // bO = tokenBalanceOut            // | bO - -------------------------- |\   | ---- |     \  //
    // tAo = tokenAmountOut      pS - ||   \     1 - ((1 - (tO / tW)) * sF)/  | ^ \ tW /  * pS | //
    // ps = poolSupply                 \\ -----------------------------------/                /  //
    // wO = tokenWeightOut  pAi =       \\               bO                 /                /   //
    // tW = totalWeight           -------------------------------------------------------------  //
    // sF = swapFee                                        ( 1 - eF )                            //
    // eF = exitFee                                                                              //
    **********************************************************************************************/
    function calcPoolInGivenSingleOut(
        uint tokenBalanceOut,
        uint tokenWeightOut,
        uint poolSupply,
        uint totalWeight,
        uint tokenAmountOut,
        uint swapFee,
        uint reservesRatio
    )
        public pure
        returns (uint poolAmountIn, uint reserves)
    {

// charge swap fee on the output token side
        uint normalizedWeight = bdiv(tokenWeightOut, totalWeight);
        uint zar = bmul(bsub(BONE, normalizedWeight), swapFee);
        uint tokenAmountOutBeforeSwapFee = bdiv(tokenAmountOut, bsub(BONE, zar));
        reserves = calcReserves(tokenAmountOutBeforeSwapFee, tokenAmountOut, reservesRatio);

uint newTokenBalanceOut = bsub(tokenBalanceOut, tokenAmountOutBeforeSwapFee);
        uint tokenOutRatio = bdiv(newTokenBalanceOut, tokenBalanceOut);

// charge exit fee on the pool token side
        // pAi = pAiAfterExitFee/(1-exitFee)
        poolAmountIn = bdiv(poolAmountInAfterExitFee, bsub(BONE, EXIT_FEE));
        return (poolAmountIn, reserves);
    }

// `swapFeeAndReserves = amountWithFee - amountWithoutFee` is the swap fee in balancer.
    // We divide `swapFeeAndReserves` into halves, `actualSwapFee` and `reserves`.
    // `reserves` goes to the admin and `actualSwapFee` still goes to the liquidity
    // providers.
    function calcReserves(uint amountWithFee, uint amountWithoutFee, uint reservesRatio)
        internal pure
        returns (uint reserves)
    {
        require(amountWithFee >= amountWithoutFee, "ERR_MATH_APPROX");
        require(reservesRatio <= BONE, "ERR_INVALID_RESERVE");
        uint swapFeeAndReserves = bsub(amountWithFee, amountWithoutFee);
        reserves = bmul(swapFeeAndReserves, reservesRatio);
        require(swapFeeAndReserves >= reserves, "ERR_MATH_APPROX");
    }

function calcReservesFromFee(uint fee, uint reservesRatio)
        internal pure
        returns (uint reserves)
    {
        require(reservesRatio <= BONE, "ERR_INVALID_RESERVE");
        reserves = bmul(fee, reservesRatio);
    }
}