@pendle/core-v2 2.5.0-mainnet → 2.6.0-mainnet

package/build/artifacts/contracts/router/base/ActionBaseCallback.sol/ActionBaseCallback.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/6b18eba6d50d13d3fa953207318c13bb.json"
+  "buildInfo": "../../../../build-info/ab2554ba7dc9de84a88881282a151fdb.json"
 }

package/build/artifacts/contracts/router/base/ActionBaseMintRedeem.sol/ActionBaseMintRedeem.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/6b18eba6d50d13d3fa953207318c13bb.json"
+  "buildInfo": "../../../../build-info/ab2554ba7dc9de84a88881282a151fdb.json"
 }

package/contracts/interfaces/IPRouterHelper.sol

@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../router/base/MarketApproxLib.sol";
+import "../router/base/ActionBaseMintRedeem.sol";
+
+interface IPRouterHelper {
+    /**
+     * @param output This output struct should be filled the same way as the normal removeLiquiditySingleToken
+     operation (This means all BulkSeller, PendleSwap still works the same way). Note that the
+     output.tokenOut will also be used as the input token for the addLiquidity
+     */
+    struct RemoveLiquiditySingleTokenStruct {
+        address market;
+        uint256 netLpToRemove;
+        bool doRedeemRewards;
+        TokenOutput output;
+    }
+
+    /**
+     * @param guessNetTokenIn the predicted amount of tokenIn that will be used to add liquidity. This
+     should be the same amount that was used to generate guessPtReceivedFromSy (if any).
+     * @param guessPtReceivedFromSy the same guess struct in the normal addLiquiditySingleToken operation.
+     Again, note that this struct, if not empty (i.e. if guessOffchain == 0), should be generated
+     using `guessNetTokenIn` amount of tokenIn
+     * @dev tokenIn is the output.tokenOut of the removeLiquiditySingleTokenStruct
+     */
+    struct AddLiquiditySingleTokenStruct {
+        address market;
+        uint256 minLpOut;
+        uint256 guessNetTokenIn;
+        ApproxParams guessPtReceivedFromSy;
+        address bulk;
+    }
+
+    /**
+     * @dev tokenIn is the output.tokenOut of the removeLiquiditySingleTokenStruct
+     */
+    struct AddLiquiditySingleTokenKeepYtStruct {
+        address market;
+        uint256 minLpOut;
+        uint256 minYtOut;
+        address bulk;
+    }
+
+    struct RemoveLiquiditySingleSyStruct {
+        address market;
+        uint256 netLpToRemove;
+        bool doRedeemRewards;
+    }
+
+    /**
+     * @dev guessNetSyIn & guessPtReceivedFromSy have similar meanings to AddLiquiditySingleTokenStruct
+     */
+    struct AddLiquiditySingleSyStruct {
+        address market;
+        uint256 minLpOut;
+        uint256 guessNetSyIn;
+        ApproxParams guessPtReceivedFromSy;
+    }
+
+    struct AddLiquiditySingleSyKeepYtStruct {
+        address market;
+        uint256 minLpOut;
+        uint256 minYtOut;
+    }
+
+    event RemoveLiquiditySingleToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpToRemove,
+        uint256 netTokenOut
+    );
+
+    event RemoveLiquiditySingleSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpToRemove,
+        uint256 netSyOut
+    );
+
+    event AddLiquiditySingleToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netTokenIn,
+        uint256 netLpOut
+    );
+
+    event AddLiquiditySingleSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netSyIn,
+        uint256 netLpOut
+    );
+
+    event AddLiquiditySingleTokenKeepYt(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netTokenIn,
+        uint256 netLpOut,
+        uint256 netYtOut
+    );
+
+    event AddLiquiditySingleSyKeepYt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netSyIn,
+        uint256 netLpOut,
+        uint256 netYtOut
+    );
+
+    function transferLiquidityDifferentSyNormal(
+        RemoveLiquiditySingleTokenStruct calldata fromMarket,
+        AddLiquiditySingleTokenStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netTokenZapIn,
+            uint256 netSyFeeOfRemove,
+            uint256 netSyFeeOfAdd
+        );
+
+    function transferLiquidityDifferentSyKeepYt(
+        RemoveLiquiditySingleTokenStruct calldata fromMarket,
+        AddLiquiditySingleTokenKeepYtStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netYtOut,
+            uint256 netTokenZapIn,
+            uint256 netSyFeeOfRemove
+        );
+
+    function transferLiquiditySameSyNormal(
+        RemoveLiquiditySingleSyStruct calldata fromMarket,
+        AddLiquiditySingleSyStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netSyZapIn,
+            uint256 netSyFeeOfRemove,
+            uint256 netSyFeeOfAdd
+        );
+
+    function transferLiquiditySameSyKeepYt(
+        RemoveLiquiditySingleSyStruct calldata fromMarket,
+        AddLiquiditySingleSyKeepYtStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netYtOut,
+            uint256 netSyZapIn,
+            uint256 netSyFeeOfRemove
+        );
+
+    function removeLiquiditySingleToken(RemoveLiquiditySingleTokenStruct calldata fromMarket)
+        external
+        returns (uint256 netTokenOut, uint256 netSyFee);
+
+    function removeLiquiditySingleSy(RemoveLiquiditySingleSyStruct calldata fromMarket)
+        external
+        returns (uint256 netSyOut, uint256 netSyFee);
+}

