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

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/PendleAuraBalancerStableLPSY.sol

@@ -0,0 +1,329 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import "../../../../../interfaces/Balancer/IVault.sol";
+import "../../../../../interfaces/Balancer/IRateProvider.sol";
+import "../../../../../interfaces/Balancer/IBasePool.sol";
+import "../../../../../interfaces/Balancer/IBalancerStablePreview.sol";
+import "../../../../../interfaces/ConvexCurve/IBooster.sol";
+import "../../../../../interfaces/ConvexCurve/IRewards.sol";
+
+import "./StablePoolUserData.sol";
+import "../../../../libraries/ArrayLib.sol";
+import "../../../SYBaseWithRewards.sol";
+
+abstract contract PendleAuraBalancerStableLPSY is SYBaseWithRewards {
+    using ArrayLib for address[];
+
+    address public constant BAL_TOKEN = 0xba100000625a3754423978a60c9317c58a424e3D;
+    address public constant AURA_TOKEN = 0xC0c293ce456fF0ED870ADd98a0828Dd4d2903DBF;
+    address public constant AURA_BOOSTER = 0xA57b8d98dAE62B26Ec3bcC4a365338157060B234;
+    address public constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
+
+    address public immutable balLp;
+    bytes32 public immutable balPoolId;
+
+    uint256 public immutable auraPid;
+    address public immutable auraRewardManager;
+
+    IBalancerStablePreview public immutable previewHelper;
+
+    address[] public extraRewards;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _balLp,
+        uint256 _auraPid,
+        IBalancerStablePreview _previewHelper
+    ) SYBaseWithRewards(_name, _symbol, _balLp) {
+        balPoolId = IBasePool(_balLp).getPoolId();
+        auraPid = _auraPid;
+
+        (balLp, auraRewardManager) = _getPoolInfo(_auraPid);
+        if (balLp != _balLp) revert Errors.SYBalancerInvalidPid();
+
+        _safeApproveInf(_balLp, AURA_BOOSTER);
+
+        address[] memory tokens = _getPoolTokenAddresses();
+        for (uint256 i = 0; i < tokens.length; ++i) {
+            _safeApproveInf(tokens[i], BALANCER_VAULT);
+        }
+
+        previewHelper = _previewHelper;
+    }
+
+    function _getPoolInfo(uint256 _auraPid)
+        internal
+        view
+        returns (address _auraLp, address _auraRewardManager)
+    {
+        if (_auraPid > IBooster(AURA_BOOSTER).poolLength()) revert Errors.SYBalancerInvalidPid();
+        (_auraLp, , , _auraRewardManager, , ) = IBooster(AURA_BOOSTER).poolInfo(_auraPid);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Either wraps LP, or also joins pool using exact tokenIn
+     */
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == balLp) {
+            amountSharesOut = amount;
+        } else {
+            amountSharesOut = _depositToBalancer(tokenIn, amount);
+        }
+        IBooster(AURA_BOOSTER).deposit(auraPid, amountSharesOut, true);
+    }
+
+    /**
+     * @notice Either unwraps LP, or also exits pool using exact LP for only `tokenOut`
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        IRewards(auraRewardManager).withdrawAndUnwrap(amountSharesToRedeem, false);
+
+        if (tokenOut == balLp) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(tokenOut, receiver, amountTokenOut);
+        } else {
+            amountTokenOut = _redeemFromBalancer(receiver, tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function exchangeRate() external view override returns (uint256) {
+        return IRateProvider(balLp).getRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    BALANCER-RELATED FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function _depositToBalancer(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        virtual
+        returns (uint256)
+    {
+        IVault.JoinPoolRequest memory request = _assembleJoinRequest(
+            tokenIn,
+            amountTokenToDeposit
+        );
+        IVault(BALANCER_VAULT).joinPool(balPoolId, address(this), address(this), request);
+
+        // amount shares out = amount LP received
+        return _selfBalance(balLp);
+    }
+
+    function _assembleJoinRequest(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        returns (IVault.JoinPoolRequest memory request)
+    {
+        // max amounts in
+        address[] memory assets = _getPoolTokenAddresses();
+
+        uint256 amountsLength = _getBPTIndex() < type(uint256).max
+            ? assets.length - 1
+            : assets.length;
+
+        uint256[] memory amountsIn = new uint256[](amountsLength);
+        uint256[] memory maxAmountsIn = new uint256[](assets.length);
+
+        uint256 index = assets.find(tokenIn);
+        uint256 indexSkipBPT = index > _getBPTIndex() ? index - 1 : index;
+        maxAmountsIn[index] = amountsIn[indexSkipBPT] = amountTokenToDeposit;
+
+        // encode user data
+        StablePoolUserData.JoinKind joinKind = StablePoolUserData
+            .JoinKind
+            .EXACT_TOKENS_IN_FOR_BPT_OUT;
+        uint256 minimumBPT = 0;
+
+        bytes memory userData = abi.encode(joinKind, amountsIn, minimumBPT);
+
+        // assemble joinpoolrequest
+        request = IVault.JoinPoolRequest(assets, maxAmountsIn, userData, false);
+    }
+
+    function _redeemFromBalancer(
+        address receiver,
+        address tokenOut,
+        uint256 amountLpToRedeem
+    ) internal virtual returns (uint256) {
+        uint256 balanceBefore = IERC20(tokenOut).balanceOf(receiver);
+
+        IVault.ExitPoolRequest memory request = _assembleExitRequest(tokenOut, amountLpToRedeem);
+        IVault(BALANCER_VAULT).exitPool(balPoolId, address(this), payable(receiver), request);
+
+        // calculate amount of tokens out
+        uint256 balanceAfter = IERC20(tokenOut).balanceOf(receiver);
+        return balanceAfter - balanceBefore;
+    }
+
+    function _assembleExitRequest(address tokenOut, uint256 amountLpToRedeem)
+        internal
+        view
+        virtual
+        returns (IVault.ExitPoolRequest memory request)
+    {
+        address[] memory assets = _getPoolTokenAddresses();
+        uint256[] memory minAmountsOut = new uint256[](assets.length);
+
+        // encode user data
+        StablePoolUserData.ExitKind exitKind = StablePoolUserData
+            .ExitKind
+            .EXACT_BPT_IN_FOR_ONE_TOKEN_OUT;
+        uint256 bptAmountIn = amountLpToRedeem;
+        uint256 exitTokenIndex = assets.find(tokenOut);
+
+        // must drop BPT index as well
+        exitTokenIndex = _getBPTIndex() < exitTokenIndex ? exitTokenIndex - 1 : exitTokenIndex;
+
+        bytes memory userData = abi.encode(exitKind, bptAmountIn, exitTokenIndex);
+
+        // assemble exitpoolrequest
+        request = IVault.ExitPoolRequest(assets, minAmountsOut, userData, false);
+    }
+
+    /// @dev this should return tokens in the same order as `IVault.getPoolTokens()`
+    function _getPoolTokenAddresses() internal view virtual returns (address[] memory res);
+
+    /// @dev should be overriden if and only if BPT is one of the pool tokens
+    function _getBPTIndex() internal view virtual returns (uint256) {
+        return type(uint256).max;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                   PREVIEW FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == balLp) {
+            amountSharesOut = amountTokenToDeposit;
+        } else {
+            IVault.JoinPoolRequest memory request = _assembleJoinRequest(
+                tokenIn,
+                amountTokenToDeposit
+            );
+            amountSharesOut = previewHelper.joinPoolPreview(
+                balPoolId,
+                address(this),
+                address(this),
+                request,
+                _getImmutablePoolData()
+            );
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == balLp) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            IVault.ExitPoolRequest memory request = _assembleExitRequest(
+                tokenOut,
+                amountSharesToRedeem
+            );
+
+            amountTokenOut = previewHelper.exitPoolPreview(
+                balPoolId,
+                address(this),
+                address(this),
+                request,
+                _getImmutablePoolData()
+            );
+        }
+    }
+
+    function _getImmutablePoolData() internal view virtual returns (bytes memory);
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice allows owner to add new reward tokens in in case Aura does so with their pools
+    function addRewardTokens(address token) external virtual onlyOwner {
+        if (token == BAL_TOKEN || token == AURA_TOKEN || extraRewards.contains(token))
+            revert Errors.SYInvalidRewardToken(token);
+
+        uint256 nRewardsAura = IRewards(auraRewardManager).extraRewardsLength();
+        for (uint256 i = 0; i < nRewardsAura; i++) {
+            if (token == IRewards(IRewards(auraRewardManager).extraRewards(i)).rewardToken()) {
+                extraRewards.push(token);
+                return;
+            }
+        }
+
+        revert Errors.SYInvalidRewardToken(token);
+    }
+
+    function extraRewardsLength() external view virtual returns (uint256) {
+        return extraRewards.length;
+    }
+
+    function _getRewardTokens() internal view virtual override returns (address[] memory res) {
+        uint256 extraRewardsLen = extraRewards.length;
+        res = new address[](2 + extraRewardsLen);
+        res[0] = BAL_TOKEN;
+        res[1] = AURA_TOKEN;
+        for (uint256 i = 0; i < extraRewardsLen; i++) {
+            res[2 + i] = extraRewards[i];
+        }
+    }
+
+    /// @dev if there is no extra rewards, we can call getReward with the 2nd arg (_claimExtra) to be false
+    /// which helps save even more gas
+    function _redeemExternalReward() internal virtual override {
+        uint256 extraRewardsLen = extraRewards.length;
+        if (extraRewardsLen == 0) IRewards(auraRewardManager).getReward(address(this), false);
+        else IRewards(auraRewardManager).getReward(address(this), true);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function getTokensIn() public view virtual override returns (address[] memory res);
+
+    function getTokensOut() public view virtual override returns (address[] memory res);
+
+    function isValidTokenIn(address token) public view virtual override returns (bool);
+
+    function isValidTokenOut(address token) public view virtual override returns (bool);
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.LIQUIDITY, balLp, IERC20Metadata(balLp).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/StablePoolUserData.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+library StablePoolUserData {
+    enum JoinKind {
+        INIT,
+        EXACT_TOKENS_IN_FOR_BPT_OUT,
+        TOKEN_IN_FOR_EXACT_BPT_OUT
+    }
+    enum ExitKind {
+        EXACT_BPT_IN_FOR_ONE_TOKEN_OUT,
+        BPT_IN_FOR_EXACT_TOKENS_OUT
+    }
+
+    function exactTokensInForBptOut(bytes memory self)
+        internal
+        pure
+        returns (uint256[] memory amountsIn, uint256 minBPTAmountOut)
+    {
+        (, amountsIn, minBPTAmountOut) = abi.decode(self, (JoinKind, uint256[], uint256));
+    }
+
+    function exactBptInForTokenOut(bytes memory self)
+        internal
+        pure
+        returns (uint256 bptAmountIn, uint256 tokenIndex)
+    {
+        (, bptAmountIn, tokenIndex) = abi.decode(self, (ExitKind, uint256, uint256));
+    }
+}

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/StablePreviewBase.sol

@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "../../../../../interfaces/Balancer/IVault.sol";
+import "../../../../../interfaces/Balancer/IBalancerFees.sol";
+import "../../../../../interfaces/Balancer/IBalancerStablePreview.sol";
+
+abstract contract StablePreviewBase is IBalancerStablePreview {
+    address internal constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
+    address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+    address internal constant FEE_COLLECTOR = 0xce88686553686DA562CE7Cea497CE749DA109f9F;
+
+    enum PoolBalanceChangeKind {
+        JOIN,
+        EXIT
+    }
+
+    struct PoolBalanceChange {
+        IAsset[] assets;
+        uint256[] limits;
+        bytes userData;
+        bool useInternalBalance;
+    }
+
+    function joinPoolPreview(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        IVault.JoinPoolRequest memory request,
+        bytes memory data
+    ) external view returns (uint256 amountBptOut) {
+        amountBptOut = _joinOrExit(
+            PoolBalanceChangeKind.JOIN,
+            poolId,
+            sender,
+            payable(recipient),
+            _toPoolBalanceChange(request),
+            data
+        );
+    }
+
+    function exitPoolPreview(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        IVault.ExitPoolRequest memory request,
+        bytes memory data
+    ) external view returns (uint256 amountTokenOut) {
+        amountTokenOut = _joinOrExit(
+            PoolBalanceChangeKind.EXIT,
+            poolId,
+            sender,
+            recipient,
+            _toPoolBalanceChange(request),
+            data
+        );
+    }
+
+    function _joinOrExit(
+        PoolBalanceChangeKind kind,
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        PoolBalanceChange memory change,
+        bytes memory data
+    ) private view returns (uint256 amountBptOrTokensOut) {
+        IERC20[] memory tokens = _translateToIERC20(change.assets);
+        (uint256[] memory balances, uint256 lastChangeBlock) = _validateTokensAndGetBalances(
+            poolId,
+            tokens
+        );
+
+        amountBptOrTokensOut = _callPoolBalanceChange(
+            kind,
+            poolId,
+            sender,
+            recipient,
+            change,
+            balances,
+            lastChangeBlock,
+            data
+        );
+    }
+
+    function _callPoolBalanceChange(
+        PoolBalanceChangeKind kind,
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        PoolBalanceChange memory change,
+        uint256[] memory balances,
+        uint256 lastChangeBlock,
+        bytes memory data
+    ) private view returns (uint256 amountsChanged) {
+        if (kind == PoolBalanceChangeKind.JOIN) {
+            amountsChanged = onJoinPool(
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                _getProtocolSwapFeePercentage(),
+                change.userData,
+                data
+            );
+        } else {
+            amountsChanged = onExitPool(
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                _getProtocolSwapFeePercentage(),
+                change.userData,
+                data
+            );
+        }
+    }
+
+    function _getProtocolSwapFeePercentage() private view returns (uint256) {
+        return IBalancerFees(FEE_COLLECTOR).getSwapFeePercentage();
+    }
+
+    function _validateTokensAndGetBalances(
+        bytes32 poolId,
+        IERC20[] memory //expectedTokens
+    ) private view returns (uint256[] memory, uint256) {
+        (, uint256[] memory balances, uint256 lastChangeBlock) = IVault(BALANCER_VAULT)
+            .getPoolTokens(poolId);
+        return (balances, lastChangeBlock);
+    }
+
+    function _translateToIERC20(IAsset[] memory assets) internal pure returns (IERC20[] memory) {
+        IERC20[] memory tokens = new IERC20[](assets.length);
+        for (uint256 i = 0; i < assets.length; ++i) {
+            tokens[i] = _translateToIERC20(assets[i]);
+        }
+        return tokens;
+    }
+
+    function _translateToIERC20(IAsset asset) internal pure returns (IERC20) {
+        return address(asset) == address(0) ? IERC20(WETH) : IERC20(address(asset));
+    }
+
+    function _toPoolBalanceChange(IVault.JoinPoolRequest memory request)
+        private
+        pure
+        returns (PoolBalanceChange memory change)
+    {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            change := request
+        }
+    }
+
+    function _toPoolBalanceChange(IVault.ExitPoolRequest memory request)
+        private
+        pure
+        returns (PoolBalanceChange memory change)
+    {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            change := request
+        }
+    }
+
+    function onJoinPool(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        uint256[] memory balances,
+        uint256 lastChangeBlock,
+        uint256 protocolSwapFeePercentage,
+        bytes memory userData,
+        bytes memory data
+    ) internal view virtual returns (uint256 bptAmountOut);
+
+    function onExitPool(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        uint256[] memory balances,
+        uint256 lastChangeBlock,
+        uint256 protocolSwapFeePercentage,
+        bytes memory userData,
+        bytes memory data
+    ) internal view virtual returns (uint256 amountTokenOut);
+}

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

@@ -0,0 +1,142 @@
+// 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();
+    }
+}