@pendle/core-v2 0.16.6-testnet → 0.17.0-testnet

package/contracts/core/Market/PendleMarket.sol

@@ -83,6 +83,10 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     /**
      * @notice PendleMarket allows users to provide in PT & SY in exchange for LPs, which
      * will grant LP holders more exchange fee over time
+     * @dev will mint as much LP as possible such that the corresponding SY and PT used do
+     * not exceed `netSyDesired` and `netPtDesired`, respectively
+     * @dev PT and SY should be transferred to this contract prior to calling
+     * @dev will revert if PT is expired
      */
     function mint(
         address receiver,
@@ -98,7 +102,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
             uint256 netPtUsed
         )
     {
-        MarketState memory market = readState();
+        MarketState memory market = readState(msg.sender);
         PYIndex index = YT.newIndex();
 
         uint256 lpToReserve;
@@ -129,14 +133,14 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
 
     /**
      * @notice LP Holders can burn their LP to receive back SY & PT proportionally
-     * to their share of market
+     * to their share of the market
      */
     function burn(
         address receiverSy,
         address receiverPt,
         uint256 netLpToBurn
     ) external nonReentrant returns (uint256 netSyOut, uint256 netPtOut) {
-        MarketState memory market = readState();
+        MarketState memory market = readState(msg.sender);
 
         _burn(address(this), netLpToBurn);
 
@@ -158,16 +162,18 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
        - Release the calculated amount of SY to receiver
        - Callback to msg.sender if data.length > 0
        - Ensure exactPtIn amount of PT has been transferred to this address
-     * @param data bytes data to be sent in the callback
+     * @dev will revert if PT is expired
+     * @param data bytes data to be sent in the callback (if any)
      */
     function swapExactPtForSy(
         address receiver,
         uint256 exactPtIn,
         bytes calldata data
-    ) external nonReentrant notExpired returns (uint256 netSyOut, uint256 netSyToReserve) {
-        MarketState memory market = readState();
+    ) external nonReentrant notExpired returns (uint256 netSyOut, uint256 netSyFee) {
+        MarketState memory market = readState(msg.sender);
 
-        (netSyOut, netSyToReserve) = market.swapExactPtForSy(
+        uint256 netSyToReserve;
+        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(
             YT.newIndex(),
             exactPtIn,
             block.timestamp
@@ -185,26 +191,28 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         if (_selfBalance(PT) < market.totalPt.Uint())
             revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
 
-        emit Swap(receiver, exactPtIn.neg(), netSyOut.Int(), netSyToReserve);
+        emit Swap(receiver, exactPtIn.neg(), netSyOut.Int(), netSyFee, netSyToReserve);
     }
 
     /**
      * @notice Pendle Market allows swaps between PT & SY it is holding. This function
-     * aims to swap an exact amount of SY to PT.
+     * aims to swap SY for an exact amount of PT.
      * @dev steps working of this function
        - The exact outcome amount of PT will be transferred to receiver
        - Callback to msg.sender if data.length > 0
        - Ensure the calculated required amount of SY is transferred to this address
-     * @param data bytes data to be sent in the callback
+     * @dev will revert if PT is expired
+     * @param data bytes data to be sent in the callback (if any)
      */
     function swapSyForExactPt(
         address receiver,
         uint256 exactPtOut,
         bytes calldata data
-    ) external nonReentrant notExpired returns (uint256 netSyIn, uint256 netSyToReserve) {
-        MarketState memory market = readState();
+    ) external nonReentrant notExpired returns (uint256 netSyIn, uint256 netSyFee) {
+        MarketState memory market = readState(msg.sender);
 
-        (netSyIn, netSyToReserve) = market.swapSyForExactPt(
+        uint256 netSyToReserve;
+        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(
             YT.newIndex(),
             exactPtOut,
             block.timestamp
@@ -223,22 +231,27 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         if (_selfBalance(SY) < market.totalSy.Uint())
             revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
 
-        emit Swap(receiver, exactPtOut.Int(), netSyIn.neg(), netSyToReserve);
+        emit Swap(receiver, exactPtOut.Int(), netSyIn.neg(), netSyFee, netSyToReserve);
     }
 
-    /// @notice force balances to match reserves
+    /// @notice forces balances to match reserves
     function skim() external nonReentrant {
-        MarketState memory market = readState();
+        MarketState memory market = readState(msg.sender);
         uint256 excessPt = _selfBalance(PT) - market.totalPt.Uint();
         uint256 excessSy = _selfBalance(SY) - market.totalSy.Uint();
-        IERC20(PT).safeTransfer(market.treasury, excessPt);
-        IERC20(SY).safeTransfer(market.treasury, excessSy);
+        if (excessPt != 0) IERC20(PT).safeTransfer(market.treasury, excessPt);
+        if (excessSy != 0) IERC20(SY).safeTransfer(market.treasury, excessSy);
     }
 
+    /**
+     * @notice redeems the user's reward
+     * @return amount of reward token redeemed, in the same order as `getRewardTokens()`
+     */
     function redeemRewards(address user) external nonReentrant returns (uint256[] memory) {
         return _redeemRewards(user);
     }
 
+    /// @notice returns the list of reward tokens
     function getRewardTokens() external view returns (address[] memory) {
         return _getRewardTokens();
     }
@@ -248,7 +261,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     //////////////////////////////////////////////////////////////*/
 
     function observe(uint32[] memory secondsAgos)
-        public
+        external
         view
         returns (uint216[] memory lnImpliedRateCumulative)
     {
@@ -278,14 +291,14 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     /**
      * @notice read the state of the market from storage into memory for gas-efficient manipulation
      */
-    function readState() public view returns (MarketState memory market) {
+    function readState(address router) public view returns (MarketState memory market) {
         market.totalPt = _storage.totalPt;
         market.totalSy = _storage.totalSy;
         market.totalLp = totalSupply().Int();
 
         (market.treasury, market.lnFeeRateRoot, market.reserveFeePercent) = IPMarketFactory(
             factory
-        ).marketConfig();
+        ).getMarketConfig(router);
 
         market.scalarRoot = scalarRoot;
         market.expiry = expiry;
@@ -302,7 +315,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         (uint16 observationIndex, uint16 observationCardinality) = observations.write(
             _storage.observationIndex,
             uint32(block.timestamp),
-            lastLnImpliedRate96,
+            _storage.lastLnImpliedRate,
             _storage.observationCardinality,
             _storage.observationCardinalityNext
         );

package/contracts/core/Market/PendleMarketFactory.sol

@@ -10,19 +10,9 @@ import "../libraries/BaseSplitCodeFactory.sol";
 import "../libraries/Errors.sol";
 import "../libraries/BoringOwnableUpgradeable.sol";
 
-import "./PendleMarket.sol";
-import "./PendleGauge.sol";
-
 contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
 
-    struct MarketConfig {
-        address treasury;
-        uint88 lnFeeRateRoot;
-        uint8 reserveFeePercent;
-        // 1 SLOT = 256 bits
-    }
-
     address public immutable marketCreationCodeContractA;
     uint256 public immutable marketCreationCodeSizeA;
     address public immutable marketCreationCodeContractB;
@@ -30,6 +20,15 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
 
     address public immutable yieldContractFactory;
     uint256 public immutable maxLnFeeRateRoot;
+    uint8 public constant maxReserveFeePercent = 100;
+    int256 public constant minInitialAnchor = Math.IONE;
+
+    address public treasury;
+    FeeConfig public defaultFee;
+    /// 1 SLOT
+
+    // router -> overriddenFee
+    mapping(address => FeeConfig) public overriddenFee;
 
     // PT -> scalarRoot -> initialAnchor
     mapping(address => mapping(int256 => mapping(int256 => address))) internal markets;
@@ -37,8 +36,6 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
     address public vePendle;
     address public gaugeController;
 
-    MarketConfig public marketConfig;
-
     constructor(
         address _yieldContractFactory,
         address _marketCreationCodeContractA,
@@ -57,23 +54,22 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
 
     function initialize(
         address _treasury,
-        uint88 _lnFeeRateRoot,
-        uint8 _reserveFeePercent,
+        uint80 _defaultLnFeeRateRoot,
+        uint8 _defaultReserveFeePercent,
         address newVePendle,
         address newGaugeController
     ) external initializer {
         __BoringOwnable_init();
         setTreasury(_treasury);
-        setlnFeeRateRoot(_lnFeeRateRoot);
-        setReserveFeePercent(_reserveFeePercent);
+        setDefaultFee(_defaultLnFeeRateRoot, _defaultReserveFeePercent);
 
         vePendle = newVePendle;
         gaugeController = newGaugeController;
     }
 
     /**
-     * @notice Create a market between PT and its corresponding SY
-     * with scalar & anchor config. Anyone is allowed to create a market on their own.
+     * @notice Create a market between PT and its corresponding SY with scalar & anchor config.
+     * Anyone is allowed to create a market on their own.
      */
     function createNewMarket(
         address PT,
@@ -87,6 +83,9 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
         if (markets[PT][scalarRoot][initialAnchor] != address(0))
             revert Errors.MarketFactoryMarketExists();
 
+        if (initialAnchor < minInitialAnchor)
+            revert Errors.MarketFactoryInitialAnchorTooLow(initialAnchor, minInitialAnchor);
+
         market = BaseSplitCodeFactory._create2(
             0,
             bytes32(block.chainid),
@@ -104,38 +103,71 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
         emit CreateNewMarket(market, PT, scalarRoot, initialAnchor);
     }
 
+    function getMarketConfig(address router)
+        external
+        view
+        returns (
+            address _treasury,
+            uint80 _lnFeeRateRoot,
+            uint8 _reserveFeePercent
+        )
+    {
+        (_treasury, _lnFeeRateRoot, _reserveFeePercent) = (
+            treasury,
+            defaultFee.lnFeeRateRoot,
+            defaultFee.reserveFeePercent
+        );
+
+        FeeConfig memory over = overriddenFee[router];
+        if (over.active) {
+            (_lnFeeRateRoot, _reserveFeePercent) = (over.lnFeeRateRoot, over.reserveFeePercent);
+        }
+    }
+
     /// @dev for gas-efficient verification of market
     function isValidMarket(address market) external view returns (bool) {
         return allMarkets.contains(market);
     }
 
-    function treasury() external view returns (address) {
-        return marketConfig.treasury;
-    }
-
     function setTreasury(address newTreasury) public onlyOwner {
-        marketConfig.treasury = newTreasury;
+        if (newTreasury == address(0)) revert Errors.MarketFactoryZeroTreasury();
+
+        treasury = newTreasury;
         _emitNewMarketConfigEvent();
     }
 
-    function setlnFeeRateRoot(uint88 newLnFeeRateRoot) public onlyOwner {
-        if (newLnFeeRateRoot > maxLnFeeRateRoot)
-            revert Errors.MFactoryLnFeeRateRootTooHigh(newLnFeeRateRoot, maxLnFeeRateRoot);
-
-        marketConfig.lnFeeRateRoot = newLnFeeRateRoot;
+    function setDefaultFee(uint80 newLnFeeRateRoot, uint8 newReserveFeePercent) public onlyOwner {
+        _verifyFeeConfig(newLnFeeRateRoot, newReserveFeePercent);
+        defaultFee = FeeConfig(newLnFeeRateRoot, newReserveFeePercent, true);
         _emitNewMarketConfigEvent();
     }
 
-    function setReserveFeePercent(uint8 newReserveFeePercent) public onlyOwner {
-        if (newReserveFeePercent > 100)
-            revert Errors.MFactoryReserveFeePercentTooHigh(newReserveFeePercent, 100);
+    function setOverriddenFee(
+        address router,
+        uint80 newLnFeeRateRoot,
+        uint8 newReserveFeePercent
+    ) public onlyOwner {
+        _verifyFeeConfig(newLnFeeRateRoot, newReserveFeePercent);
+        overriddenFee[router] = FeeConfig(newLnFeeRateRoot, newReserveFeePercent, true);
+        emit SetOverriddenFee(router, newLnFeeRateRoot, newReserveFeePercent);
+    }
 
-        marketConfig.reserveFeePercent = newReserveFeePercent;
-        _emitNewMarketConfigEvent();
+    function unsetOverriddenFee(address router) external onlyOwner {
+        delete overriddenFee[router];
+        emit UnsetOverriddenFee(router);
+    }
+
+    function _verifyFeeConfig(uint80 newLnFeeRateRoot, uint8 newReserveFeePercent) internal view {
+        if (newLnFeeRateRoot > maxLnFeeRateRoot)
+            revert Errors.MarketFactoryLnFeeRateRootTooHigh(newLnFeeRateRoot, maxLnFeeRateRoot);
+        if (newReserveFeePercent > maxReserveFeePercent)
+            revert Errors.MarketFactoryReserveFeePercentTooHigh(
+                newReserveFeePercent,
+                maxReserveFeePercent
+            );
     }
 
     function _emitNewMarketConfigEvent() internal {
-        MarketConfig memory local = marketConfig;
-        emit NewMarketConfig(local.treasury, local.lnFeeRateRoot, local.reserveFeePercent);
+        emit NewMarketConfig(treasury, defaultFee.lnFeeRateRoot, defaultFee.reserveFeePercent);
     }
 }

package/contracts/core/StandardizedYield/SYBase.sol

@@ -7,8 +7,16 @@ import "../erc20/PendleERC20Permit.sol";
 import "../libraries/math/Math.sol";
 import "../libraries/TokenHelper.sol";
 import "../libraries/Errors.sol";
-
-abstract contract SYBase is IStandardizedYield, PendleERC20Permit, TokenHelper {
+import "../libraries/BoringOwnableUpgradeable.sol";
+import "@openzeppelin/contracts/security/Pausable.sol";
+
+abstract contract SYBase is
+    IStandardizedYield,
+    PendleERC20Permit,
+    TokenHelper,
+    BoringOwnableUpgradeable,
+    Pausable
+{
     using Math for uint256;
 
     address public immutable yieldToken;
@@ -17,8 +25,9 @@ abstract contract SYBase is IStandardizedYield, PendleERC20Permit, TokenHelper {
         string memory _name,
         string memory _symbol,
         address _yieldToken
-    ) PendleERC20Permit(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) {
+    ) PendleERC20Permit(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) initializer {
         yieldToken = _yieldToken;
+        __BoringOwnable_init();
     }
 
     // solhint-disable no-empty-blocks
@@ -180,6 +189,20 @@ abstract contract SYBase is IStandardizedYield, PendleERC20Permit, TokenHelper {
         return _previewRedeem(tokenOut, amountSharesToRedeem);
     }
 
+    function pause() external onlyOwner {
+        _pause();
+    }
+
+    function unpause() external onlyOwner {
+        _unpause();
+    }
+
+    function _beforeTokenTransfer(
+        address,
+        address,
+        uint256
+    ) internal virtual override whenNotPaused {}
+
     function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
         internal
         view

package/contracts/core/StandardizedYield/SYBaseWithRewards.sol

@@ -29,6 +29,7 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
         virtual
         override
         nonReentrant
+        whenNotPaused
         returns (uint256[] memory rewardAmounts)
     {
         _updateAndDistributeRewards(user);
@@ -73,6 +74,7 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     function rewardIndexesCurrent()
         external
         override
+        whenNotPaused
         nonReentrant
         returns (uint256[] memory indexes)
     {
@@ -120,7 +122,7 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
         address from,
         address to,
         uint256
-    ) internal virtual override {
+    ) internal virtual override whenNotPaused {
         _updateAndDistributeRewardsForTwo(from, to);
     }
 }

package/contracts/core/StandardizedYield/implementations/Convex/PendleCurveFraxUsdcSY.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./base/PendleConvexLPSY.sol";
+import "./base/CurveFraxUsdcPoolHelper.sol";
+import "../../../libraries/ArrayLib.sol";
+
+contract PendleCurveFraxUsdcSY is PendleConvexLPSY {
+    using ArrayLib for address[];
+
+    uint256 public constant PID = 100;
+
+    address public constant FRAX = CurveFraxUsdcPoolHelper.FRAX;
+    address public constant USDC = CurveFraxUsdcPoolHelper.USDC;
+
+    constructor(string memory _name, string memory _symbol)
+        PendleConvexLPSY(
+            _name,
+            _symbol,
+            PID,
+            CurveFraxUsdcPoolHelper.LP,
+            CurveFraxUsdcPoolHelper.POOL
+        )
+    {
+        _safeApproveInf(FRAX, crvPool);
+        _safeApproveInf(USDC, crvPool);
+    }
+
+    function _depositToCurve(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        virtual
+        override
+        returns (uint256 amountLpOut)
+    {
+        uint256[2] memory amounts;
+        amounts[_getIndex(tokenIn)] = amountTokenToDeposit;
+        amountLpOut = ICrvPool(crvPool).add_liquidity(amounts, 0);
+    }
+
+    function _redeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
+        internal
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        amountTokenOut = ICrvPool(crvPool).remove_liquidity_one_coin(
+            amountLpToRedeem,
+            Math.Int128(_getIndex(tokenOut)),
+            0
+        );
+    }
+
+    function _previewDepositToCurve(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        return CurveFraxUsdcPoolHelper.previewAddLiquidity(tokenIn, amountTokenToDeposit);
+    }
+
+    function _previewRedeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        return
+            ICrvPool(crvPool).calc_withdraw_one_coin(
+                amountLpToRedeem,
+                Math.Int128(_getIndex(tokenOut))
+            );
+    }
+
+    function _getIndex(address token) internal pure returns (uint256) {
+        return (token == FRAX ? 0 : 1);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = crvLp;
+        res[1] = FRAX;
+        res[2] = USDC;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = crvLp;
+        res[1] = FRAX;
+        res[2] = USDC;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool res) {
+        res = (token == crvLp || token == FRAX || token == USDC);
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool res) {
+        res = (token == crvLp || token == FRAX || token == USDC);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Convex/PendleCurveUsdd3CrvSY.sol

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./base/PendleConvexLPSY.sol";
+import "./base/CurveUsdd3CrvPoolHelper.sol";
+import "../../../libraries/ArrayLib.sol";
+
+contract PendleCurveUsdd3CrvSY is PendleConvexLPSY {
+    using ArrayLib for address[];
+
+    uint256 public constant PID = 96;
+    address public constant USDD = CurveUsdd3CrvPoolHelper.USDD;
+    address public constant LP_3CRV = Curve3CrvPoolHelper.LP;
+    address public constant DAI = Curve3CrvPoolHelper.DAI;
+    address public constant USDC = Curve3CrvPoolHelper.USDC;
+    address public constant USDT = Curve3CrvPoolHelper.USDT;
+    address public constant POOL_3CRV = Curve3CrvPoolHelper.POOL;
+    uint256 public constant INDEX_OF_3CRV = 1;
+
+    constructor(string memory _name, string memory _symbol)
+        PendleConvexLPSY(
+            _name,
+            _symbol,
+            PID,
+            CurveUsdd3CrvPoolHelper.POOL,
+            CurveUsdd3CrvPoolHelper.POOL
+        )
+    {
+        _safeApproveInf(USDD, crvPool);
+        _safeApproveInf(LP_3CRV, crvPool);
+        _safeApproveInf(DAI, POOL_3CRV);
+        _safeApproveInf(USDC, POOL_3CRV);
+        _safeApproveInf(USDT, POOL_3CRV);
+    }
+
+    function _depositToCurve(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        virtual
+        override
+        returns (uint256 amountLpOut)
+    {
+        uint256 preBalanceLp = _selfBalance(crvLp);
+
+        uint256[2] memory amounts;
+
+        if (Curve3CrvPoolHelper.is3CrvToken(tokenIn)) {
+            uint256 amount3CrvLp = Curve3CrvPoolHelper.deposit3Crv(tokenIn, amountTokenToDeposit);
+            amounts[INDEX_OF_3CRV] = amount3CrvLp;
+        } else {
+            // one of the 2 LP
+            amounts[_getIndex(tokenIn)] = amountTokenToDeposit;
+        }
+
+        ICrvPool(crvPool).add_liquidity(amounts, 0);
+
+        amountLpOut = _selfBalance(crvLp) - preBalanceLp;
+    }
+
+    function _redeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
+        internal
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        address tokenToRemove = (tokenOut == USDD) ? USDD : LP_3CRV;
+
+        uint256 preBalanceToken = _selfBalance(tokenToRemove);
+
+        ICrvPool(crvPool).remove_liquidity_one_coin(
+            amountLpToRedeem,
+            Math.Int128(_getIndex(tokenToRemove)),
+            0
+        );
+
+        uint256 amountTokenRemoved = _selfBalance(tokenToRemove) - preBalanceToken;
+
+        if (Curve3CrvPoolHelper.is3CrvToken(tokenOut)) {
+            amountTokenOut = Curve3CrvPoolHelper.redeem3Crv(tokenOut, amountTokenRemoved);
+        } else {
+            // one of the 2 LP
+            amountTokenOut = amountTokenRemoved;
+        }
+    }
+
+    function _previewDepositToCurve(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        return CurveUsdd3CrvPoolHelper.previewAddLiquidity(tokenIn, amountTokenToDeposit);
+    }
+
+    function _previewRedeemFromCurve(address tokenOut, uint256 amountLpToRedeem)
+        internal
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        address tokenToRemove = tokenOut == USDD ? USDD : LP_3CRV;
+        uint256 amountTokenRemoved = ICrvPool(crvPool).calc_withdraw_one_coin(
+            amountLpToRedeem,
+            Math.Int128(_getIndex(tokenToRemove))
+        );
+
+        if (Curve3CrvPoolHelper.is3CrvToken(tokenOut)) {
+            return Curve3CrvPoolHelper.preview3CrvRedeem(tokenOut, amountTokenRemoved);
+        } else {
+            // one of the 2 LP
+            return amountTokenRemoved;
+        }
+    }
+
+    function _getIndex(address token) internal pure returns (uint256) {
+        return (token == USDD ? 0 : 1);
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](6);
+        res[0] = crvLp;
+        res[1] = USDD;
+        res[2] = LP_3CRV;
+        res[3] = DAI;
+        res[4] = USDC;
+        res[5] = USDT;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](6);
+        res[0] = crvLp;
+        res[1] = USDD;
+        res[2] = LP_3CRV;
+        res[3] = DAI;
+        res[4] = USDC;
+        res[5] = USDT;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool res) {
+        res = (token == crvLp ||
+            token == USDD ||
+            token == LP_3CRV ||
+            Curve3CrvPoolHelper.is3CrvToken(token));
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool res) {
+        res = (token == crvLp ||
+            token == USDD ||
+            token == LP_3CRV ||
+            Curve3CrvPoolHelper.is3CrvToken(token));
+    }
+
+    function _getRewardTokens() internal pure override returns (address[] memory rewardTokens) {
+        rewardTokens = new address[](3);
+        rewardTokens[0] = USDD;
+        rewardTokens[1] = CRV;
+        rewardTokens[2] = CVX;
+    }
+}