Texte vergleichen

Finde den Unterschied zwischen zwei Textdateien

Live-Editor

Gleiches ausblenden

Zeilenumbruch aus

Ansicht

Vergleichsgenauigkeit

Syntaxhervorhebung

Diffchecker Desktop Der sicherste Weg, Diffchecker zu nutzen. Hol dir die Desktop-App: Deine Diffs verlassen nie deinen Computer!Desktop holen

BMath.sol

Erstellt vor 6 JahrenDiff läuft nie ab

17 Entfernungen

Zeilen
Gesamt
Entfernt

Zeichen
Gesamt
Entfernt

Um diese Funktion weiterhin zu nutzen, aktualisiere auf Diffchecker Pro Preise anzeigen

272 Zeilen

51 Hinzufügungen

Zeilen
Gesamt
Hinzugefügt

Zeichen
Gesamt
Hinzugefügt

Um diese Funktion weiterhin zu nutzen, aktualisiere auf Diffchecker Pro Preise anzeigen

299 Zeilen

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

}

Gespeicherte Diffs

Originaltext

Datei öffnen

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

}

Bearbeitung

Datei öffnen

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