@pendle/core-v2 2.19.0 → 2.20.0-tradingbot

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";
+    }
+}

package/contracts/core/TradingBot/libraries/BotSimulationLib.sol

@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./MarketExtLib.sol";
+import "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
+
+library BotSimulationLib {
+    using MarketMathCore for MarketState;
+    using MarketExtLib for MarketExtState;
+    using Math for uint256;
+    using Math for int256;
+
+    function swapSyToYt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 exactYtOut
+    ) internal pure returns (bool /*success*/) {
+        uint256 netSyIn = marketExt.swapSyToYt(exactYtOut);
+
+        if (netSyIn > bot.syBalance) return false;
+
+        bot.syBalance -= netSyIn;
+        bot.ytBalance += exactYtOut;
+
+        return true;
+    }
+
+    function addLiqKeepYt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netSyIn
+    ) internal pure returns (bool /*success*/) {
+        if (netSyIn > bot.syBalance) return false;
+
+        (uint256 netLpOut, uint256 netYtOut) = marketExt.addLiqKeepYt(netSyIn);
+
+        bot.syBalance -= netSyIn;
+        bot.lpBalance += netLpOut;
+        bot.ytBalance += netYtOut;
+
+        return true;
+    }
+
+    function addLiqFromSy(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netPtFromSwap
+    ) internal pure returns (bool /*success*/) {
+        (uint256 netLpOut, uint256 netSyIn) = marketExt.addLiqFromSy(netPtFromSwap);
+
+        if (netSyIn > bot.syBalance) return false;
+
+        bot.syBalance -= netSyIn;
+        bot.lpBalance += netLpOut;
+
+        return true;
+    }
+
+    function addLiqFromYt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netPtFromSwap
+    ) internal pure returns (bool /*success*/) {
+        (uint256 netLpOut, uint256 netYtIn) = marketExt.addLiqFromYt(netPtFromSwap);
+
+        if (netYtIn > bot.ytBalance) return false;
+
+        bot.ytBalance -= netYtIn;
+        bot.lpBalance += netLpOut;
+
+        return true;
+    }
+
+    function removeLiqToYt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netLpToRemove,
+        ApproxParams memory approxParams
+    ) internal pure returns (bool /*success*/) {
+        if (netLpToRemove > bot.lpBalance) return false;
+
+        (uint256 netYtOut, ) = marketExt.removeLiqToYt(
+            netLpToRemove,
+            cloneApproxParams(approxParams)
+        );
+
+        bot.lpBalance -= netLpToRemove;
+        bot.ytBalance += netYtOut;
+
+        return true;
+    }
+
+    function swapPtToYt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netPtToSwap,
+        ApproxParams memory approxParams
+    ) internal pure returns (bool /*success*/) {
+        if (netPtToSwap > bot.ptBalance) return false;
+        (uint256 netYtOut, ) = marketExt.swapPtToYt(netPtToSwap, cloneApproxParams(approxParams));
+        bot.ptBalance -= netPtToSwap;
+        bot.ytBalance += netYtOut;
+        return true;
+    }
+
+    function swapYtToPt(
+        BotState memory bot,
+        MarketExtState memory marketExt,
+        uint256 netYtToSwap,
+        ApproxParams memory approxParams
+    ) internal pure returns (bool /*success*/) {
+        if (netYtToSwap > bot.ytBalance) return false;
+        (uint256 netPtOut, ) = marketExt.swapYtToPt(netYtToSwap, cloneApproxParams(approxParams));
+        bot.ptBalance += netPtOut;
+        bot.ytBalance -= netYtToSwap;
+        return true;
+    }
+
+    function tvlInSy(
+        BotState memory bot,
+        MarketExtState memory marketExt
+    ) internal pure returns (uint256) {
+        MarketExtState memory marketExtClone = marketExt.clone();
+
+        (uint256 syInLp, uint256 ptInLp) = marketExtClone.removeLiqDual(bot.lpBalance);
+        uint256 totalValue = bot.syBalance + syInLp;
+
+        uint256 totalPt = ptInLp + bot.ptBalance;
+        if (totalPt <= bot.ytBalance) {
+            totalValue += marketExtClone.previewPyToSy(totalPt);
+            totalValue += marketExtClone.swapYtToSy(bot.ytBalance - totalPt);
+        } else {
+            totalValue += marketExtClone.previewPyToSy(bot.ytBalance);
+            totalValue += marketExtClone.swapPtToSy(totalPt - bot.ytBalance);
+        }
+        return totalValue;
+    }
+
+    function clone(BotState memory bot) internal pure returns (BotState memory) {
+        return BotState(bot.lpBalance, bot.ytBalance, bot.ptBalance, bot.syBalance, bot.buyBins);
+    }
+
+    function cloneApproxParams(
+        ApproxParams memory params
+    ) internal pure returns (ApproxParams memory) {
+        return
+            ApproxParams(
+                params.guessMin,
+                params.guessMax,
+                params.guessOffchain,
+                params.maxIteration,
+                params.eps
+            );
+    }
+}

package/contracts/core/TradingBot/libraries/LongYieldActionLib.sol

