@pendle/core-v2 1.2.1-testnet → 1.3.0-testnet

package/contracts/offchain-helpers/router-static/base/ActionMintRedeemStatic.sol

@@ -4,24 +4,24 @@ pragma solidity 0.8.17;
 import "../../../interfaces/IPRouterStatic.sol";
 import "../../../interfaces/IPBulkSeller.sol";
 import "../../../interfaces/IPBulkSellerFactory.sol";
-import "../StorageLayout.sol";
+import "./StorageLayout.sol";
 
 contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
     using Math for uint256;
     using BulkSellerMathCore for BulkSellerState;
 
-    function mintPyFromSyStatic(address YT, uint256 netSyToMint)
-        public
-        returns (uint256 netPYOut)
-    {
+    function mintPyFromSyStatic(
+        address YT,
+        uint256 netSyToMint
+    ) public returns (uint256 netPYOut) {
         if (IPYieldToken(YT).isExpired()) revert Errors.YCExpired();
         return netSyToMint.mulDown(IPYieldToken(YT).pyIndexCurrent());
     }
 
-    function redeemPyToSyStatic(address YT, uint256 netPYToRedeem)
-        public
-        returns (uint256 netSyOut)
-    {
+    function redeemPyToSyStatic(
+        address YT,
+        uint256 netPYToRedeem
+    ) public returns (uint256 netSyOut) {
         return netPYToRedeem.divDown(IPYieldToken(YT).pyIndexCurrent());
     }
 
@@ -80,11 +80,11 @@ contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
         address tokenIn,
         address bulk,
         uint256 netSyOut
-    ) public view returns (uint256 netTokenIn) {
+    ) external view returns (uint256 netTokenIn) {
         uint256 pivotAmount;
 
         if (tokenIn == address(0)) pivotAmount = 1e18;
-        else pivotAmount = 10**IStandardizedYield(SY).decimals();
+        else pivotAmount = 10 ** IStandardizedYield(SY).decimals();
 
         uint256 low = pivotAmount;
         {
@@ -124,15 +124,7 @@ contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
         address SY,
         uint256 netTokenIn,
         uint256 netSyIn
-    )
-        public
-        view
-        returns (
-            address bulk,
-            uint256 totalToken,
-            uint256 totalSy
-        )
-    {
+    ) external view returns (address bulk, uint256 totalToken, uint256 totalSy) {
         if (address(bulkSellerFactory) == address(0)) return (address(0), 0, 0);
 
         bulk = bulkSellerFactory.get(token, SY);

package/contracts/offchain-helpers/router-static/base/ActionStorageStatic.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "../StorageLayout.sol";
+import "./StorageLayout.sol";
 import "../../../interfaces/IPActionStorageStatic.sol";
 import "../../../interfaces/IPMiniDiamond.sol";
 
 contract ActionStorageStatic is StorageLayout, IPActionStorageStatic, IPMiniDiamond {
-    function setDefaultApproxParams(ApproxParams memory params) public onlyOwner {
+    function setDefaultApproxParams(ApproxParams memory params) external onlyOwner {
         defaultApproxParams = params;
     }
 
@@ -14,7 +14,7 @@ contract ActionStorageStatic is StorageLayout, IPActionStorageStatic, IPMiniDiam
         bulkSellerFactory = IPBulkSellerFactory(_bulkSellerFactory);
     }
 
-    function getDefaultApproxParams() public view returns (ApproxParams memory) {
+    function getDefaultApproxParams() external view returns (ApproxParams memory) {
         return defaultApproxParams;
     }
 
@@ -22,8 +22,13 @@ contract ActionStorageStatic is StorageLayout, IPActionStorageStatic, IPMiniDiam
         return address(bulkSellerFactory);
     }
 
-    function getOwnerAndPendingOwner() external view returns (address, address) {
-        return (owner, pendingOwner);
+    function getOwnerAndPendingOwner()
+        external
+        view
+        returns (address _owner, address _pendingOwner)
+    {
+        _owner = owner;
+        _pendingOwner = pendingOwner;
     }
 
     function setFacetForSelectors(SelectorsToFacet[] calldata arr) external onlyOwner {
@@ -41,17 +46,13 @@ contract ActionStorageStatic is StorageLayout, IPActionStorageStatic, IPMiniDiam
         }
     }
 
-    function facetAddress(bytes4 selector) public view returns (address res) {
+    function facetAddress(bytes4 selector) external view returns (address res) {
         res = selectorToFacet[selector];
         require(res != address(0), "selector not found");
     }
 
     // Ownable
-    function transferOwnership(
-        address newOwner,
-        bool direct,
-        bool renounce
-    ) public onlyOwner {
+    function transferOwnership(address newOwner, bool direct, bool renounce) external onlyOwner {
         if (direct) {
             require(newOwner != address(0) || renounce, "Ownable: zero address");
 
@@ -63,7 +64,7 @@ contract ActionStorageStatic is StorageLayout, IPActionStorageStatic, IPMiniDiam
         }
     }
 
-    function claimOwnership() public {
+    function claimOwnership() external {
         address _pendingOwner = pendingOwner;
 
         require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");

package/contracts/offchain-helpers/router-static/{StorageLayout.sol → base/StorageLayout.sol}

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "../../router/base/MarketApproxLib.sol";
-import "../../interfaces/IPBulkSellerFactory.sol";
+import "../../../router/base/MarketApproxLib.sol";
+import "../../../interfaces/IPBulkSellerFactory.sol";
 
-contract StorageLayout {
+abstract contract StorageLayout {
     address internal owner;
     address internal pendingOwner;
 

package/contracts/router/ActionAddRemoveLiq.sol

@@ -22,7 +22,6 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     using MarketApproxPtOutLib for MarketState;
     using PYIndexLib for IPYieldToken;
     using PYIndexLib for PYIndex;
-    using BulkSellerMathCore for BulkSellerState;
 
     /**
      * @notice Adds liquidity to the SY/PT market, granting LP tokens in return
@@ -37,14 +36,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 netSyDesired,
         uint256 netPtDesired,
         uint256 minLpOut
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netSyUsed,
-            uint256 netPtUsed
-        )
-    {
+    ) external returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed) {
         (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         // calculate the amount of SY and PT to be used
@@ -87,15 +79,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         TokenInput calldata input,
         uint256 netPtDesired,
         uint256 minLpOut
-    )
-        external
-        payable
-        returns (
-            uint256 netLpOut,
-            uint256 netTokenUsed,
-            uint256 netPtUsed
-        )
-    {
+    ) external payable returns (uint256 netLpOut, uint256 netTokenUsed, uint256 netPtUsed) {
         (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         uint256 netSyDesired = _mintSyFromToken(market, address(SY), 1, input);

package/contracts/router/ActionSwapYT.sol

@@ -19,9 +19,15 @@ contract ActionSwapYT is ActionBaseCallback, IPActionSwapYT, ActionBaseMintRedee
     using MarketApproxPtOutLib for MarketState;
     using PYIndexLib for IPYieldToken;
 
-    constructor(IAddressProvider provider, uint256 providerId) ActionBaseCallback(_getMarketFactory(provider,providerId)) {}
-
-    function _getMarketFactory(IAddressProvider provider, uint256 providerId) internal view returns (address) {
+    constructor(
+        IAddressProvider provider,
+        uint256 providerId
+    ) ActionBaseCallback(_getMarketFactory(provider, providerId)) {}
+
+    function _getMarketFactory(
+        IAddressProvider provider,
+        uint256 providerId
+    ) internal view returns (address) {
         return provider.get(providerId);
     }
 

package/contracts/router/PendleRouterHelper.sol

@@ -0,0 +1,315 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../interfaces/IPAllAction.sol";
+import "../interfaces/IPMarket.sol";
+import "../interfaces/IPLiquidityMigrator.sol";
+import "./base/ActionBaseMintRedeem.sol";
+import "./base/MarketApproxLib.sol";
+
+contract PendleRouterHelper is TokenHelper, IPLiquidityMigrator {
+    IPAllAction private immutable ROUTER;
+    address private immutable WETH;
+
+    constructor(address _ROUTER, address _WETH) {
+        ROUTER = IPAllAction(_ROUTER);
+        WETH = _WETH;
+    }
+
+    receive() external payable {}
+
+    /// @dev input should be all based on input token being WETH
+    function addLiquiditySingleTokenKeepYtWithEth(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut) {
+        _wrap_unwrap_ETH(NATIVE, WETH, msg.value);
+
+        _safeApproveInf(WETH, address(ROUTER));
+
+        (netLpOut, netYtOut) = ROUTER.addLiquiditySingleTokenKeepYt(
+            receiver,
+            market,
+            minLpOut,
+            minYtOut,
+            input
+        );
+    }
+
+    // ============ Same SY ============
+
+    function migrateDifferentSyNormal(
+        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
+        );
+
+        emit MigrateDifferentSyNormal(
+            fromMarket.market,
+            toMarket.market,
+            msg.sender,
+            fromMarket.netLpToRemove,
+            netLpOut
+        );
+    }
+
+    function migrateDifferentSyKeepYt(
+        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
+        );
+
+        emit MigrateDifferentSyKeepYt(
+            fromMarket.market,
+            toMarket.market,
+            msg.sender,
+            fromMarket.netLpToRemove,
+            netLpOut,
+            netYtOut
+        );
+    }
+
+    function migrateSameSyNormal(
+        RemoveLiquiditySingleSyStruct calldata fromMarket,
+        AddLiquiditySingleSyStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netSyMigrated,
+            uint256 netSyFeeOfRemove,
+            uint256 netSyFeeOfAdd
+        )
+    {
+        (netSyMigrated, netSyFeeOfRemove) = _removeLiquiditySingleSy(fromMarket);
+        (netLpOut, netSyFeeOfAdd) = _addLiquiditySingleSy(toMarket, netSyMigrated);
+        emit MigrateSameSyNormal(
+            fromMarket.market,
+            toMarket.market,
+            msg.sender,
+            fromMarket.netLpToRemove,
+            netLpOut
+        );
+    }
+
+    function migrateSameSyKeepYt(
+        RemoveLiquiditySingleSyStruct calldata fromMarket,
+        AddLiquiditySingleSyKeepYtStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netYtOut,
+            uint256 netSyMigrated,
+            uint256 netSyFeeOfRemove
+        )
+    {
+        (netSyMigrated, netSyFeeOfRemove) = _removeLiquiditySingleSy(fromMarket);
+        (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(toMarket, netSyMigrated);
+        emit MigrateSameSyKeepYt(
+            fromMarket.market,
+            toMarket.market,
+            msg.sender,
+            fromMarket.netLpToRemove,
+            netLpOut,
+            netYtOut
+        );
+    }
+
+    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);
+        }
+    }
+
+    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);
+        }
+    }
+
+    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)
+        );
+    }
+
+    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
+            )
+        );
+    }
+
+    function _addLiquiditySingleTokenKeepYt(
+        AddLiquiditySingleTokenKeepYtStruct calldata toMarket,
+        address tokenToZapIn,
+        uint256 actualNetTokenIn
+    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
+        if (tokenToZapIn == NATIVE) {
+            tokenToZapIn = WETH;
+            _wrap_unwrap_ETH(NATIVE, WETH, actualNetTokenIn);
+        }
+
+        _safeApproveInf(tokenToZapIn, address(ROUTER));
+
+        (netLpOut, netSyFee) = ROUTER.addLiquiditySingleTokenKeepYt(
+            msg.sender,
+            toMarket.market,
+            toMarket.minLpOut,
+            toMarket.minYtOut,
+            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn, toMarket.bulk)
+        );
+    }
+
+    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
+        );
+    }
+
+    // ============ 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/ActionBaseCallback.sol

@@ -58,7 +58,7 @@ abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, To
     /// @dev refer to _swapExactSyForYt
     function _callbackSwapExactSyForYt(
         int256 ptToAccount,
-        int256, /*syToAccount*/
+        int256 /*syToAccount*/,
         bytes calldata data
     ) internal {
         (address receiver, uint256 minYtOut, IPYieldToken YT) = _decodeSwapExactSyForYt(data);
@@ -139,7 +139,7 @@ abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, To
 
     function _callbackSwapExactPtForYt(
         int256 ptToAccount,
-        int256, /*syToAccount*/
+        int256 /*syToAccount*/,
         bytes calldata data
     ) internal {
         (

package/contracts/router/base/ActionBaseMintRedeem.sol

@@ -39,7 +39,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper {
         address receiver,
         address SY,
         uint256 minSyOut,
-        TokenInput calldata inp
+        TokenInput memory inp
     ) internal returns (uint256 netSyOut) {
         SwapType swapType = inp.swapData.swapType;
 
@@ -73,7 +73,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper {
         address SY,
         uint256 netTokenMintSy,
         uint256 minSyOut,
-        TokenInput calldata inp
+        TokenInput memory inp
     ) private returns (uint256 netSyOut) {
         uint256 netNative = inp.tokenMintSy == NATIVE ? netTokenMintSy : 0;
 
@@ -97,7 +97,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper {
         address receiver,
         address SY,
         uint256 netSyIn,
-        TokenOutput calldata out,
+        TokenOutput memory out,
         bool doPull
     ) internal returns (uint256 netTokenOut) {
         SwapType swapType = out.swapData.swapType;
@@ -135,7 +135,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper {
         address receiver,
         address SY,
         uint256 netSyIn,
-        TokenOutput calldata out,
+        TokenOutput memory out,
         bool doPull
     ) private returns (uint256 netTokenRedeemed) {
         if (doPull) {
@@ -193,11 +193,10 @@ 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 memory output
+    ) internal pure returns (address addr) {
         return output.bulk != address(0) ? output.bulk : SY;
     }
 }

package/contracts/router/base/CallbackHelper.sol

@@ -34,15 +34,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactSyForYt(bytes calldata data)
-        internal
-        pure
-        returns (
-            address receiver,
-            uint256 minYtOut,
-            IPYieldToken YT
-        )
-    {
+    function _decodeSwapExactSyForYt(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 minYtOut, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
@@ -75,7 +69,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapSyForExactYt(bytes calldata data)
+    function _decodeSwapSyForExactYt(
+        bytes calldata data
+    )
         internal
         pure
         returns (
@@ -116,15 +112,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapYtForSy(bytes calldata data)
-        internal
-        pure
-        returns (
-            address receiver,
-            uint256 minSyOut,
-            IPYieldToken YT
-        )
-    {
+    function _decodeSwapYtForSy(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 minSyOut, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
@@ -153,7 +143,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactYtForPt(bytes calldata data)
+    function _decodeSwapExactYtForPt(
+        bytes calldata data
+    )
         internal
         pure
         returns (
@@ -192,15 +184,12 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactPtForYt(bytes calldata data)
+    function _decodeSwapExactPtForYt(
+        bytes calldata data
+    )
         internal
         pure
-        returns (
-            address receiver,
-            uint256 exactPtIn,
-            uint256 minYtOut,
-            IPYieldToken YT
-        )
+        returns (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT)
     {
         assembly {
             // first 32 bytes is ActionType