package/contracts/router/PendleRouterHelper.sol

@@ -0,0 +1,359 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../interfaces/IPAllAction.sol";
+import "../interfaces/IPMarket.sol";
+import "../interfaces/IPRouterHelper.sol";
+import "./base/ActionBaseMintRedeem.sol";
+import "./base/MarketApproxLib.sol";
+import "../interfaces/IAddressProvider.sol";
+
+contract PendleRouterHelper is TokenHelper, IPRouterHelper {
+    IPAllAction public immutable ROUTER;
+    address public immutable WETH;
+
+    constructor(address _ROUTER, IAddressProvider provider) {
+        ROUTER = IPAllAction(_ROUTER);
+        WETH = _getWETHAddress(provider, 1);
+        _safeApproveInf(WETH, address(ROUTER));
+    }
+
+    function _getWETHAddress(IAddressProvider provider, uint256 providerId)
+        internal
+        view
+        returns (address)
+    {
+        return provider.get(providerId);
+    }
+
+    receive() external payable {}
+
+    /**
+     * @dev all the parameters for this function should be generated in the same way as they are
+     generated for the main Router, except that input.tokenIn & swapData should be generated
+     for tokenIn == WETH instead of ETH
+     */
+    function addLiquiditySingleTokenKeepYtWithEth(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut) {
+        require(input.tokenIn == WETH);
+
+        _transferIn(NATIVE, msg.sender, input.netTokenIn);
+
+        _wrap_unwrap_ETH(NATIVE, WETH, input.netTokenIn);
+        (netLpOut, netYtOut) = ROUTER.addLiquiditySingleTokenKeepYt(
+            receiver,
+            market,
+            minLpOut,
+            minYtOut,
+            input
+        );
+
+        emit AddLiquiditySingleTokenKeepYt(
+            msg.sender,
+            market,
+            NATIVE,
+            msg.sender,
+            input.netTokenIn,
+            netLpOut,
+            netYtOut
+        );
+    }
+
+    function transferLiquidityDifferentSyNormal(
+        RemoveLiquiditySingleTokenStruct calldata fromMarket,
+        AddLiquiditySingleTokenStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netTokenZapIn,
+            uint256 netSyFeeOfRemove,
+            uint256 netSyFeeOfAdd
+        )
+    {
+        (netTokenZapIn, netSyFeeOfRemove) = removeLiquiditySingleToken(fromMarket);
+        (netLpOut, netSyFeeOfAdd) = _addLiquiditySingleToken(
+            toMarket,
+            fromMarket.output.tokenOut,
+            netTokenZapIn
+        );
+    }
+
+    function transferLiquidityDifferentSyKeepYt(
+        RemoveLiquiditySingleTokenStruct calldata fromMarket,
+        AddLiquiditySingleTokenKeepYtStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netYtOut,
+            uint256 netTokenZapIn,
+            uint256 netSyFeeOfRemove
+        )
+    {
+        (netTokenZapIn, netSyFeeOfRemove) = removeLiquiditySingleToken(fromMarket);
+        (netLpOut, netYtOut) = _addLiquiditySingleTokenKeepYt(
+            toMarket,
+            fromMarket.output.tokenOut,
+            netTokenZapIn
+        );
+    }
+
+    function transferLiquiditySameSyNormal(
+        RemoveLiquiditySingleSyStruct calldata fromMarket,
+        AddLiquiditySingleSyStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netSyZapIn,
+            uint256 netSyFeeOfRemove,
+            uint256 netSyFeeOfAdd
+        )
+    {
+        (netSyZapIn, netSyFeeOfRemove) = removeLiquiditySingleSy(fromMarket);
+        (netLpOut, netSyFeeOfAdd) = _addLiquiditySingleSy(toMarket, netSyZapIn);
+    }
+
+    function transferLiquiditySameSyKeepYt(
+        RemoveLiquiditySingleSyStruct calldata fromMarket,
+        AddLiquiditySingleSyKeepYtStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netYtOut,
+            uint256 netSyZapIn,
+            uint256 netSyFeeOfRemove
+        )
+    {
+        (netSyZapIn, netSyFeeOfRemove) = removeLiquiditySingleSy(fromMarket);
+        (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(toMarket, netSyZapIn);
+    }
+
+    function removeLiquiditySingleToken(RemoveLiquiditySingleTokenStruct calldata fromMarket)
+        public
+        returns (uint256 netTokenOut, uint256 netSyFee)
+    {
+        _transferFrom(
+            IERC20(fromMarket.market),
+            msg.sender,
+            address(this),
+            fromMarket.netLpToRemove
+        );
+
+        _safeApproveInf(fromMarket.market, address(ROUTER));
+
+        (netTokenOut, netSyFee) = ROUTER.removeLiquiditySingleToken(
+            address(this),
+            fromMarket.market,
+            fromMarket.netLpToRemove,
+            fromMarket.output
+        );
+
+        if (fromMarket.doRedeemRewards) {
+            IPMarket(fromMarket.market).redeemRewards(msg.sender);
+        }
+
+        emit RemoveLiquiditySingleToken(
+            msg.sender,
+            fromMarket.market,
+            fromMarket.output.tokenOut,
+            msg.sender,
+            fromMarket.netLpToRemove,
+            netTokenOut
+        );
+    }
+
+    function removeLiquiditySingleSy(RemoveLiquiditySingleSyStruct calldata fromMarket)
+        public
+        returns (uint256 netSyOut, uint256 netSyFee)
+    {
+        _transferFrom(
+            IERC20(fromMarket.market),
+            msg.sender,
+            address(this),
+            fromMarket.netLpToRemove
+        );
+
+        _safeApproveInf(fromMarket.market, address(ROUTER));
+
+        (netSyOut, netSyFee) = ROUTER.removeLiquiditySingleSy(
+            address(this),
+            fromMarket.market,
+            fromMarket.netLpToRemove,
+            0
+        );
+
+        if (fromMarket.doRedeemRewards) {
+            IPMarket(fromMarket.market).redeemRewards(msg.sender);
+        }
+
+        emit RemoveLiquiditySingleSy(
+            msg.sender,
+            fromMarket.market,
+            msg.sender,
+            fromMarket.netLpToRemove,
+            netSyOut
+        );
+    }
+
+    function _addLiquiditySingleToken(
+        AddLiquiditySingleTokenStruct calldata toMarket,
+        address tokenToZapIn,
+        uint256 actualNetTokenIn
+    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
+        uint256 netNativeToAttach;
+        if (tokenToZapIn == NATIVE) {
+            netNativeToAttach = actualNetTokenIn;
+        }
+
+        _safeApproveInf(tokenToZapIn, address(ROUTER));
+
+        (netLpOut, netSyFee) = ROUTER.addLiquiditySingleToken{ value: netNativeToAttach }(
+            msg.sender,
+            toMarket.market,
+            toMarket.minLpOut,
+            _scaleApproxParams(
+                toMarket.guessPtReceivedFromSy,
+                toMarket.guessNetTokenIn,
+                actualNetTokenIn
+            ),
+            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn, toMarket.bulk)
+        );
+
+        emit AddLiquiditySingleToken(
+            msg.sender,
+            toMarket.market,
+            tokenToZapIn,
+            msg.sender,
+            actualNetTokenIn,
+            netLpOut
+        );
+    }
+
+    function _addLiquiditySingleSy(
+        AddLiquiditySingleSyStruct calldata toMarket,
+        uint256 actualNetSyIn
+    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , ) = IPMarket(toMarket.market).readTokens();
+
+        _safeApproveInf(address(SY), address(ROUTER));
+
+        (netLpOut, netSyFee) = ROUTER.addLiquiditySingleSy(
+            msg.sender,
+            toMarket.market,
+            actualNetSyIn,
+            toMarket.minLpOut,
+            _scaleApproxParams(
+                toMarket.guessPtReceivedFromSy,
+                toMarket.guessNetSyIn,
+                actualNetSyIn
+            )
+        );
+
+        emit AddLiquiditySingleSy(
+            msg.sender,
+            toMarket.market,
+            msg.sender,
+            actualNetSyIn,
+            netLpOut
+        );
+    }
+
+    function _addLiquiditySingleTokenKeepYt(
+        AddLiquiditySingleTokenKeepYtStruct calldata toMarket,
+        address tokenToZapIn,
+        uint256 actualNetTokenIn
+    ) internal returns (uint256 netLpOut, uint256 netYtOut) {
+        if (tokenToZapIn == NATIVE) {
+            tokenToZapIn = WETH;
+            _wrap_unwrap_ETH(NATIVE, WETH, actualNetTokenIn);
+        }
+
+        _safeApproveInf(tokenToZapIn, address(ROUTER));
+
+        (netLpOut, netYtOut) = ROUTER.addLiquiditySingleTokenKeepYt(
+            msg.sender,
+            toMarket.market,
+            toMarket.minLpOut,
+            toMarket.minYtOut,
+            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn, toMarket.bulk)
+        );
+
+        emit AddLiquiditySingleTokenKeepYt(
+            msg.sender,
+            toMarket.market,
+            tokenToZapIn,
+            msg.sender,
+            actualNetTokenIn,
+            netLpOut,
+            netYtOut
+        );
+    }
+
+    function _addLiquiditySingleSyKeepYt(
+        AddLiquiditySingleSyKeepYtStruct calldata toMarket,
+        uint256 actualNetSyIn
+    ) internal returns (uint256 netLpOut, uint256 netYtOut) {
+        (IStandardizedYield SY, , ) = IPMarket(toMarket.market).readTokens();
+
+        _safeApproveInf(address(SY), address(ROUTER));
+
+        (netLpOut, netYtOut) = ROUTER.addLiquiditySingleSyKeepYt(
+            msg.sender,
+            toMarket.market,
+            actualNetSyIn,
+            toMarket.minLpOut,
+            toMarket.minYtOut
+        );
+
+        emit AddLiquiditySingleSyKeepYt(
+            msg.sender,
+            toMarket.market,
+            msg.sender,
+            actualNetSyIn,
+            netLpOut,
+            netYtOut
+        );
+    }
+
+    // ============ struct helpers ============
+
+    function _newTokenInputStruct(
+        address tokenIn,
+        uint256 netTokenIn,
+        address bulk
+    ) internal pure returns (TokenInput memory res) {
+        res.tokenIn = res.tokenMintSy = tokenIn;
+        res.netTokenIn = netTokenIn;
+        res.bulk = bulk;
+        return res;
+    }
+
+    /// @dev either SY or Token here is good since token->sy conversion is almost linearly proportional
+    function _scaleApproxParams(
+        ApproxParams calldata params,
+        uint256 guessNetTokenIn,
+        uint256 actualNetTokenIn
+    ) internal pure returns (ApproxParams memory) {
+        if (params.guessOffchain == 0) {
+            require(params.guessMin == 0 && params.guessMax == type(uint256).max, "invalid guess");
+            return params;
+        }
+
+        return
+            ApproxParams({
+                guessMin: (params.guessMin * actualNetTokenIn) / guessNetTokenIn,
+                guessMax: (params.guessMax * actualNetTokenIn) / guessNetTokenIn,
+                guessOffchain: (params.guessOffchain * actualNetTokenIn) / guessNetTokenIn,
+                maxIteration: params.maxIteration,
+                eps: params.eps
+            });
+    }
+}

