@pendle/core-v2 1.3.0-mainnet → 1.3.0-testnet

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveFraxUsdcPoolHelper.sol

@@ -8,10 +8,10 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 library CurveFraxUsdcPoolHelper {
     uint256 internal constant N_COINS = 2;
     uint256 internal constant A_PRECISION = 100;
-    uint256 internal constant PRECISION = 10**18;
+    uint256 internal constant PRECISION = 10 ** 18;
     uint256 internal constant RATE_0 = 1000000000000000000;
     uint256 internal constant RATE_1 = 1000000000000000000000000000000;
-    uint256 internal constant FEE_DENOMINATOR = 10**10;
+    uint256 internal constant FEE_DENOMINATOR = 10 ** 10;
 
     address internal constant POOL = 0xDcEF968d416a41Cdac0ED8702fAC8128A64241A2;
     address internal constant LP = 0x3175Df0976dFA876431C2E9eE6Bc45b65d3473CC;
@@ -59,11 +59,10 @@ library CurveFraxUsdcPoolHelper {
         return (total_supply * (D2 - D0)) / D0;
     }
 
-    function _get_D_mem(uint256[N_COINS] memory balances, uint256 _amp)
-        internal
-        pure
-        returns (uint256)
-    {
+    function _get_D_mem(
+        uint256[N_COINS] memory balances,
+        uint256 _amp
+    ) internal pure returns (uint256) {
         uint256[N_COINS] memory _xp;
         _xp[0] = (RATE_0 * balances[0]) / PRECISION;
         _xp[1] = (RATE_1 * balances[1]) / PRECISION;
@@ -117,11 +116,10 @@ library CurveFraxUsdcPoolHelper {
         }
     }
 
-    function _getTokenAmounts(address token, uint256 amount)
-        internal
-        pure
-        returns (uint256[N_COINS] memory res)
-    {
+    function _getTokenAmounts(
+        address token,
+        uint256 amount
+    ) internal pure returns (uint256[N_COINS] memory res) {
         res[token == FRAX ? 0 : 1] = amount;
     }
 }

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveUsdd3CrvPoolHelper.sol

@@ -11,9 +11,9 @@ library CurveUsdd3CrvPoolHelper {
 
     uint256 internal constant N_COINS = 2;
     uint256 internal constant A_PRECISION = 100;
-    uint256 internal constant PRECISION = 10**18;
-    uint256 internal constant rate_multiplier = 10**18;
-    uint256 internal constant FEE_DENOMINATOR = 10**10;
+    uint256 internal constant PRECISION = 10 ** 18;
+    uint256 internal constant rate_multiplier = 10 ** 18;
+    uint256 internal constant FEE_DENOMINATOR = 10 ** 10;
 
     // LP == POOL
     address internal constant POOL = 0xe6b5CC1B4b47305c58392CE3D359B10282FC36Ea;
@@ -25,11 +25,10 @@ library CurveUsdd3CrvPoolHelper {
         balances[1] = ICrvPool(POOL).balances(1);
     }
 
-    function _getTokenAmounts(address token, uint256 amount)
-        internal
-        pure
-        returns (uint256[N_COINS] memory res)
-    {
+    function _getTokenAmounts(
+        address token,
+        uint256 amount
+    ) internal pure returns (uint256[N_COINS] memory res) {
         res[token == USDD ? 0 : 1] = amount;
     }
 
@@ -95,11 +94,10 @@ library CurveUsdd3CrvPoolHelper {
         return get_D(xp, _amp);
     }
 
-    function _xp_mem(uint256[N_COINS] memory _rates, uint256[N_COINS] memory balances)
-        internal
-        pure
-        returns (uint256[N_COINS] memory)
-    {
+    function _xp_mem(
+        uint256[N_COINS] memory _rates,
+        uint256[N_COINS] memory balances
+    ) internal pure returns (uint256[N_COINS] memory) {
         uint256[N_COINS] memory result;
         for (uint256 i = 0; i < N_COINS; ++i) {
             result[i] = (balances[i] * _rates[i]) / PRECISION;
@@ -140,11 +138,9 @@ library CurveUsdd3CrvPoolHelper {
         assert(false);
     }
 
-    function arrayClone(uint256[N_COINS] memory a)
-        internal
-        pure
-        returns (uint256[N_COINS] memory res)
-    {
+    function arrayClone(
+        uint256[N_COINS] memory a
+    ) internal pure returns (uint256[N_COINS] memory res) {
         for (uint256 i = 0; i < N_COINS; ++i) {
             res[i] = a[i];
         }

package/contracts/core/StandardizedYield/implementations/Convex/base/PendleConvexLPSY.sol

@@ -35,11 +35,9 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
         _safeApproveInf(crvLp, BOOSTER);
     }
 
-    function _getPoolInfo(uint256 _cvxPid)
-        internal
-        view
-        returns (address _crvLp, address _cvxRewardManager)
-    {
+    function _getPoolInfo(
+        uint256 _cvxPid
+    ) internal view returns (address _crvLp, address _cvxRewardManager) {
         if (_cvxPid > IBooster(BOOSTER).poolLength()) revert Errors.SYCurveInvalidPid();
 
         (_crvLp, , , _cvxRewardManager, , ) = IBooster(BOOSTER).poolInfo(_cvxPid);
@@ -53,12 +51,10 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
      * If any of the base pool tokens are deposited, it will first add liquidity to the curve pool and mint LP,
      * which will then be deposited into convex
      */
-    function _deposit(address tokenIn, uint256 amount)
-        internal
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
+    function _deposit(
+        address tokenIn,
+        uint256 amount
+    ) internal virtual override returns (uint256 amountSharesOut) {
         if (tokenIn == crvLp) {
             amountSharesOut = amount;
         } else {
@@ -122,13 +118,10 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
                     MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 amountSharesOut) {
         if (tokenIn == crvLp) {
             amountSharesOut = amountTokenToDeposit;
         } else {
@@ -136,13 +129,10 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
         }
     }
 
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        virtual
-        override
-        returns (uint256 amountTokenOut)
-    {
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 amountTokenOut) {
         if (tokenOut == crvLp) {
             amountTokenOut = amountSharesToRedeem;
         } else {
@@ -158,36 +148,30 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
 
     function isValidTokenOut(address token) public view virtual override returns (bool);
 
-    function _depositToCurve(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        virtual
-        returns (uint256);
+    function _depositToCurve(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal virtual returns (uint256);
 
-    function _redeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
-        internal
-        virtual
-        returns (uint256);
+    function _redeemFromCurve(
+        address tokenOut,
+        uint256 amountLpToRedeem
+    ) internal virtual returns (uint256);
 
-    function _previewDepositToCurve(address token, uint256 amountTokenToDeposit)
-        internal
-        view
-        virtual
-        returns (uint256 amountLpOut);
+    function _previewDepositToCurve(
+        address token,
+        uint256 amountTokenToDeposit
+    ) internal view virtual returns (uint256 amountLpOut);
 
-    function _previewRedeemFromCurve(address token, uint256 amountLpToRedeem)
-        internal
-        view
-        virtual
-        returns (uint256 amountTokenOut);
+    function _previewRedeemFromCurve(
+        address token,
+        uint256 amountLpToRedeem
+    ) internal view virtual returns (uint256 amountTokenOut);
 
     function assetInfo()
         external
         view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
     {
         return (AssetType.LIQUIDITY, crvLp, IERC20Metadata(crvLp).decimals());
     }

package/contracts/core/StandardizedYield/implementations/GLP/GLPPreviewHelper.sol

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "../../../../interfaces/GMX/IGMXVault.sol";
+import "../../../../interfaces/GMX/IVaultPriceFeed.sol";
+
+abstract contract GLPPreviewHelper {
+    // Based on Vault functions
+
+    IGMXVault public immutable vault;
+    address internal immutable usdg;
+    uint256 public constant PRICE_PRECISION = 10 ** 30;
+    uint256 public constant BASIS_POINTS_DIVISOR = 10000;
+
+    constructor(address _vaultAddress) {
+        vault = IGMXVault(_vaultAddress);
+        usdg = vault.usdg();
+    }
+
+    function _buyUSDG(address _token, uint256 tokenAmount) internal view returns (uint256) {
+        tokenAmount = __transferIn(_token, tokenAmount);
+        assert(tokenAmount > 0);
+
+        uint256 price = vault.getMinPrice(_token);
+
+        uint256 usdgAmount = (tokenAmount * price) / PRICE_PRECISION;
+        usdgAmount = vault.adjustForDecimals(usdgAmount, _token, usdg);
+        require(usdgAmount > 0, "preview buyUSDG: usdgAmount must be > 0");
+
+        uint256 feeBasisPoints = __getFeeBasisPoints(
+            _token,
+            usdgAmount,
+            0,
+            vault.mintBurnFeeBasisPoints(),
+            vault.taxBasisPoints(),
+            true
+        );
+        uint256 amountAfterFees = __collectSwapFees(_token, tokenAmount, feeBasisPoints);
+        uint256 mintAmount = (amountAfterFees * price) / PRICE_PRECISION;
+        mintAmount = vault.adjustForDecimals(mintAmount, _token, usdg);
+
+        return mintAmount;
+    }
+
+    function _sellUSDG(address _token, uint256 usdgAmount) internal view returns (uint256) {
+        usdgAmount = __transferIn(usdg, usdgAmount);
+        assert(usdgAmount > 0);
+
+        uint256 redemptionAmount = vault.getRedemptionAmount(_token, usdgAmount);
+        require(redemptionAmount > 0, "preview sellUSDG: redemptionAmount must be > 0");
+
+        uint256 feeBasisPoints = __getFeeBasisPoints(
+            _token,
+            usdgAmount,
+            usdgAmount,
+            vault.mintBurnFeeBasisPoints(),
+            vault.taxBasisPoints(),
+            false
+        );
+        uint256 amountOut = __collectSwapFees(_token, redemptionAmount, feeBasisPoints);
+        require(amountOut > 0, "preview sellUSDG: amountOut must be > 0");
+
+        return amountOut;
+    }
+
+    function __transferIn(address _token, uint256 _amount) private view returns (uint256) {
+        uint256 prevBalance = vault.tokenBalances(_token);
+        uint256 nextBalance = IERC20(_token).balanceOf(address(vault)) + _amount;
+
+        return nextBalance - prevBalance;
+    }
+
+    function __collectSwapFees(
+        address /*_token*/,
+        uint256 _amount,
+        uint256 _feeBasisPoints
+    ) private pure returns (uint256) {
+        uint256 afterFeeAmount = (_amount * (BASIS_POINTS_DIVISOR - _feeBasisPoints)) /
+            (BASIS_POINTS_DIVISOR);
+        return afterFeeAmount;
+    }
+
+    function __getFeeBasisPoints(
+        address _token,
+        uint256 _usdgDelta,
+        uint256 _burnedUsdg,
+        uint256 _feeBasisPoints,
+        uint256 _taxBasisPoints,
+        bool _increment
+    ) private view returns (uint256) {
+        if (!vault.hasDynamicFees()) {
+            return _feeBasisPoints;
+        }
+
+        uint256 initialAmount = vault.usdgAmounts(_token);
+        initialAmount = (initialAmount >= _burnedUsdg) ? initialAmount - _burnedUsdg : 0;
+
+        uint256 nextAmount = initialAmount + _usdgDelta;
+        if (!_increment) {
+            nextAmount = _usdgDelta > initialAmount ? 0 : initialAmount - _usdgDelta;
+        }
+
+        uint256 targetAmount = __getTargetUsdgAmount(_token, _burnedUsdg);
+        if (targetAmount == 0) {
+            return _feeBasisPoints;
+        }
+
+        uint256 initialDiff = initialAmount > targetAmount
+            ? initialAmount - targetAmount
+            : targetAmount - initialAmount;
+        uint256 nextDiff = nextAmount > targetAmount
+            ? nextAmount - targetAmount
+            : targetAmount - nextAmount;
+
+        // action improves relative asset balance
+        if (nextDiff < initialDiff) {
+            uint256 rebateBps = (_taxBasisPoints * initialDiff) / targetAmount;
+            return rebateBps > _feeBasisPoints ? 0 : _feeBasisPoints - rebateBps;
+        }
+
+        uint256 averageDiff = (initialDiff + nextDiff) / 2;
+        if (averageDiff > targetAmount) {
+            averageDiff = targetAmount;
+        }
+        uint256 taxBps = (_taxBasisPoints * averageDiff) / targetAmount;
+        return _feeBasisPoints + taxBps;
+    }
+
+    function __getTargetUsdgAmount(
+        address _token,
+        uint256 _burnedUsdg
+    ) private view returns (uint256) {
+        uint256 supply = IERC20(usdg).totalSupply() - _burnedUsdg;
+        if (supply == 0) {
+            return 0;
+        }
+        uint256 weight = vault.tokenWeights(_token);
+        return (weight * supply) / vault.totalTokenWeights();
+    }
+}

package/contracts/core/StandardizedYield/implementations/GLP/PendleGlpSY.sol

@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "./GLPPreviewHelper.sol";
+import "../../../libraries/ArrayLib.sol";
+import "../../../../interfaces/GMX/IRewardRouterV2.sol";
+import "../../../../interfaces/GMX/IGlpManager.sol";
+import "../../../../interfaces/GMX/IGMXVault.sol";
+
+contract PendleGlpSY is SYBaseWithRewards, GLPPreviewHelper {
+    using ArrayLib for address[];
+
+    address public immutable glp;
+    address public immutable stakedGlp;
+    address public immutable rewardRouter;
+    address public immutable glpRouter;
+    address public immutable glpManager;
+    address public immutable weth;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _glp,
+        address _fsGlp,
+        address _stakedGlp,
+        address _rewardRouter,
+        address _glpRouter,
+        address _vault
+    ) SYBaseWithRewards(_name, _symbol, _fsGlp) GLPPreviewHelper(_vault) {
+        glp = _glp;
+        stakedGlp = _stakedGlp;
+        rewardRouter = _rewardRouter;
+        glpRouter = _glpRouter;
+        glpManager = IRewardRouterV2(glpRouter).glpManager();
+        weth = IRewardRouterV2(glpRouter).weth();
+
+        approveAllWhitelisted();
+    }
+
+    function approveAllWhitelisted() public {
+        uint256 length = vault.allWhitelistedTokensLength();
+        for (uint256 i = 0; i < length; ++i) {
+            address token = vault.allWhitelistedTokens(i);
+            if (vault.whitelistedTokens(token)) {
+                _safeApproveInf(token, glpManager);
+            }
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SYBase-_deposit}
+     */
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == stakedGlp) {
+            // GLP is already staked in stakedGlp's transferFrom, called in _transferIn()
+            amountSharesOut = amountDeposited;
+        } else if (tokenIn == NATIVE) {
+            amountSharesOut = IRewardRouterV2(glpRouter).mintAndStakeGlpETH{ value: msg.value }(
+                0,
+                0
+            );
+        } else {
+            amountSharesOut = IRewardRouterV2(glpRouter).mintAndStakeGlp(
+                tokenIn,
+                amountDeposited,
+                0,
+                0
+            );
+        }
+    }
+
+    /**
+     * @dev See {SYBase-_redeem}
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == stakedGlp) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(tokenOut, receiver, amountTokenOut);
+        } else if (tokenOut == NATIVE) {
+            amountTokenOut = IRewardRouterV2(glpRouter).unstakeAndRedeemGlpETH(
+                amountSharesToRedeem,
+                0,
+                payable(receiver)
+            );
+        } else {
+            amountTokenOut = IRewardRouterV2(glpRouter).unstakeAndRedeemGlp(
+                tokenOut,
+                amountSharesToRedeem,
+                0,
+                receiver
+            );
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev 1 SY = 1 GLP
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return Math.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = weth;
+    }
+
+    function _redeemExternalReward() internal override {
+        IRewardRouterV2(rewardRouter).handleRewards(false, false, true, true, false, true, false);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        if (tokenIn == stakedGlp) amountSharesOut = amountTokenToDeposit;
+        else {
+            if (tokenIn == NATIVE) tokenIn = weth;
+
+            // Based on GlpManager's _addLiquidity
+            uint256 aumInUsdg = IGlpManager(glpManager).getAumInUsdg(true);
+            uint256 glpSupply = IERC20(glp).totalSupply();
+            uint256 usdgAmount = super._buyUSDG(tokenIn, amountTokenToDeposit);
+
+            uint256 mintAmount = aumInUsdg == 0
+                ? usdgAmount
+                : (usdgAmount * glpSupply) / aumInUsdg;
+            amountSharesOut = mintAmount;
+        }
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        if (tokenOut == stakedGlp) amountTokenOut = amountSharesToRedeem;
+        else {
+            if (tokenOut == NATIVE) tokenOut = weth;
+
+            // Based on GlpManager's _removeLiquidity
+            uint256 aumInUsdg = IGlpManager(glpManager).getAumInUsdg(false);
+            uint256 glpSupply = IERC20(glp).totalSupply();
+
+            uint256 usdgAmount = (amountSharesToRedeem * aumInUsdg) / glpSupply;
+            uint256 amountOut = super._sellUSDG(tokenOut, usdgAmount);
+
+            amountTokenOut = amountOut;
+        }
+    }
+
+    function _getGlpTokens() internal view returns (address[] memory res) {
+        res = new address[](0);
+        uint256 length = vault.allWhitelistedTokensLength();
+        for (uint256 i = 0; i < length; ++i) {
+            address token = vault.allWhitelistedTokens(i);
+            if (vault.whitelistedTokens(token) && !res.contains(token)) {
+                res = res.append(token);
+            }
+        }
+        res = res.append(stakedGlp);
+        res = res.append(NATIVE);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return _getGlpTokens();
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        return _getGlpTokens();
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == stakedGlp || token == NATIVE || vault.whitelistedTokens(token);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == stakedGlp || token == NATIVE || vault.whitelistedTokens(token);
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.LIQUIDITY, glp, IERC20Metadata(glp).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/GLP/README.md

@@ -0,0 +1,63 @@
+# Audit note GLP SY
+
+Our goal is to support SY for the GLP token of GMX.
+
+The SY supports mint-and-staking GLP with a whitelisted token (ETH, WBTC, etc) or receiving staked GLP from user.
+
+## Overview
+
+- _The main contract_ for the SY is: `PendleGlpSY.sol`.  
+  This contract contains the main logic ofk all SY operations, except GMX's Vault-related logic for preview functions. This part is contained in the abstract preview contract, which is inherited by the main contract.
+
+* _The preview contract_ is: `GMXPreviewHelper.sol`.  
+  This contract simulates the logic of GMX's Vault to preview buying/selling USDG during deposit/redeem.
+
+## About PendleGlpSY
+
+A typical, ordinary SY contract.
+
+- _Constructor_: Initialize global variables and approve whitelisted tokens to GMX's GlpManager, which would pull tokens in from the SY contract when minting GLP.
+  - There are two routers: _rewardRouter_ is used for claiming rewards,, _glpRouter_ is used to deposit/redeem; hence the two global router variables.
+- _Deposit_:
+  - In case of receiving staked GLP, then staked GLP is already pulled in with \_transferIn() in SYBase.
+    **Note:** StakedGLP (sGLP) is a helper contract by GMX for users to transfer their staked GLP between each other, where staking and unstaking happen behind the scenes. It is not an ERC20 token, but it behaves similar enough to one so that we treat it is ERC20 in the contract.
+  - Otherwise, use GlpRewardRouter to mint and stake.
+- _Redeem_: Same as deposit, reversed. If user redeems in staked GLP, \_transferOut() is used for staked GLP.
+- _Exchange rate_: The SY directly wraps GLP, so the exchange rate is always 1.
+- _Preview deposit_: Mimics the logic of _\_addLiquidity()_ in GMX's GlpManager. The functions needs to preview _buyUSDG()_ of GMX's Vault, which is mimicked in GMXPreviewHelper.
+- _Preview redeem_: Mimics the logic of _\_removeLiquidity()_ in GMX's GlpManager. The functions needs to preview _sellUSDG()_ of GMX's Vault, which is also mimicked in GMXPreviewHelper.
+- _Get tokens in/out_: Queries whitelisted tokens from GMX's Vault, then return them along with staked GLP and native ETH.
+- _Check valid token in/out_: Calls _whitelistedTokens()_ from GMX's Vault to check.
+
+## About GMXPreviewHelper
+
+This contract's purpose is to support preview for _buyUSDG()_ and _sellUSDG()_ functions from GMX's Vault. The contracts has two view functions _buyUSDG()_ and _sellUSDG()_ which mimics their respective Vault counterpart's logic.
+
+About _buyUSDG()_:
+
+- First, _tokenAmount_ is calculated with \_transferIn(), which should give the same as the corresponding Vault function.
+- _updateCumulativeFundingRate()_ in Vault should not impact amount out, so this is ignored.
+- For _price_ and _usdgAmount_, the Vault view functions used in Vault's buyUSDG() should behave the same as during actual redeeming, so they are called directly from Vault.
+- For _feeBasisPoints_, _getFeeBasisPoints()_ also behave the same as Vault, becacuse the extra parameter _\_burnedUsdg_ = 0 which has no affect on the return value.
+- For _amountAfterFees_, see _\_collectSwapFees()_ below.
+- Finally, _mintAmount_ is calculated normally.
+
+About _sellUSDG()_:
+
+- Again, first _usdgAmount_ is calculated.
+- _updateCumulativeFundingRate()_ in Vault should not impact amount out, so this is ignored.
+- We directly call Vault's getRedemptionAmount() to calculate _redemptionAmount_. Although _useSwapPricing_ is set to true earlier in Vault's _sellUSDG()_, and _getRedemptionAmount()_ calls _getMaxPrice()_, which then calls priceFeed's _getPrice()_ with _useSwapPricing_ as a parameter, this parameter is then ignored in _getPrice()_. So we can ignore _useSwapPricing_, and Vault's _getRedemptionAmount()_ called in preview should behave the same as actual redeem.
+- Next, _decreaseUsdgAmount() and USDG's \_burn()_ are called. This affects USDG balances, which would later affect _getFeeBasisPoints()_.
+- _poolAmounts_ and _tokenBalances_ should not affect the amount out, so _\_decreasePoolAmount()_ and _\_updateTokenBalance()_ are ignored.
+- For _feeBasisPoints_, we need _getFeeBasisPoints()_. But _usdgAmounts[\_token]_ has been decreased by _usdgAmount_, so we account for this by adding parameter _\_burnedUsdg_ in our "fake" _getFeeBasisPoints()_.
+- Finally, _amountOut_ is calculated with _\_collectSwapFees()_.
+
+Other helper functions:
+
+- _\_transferIn()_: Mimics Vault's counterpart, should return the same value.
+- _\_collectSwapFees()_: In Vault, this function only changes _feeReserves_ which does not affect deposit/redeem, so we only need the _afterFeeAmount_.
+- _getFeeBasisPoints()_: Since USDG balances are affected in _sellUSDG()_, another parameter _\_burnedUsdg_ is introduced to account for this decrease in USDG. Namely, this affects:
+  - _initialAmount_: The new _usdgAmount[\_token]_ is different, which is calculated here similar to Vault's decreaseUsdgAmount().
+  - _getTargetUsdgAmount()_: The formula for the target amount concerns the total supply of USDG, which is affected by _burn()_ in _sellUSDG()_. This is accounted for in our "fake" _getTargetUsdgAmount()_, which takes _\_burnedUsdg_ as parameter and uses it to calculate the real _supply_.
+
+In our tests, all - intermediate and final return - values perfectly matches between Vault's functions and our replicas.