@pendle/core-v2 5.2.3-beta-2 → 5.2.4

package/contracts/core/StandardizedYield/implementations/Thena/PendleThenaSY.sol

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "./ThenaLpHelper.sol";
+import "../../../../interfaces/IPPreviewHelper.sol";
+import "../../../../interfaces/Thena/IThenaGaugeV2.sol";
+import "../../../libraries/ArrayLib.sol";
+
+contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
+    event SetNewBinarySearchEps(uint256 newEps);
+    event AddExternalRewardToken(address indexed token);
+
+    using PMath for uint256;
+    using ArrayLib for address[];
+
+    address[] public externalRewardTokens;
+    address public immutable gauge;
+    address public immutable THENA;
+    IPPreviewHelper public immutable previewHelper;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _pair,
+        address _factory,
+        address _router,
+        address _gauge,
+        address _THENA,
+        IPPreviewHelper _previewHelper
+    ) SYBaseWithRewards(_name, _symbol, _pair) ThenaLpHelper(_pair, _factory, _router) {
+        THENA = _THENA;
+        gauge = _gauge;
+        previewHelper = _previewHelper;
+        _safeApproveInf(_pair, _gauge);
+    }
+
+    /**
+     * @dev See {SYBase-_deposit}
+     */
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountLpDeposited) {
+        _withdrawAllFromGauge();
+        if (tokenIn == pair) {
+            amountLpDeposited = amountDeposited;
+        } else {
+            amountLpDeposited = _zapIn(tokenIn, amountDeposited);
+        }
+        _depositToGaugeIfNotEmergency();
+    }
+
+    /**
+     * @dev See {SYBase-_redeem}
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        _withdrawAllFromGauge();
+        if (tokenOut == pair) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            amountTokenOut = _zapOut(tokenOut, amountSharesToRedeem);
+        }
+        _transferOut(tokenOut, receiver, amountTokenOut);
+        _depositToGaugeIfNotEmergency();
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view virtual override returns (address[] memory res) {
+        res = new address[](1 + externalRewardTokens.length);
+        res[0] = THENA;
+        for (uint256 i = 1; i < res.length; ++i) {
+            res[i] = externalRewardTokens[i - 1];
+        }
+    }
+
+    function _redeemExternalReward() internal override {
+        IThenaGaugeV2(gauge).getReward();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    PREVIEW-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
+        if (tokenIn == pair) {
+            return amountTokenToDeposit;
+        } else {
+            return previewHelper.previewDeposit(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem) internal view override returns (uint256) {
+        if (tokenOut == pair) {
+            return amountSharesToRedeem;
+        } else {
+            return previewHelper.previewRedeem(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = token0;
+        res[1] = token1;
+        res[2] = pair;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = token0;
+        res[1] = token1;
+        res[2] = pair;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == token0 || token == token1 || token == pair;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == token0 || token == token1 || token == pair;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.LIQUIDITY, pair, IERC20Metadata(pair).decimals());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        REWARD RELATED FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function _withdrawAllFromGauge() internal {
+        if (IThenaGaugeV2(gauge).balanceOf(address(this)) == 0) {
+            return;
+        }
+
+        if (IThenaGaugeV2(gauge).emergency()) {
+            IThenaGaugeV2(gauge).emergencyWithdraw();
+        } else {
+            IThenaGaugeV2(gauge).withdrawAll();
+        }
+    }
+
+    function _depositToGaugeIfNotEmergency() internal {
+        if (!IThenaGaugeV2(gauge).emergency()) {
+            IThenaGaugeV2(gauge).depositAll();
+        }
+    }
+
+    function setBinarySearchEps(uint256 newEps) external onlyOwner {
+        require(newEps > 0 && newEps < 1e18, "invalid newEps");
+        binarySearchEps = newEps;
+
+        emit SetNewBinarySearchEps(newEps);
+    }
+
+    function addExternalRewardToken(address token) external onlyOwner {
+        // prevent adding THE as well
+        require(!_getRewardTokens().contains(token), "rewardToken existed");
+        externalRewardTokens.push(token);
+
+        emit AddExternalRewardToken(token);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Thena/ThenaLpHelper.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import "../../../../interfaces/Thena/IThenaPair.sol";
+import "../../../../interfaces/Thena/IThenaRouter.sol";
+import "../../../../interfaces/Thena/IThenaFactory.sol";
+import "../../../libraries/TokenHelper.sol";
+import "../../../libraries/math/PMath.sol";
+import "./ThenaMath.sol";
+
+abstract contract ThenaLpHelper is TokenHelper, ThenaMath {
+    address public immutable factory;
+    address public immutable pair;
+
+    bool public immutable isStable;
+    address public immutable token0;
+    address public immutable token1;
+    uint256 public immutable decimals0;
+    uint256 public immutable decimals1;
+    address public immutable router;
+
+    constructor(address _pair, address _factory, address _router) {
+        factory = _factory;
+        pair = _pair;
+        router = _router;
+
+        isStable = IThenaPair(pair).isStable();
+        token0 = IThenaPair(pair).token0();
+        token1 = IThenaPair(pair).token1();
+        decimals0 = 10 ** IERC20Metadata(token0).decimals();
+        decimals1 = 10 ** IERC20Metadata(token1).decimals();
+
+        _safeApproveInf(token0, router);
+        _safeApproveInf(token1, router);
+        _safeApproveInf(pair, router);
+    }
+
+    /**
+     * ==================================================================
+     *                      ZAP ACTION RELATED
+     * ==================================================================
+     */
+    function _zapIn(address tokenIn, uint256 amountIn) internal returns (uint256) {
+        (uint256 amount0ToAddLiq, uint256 amount1ToAddLiq) = _swapZapIn(tokenIn, amountIn);
+        return _addLiquidity(amount0ToAddLiq, amount1ToAddLiq);
+    }
+
+    function _zapOut(address tokenOut, uint256 amountLpIn) internal returns (uint256) {
+        (uint256 amount0, uint256 amount1) = _removeLiquidity(amountLpIn);
+        if (tokenOut == token0) {
+            return amount0 + _swap(token1, amount1);
+        } else {
+            return amount1 + _swap(token0, amount0);
+        }
+    }
+
+    function _swapZapIn(
+        address tokenIn,
+        uint256 amountIn
+    ) private returns (uint256 amount0ToAddLiq, uint256 amount1ToAddLiq) {
+        ThenaData memory data = _getNormalizedThenaData(tokenIn);
+        if (tokenIn == token0) {
+            uint256 amount0ToSwap = _getZapInSwapAmount(data, tokenIn, amountIn);
+            amount0ToAddLiq = amountIn - amount0ToSwap;
+            amount1ToAddLiq = _swap(token0, amount0ToSwap);
+        } else {
+            uint256 amount1ToSwap = _getZapInSwapAmount(data, tokenIn, amountIn);
+            amount0ToAddLiq = _swap(token1, amount1ToSwap);
+            amount1ToAddLiq = amountIn - amount1ToSwap;
+        }
+    }
+
+    /**
+     * ==================================================================
+     *                      CAMELOT ROUTER RELATED
+     * ==================================================================
+     */
+
+    function _addLiquidity(uint256 amount0ToAddLiq, uint256 amount1ToAddLiq) private returns (uint256 amountLpOut) {
+        (, , amountLpOut) = IThenaRouter(router).addLiquidity(
+            token0,
+            token1,
+            isStable,
+            amount0ToAddLiq,
+            amount1ToAddLiq,
+            0,
+            0,
+            address(this),
+            block.timestamp
+        );
+    }
+
+    function _removeLiquidity(uint256 amountLpToRemove) private returns (uint256 amountTokenA, uint256 amountTokenB) {
+        return
+            IThenaRouter(router).removeLiquidity(
+                token0,
+                token1,
+                isStable,
+                amountLpToRemove,
+                0,
+                0,
+                address(this),
+                block.timestamp
+            );
+    }
+
+    function _swap(address tokenIn, uint256 amountTokenIn) private returns (uint256) {
+        address tokenOut = tokenIn == token0 ? token1 : token0;
+        uint256 preBalance = _selfBalance(tokenOut);
+
+        IThenaRouter(router).swapExactTokensForTokensSimple(
+            amountTokenIn,
+            0,
+            tokenIn,
+            tokenOut,
+            isStable,
+            address(this),
+            block.timestamp
+        );
+
+        return _selfBalance(tokenOut) - preBalance;
+    }
+
+    /**
+     * ==================================================================
+     *                      CAMELOT PAIR DATA READ
+     * ==================================================================
+     */
+
+    function _getNormalizedThenaData(address tokenIn) internal view returns (ThenaData memory data) {
+        data.pair = pair;
+        data.isStable = isStable;
+        data.fee = IThenaFactory(factory).getFee(data.isStable);
+        (data.reserve0, data.reserve1, ) = IThenaPair(pair).getReserves();
+
+        if (data.isStable) {
+            // if not stable, skip reading these data
+            data.decimals0 = decimals0;
+            data.decimals1 = decimals1;
+        }
+
+        // Normalize token order
+        if (tokenIn == token1) {
+            (data.reserve0, data.reserve1) = (data.reserve1, data.reserve0);
+            (data.decimals0, data.decimals1) = (data.decimals1, data.decimals0);
+        }
+    }
+}