package/contracts/router/base/ActionBaseMintRedeem.sol

@@ -193,10 +193,11 @@ abstract contract ActionBaseMintRedeem is TokenHelper {
         if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
     }
 
-    function _syOrBulk(
-        address SY,
-        TokenOutput calldata output
-    ) internal pure returns (address addr) {
+    function _syOrBulk(address SY, TokenOutput calldata output)
+        internal
+        pure
+        returns (address addr)
+    {
         return output.bulk != address(0) ? output.bulk : SY;
     }
 }

package/deployments/1-core.json

@@ -28,5 +28,5 @@
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
     "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
     "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
-    "routerHelper": "0xeb984195D54Df02BaF757e21B0705032FaEFde2E"
+    "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335"
 }

package/deployments/42161-core.json

@@ -23,5 +23,5 @@
     "receiverEndpoint": "0xC9215ae9EC67385F38C755D862C8eE3702B5793A",
     "vePendle": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
     "gaugeController": "0x1e56299ebc8a1010cec26005d12e3e5c5cc2db00",
-    "routerHelper": "0xeb984195D54Df02BaF757e21B0705032FaEFde2E"
+    "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335"
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.5.0-mainnet",
+  "version": "2.6.0-mainnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -27,7 +27,7 @@
     "@typechain/hardhat": "^4.0.0",
     "hardhat": "^2.13.0",
     "hardhat-contract-sizer": "^2.8.0",
-    "prettier": "^2.8.4",
+    "prettier": "^2.8.5",
     "prettier-plugin-solidity": "^1.1.3",
     "solc": "^0.8.19",
     "solhint": "^3.4.1",