@@ -0,0 +1,279 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+// import "../base/TradingBotBase.sol";
+import "../../../router/base/MarketApproxLib.sol";
+import "../../../interfaces/IPAllAction.sol";
+import "../../../interfaces/IPMarket.sol";
+import "../../../interfaces/TradingBot/IBotDecisionHelper.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+library LongYieldActionLib {
+    using PYIndexLib for IPYieldToken;
+    using PYIndexLib for PYIndex;
+    using MarketMathCore for MarketState;
+    using MarketApproxPtInLib for MarketState;
+    using Math for int256;
+    using SafeERC20 for IERC20;
+
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    address internal constant ROUTER = 0x0000000001E4ef00d069e71d6bA041b0A16F7eA0;
+
+    function removeLiquidityToSy(
+        address market,
+        uint256 netLpToRemove,
+        uint256 minSyOut
+    ) public returns (uint256 netSyOut) {
+        (uint256 netSyFromLp, uint256 netPtOut) = IPAllAction(ROUTER).removeLiquidityDualSyAndPt(
+            address(this),
+            market,
+            netLpToRemove,
+            0,
+            0
+        );
+
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        uint256 netSyFromRedeemPY = IPAllAction(ROUTER).redeemPyToSy(
+            address(this),
+            address(YT),
+            Math.min(netPtOut, YT.balanceOf(address(this))),
+            0
+        );
+
+        netSyOut = netSyFromLp + netSyFromRedeemPY;
+        require(netSyOut > minSyOut, "removeLiquidityToSy: insufficient sy out");
+    }
+
+    function swapYtToSy(
+        address market,
+        uint256 netYtIn,
+        uint256 minSyOut
+    ) public returns (uint256 netSyOut) {
+        (netSyOut, ) = IPAllAction(ROUTER).swapExactYtForSy(
+            address(this),
+            market,
+            netYtIn,
+            minSyOut
+        );
+    }
+
+    function addLiqKeepYt(
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) public returns (uint256 /*netLpOut*/, uint256 /*netYtOut*/) {
+        return
+            IPAllAction(ROUTER).addLiquiditySingleSyKeepYt(
+                address(this),
+                market,
+                netSyIn,
+                minLpOut,
+                minYtOut
+            );
+    }
+
+    function addLiqFromYt(
+        address market,
+        uint256 netPtFromSwap,
+        uint256 minLpOut
+    ) public returns (uint256 netLpOut, uint256 netYtIn) {
+        MarketState memory state = IPMarket(market).readState(address(this));
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        PYIndex index = YT.newIndex();
+
+        (uint256 netSyToSwap, , ) = state.swapSyForExactPt(index, netPtFromSwap, block.timestamp);
+
+        // (1) --> netPtRedeemSy = netPtFromSwap - netPtToAdd
+        // (2) --> (netPtRedeemSy * ONE / pyIndex) = (netPtToAdd * totalSy / totalPt) + netSyToSwap
+        // (2) * pyIndex / ONE --> netPtRedeemSy = (netPtToAdd * totalSy / totalPt * pyIndex / ONE) + netSyToSwap * pyIndex / ONE
+        // ==> netPtFromSwap - netPtToAdd = (netPtToAdd * totalSy / totalPt * pyIndex / ONE) + netSyToSwap * pyIndex / ONE
+        // ==> netPtToAdd * (ONE + totalSy * pyIndex / totalPt) = netPtFromSwap * ONE - netSyToSwap * pyIndex
+
+        uint256 pyIndex = PYIndex.unwrap(index);
+        uint256 netPtToAddNumerator = (netPtFromSwap * Math.ONE - netSyToSwap * pyIndex);
+        uint256 netPtToAddDenominator = (Math.ONE +
+            (state.totalSy.Uint() * pyIndex) /
+            state.totalPt.Uint());
+        uint256 netPtToAdd = netPtToAddNumerator / netPtToAddDenominator;
+
+        netYtIn = netPtFromSwap - netPtToAdd; // = netPtRedeemSy
+
+        IPMarket(market).swapSyForExactPt(
+            address(this),
+            netPtFromSwap,
+            _encodeAddLiqFromYt(netYtIn)
+        );
+
+        uint256 netSyFromPy = index.assetToSy(netYtIn);
+        uint256 netSyToAdd = netSyFromPy - netSyToSwap;
+
+        (netLpOut, , ) = IPMarket(market).mint(address(this), netSyToAdd, netPtToAdd);
+        if (netLpOut < minLpOut) revert Errors.BotInsufficientLpOut(netLpOut, minLpOut);
+    }
+
+    /// @dev Behaves like PendleRouter's removeLiquidityDualSyAndPt then swapExactPtForYt
+    /// @param guessTotalPtToSwap Same like for PendleRouter's swapExactPtForYt
+    function removeLiqToYt(
+        address market,
+        uint256 netLpToRemove,
+        ApproxParams memory guessTotalPtToSwap,
+        uint256 minYtOut
+    ) public returns (uint256 netYtOut, uint256 totalPtToSwap) {
+        IERC20(market).safeTransfer(market, netLpToRemove);
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (uint256 netSyFromLp, uint256 netPtFromLp) = IPMarket(market).burn(
+            address(YT),
+            market,
+            netLpToRemove
+        ); // SY goes to YT to mint PY, PT goes to market to swap
+
+        MarketState memory state = IPMarket(market).readState(address(this));
+        PYIndex index = IPYieldToken(YT).newIndex();
+
+        uint256 netPtFromSy = index.syToAsset(netSyFromLp);
+
+        uint256 netYtFromSwap;
+        (netYtFromSwap, totalPtToSwap, ) = state.approxSwapExactPtForYt(
+            index,
+            netPtFromLp + netPtFromSy,
+            block.timestamp,
+            guessTotalPtToSwap
+        );
+
+        netYtOut = netYtFromSwap + netPtFromSy;
+        if (netYtOut < minYtOut) revert Errors.BotInsufficientYtOut(netYtOut, minYtOut);
+
+        IPMarket(market).swapExactPtForSy(
+            address(YT),
+            totalPtToSwap,
+            _encodeRemoveLiqToYt(minYtOut)
+        ); // SY goes to YT to mint PY
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               Callback
+    //////////////////////////////////////////////////////////////*/
+
+    function swapCallback(
+        address market,
+        int256 ptToAccount,
+        int256 syToAccount,
+        bytes calldata data
+    ) public {
+        TradeActionType swapType = _getActionType(data);
+
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+
+        if (swapType == TradeActionType.AddLiqFromYt) {
+            _callbackAddLiqFromYt(
+                market,
+                address(PT),
+                address(YT),
+                ptToAccount,
+                syToAccount,
+                data
+            );
+        } else if (swapType == TradeActionType.RemoveLiqToYt) {
+            _callbackRemoveLiqToYt(
+                market,
+                address(PT),
+                address(YT),
+                ptToAccount,
+                syToAccount,
+                data
+            );
+        } else {
+            assert(false);
+        }
+    }
+
+    /// ------------------------------------------------------------
+    /// AddLiqFromYt
+    /// ------------------------------------------------------------
+
+    function _callbackAddLiqFromYt(
+        address market,
+        address PT,
+        address YT,
+        int256 ptToAccount,
+        int256 /*syToAccount*/,
+        bytes calldata data
+    ) internal {
+        uint256 netPyRedeemSy = _decodeAddLiqFromYt(data);
+        IERC20(PT).safeTransfer(address(YT), netPyRedeemSy);
+
+        bool needToBurnYt = (!IPYieldToken(YT).isExpired());
+        if (needToBurnYt) IERC20(YT).safeTransfer(YT, netPyRedeemSy);
+
+        IPYieldToken(YT).redeemPY(market); // all SY goes to market to repay and mint LP
+        IERC20(PT).safeTransfer(market, ptToAccount.Uint() - netPyRedeemSy); // remaining PT goes to market to mint LP
+    }
+
+    function _decodeAddLiqFromYt(
+        bytes calldata data
+    ) internal pure returns (uint256 netPyRedeemSy) {
+        assembly {
+            // first 32 bytes is ActionType
+            netPyRedeemSy := calldataload(add(data.offset, 32))
+        }
+    }
+
+    /// ------------------------------------------------------------
+    /// RemoveLiqToYt
+    /// ------------------------------------------------------------
+
+    function _callbackRemoveLiqToYt(
+        address market,
+        address /*PT*/,
+        address YT,
+        int256 /*ptToAccount*/,
+        int256 /*syToAccount*/,
+        bytes calldata data
+    ) internal {
+        uint256 minYtOut = _decodeRemoveLiqToYt(data);
+
+        uint256 netYtOut = IPYieldToken(YT).mintPY(market, address(this)); // PT goes to market to repay
+        if (netYtOut < minYtOut) revert Errors.BotInsufficientYtOut(netYtOut, minYtOut); // 2nd check
+    }
+
+    /// ------------------------------------------------------------
+    /// Misc functions
+    /// ------------------------------------------------------------
+
+    function _getActionType(bytes calldata data) internal pure returns (TradeActionType actionType) {
+        assembly {
+            actionType := calldataload(data.offset)
+        }
+    }
+
+    function _decodeRemoveLiqToYt(bytes calldata data) internal pure returns (uint256 minYtOut) {
+        assembly {
+            // first 32 bytes is ActionType
+            minYtOut := calldataload(add(data.offset, 32))
+        }
+    }
+
+    function _encodeRemoveLiqToYt(uint256 minYtOut) internal pure returns (bytes memory res) {
+        res = new bytes(64);
+        uint256 actionType = uint256(TradeActionType.RemoveLiqToYt);
+
+        assembly {
+            mstore(add(res, 32), actionType)
+            mstore(add(res, 64), minYtOut)
+        }
+    }
+
+    function _encodeAddLiqFromYt(uint256 netPyRedeemSy) internal pure returns (bytes memory res) {
+        res = new bytes(64);
+        uint256 actionType = uint256(TradeActionType.AddLiqFromYt);
+
+        assembly {
+            mstore(add(res, 32), actionType)
+            mstore(add(res, 64), netPyRedeemSy)
+        }
+    }
+}