package/contracts/core/StandardizedYield/implementations/Thena/ThenaMath.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import "../../../libraries/math/PMath.sol";
+import "../../../../interfaces/Thena/IThenaPair.sol";
+
+abstract contract ThenaMath {
+    using PMath for uint256;
+
+    struct ThenaData {
+        address pair;
+        bool isStable;
+        uint256 reserve0;
+        uint256 reserve1;
+        uint256 fee;
+        uint256 decimals0;
+        uint256 decimals1;
+    }
+
+    struct StableBinarySearchParams {
+        uint256 guessMin;
+        uint256 guessMax;
+        uint256 amountSwapIn;
+        uint256 newReserve0;
+        uint256 newReserve1;
+        uint256 amount0ToAddLiq;
+        uint256 amount1ToAddLiq;
+    }
+
+    uint256 internal constant FEE_DENOMINATOR = 10000;
+    uint256 internal constant ONE = 1 * FEE_DENOMINATOR;
+    uint256 internal constant TWO = 2 * FEE_DENOMINATOR;
+    uint256 internal constant FOUR = 4 * FEE_DENOMINATOR;
+    uint256 internal constant DEFAULT_BINARY_SEARCH_EPS = 1e14; // 0.01% accuracy
+
+    uint256 public binarySearchEps = DEFAULT_BINARY_SEARCH_EPS;
+
+    function _getZapInSwapAmount(
+        ThenaData memory data,
+        address tokenIn,
+        uint256 amountIn
+    ) internal view returns (uint256) {
+        return data.isStable ? _getStableZapAmount(data, tokenIn, amountIn) : _getVolatileZapAmount(data, amountIn);
+    }
+
+    function _getVolatileZapAmount(ThenaData memory data, uint256 amountIn) private pure returns (uint256) {
+        uint256 numer0 = ((TWO - FEE_DENOMINATOR) * data.reserve0) / FEE_DENOMINATOR;
+        uint256 numer1 = PMath.square(numer0);
+        uint256 numer2 = 4 * PMath.square(ONE - data.fee) * amountIn * data.reserve0;
+
+        uint256 numer = PMath.sqrt(numer1 + numer2) - numer0;
+        uint256 denom = 2 * PMath.square(ONE - data.fee);
+
+        return (numer * FEE_DENOMINATOR) / denom;
+    }
+
+    function _getStableZapAmount(
+        ThenaData memory data,
+        address tokenIn,
+        uint256 amountIn
+    ) private view returns (uint256) {
+        StableBinarySearchParams memory params = _prepareStableBinarySearchParams(amountIn, data);
+
+        while (!PMath.isAApproxB(params.guessMin, params.guessMax, binarySearchEps)) {
+            params.amountSwapIn = (params.guessMax + params.guessMin) / 2;
+            params.amount1ToAddLiq = IThenaPair(data.pair).getAmountOut(params.amountSwapIn, tokenIn);
+
+            params.newReserve0 = _getReserveAfterSwap(params.amountSwapIn, data.reserve0, data.fee);
+            params.newReserve1 = data.reserve1 - params.amount1ToAddLiq;
+            params.amount0ToAddLiq = amountIn - params.amountSwapIn;
+
+            if (params.amount0ToAddLiq * params.newReserve1 < params.amount1ToAddLiq * params.newReserve0) {
+                params.guessMax = params.amountSwapIn - 1; // need swap less
+            } else {
+                params.guessMin = params.amountSwapIn + 1; // swap more
+            }
+        }
+        return params.guessMin;
+    }
+
+    function _prepareStableBinarySearchParams(
+        uint256 amountIn,
+        ThenaData memory data
+    ) private pure returns (StableBinarySearchParams memory params) {
+        uint256 X = data.reserve0.divDown(data.decimals0);
+        uint256 Y = data.reserve1.divDown(data.decimals1);
+        amountIn = amountIn.divDown(data.decimals0);
+
+        uint256 t = Y.divDown(X + amountIn);
+        uint256 K = X.mulDown(Y).mulDown(X.mulDown(X) + Y.mulDown(Y));
+        uint256 denom = t.mulDown(t).mulDown(t) + t;
+
+        params.guessMin = (_fourthRoot(K.divDown(denom)) - X).mulDown(data.decimals0);
+        params.guessMax = (params.guessMin * FEE_DENOMINATOR) / (FEE_DENOMINATOR - data.fee);
+    }
+
+    function _getReserveAfterSwap(uint256 amountIn, uint256 reserve, uint256 fee) internal pure returns (uint256) {
+        return reserve + amountIn - (amountIn * fee) / FEE_DENOMINATOR;
+    }
+
+    // this returns the fourthRoot of y in base 18
+    function _fourthRoot(uint256 y) private pure returns (uint256) {
+        uint256 root = PMath.sqrt(y) * (10 ** 9);
+        return PMath.sqrt(root) * (10 ** 9);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Thena/ThenaPreview.sol

@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.17;
+
+import "./ThenaMath.sol";
+
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+import "../../../../interfaces/IPPreviewHelper.sol";
+import "../../../../interfaces/Thena/IThenaFactory.sol";
+
+interface IThenaSY {
+    function pair() external view returns (address);
+}
+
+contract ThenaPreview is IPPreviewHelper, ThenaMath, BoringOwnableUpgradeable, UUPSUpgradeable {
+    using PMath for uint256;
+
+    address internal immutable factory;
+
+    constructor(address _factory) initializer {
+        factory = _factory;
+    }
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    // solhint-disable-next-line
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+    function previewDeposit(address tokenIn, uint256 amountTokenIn) external view returns (uint256 amountLpOut) {
+        address pair = IThenaSY(msg.sender).pair();
+
+        ThenaData memory data = _getNormalizedPairData(pair, tokenIn);
+
+        uint256 amountToSwap = _getZapInSwapAmount(data, tokenIn, amountTokenIn);
+        uint256 amountSwapOut = _getSwapAmountOut(data, amountToSwap);
+
+        uint256 amount0ToAddLiq;
+        uint256 amount1ToAddLiq;
+
+        data.reserve0 = _getReserveAfterSwap(amountToSwap, data.reserve0, data.fee); // no need getBalance here since we dont need 100% accuracy
+        data.reserve1 -= amountSwapOut;
+
+        amount0ToAddLiq = amountTokenIn - amountToSwap;
+        amount1ToAddLiq = amountSwapOut;
+
+        return _calcAmountLpOut(data, amount0ToAddLiq, amount1ToAddLiq);
+    }
+
+    function previewRedeem(address tokenOut, uint256 amountLpIn) external view returns (uint256) {
+        address pair = IThenaSY(msg.sender).pair();
+
+        // Token1 = tokenOut
+        address token0 = IThenaPair(pair).token0();
+        address token1 = IThenaPair(pair).token1();
+
+        ThenaData memory data = _getNormalizedPairData(pair, tokenOut == token0 ? token1 : token0);
+
+        uint256 totalSupply = IThenaPair(data.pair).totalSupply();
+
+        uint256 amount0Removed = (data.reserve0 * amountLpIn) / totalSupply;
+        uint256 amount1Removed = (data.reserve1 * amountLpIn) / totalSupply;
+
+        data.reserve0 -= amount0Removed;
+        data.reserve1 -= amount1Removed;
+
+        return amount1Removed + _getSwapAmountOut(data, amount0Removed);
+    }
+
+    // @reference: Camelot
+    function _getSwapAmountOut(ThenaData memory data, uint256 amountIn) internal pure returns (uint256) {
+        if (!data.isStable) {
+            amountIn = amountIn * (FEE_DENOMINATOR - data.fee);
+            return (amountIn * data.reserve1) / (data.reserve0 * FEE_DENOMINATOR + amountIn);
+        } else {
+            amountIn = (amountIn - (amountIn * data.fee) / FEE_DENOMINATOR).divDown(data.decimals0);
+            uint256 reserveA = data.reserve0.divDown(data.decimals0);
+            uint256 reserveB = data.reserve1.divDown(data.decimals1);
+            uint256 xy = reserveA.mulDown(reserveB).mulDown(reserveA.squareDown() + reserveB.squareDown());
+            uint256 y = reserveB - _get_y(amountIn + reserveA, xy, reserveB);
+            return y.mulDown(data.decimals1);
+        }
+    }
+
+    /**
+     * @notice This function simulates Camelot router so any precision issues from their calculation
+     * is preserved in preview functions...
+     */
+    function _calcAmountLpOut(
+        ThenaData memory data,
+        uint256 amount0ToAddLiq,
+        uint256 amount1ToAddLiq
+    ) private view returns (uint256 amountLpOut) {
+        uint256 amount1Optimal = _quote(amount0ToAddLiq, data.reserve0, data.reserve1);
+        if (amount1Optimal <= amount1ToAddLiq) {
+            amount1ToAddLiq = amount1Optimal;
+        } else {
+            amount0ToAddLiq = _quote(amount1ToAddLiq, data.reserve1, data.reserve0);
+        }
+
+        uint256 supply = IThenaPair(data.pair).totalSupply();
+        return PMath.min((amount0ToAddLiq * supply) / data.reserve0, (amount1ToAddLiq * supply) / data.reserve1);
+    }
+
+    function _quote(uint256 amountA, uint256 reserveA, uint256 reserveB) private pure returns (uint256 amountB) {
+        amountB = (amountA * reserveB) / reserveA;
+    }
+
+    function _getNormalizedPairData(address pair, address pivotToken) internal view returns (ThenaData memory data) {
+        data.pair = pair;
+        data.isStable = IThenaPair(pair).isStable();
+        data.fee = IThenaFactory(factory).getFee(data.isStable);
+        (data.reserve0, data.reserve1, ) = IThenaPair(pair).getReserves();
+
+        if (data.isStable) {
+            // if not stable, skip readding these datas
+            data.decimals0 = 10 ** IERC20Metadata(IThenaPair(pair).token0()).decimals();
+            data.decimals1 = 10 ** IERC20Metadata(IThenaPair(pair).token1()).decimals();
+        }
+
+        // Normalize token order
+        if (pivotToken == IThenaPair(pair).token1()) {
+            (data.reserve0, data.reserve1) = (data.reserve1, data.reserve0);
+            (data.decimals0, data.decimals1) = (data.decimals1, data.decimals0);
+        }
+    }
+
+    // Camelot copied math functions
+    function _get_y(uint256 x0, uint256 xy, uint256 y) internal pure returns (uint256) {
+        for (uint256 i = 0; i < 255; i++) {
+            uint256 y_prev = y;
+            uint256 k = _f(x0, y);
+            if (k < xy) {
+                uint256 dy = ((xy - k) * 1e18) / _d(x0, y);
+                y = y + dy;
+            } else {
+                uint256 dy = ((k - xy) * 1e18) / _d(x0, y);
+                y = y - dy;
+            }
+            if (y > y_prev) {
+                if (y - y_prev <= 1) {
+                    return y;
+                }
+            } else {
+                if (y_prev - y <= 1) {
+                    return y;
+                }
+            }
+        }
+        return y;
+    }
+
+    function _f(uint256 x0, uint256 y) internal pure returns (uint256) {
+        return (x0 * ((((y * y) / 1e18) * y) / 1e18)) / 1e18 + (((((x0 * x0) / 1e18) * x0) / 1e18) * y) / 1e18;
+    }
+
+    function _d(uint256 x0, uint256 y) internal pure returns (uint256) {
+        return (3 * x0 * ((y * y) / 1e18)) / 1e18 + ((((x0 * x0) / 1e18) * x0) / 1e18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Usual/PendleUsualUSD0PPSY.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+import "../../SYBase.sol";
+import "../../../../interfaces/Usual/IUsualUSD0PP.sol";
+
+contract PendleUsualUSD0PPSY is SYBase {
+    address public constant USD0PP = 0x35D8949372D46B7a3D5A56006AE77B215fc69bC0;
+    address public constant USD0 = 0x73A15FeD60Bf67631dC6cd7Bc5B6e8da8190aCF5;
+
+    constructor() SYBase("SY USD0++", "SY-USD0++", USD0PP) {
+        _safeApproveInf(USD0, USD0PP);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == USD0) {
+            IUsualUSD0PP(USD0PP).mint(amountDeposited);
+        }
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256) {
+        _transferOut(yieldToken, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256 res) {
+        return PMath.ONE;
+    }
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public pure override returns (address[] memory res) {
+        return ArrayLib.create(USD0PP, USD0);
+    }
+
+    function getTokensOut() public pure override returns (address[] memory res) {
+        return ArrayLib.create(USD0PP);
+    }
+
+    function isValidTokenIn(address token) public pure override returns (bool) {
+        return token == USD0PP || token == USD0;
+    }
+
+    function isValidTokenOut(address token) public pure override returns (bool) {
+        return token == USD0PP;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, USD0PP, IERC20Metadata(USD0PP).decimals());
+    }
+}