@pendle/core-v2 2.19.1-tradingbot → 2.20.0-tradingbot

package/contracts/core/TradingBot/{LongYield → DecisionHelper}/LongYieldDecisionHelper.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.0;
 import "./../libraries/BotSimulationLib.sol";
 import "../../libraries/Errors.sol";
 import "../libraries/SpecSegmentLib.sol";
-import "../base/BotDecisionHelperBase.sol";
+import "./BotDecisionHelperBase.sol";
 import "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
 import "../../../interfaces/TradingBot/ILongYieldTradingBot.sol";
 
@@ -20,14 +20,47 @@ contract LongYieldDecisionHelper is BotDecisionHelperBase {
     using LogExpMath for uint256;
     using SpecSegmentLib for TradingSpecs;
 
+    function getRebalanceAction(
+        address botAddress
+    ) public view returns (RebalanceOutput memory output) {
+        StrategyData memory strategyData = ITradingBotBase(botAddress).readStrategyData();
+        (uint256 tvlInSy, , uint256 syRatio, ) = _calcBotExtStats(
+            strategyData.botState,
+            strategyData.marketExt
+        );
+
+        uint256 lowerBound = strategyData.specs.targetSyRatio.mulDown(
+            Math.ONE - strategyData.specs.bufferSyRatio
+        );
+
+        uint256 upperBound = strategyData.specs.targetSyRatio.mulDown(
+            Math.ONE + strategyData.specs.bufferSyRatio
+        );
+
+        if (syRatio > upperBound) {
+            output.rebalanceType = RebalanceType.AddLiqKeepYt;
+            (output.amountIn, output.amountOut, output.amountOut2) = _getSyAmountForZPI(
+                strategyData.marketExt,
+                tvlInSy,
+                syRatio,
+                strategyData.specs.targetSyRatio
+            );
+        } else if (syRatio < lowerBound) {
+            (output.rebalanceType, output.amountIn, output.amountOut) = _getRemoveRebalance(
+                strategyData,
+                tvlInSy
+            );
+        }
+    }
+
     // We dont care about AddLiqKeepYt here
-    function getActionDetails(address botAddress) public returns (ActionToTakeResult memory res) {
+    function getTradeAction(address botAddress) public view returns (TradeResult memory res) {
         StrategyData memory strategyData = ILongYieldTradingBot(botAddress).readStrategyData();
         uint256 iy = strategyData.marketExt.impliedYield();
 
         res.currentBin = _getCurrentBin(strategyData.botState, strategyData.specs, iy);
         if (res.currentBin == 0) {
-            res.action = ActionType.NONE;
+            res.action = TradeActionType.NONE;
             return res;
         }
         res.targetIy = _getTargetImpliedYieldForBin(
@@ -40,8 +73,8 @@ contract LongYieldDecisionHelper is BotDecisionHelperBase {
         uint256 rebalanceAdditionalCheck;
 
         if (res.currentBin < 0) {
-            res.action = ActionType.RemoveLiqToYt;
-            maxAmountForAction = _calcMaxAmountForAction(
+            res.action = TradeActionType.RemoveLiqToYt;
+            maxAmountForAction = _calcTradeActionMaxAmount(
                 strategyData.botState.lpBalance,
                 res.currentBin,
                 strategyData.botState.buyBins,
@@ -49,13 +82,14 @@ contract LongYieldDecisionHelper is BotDecisionHelperBase {
             );
 
             if (maxAmountForAction == 0) {
+                res.action = TradeActionType.NONE;
                 return res;
             }
         } else {
-            res.action = ActionType.AddLiqFromYt;
-            uint256 maxYtToAddLiq = _searchMaxYtToAddLiq(strategyData);
+            res.action = TradeActionType.AddLiqFromYt;
+            uint256 maxYtToAddLiq = searchMaxYtToAddLiq(strategyData);
 
-            rebalanceAdditionalCheck = _calcMaxAmountForAction(
+            rebalanceAdditionalCheck = _calcTradeActionMaxAmount(
                 maxYtToAddLiq,
                 res.currentBin,
                 strategyData.botState.buyBins,
@@ -63,6 +97,7 @@ contract LongYieldDecisionHelper is BotDecisionHelperBase {
             );
 
             if (rebalanceAdditionalCheck == 0) {
+                res.action = TradeActionType.NONE;
                 return res;
             }
         }
@@ -75,7 +110,7 @@ contract LongYieldDecisionHelper is BotDecisionHelperBase {
             _getMockApproxParamsWithGuessMax(maxAmountForAction),
             _getMockApproxParams()
         );
-        (res.amountOut, res.guessIntParams) = _calcAmountOutAndIntParams(
+        (res.amountOut, res.guessIntParams) = _calcTradeActionAmountOutAndIntParams(
             strategyData.marketExt,
             res.action,
             res.guessBotParams
@@ -86,12 +121,12 @@ contract LongYieldDecisionHelper is BotDecisionHelperBase {
      * Given the rebalancing action and its `botParam`, binary search for the optimal internal
      * parameter `intParam` for the internal action's approximation (e.g. for router's swap)
      */
-    function _calcAmountOutAndIntParams(
+    function _calcTradeActionAmountOutAndIntParams(
         MarketExtState memory marketExt,
-        ActionType action,
+        TradeActionType action,
         uint256 botParam
     ) public pure returns (uint256 amountOut, uint256 intParams) {
-        if (action == ActionType.RemoveLiqToYt) {
+        if (action == TradeActionType.RemoveLiqToYt) {
             (amountOut, intParams) = marketExt.clone().removeLiqToYt(
                 botParam,
                 _getMockApproxParams()
@@ -101,9 +136,9 @@ contract LongYieldDecisionHelper is BotDecisionHelperBase {
         }
     }
 
-    function _searchMaxYtToAddLiq(
+    function searchMaxYtToAddLiq(
         StrategyData memory strategyData
-    ) internal pure returns (uint256) {
+    ) public view returns (uint256 maxYtToAddLiq) {
         (, , , uint256 ytPtRatioAfter) = _calcBotExtStats(
             strategyData.botState,
             strategyData.marketExt
@@ -113,19 +148,22 @@ contract LongYieldDecisionHelper is BotDecisionHelperBase {
         }
 
         ApproxParams memory guessParams = _getMockApproxParamsWithGuessMax(
-            strategyData.botState.ytBalance
+            _weakUpperBound(
+                strategyData.botState,
+                strategyData.marketExt,
+                TradeActionType.AddLiqFromYt
+            )
         );
         ApproxParams memory mockSwapParams = _getMockApproxParams();
         while (guessParams.guessMax > guessParams.guessMin + 1) {
             uint256 guess = guessParams.guessMin +
                 (guessParams.guessMax - guessParams.guessMin) /
                 2;
-
             (
                 bool success,
                 BotState memory botStateAfter,
                 MarketExtState memory marketExtAfter
-            ) = previewAction(strategyData, ActionType.AddLiqFromYt, guess, mockSwapParams);
+            ) = previewAction(strategyData, TradeActionType.AddLiqFromYt, guess, mockSwapParams);
 
             if (!success) {
                 guessParams.guessMax = guess - 1;
@@ -135,26 +173,27 @@ contract LongYieldDecisionHelper is BotDecisionHelperBase {
             (, , , ytPtRatioAfter) = _calcBotExtStats(botStateAfter, marketExtAfter);
             if (ytPtRatioAfter >= strategyData.specs.targetYtPtRatio) {
                 guessParams.guessMin = guess;
+                maxYtToAddLiq = strategyData.botState.ytBalance - botStateAfter.ytBalance;
             } else {
                 guessParams.guessMax = guess - 1;
             }
         }
-        return guessParams.guessMin;
+        return maxYtToAddLiq;
     }
 
     /// @dev Does not modify params, structs are cloned before simulation
     function previewAction(
         StrategyData memory strategyData,
-        ActionType action,
+        TradeActionType action,
         uint256 botParam,
         ApproxParams memory intParams
     ) public pure returns (bool success, BotState memory bot, MarketExtState memory marketExt) {
         bot = strategyData.botState.clone();
         marketExt = strategyData.marketExt.clone();
 
-        if (action == ActionType.AddLiqFromYt) {
+        if (action == TradeActionType.AddLiqFromYt) {
             success = bot.addLiqFromYt(marketExt, botParam);
-        } else if (action == ActionType.RemoveLiqToYt) {
+        } else if (action == TradeActionType.RemoveLiqToYt) {
             success = bot.removeLiqToYt(marketExt, botParam, intParams);
         } else {
             success = false;
@@ -165,52 +204,88 @@ contract LongYieldDecisionHelper is BotDecisionHelperBase {
     function _weakUpperBound(
         BotState memory bot,
         MarketExtState memory marketExt,
-        ActionType action
+        TradeActionType action
     ) internal pure override returns (uint256) {
-        if (action == ActionType.AddLiqFromYt) {
+        if (action == TradeActionType.AddLiqFromYt) {
             return marketExt.calcMaxPtOut();
         } else {
             return bot.lpBalance;
         }
     }
 
-    function _rebalanceResult(
-        RebalanceDetails memory rebalance,
+    function _getTradeActionResult(
+        TradeParams memory params,
         uint256 botParam,
         uint256 rebalanceAdditionalCheck,
         uint256 eps,
         ApproxParams memory intParams
-    ) internal pure override returns (RebalanceResult) {
+    ) internal pure override returns (TradeActionResult) {
         (
             bool success,
             BotState memory newBotState,
             MarketExtState memory marketExt
-        ) = previewAction(rebalance.strategyData, rebalance.action, botParam, intParams);
+        ) = previewAction(params.strategyData, params.action, botParam, intParams);
 
-        if (!success) return RebalanceResult.FAIL_OR_TARGET_EXCEED;
-        // return RebalanceResult.SUCCESS;
+        if (!success) return TradeActionResult.FAIL_OR_TARGET_EXCEED;
 
         uint256 iy = marketExt.impliedYield();
-        if (rebalance.action == ActionType.AddLiqFromYt) {
-            uint256 netYtSwapped = rebalance.strategyData.botState.ytBalance -
-                newBotState.ytBalance;
+        if (params.action == TradeActionType.AddLiqFromYt) {
+            uint256 netYtSwapped = params.strategyData.botState.ytBalance - newBotState.ytBalance;
 
             if (netYtSwapped > rebalanceAdditionalCheck) {
-                return RebalanceResult.FAIL_OR_TARGET_EXCEED;
+                return TradeActionResult.FAIL_OR_TARGET_EXCEED;
             }
-            if (Math.isAGreaterApproxB(iy, rebalance.targetIy, eps)) {
-                return RebalanceResult.SUCCESS;
+            if (Math.isAGreaterApproxB(iy, params.targetIy, eps)) {
+                return TradeActionResult.SUCCESS;
             } else {
-                if (iy < rebalance.targetIy) return RebalanceResult.FAIL_OR_TARGET_EXCEED;
-                else return RebalanceResult.TARGET_NOT_REACHED;
+                if (iy < params.targetIy) return TradeActionResult.FAIL_OR_TARGET_EXCEED;
+                else return TradeActionResult.TARGET_NOT_REACHED;
             }
         } else {
-            if (Math.isASmallerApproxB(iy, rebalance.targetIy, eps)) {
-                return RebalanceResult.SUCCESS;
+            if (Math.isASmallerApproxB(iy, params.targetIy, eps)) {
+                return TradeActionResult.SUCCESS;
             } else {
-                if (iy > rebalance.targetIy) return RebalanceResult.FAIL_OR_TARGET_EXCEED;
-                else return RebalanceResult.TARGET_NOT_REACHED;
+                if (iy > params.targetIy) return TradeActionResult.FAIL_OR_TARGET_EXCEED;
+                else return TradeActionResult.TARGET_NOT_REACHED;
             }
         }
     }
+
+    function _getRemoveRebalance(
+        StrategyData memory strategyData,
+        uint256 tvl
+    ) internal pure returns (RebalanceType rebalanceType, uint256 amountIn, uint256 amountOut) {
+        uint256 totalSyRequired = tvl.mulDown(strategyData.specs.targetSyRatio) -
+            strategyData.botState.syBalance;
+
+        if (strategyData.botState.lpBalance > 0) {
+            (int256 syFromLp, int256 ptFromLp) = strategyData
+                .marketExt
+                .clone()
+                .state
+                .removeLiquidityCore(strategyData.botState.lpBalance.Int());
+
+            uint256 availablePYToRedeem = Math.min(
+                strategyData.botState.ytBalance,
+                ptFromLp.Uint()
+            );
+
+            // PT should be zpi redeemed together with YT
+            uint256 totalSyZpi = syFromLp.Uint() +
+                strategyData.marketExt.index.assetToSyUp(availablePYToRedeem);
+
+            rebalanceType = RebalanceType.RemoveLpAndYt;
+            amountOut = Math.min(totalSyZpi, totalSyRequired);
+            amountIn = (strategyData.botState.lpBalance * amountOut) / totalSyZpi;
+        } else {
+            // Position now should only consist of SY & YT
+            uint256 syFromYT = strategyData.marketExt.clone().swapYtToSy(
+                strategyData.botState.ytBalance
+            );
+
+            rebalanceType = RebalanceType.SellYt;
+            amountIn = (totalSyRequired * strategyData.botState.ytBalance) / syFromYT;
+            amountOut = strategyData.marketExt.clone().swapYtToSy(amountIn);
+        }
+    }
 }

package/contracts/core/TradingBot/{LongYield/LongYieldTradingBot.sol → LongYieldTradingBot.sol}

@@ -1,16 +1,17 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "../base/TradingBotBase.sol";
-import "./LongYieldActionHelper.sol";
-import "../../../interfaces/TradingBot/ILongYieldTradingBot.sol";
+import "./TradingBotBase.sol";
+import "./libraries/LongYieldActionLib.sol";
+import "../../interfaces/TradingBot/ILongYieldTradingBot.sol";
+import "../../interfaces/IPMarketSwapCallback.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
 contract LongYieldTradingBot is
     TradingBotBase,
-    LongYieldActionHelper,
+    UUPSUpgradeable,
     ILongYieldTradingBot,
-    UUPSUpgradeable
+    IPMarketSwapCallback
 {
     using MarketExtLib for MarketExtState;
     using Math for uint256;
@@ -30,12 +31,32 @@ contract LongYieldTradingBot is
         __BoringOwnable_init();
     }
 
+    function removeLiquidityToSy(
+        uint256 netLpToRemove,
+        uint256 minSyOut
+    ) external onlyOwner returns (uint256 netSyOut) {
+        return LongYieldActionLib.removeLiquidityToSy(market, netLpToRemove, minSyOut);
+    }
+
+
+    function swapYtToSy(
+        uint256 netYtToSell,
+        uint256 minSyOut
+    ) external onlyOwner returns (uint256 netSyOut) {
+        return LongYieldActionLib.swapYtToSy(market, netYtToSell, minSyOut);
+    }
+
     function addLiqKeepYt(
         uint256 netSyIn,
         uint256 minLpOut,
         uint256 minYtOut
     ) external onlyOwner returns (uint256 netLpOut, uint256 netYtOut) {
-        (netLpOut, netYtOut) = _addLiqKeepYt(router, netSyIn, minLpOut, minYtOut);
+        (netLpOut, netYtOut) = LongYieldActionLib.addLiqKeepYt(
+            market,
+            netSyIn,
+            minLpOut,
+            minYtOut
+        );
         emit AddLiqKeepYt(netSyIn, netLpOut, netYtOut);
     }
 
@@ -51,13 +72,17 @@ contract LongYieldTradingBot is
         );
         netPtFromSwap = decisionHelper.searchForBotParam(
             readStrategyData(),
-            ActionType.AddLiqFromYt,
+            TradeActionType.AddLiqFromYt,
             inputParams.targetIy,
             type(uint256).max,
             inputParams.botParams,
             inputParams.botParams // only placeholder, value doesn't matter
         );
-        (netLpOut, netYtIn) = _addLiqFromYt(netPtFromSwap, inputParams.minLpOut);
+        (netLpOut, netYtIn) = LongYieldActionLib.addLiqFromYt(
+            market,
+            netPtFromSwap,
+            inputParams.minLpOut
+        );
 
         _updateSellBinAfterTrade();
 
@@ -77,14 +102,15 @@ contract LongYieldTradingBot is
 
         netLpRemoved = decisionHelper.searchForBotParam(
             strategyData,
-            ActionType.RemoveLiqToYt,
+            TradeActionType.RemoveLiqToYt,
             inputParams.targetIy,
             type(uint256).max,
             inputParams.botParams,
             inputParams.guessTotalPtToSwap // value DOES matter
         );
 
-        (netYtOut, ) = _removeLiqToYt(
+        (netYtOut, ) = LongYieldActionLib.removeLiqToYt(
+            market,
             netLpRemoved,
             inputParams.guessTotalPtToSwap,
             inputParams.minYtOut
@@ -94,4 +120,9 @@ contract LongYieldTradingBot is
 
         emit RemoveLiqToYt(inputParams.botParams, netLpRemoved, netYtOut);
     }
+
+    function swapCallback(int256 ptToAccount, int256 syToAccount, bytes calldata data) external {
+        require(msg.sender == market, "not market");
+        LongYieldActionLib.swapCallback(market, ptToAccount, syToAccount, data);
+    }
 }

package/contracts/core/TradingBot/TradingBotBase.sol

@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../libraries/BoringOwnableUpgradeable.sol";
+import "../libraries/TokenHelper.sol";
+import "../../interfaces/TradingBot/ITradingBotBase.sol";
+import "../../interfaces/TradingBot/IBotDecisionHelper.sol";
+import "../StandardizedYield/SYBaseWithRewards.sol";
+import "./libraries/TvlLib.sol";
+
+contract TradingBotBase is SYBaseWithRewards, ITradingBotBase {
+    using TokenAmountLib for TokenAmount[];
+    using PYIndexLib for IPYieldToken;
+    using MarketExtLib for MarketExtState;
+    using Math for uint256;
+    using Math for int256;
+
+    IBotDecisionHelper public immutable decisionHelper;
+    address public immutable market;
+    address public immutable router;
+    address public immutable SY;
+    address public immutable PT;
+    address public immutable YT;
+    address public immutable PENDLE;
+
+    TradingSpecs public specs;
+    uint256 public buyBins;
+
+    constructor(
+        address _market,
+        address _router,
+        address _PENDLE,
+        address _decisionHelper
+    ) SYBaseWithRewards("Fortknox Vault", "Fortknox Vault", _getSYAddress(_market)) {
+        (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) = IPMarket(_market)
+            .readTokens();
+
+        market = _market;
+        router = _router;
+        SY = address(_SY);
+        PT = address(_PT);
+        YT = address(_YT);
+        PENDLE = _PENDLE;
+        decisionHelper = IBotDecisionHelper(_decisionHelper);
+    }
+
+    function _getSYAddress(address _market) internal view returns (address) {
+        (IStandardizedYield _SY, , ) = IPMarket(_market).readTokens();
+        return address(_SY);
+    }
+
+    function approveInf(address token, address to) external onlyOwner {
+        _safeApproveInf(token, to);
+    }
+
+    function compound(
+        TokenInput calldata inp,
+        uint256 minSyOut
+    ) external onlyOwner returns (uint256 netSyOut) {
+        netSyOut = _compoundSingle(inp, minSyOut);
+        _transferOut(PENDLE, owner, _selfBalance(PENDLE));
+        emit ClaimAndCompound(netSyOut);
+    }
+
+    function _readMarketExtState() internal view returns (MarketExtState memory marketExt) {
+        marketExt.state = IPMarket(market).readState(router);
+        marketExt.index = IPYieldToken(YT).newIndexView();
+        marketExt.blockTime = block.timestamp;
+    }
+
+    function _readBotState() internal view returns (BotState memory botState) {
+        botState.lpBalance = _selfBalance(market);
+        botState.syBalance = _selfBalance(SY);
+        botState.ytBalance = _selfBalance(YT);
+        botState.ptBalance = _selfBalance(PT);
+        botState.buyBins = buyBins;
+    }
+
+    function _setBuyBins(uint256 _buyBins) internal {
+        buyBins = _buyBins;
+    }
+
+    function _compoundSingle(
+        TokenInput memory inp,
+        uint256 minSyOut
+    ) internal returns (uint256 /*netSyOut*/) {
+        if (inp.netTokenIn == type(uint256).max) inp.netTokenIn = _selfBalance(inp.tokenIn);
+
+        return
+            IPAllAction(router).mintSyFromToken{
+                value: inp.tokenIn == NATIVE ? inp.netTokenIn : 0
+            }(address(this), SY, minSyOut, inp);
+    }
+
+    function setSpecs(TradingSpecs calldata _specs) external onlyOwner {
+        _setSpecs(_specs);
+    }
+
+    function _setSpecs(TradingSpecs memory _specs) internal {
+        specs = _specs;
+        _setBuyBins(specs.numOfBins);
+    }
+
+    function readStrategyData() public view returns (StrategyData memory strategyData) {
+        strategyData.botState = _readBotState();
+        strategyData.marketExt = _readMarketExtState();
+        strategyData.specs = specs;
+    }
+
+    function _updateSellBinAfterTrade() internal {
+        int256 binShift = IBotDecisionHelper(decisionHelper).getCurrentBin(readStrategyData());
+        _setBuyBins((buyBins.Int() + binShift).Uint());
+    }
+
+    function getTvl(bool isLiquidateTvl) external view returns (uint256) {
+        if (isLiquidateTvl) {
+            return TvlLib.getLiquidateTvl(_readBotState(), _readMarketExtState());
+        } else {
+            return TvlLib.getOracleTvl(market, _readBotState());
+        }
+    }
+
+    function getMaxAmountSharesToRedeem() external view returns (uint256) {
+        uint256 liquidateTvl = TvlLib.getLiquidateTvl(_readBotState(), _readMarketExtState());
+        return (_selfBalance(SY) * totalSupply()) / liquidateTvl;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EIP-5115
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * The underlying yield token is startgateLP. If the base token deposited is underlying, the function
+     * deposits received underlying into the startgateLP contract.
+     */
+    function _deposit(
+        address,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        BotState memory botState = _readBotState();
+        MarketExtState memory marketExt = _readMarketExtState();
+
+        uint256 supply = totalSupply();
+        if (supply == 0) return amountDeposited;
+
+        uint256 tvl = Math.max(
+            TvlLib.getOracleTvl(market, botState),
+            TvlLib.getLiquidateTvl(botState, marketExt)
+        );
+
+        return (amountDeposited * totalSupply()) / (tvl - amountDeposited);
+    }
+
+    function _redeem(
+        address receiver,
+        address,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        uint256 tvlLiquidate = TvlLib.getLiquidateTvl(_readBotState(), _readMarketExtState());
+        amountTokenOut =
+            (tvlLiquidate * amountSharesToRedeem) /
+            (totalSupply() + amountSharesToRedeem);
+        _transferOut(SY, receiver, amountTokenOut);
+    }
+
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        uint256 supply = totalSupply();
+        if (supply == 0) return amountTokenToDeposit;
+
+        BotState memory botState = _readBotState();
+        MarketExtState memory marketExt = _readMarketExtState();
+
+        uint256 tvl = Math.max(
+            TvlLib.getOracleTvl(market, botState),
+            TvlLib.getLiquidateTvl(botState, marketExt)
+        );
+        return (amountTokenToDeposit * supply) / tvl;
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        uint256 tvlLiquidate = TvlLib.getLiquidateTvl(_readBotState(), _readMarketExtState());
+        return (tvlLiquidate * amountSharesToRedeem) / totalSupply();
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return TvlLib.getOracleTvl(market, _readBotState()).divDown(totalSupply());
+    }
+
+    function _redeemExternalReward() internal override {
+        IPYieldToken(YT).redeemDueInterestAndRewards(address(this), true, true);
+        IPMarket(market).redeemRewards(address(this));
+        IStandardizedYield(SY).claimRewards(address(this));
+    }
+
+    function _getRewardTokens() internal view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = PENDLE;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = SY;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = SY;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == SY;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == SY;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, SY, IERC20Metadata(SY).decimals());
+    }
+
+    /**
+     * ERC20 overrides
+     */
+    function name()
+        public
+        view
+        virtual
+        override(PendleERC20, IERC20Metadata)
+        returns (string memory)
+    {
+        return "Fortknox Vault";
+    }
+
+    function symbol()
+        public
+        view
+        virtual
+        override(PendleERC20, IERC20Metadata)
+        returns (string memory)
+    {
+        return "Fortknox Vault";
+    }
+}