比較文本

尋找兩個文字檔案之間的差異

即時編輯器

摺疊未變更行

關閉換行

檢視

比對精度

語法突出顯示

Diffchecker Desktop 執行Diffchecker最安全的方式。取得Diffchecker桌面應用程式：您的差異永遠不會離開您的電腦！取得桌面版

BMath.sol

建立於 6 年前差異永不過期

17 刪除

行
總計
刪除

字符
總計
刪除

要繼續使用此功能，請升級到 Diffchecker Pro 查看價格

272 行

51 新增

行
總計
新增

字符
總計
新增

要繼續使用此功能，請升級到 Diffchecker Pro 查看價格

299 行

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

}

已保存差異

原始文本

開啟檔案

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

}

更改後文本

開啟檔案

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