Comparar texto

Encuentra la diferencia entre dos archivos de texto

Editor live

Ocultar sin cambios

Sin ajuste de línea

Vista

Nivel de detalle

Resaltado de sintaxis

Diffchecker Desktop La forma más segura de usar Diffchecker. ¡Obtén la app de Diffchecker Desktop: tus diffs nunca salen de tu computadora!Obtener Desktop

BMath.sol

Creado hace 6 añosEl diff nunca expira

17 eliminaciones

Líneas
Total
Eliminado

Caracteres
Total
Eliminado

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

272 líneas

51 adiciones

Líneas
Total
Añadido

Caracteres
Total
Añadido

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

299 líneas

// 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);

}

Diferencias guardadas

Texto original

Abrir archivo

// 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;
    }

}

Texto modificado

Abrir archivo

// 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);
    }
}