@pendle/core-v2 1.4.4-testnet → 1.6.0-testnet

package/contracts/interfaces/IPFeeDistributorV2.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPFeeDistributorV2 {
+    event SetMerkleRootAndFund(bytes32 indexed merkleRoot, uint256 amountFunded);
+
+    event Claimed(address indexed user, uint256 amountOut);
+
+    event UpdateProtocolClaimable(address indexed user, uint256 sumTopUp);
+
+    struct UpdateProtocolStruct {
+        address user;
+        bytes32[] proof;
+        address[] pools;
+        uint256[] topUps;
+    }
+
+    /**
+     * @notice submit total ETH accrued & proof to claim the outstanding amount. Intended to be
+     used by retail users
+     */
+    function claimRetail(
+        address receiver,
+        uint256 totalAccrued,
+        bytes32[] calldata proof
+    ) external returns (uint256 amountOut);
+
+    /**
+     * @notice Protocols that require the use of this function & feeData should contact the Pendle team.
+     * @notice Protocols should NOT EVER use claimRetail. Using it will make getProtocolFeeData unreliable.
+     */
+    function claimProtocol(address receiver, address[] calldata pools)
+        external
+        returns (uint256 totalAmountOut, uint256[] memory amountsOut);
+
+    /**
+    * @notice returns the claimable fees per pool. Only available if the Pendle team has specifically
+    set up the data
+     */
+    function getProtocolClaimables(address user, address[] calldata pools)
+        external
+        view
+        returns (uint256[] memory claimables);
+
+    function getProtocolTotalAccrued(address user) external view returns (uint256);
+}

package/contracts/interfaces/IPMarket.sol

@@ -84,4 +84,23 @@ interface IPMarket is IERC20Metadata, IPGauge {
     function isExpired() external view returns (bool);
 
     function expiry() external view returns (uint256);
+
+    function observations(
+        uint256 index
+    )
+        external
+        view
+        returns (uint32 blockTimestamp, uint216 lnImpliedRateCumulative, bool initialized);
+
+    function _storage()
+        external
+        view
+        returns (
+            int128 totalPt,
+            int128 totalSy,
+            uint96 lastLnImpliedRate,
+            uint16 observationIndex,
+            uint16 observationCardinality,
+            uint16 observationCardinalityNext
+        );
 }

package/contracts/interfaces/IPPtOracle.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPPtOracle {
+    event SetBlockCycleNumerator(uint16 newBlockCycleNumerator);
+
+    function getPtToAssetRate(
+        address market,
+        uint32 duration
+    ) external view returns (uint256 ptToAssetRate);
+
+    function getOracleState(
+        address market,
+        uint32 duration
+    )
+        external
+        view
+        returns (
+            bool increaseCardinalityRequired,
+            uint16 cardinalityRequired,
+            bool oldestObservationSatisfied
+        );
+}

package/contracts/interfaces/IPRouterHelper.sol

@@ -165,4 +165,12 @@ interface IPRouterHelper {
             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/interfaces/IPYieldToken.sol

@@ -62,4 +62,7 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
     function isExpired() external view returns (bool);
 
     function doCacheIndexSameBlock() external view returns (bool);
+
+    function pyIndexLastUpdatedBlock() external view returns (uint128);
+
 }

package/contracts/interfaces/{IStargatePool.sol → IStargateLP.sol}

@@ -22,7 +22,9 @@
  */
 pragma solidity 0.8.17;
 
