@pendle/core-v2 2.4.0-mainnet → 2.5.1-mainnet

package/contracts/router/PendleRouterHelper.sol

@@ -0,0 +1,358 @@
+// 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);
+    }
+
+    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)
+        internal
+        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)
+        internal
+        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

@@ -27,5 +27,6 @@
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
     "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
-    "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2"
+    "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
+    "routerHelper": "0xeb984195D54Df02BaF757e21B0705032FaEFde2E"
 }

package/deployments/42161-core.json

@@ -22,5 +22,6 @@
     "pendleSwap": "0xDa78D46C4133EA548386e64eaca26FC456F71D2d",
     "receiverEndpoint": "0xC9215ae9EC67385F38C755D862C8eE3702B5793A",
     "vePendle": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
-    "gaugeController": "0x1e56299ebc8a1010cec26005d12e3e5c5cc2db00"
+    "gaugeController": "0x1e56299ebc8a1010cec26005d12e3e5c5cc2db00",
+    "routerHelper": "0xeb984195D54Df02BaF757e21B0705032FaEFde2E"
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.4.0-mainnet",
+  "version": "2.5.1-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",