-interface IStargatePool {
+interface IStargateLP {
+
+
     struct SwapObj {
         uint256 amount;
         uint256 eqFee;
@@ -45,5 +47,16 @@ interface IStargatePool {
 
     function token() external view returns (address);
 
+    function router() external view returns (address);
+
+    function totalSupply() external view returns (uint256);
+
     function totalLiquidity() external view returns (uint256);
+
+    function mintFeeBP() external view returns (uint256);
+
+    function convertRate() external view returns (uint256);
+
+    function deltaCredit() external view returns (uint256);
+
 }

package/contracts/interfaces/{IStargateLPStaking.sol → IStargateStaking.sol}

@@ -22,7 +22,7 @@
  */
 pragma solidity 0.8.17;
 
-interface IStargateLPStaking {
+interface IStargateStaking {
     struct PoolInfo {
         address lpToken; // Address of LP token contract.
         uint256 allocPoint; // How many allocation points assigned to this pool. STGs to distribute per block.
@@ -41,7 +41,7 @@ interface IStargateLPStaking {
 
     function withdraw(uint256 _pid, uint256 _amount) external;
 
-    function poolInfo(uint256 _pid) external view returns (PoolInfo memory);
+    function poolInfo(uint256 _pid) external view returns (address, uint256, uint256, uint256);
 
     function userInfo(uint256 _pid, address _user) external view returns (UserInfo memory);
 }

package/contracts/offchain-helpers/BoringPtSeller.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "../interfaces/IPMarket.sol";
+
+abstract contract BoringPtSeller {
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    constructor() {}
+
+    /// @dev slippage control should be done on a higher level with the returned parameter
+    /// @param market market address
+    /// @param netPtIn amount of Pt to sell
+    /// @param tokenOut should be included in SY.getTokensOut()
+    /// @return netTokenOut amount of token out
+    function _sellPtForToken(
+        address market,
+        uint256 netPtIn,
+        address tokenOut
+    ) internal returns (uint256 netTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
+            .readTokens();
+
+        uint256 netSyOut;
+        if (PT.isExpired()) {
+            PT.transfer(address(YT), netPtIn);
+            netSyOut = YT.redeemPY(address(SY));
+        } else {
+            // safeTransfer not required
+            PT.transfer(market, netPtIn);
+            (netSyOut, ) = IPMarket(market).swapExactPtForSy(
+                address(SY), // better gas optimization to transfer SY directly to itself and burn
+                netPtIn,
+                EMPTY_BYTES
+            );
+        }
+
+        netTokenOut = SY.redeem(address(this), netSyOut, tokenOut, 0, true);
+    }
+}

package/contracts/offchain-helpers/EmptyUUPS.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+
+contract EmptyUUPS is Initializable, UUPSUpgradeable, BoringOwnableUpgradeable {
+    constructor() initializer {}
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}

package/contracts/offchain-helpers/PendleMulticallV1.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+contract PendleMulticallV1 {
+    struct Call {
+        address target;
+        bytes callData;
+    }
+
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    function aggregate(Call[] calldata calls) public payable virtual {
+        uint256 length = calls.length;
+        Call calldata call;
+        for (uint256 i = 0; i < length; ) {
+            call = calls[i];
+
+            (bool success, bytes memory resp) = call.target.call(call.callData);
+            if (!success) {
+                assembly {
+                    revert(add(32, resp), mload(resp))
+                }
+            }
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function tryAggregate(
+        bool requireSuccess,
+        uint256 gasLimit,
+        Call[] calldata calls
+    ) public payable returns (Result[] memory returnData) {
+        uint256 length = calls.length;
+        returnData = new Result[](length);
+        Call calldata call;
+        for (uint256 i = 0; i < length; ) {
+            call = calls[i];
+
+            (bool success, bytes memory resp) = call.target.call{ gas: gasLimit }(
+                calls[i].callData
+            );
+            if (!success && requireSuccess) {
+                assembly {
+                    revert(add(32, resp), mload(resp))
+                }
+            }
+
+            returnData[i] = Result(success, resp);
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+}

package/contracts/oracles/PendlePtOracle.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./PendlePtOracleLib.sol";
+import "../interfaces/IPPtOracle.sol";
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+
+contract PendlePtOracle is BoringOwnableUpgradeable, IPPtOracle {
+    using PendlePtOracleLib for IPMarket;
+
+    error InvalidBlockRate(uint256 blockCycleNumerator);
+    error TwapDurationTooLarge(uint32 duration, uint32 cardinalityRequired);
+
+    /// @notice Oracles will be created ensuring a lowerbound in PendleMarket oracle's cardinality
+    /// @dev Cardinality lowerbound will be calculated as twap_duration * 1000 / blockCycleNumerator
+    /// @dev blockCycleNumerator should be configured so that blockCycleNumerator / 1000 < actual block cycle
+    /// @dev blockCycleNumerator should be greater or equal to 1000 since the oracle only records one
+    /// rate per timestamp
+    /// For example, on Ethereum blockCycleNumerator = 11000, where 11000/1000 = 11 < 12
+    ///                 Arbitrum blockCycleNumerator = 1000, since we can't do better than this
+    uint16 public blockCycleNumerator;
+    uint16 public constant BLOCK_CYCLE_DENOMINATOR = 1000;
+
+    constructor(uint16 _blockCycleNumerator) initializer {
+        __BoringOwnable_init();
+        setBlockCycleNumerator(_blockCycleNumerator);
+    }
+
+    function setBlockCycleNumerator(uint16 newBlockCycleNumerator) public onlyOwner {
+        if (newBlockCycleNumerator < BLOCK_CYCLE_DENOMINATOR) {
+            revert InvalidBlockRate(newBlockCycleNumerator);
+        }
+
+        blockCycleNumerator = newBlockCycleNumerator;
+        emit SetBlockCycleNumerator(newBlockCycleNumerator);
+    }
+
+    /**
+     * This function returns the twap rate PT/Asset on market
+     * @param market market to get rate from
+     * @param duration twap duration
+     */
+    function getPtToAssetRate(
+        address market,
+        uint32 duration
+    ) external view returns (uint256 ptToAssetRate) {
+        ptToAssetRate = IPMarket(market).getPtToAssetRate(duration);
+    }
+
+    /**
+     * A check function for the cardinality status of the market
+     * @param market PendleMarket address
+     * @param duration twap duration
+     * @return increaseCardinalityRequired a boolean indicates whether the cardinality should be increased to serve the duration
+     * @return cardinalityRequired the amount of cardinality required for the twap duration
+     */
+    function getOracleState(
+        address market,
+        uint32 duration
+    )
+        external
+        view
+        returns (
+            bool increaseCardinalityRequired,
+            uint16 cardinalityRequired,
+            bool oldestObservationSatisfied
+        )
+    {
+        (
+            ,
+            ,
+            ,
+            uint16 observationIndex,
+            uint16 observationCardinality,
+            uint16 cardinalityReserved
+        ) = IPMarket(market)._storage();
+
+        // checkIncreaseCardinalityRequired
+        cardinalityRequired = _calcCardinalityRequiredRequired(duration);
+        increaseCardinalityRequired = cardinalityReserved < cardinalityRequired;
+
+        // check oldestObservationSatisfied
+        (uint32 oldestTimestamp, , bool initialized) = IPMarket(market).observations(
+            (observationIndex + 1) % observationCardinality
+        );
+        if (!initialized) {
+            (oldestTimestamp, , ) = IPMarket(market).observations(0);
+        }
+        oldestObservationSatisfied = oldestTimestamp < block.timestamp - duration;
+    }
+
+    function _calcCardinalityRequiredRequired(uint32 duration) internal view returns (uint16) {
+        uint32 cardinalityRequired = (duration * BLOCK_CYCLE_DENOMINATOR) / blockCycleNumerator;
+        if (cardinalityRequired > type(uint16).max) {
+            revert TwapDurationTooLarge(duration, cardinalityRequired);
+        }
+        return uint16(cardinalityRequired);
+    }
+}

package/contracts/oracles/PendlePtOracleLib.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../interfaces/IPMarket.sol";
+import "../core/libraries/math/Math.sol";
+
+library PendlePtOracleLib {
+    using Math for uint256;
+
+    /**
+     * This function returns the twap rate PT/Asset on market
+     * @param market market to get rate from
+     * @param duration twap duration
+     */
+    function getPtToAssetRate(IPMarket market, uint32 duration)
+        internal
+        view
+        returns (uint256 ptToAssetRate)
+    {
+        uint256 expiry = market.expiry();
+        if (expiry <= block.timestamp) {
+            return _getPtToAssetRatePostExpiry(market);
+        }
+        uint256 lnImpliedRate = _getMarketLnImpliedRate(market, duration);
+        uint256 timeToExpiry = expiry - block.timestamp;
+        uint256 assetToPtRate = uint256(
+            MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry)
+        );
+
+        ptToAssetRate = Math.ONE.divDown(assetToPtRate);
+    }
+
+    function _getMarketLnImpliedRate(IPMarket market, uint32 duration)
+        private
+        view
+        returns (uint256)
+    {
+        uint32[] memory durations = new uint32[](2);
+        durations[0] = duration;
+
+        uint216[] memory lnImpliedRateCumulative = market.observe(durations);
+        return (lnImpliedRateCumulative[1] - lnImpliedRateCumulative[0]) / duration;
+    }
+
+    function _getPtToAssetRatePostExpiry(IPMarket market) private view returns (uint256) {
+        (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
+
+        uint256 syIndex = SY.exchangeRate();
+        uint256 pyIndexCurrent;
+
+        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
+            pyIndexCurrent = YT.pyIndexStored();
+        } else {
+            pyIndexCurrent = Math.max(syIndex, YT.pyIndexStored());
+        }
+
+        return syIndex.divDown(pyIndexCurrent);
+    }
+}

package/contracts/oracles/samples/PendlePtGlpOracle.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../PendlePtOracleLib.sol";
+import "../../interfaces/IPPtOracle.sol";
+import "../../interfaces/GMX/IGlpManager.sol";
+import "../../core/libraries/math/Math.sol";
+
+/**
+ * @notice The returned price from this contract is multiply with the USD price of GLP read from
+ * GLPManager contract
+ *
+ * @dev This contract uses the PendlePtOracleLibrary to get the price instead of calling PendlePtOracle contract
+ * to save 1 external call gas consumption
+ */
+contract PendlePtGlpOracle {
+    using PendlePtOracleLib for IPMarket;
+
+    uint32 public immutable twapDuration;
+    address public immutable market;
+    address public immutable glpManager;
+    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
+
+    constructor(
+        address _ptOracle,
+        uint32 _twapDuration,
+        address _market,
+        address _glpManager
+    ) {
+        twapDuration = _twapDuration;
+        market = _market;
+        glpManager = _glpManager;
+
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(
+            _ptOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired || !oldestObservationSatisfied) {
+            revert OracleNotReady(increaseCardinalityRequired, oldestObservationSatisfied);
+        }
+    }
+
+    function getPtPrice() external view virtual returns (uint256) {
+        // using library directly to save 1 external call (gas optimization)
+        uint256 ptRate = IPMarket(market).getPtToAssetRate(twapDuration);
+        uint256 assetPrice = IGlpManager(glpManager).getPrice(true);
+        return (assetPrice * ptRate) / (10 ** 30);
+    }
+
+    function decimals() external pure virtual returns (uint8) {
+        return 18;
+    }
+}

package/contracts/oracles/samples/PendlePtUsdChainlinkOracle.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../interfaces/IPPtOracle.sol";
+import "../../core/libraries/math/Math.sol";
+import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+/**
+ * @notice The returned price from this contract is multiply with the default USD price of asset
+ * read from Chainlink Oracles
+ *
+ * @dev The ptRate is fetched from PendlePtOracle contract
+ */
+contract PendlePtUsdChainlinkOracle {
+    address public immutable ptOracle;
+    uint32 public immutable twapDuration;
+    address public immutable market;
+    address public immutable feed;
+    uint8 public immutable feedDecimals;
+
+    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
+
+    constructor(
+        address _ptOracle,
+        uint32 _twapDuration,
+        address _market,
+        address _feed
+    ) {
+        ptOracle = _ptOracle;
+        twapDuration = _twapDuration;
+        market = _market;
+        feed = _feed;
+        feedDecimals = IChainlinkAggregator(feed).decimals();
+
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(
+            _ptOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired || !oldestObservationSatisfied) {
+            revert OracleNotReady(increaseCardinalityRequired, oldestObservationSatisfied);
+        }
+    }
+
+    function getPtPrice() external view virtual returns (uint256) {
+        uint256 ptRate = IPPtOracle(ptOracle).getPtToAssetRate(market, twapDuration);
+        uint256 assetPrice = _getUnderlyingAssetPrice();
+        return (assetPrice * ptRate) / Math.ONE;
+    }
+
+    function _getUnderlyingAssetPrice() internal view virtual returns (uint256) {
+        uint256 rawPrice = uint256(IChainlinkAggregator(feed).latestAnswer());
+        return
+            feedDecimals < 18
+                ? rawPrice * 10**(18 - feedDecimals)
+                : rawPrice / 10**(feedDecimals - 18);
+    }
+
+    function decimals() external pure virtual returns (uint8) {
+        return 18;
+    }
+}

package/contracts/router/PendleRouterHelper.sol

@@ -15,6 +15,7 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
     constructor(address _ROUTER, IAddressProvider provider) {
         ROUTER = IPAllAction(_ROUTER);
         WETH = _getWETHAddress(provider, 1);
+        _safeApproveInf(WETH, address(ROUTER));
     }
 
     function _getWETHAddress(IAddressProvider provider, uint256 providerId)
@@ -75,7 +76,7 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
             uint256 netSyFeeOfAdd
         )
     {
-        (netTokenZapIn, netSyFeeOfRemove) = _removeLiquiditySingleToken(fromMarket);
+        (netTokenZapIn, netSyFeeOfRemove) = removeLiquiditySingleToken(fromMarket);
         (netLpOut, netSyFeeOfAdd) = _addLiquiditySingleToken(
             toMarket,
             fromMarket.output.tokenOut,
@@ -95,7 +96,7 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
             uint256 netSyFeeOfRemove
         )
     {
-        (netTokenZapIn, netSyFeeOfRemove) = _removeLiquiditySingleToken(fromMarket);
+        (netTokenZapIn, netSyFeeOfRemove) = removeLiquiditySingleToken(fromMarket);
         (netLpOut, netYtOut) = _addLiquiditySingleTokenKeepYt(
             toMarket,
             fromMarket.output.tokenOut,
@@ -115,7 +116,7 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
             uint256 netSyFeeOfAdd
         )
     {
-        (netSyZapIn, netSyFeeOfRemove) = _removeLiquiditySingleSy(fromMarket);
+        (netSyZapIn, netSyFeeOfRemove) = removeLiquiditySingleSy(fromMarket);
         (netLpOut, netSyFeeOfAdd) = _addLiquiditySingleSy(toMarket, netSyZapIn);
     }
 
@@ -131,12 +132,12 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
             uint256 netSyFeeOfRemove
         )
     {
-        (netSyZapIn, netSyFeeOfRemove) = _removeLiquiditySingleSy(fromMarket);
+        (netSyZapIn, netSyFeeOfRemove) = removeLiquiditySingleSy(fromMarket);
         (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(toMarket, netSyZapIn);
     }
 
-    function _removeLiquiditySingleToken(RemoveLiquiditySingleTokenStruct calldata fromMarket)
-        internal
+    function removeLiquiditySingleToken(RemoveLiquiditySingleTokenStruct calldata fromMarket)
+        public
         returns (uint256 netTokenOut, uint256 netSyFee)
     {
         _transferFrom(
@@ -169,8 +170,8 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
         );
     }
 
-    function _removeLiquiditySingleSy(RemoveLiquiditySingleSyStruct calldata fromMarket)
-        internal
+    function removeLiquiditySingleSy(RemoveLiquiditySingleSyStruct calldata fromMarket)
+        public
         returns (uint256 netSyOut, uint256 netSyFee)
     {
         _transferFrom(

package/contracts/router/base/ActionBaseMintRedeem.sol

@@ -39,7 +39,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper {
         address receiver,
         address SY,
         uint256 minSyOut,
-        TokenInput memory inp
+        TokenInput calldata 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 memory inp
+        TokenInput calldata 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 memory out,
+        TokenOutput calldata 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 memory out,
+        TokenOutput calldata out,
         bool doPull
     ) private returns (uint256 netTokenRedeemed) {
         if (doPull) {
@@ -193,7 +193,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper {
         if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
     }
 
-    function _syOrBulk(address SY, TokenOutput memory output)
+    function _syOrBulk(address SY, TokenOutput calldata output)
         internal
         pure
         returns (address addr)

package/deployments/43113-core.json

@@ -22,10 +22,11 @@
     "router": "0xFC0F1237961A6ecEacAC86aD407e181Ecd5e673C",
     "pendleSwap": "0xc6404511EF2C4C05A15446aF7D54FB63AFbe4d47",
     "routerStatic": "0xedd45b3164b2B7E3d2FE7B9F1b0495825678FA95",
-    "routerHelper": "0xF44192359bBD426b5611a38D5FfDc96455C43e7e",
+    "routerHelper": "0x3C201799c6AdaaBC84C4D5DE736EA2F32c4F1649",
     "vePendle": "0xB20E3c268C993BC3c9Bc1C1cc5D7491F2268cD91",
     "senderEndpoint": "0x86bD575c36e236386284C035ffeBE66CB6ecd2DD",
     "votingController": "0x40ea97a7E9A4A0520229d1bbdf4D82E36b1a5475",
     "gaugeController": "0x90Fa61ea34f61e31e9471CEB0ED22b12bBf4263E",
-    "feeDistributor": "0x40160f3439317bCD0ec8eB09545dD6A30771A7B6"
+    "feeDistributor": "0x40160f3439317bCD0ec8eB09545dD6A30771A7B6",
+    "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9"
 }