@pendle/core-v2 6.4.4-swaphubtest → 6.5.0

package/contracts/core/Market/{PendleMarketFactoryV6Upg.sol → PendleMarketFactoryV7Upg.sol}

@@ -10,10 +10,10 @@ import "../libraries/BaseSplitCodeFactory.sol";
 import "../libraries/BoringOwnableUpgradeableV2.sol";
 import "../libraries/Errors.sol";
 
-contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory {
+contract PendleMarketFactoryV7Upg is BoringOwnableUpgradeableV2, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
 
-    uint256 public constant VERSION = 6;
+    uint256 public constant VERSION = 7;
 
     address public immutable marketCreationCodeContractA;
     uint256 public immutable marketCreationCodeSizeA;
@@ -21,7 +21,6 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
     uint256 public immutable marketCreationCodeSizeB;
 
     address public immutable yieldContractFactory;
-    address public immutable vePendle;
     address public immutable gaugeController;
 
     uint256 public immutable maxLnFeeRateRoot;
@@ -44,7 +43,6 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
         uint256 _marketCreationCodeSizeA,
         address _marketCreationCodeContractB,
         uint256 _marketCreationCodeSizeB,
-        address _vePendle,
         address _gaugeController
     ) {
         yieldContractFactory = _yieldContractFactory;
@@ -55,7 +53,6 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
         marketCreationCodeContractB = _marketCreationCodeContractB;
         marketCreationCodeSizeB = _marketCreationCodeSizeB;
 
-        vePendle = _vePendle;
         gaugeController = _gaugeController;
 
         _disableInitializers();
@@ -91,7 +88,7 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
         market = BaseSplitCodeFactory._create2(
             0,
             bytes32(block.chainid),
-            abi.encode(PT, scalarRoot, initialAnchor, lnFeeRateRoot, vePendle, gaugeController),
+            abi.encode(PT, scalarRoot, initialAnchor, lnFeeRateRoot, gaugeController),
             marketCreationCodeContractA,
             marketCreationCodeSizeA,
             marketCreationCodeContractB,

package/contracts/core/Market/{PendleMarketV6.sol → PendleMarketV7.sol}

@@ -16,7 +16,7 @@ import "./PendleGauge.sol";
  * - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
  *     guaranteed by address(0) & address(this) check in each updateForTwo function
  */
-contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
+contract PendleMarketV7 is PendleERC20, PendleGauge, IPMarket {
     using PMath for uint256;
     using PMath for int256;
     using MarketMathCore for MarketState;
@@ -44,7 +44,7 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
     string private constant LP_NAME_PREF = "PLP ";
     string private constant LP_SYMBOL_PREF = "PLP-";
 
-    uint256 public constant VERSION = 6;
+    uint256 public constant VERSION = 7;
 
     IPPrincipalToken internal immutable PT;
     IStandardizedYield internal immutable SY;
@@ -66,16 +66,9 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
         _;
     }
 
-    constructor(
-        address _PT,
-        int256 _scalarRoot,
-        int256 _initialAnchor,
-        uint80 _lnFeeRateRoot,
-        address _vePendle,
-        address _gaugeController
-    )
+    constructor(address _PT, int256 _scalarRoot, int256 _initialAnchor, uint80 _lnFeeRateRoot, address _gaugeController)
         PendleERC20(_getLPName(_PT), _getLPSymbol(_PT), 18)
-        PendleGauge(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController)
+        PendleGauge(IPPrincipalToken(_PT).SY(), _gaugeController)
     {
         PT = IPPrincipalToken(_PT);
         SY = IStandardizedYield(PT.SY());
@@ -370,11 +363,11 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
                     PENDLE GAUGE - RELATED
     //////////////////////////////////////////////////////////////*/
 
-    function _stakedBalance(address user) internal view override returns (uint256) {
+    function _rewardSharesUser(address user) internal view override returns (uint256) {
         return balanceOf(user);
     }
 
-    function _totalStaked() internal view override returns (uint256) {
+    function _rewardSharesTotal() internal view override returns (uint256) {
         return totalSupply();
     }
 
@@ -386,8 +379,15 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
         PendleGauge._beforeTokenTransfer(from, to, amount);
     }
 
-    // solhint-disable-next-line ordering
-    function _afterTokenTransfer(address from, address to, uint256 amount) internal override(PendleERC20, PendleGauge) {
-        PendleGauge._afterTokenTransfer(from, to, amount);
+    /*///////////////////////////////////////////////////////////////
+                            LEGACY FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function totalActiveSupply() external view returns (uint256) {
+        return totalSupply();
+    }
+
+    function activeBalance(address user) external view returns (uint256) {
+        return balanceOf(user);
     }
 }

package/contracts/core/libraries/Errors.sol

@@ -138,7 +138,7 @@ library Errors {
     error VEReceiveOldSupply(uint256 msgTime);
 
     error GCNotPendleMarket(address caller);
-    error GCNotVotingController(address caller);
+    error GCNotRewardDataUpdater(address caller);
 
     error InvalidWTime(uint256 wTime);
     error ExpiryInThePast(uint256 expiry);

package/contracts/core/libraries/math/PMath.sol

@@ -211,6 +211,11 @@ library PMath {
         return uint80(x);
     }
 
+    function Uint152(uint256 x) internal pure returns (uint152) {
+        require(x <= type(uint152).max);
+        return uint152(x);
+    }
+
     function isAApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
         return mulDown(b, ONE - eps) <= a && a <= mulDown(b, ONE + eps);
     }

package/contracts/interfaces/IPGauge.sol

@@ -3,10 +3,4 @@ pragma solidity ^0.8.0;
 
 interface IPGauge {
     event RedeemRewards(address indexed user, uint256[] rewardsOut);
-
-    event UpdateActiveBalance(address indexed user, uint256 newActiveBalance);
-
-    function totalActiveSupply() external view returns (uint256);
-
-    function activeBalance(address user) external view returns (uint256);
 }

package/contracts/interfaces/IPGaugeController.sol

@@ -4,17 +4,30 @@ pragma solidity ^0.8.0;
 interface IPGaugeController {
     event MarketClaimReward(address indexed market, uint256 amount);
 
+    // deprecated from MarketV7 onwards
     event ReceiveVotingResults(uint128 indexed wTime, address[] markets, uint256[] pendleAmounts);
 
+    // deprecated from MarketV7 onwards
     event UpdateMarketReward(address indexed market, uint256 pendlePerSec, uint256 incentiveEndsAt);
 
-    function fundPendle(uint256 amount) external;
+    event UpdateMarketRewardV2(address indexed market, uint128 pendlePerSec, uint128 incentiveEndsAt);
+
+    function setRewardDatas(
+        address[] calldata markets,
+        uint128[] calldata pendlePerSecs,
+        uint128[] calldata incentiveEndsAts
+    ) external;
 
     function withdrawPendle(uint256 amount) external;
 
-    function pendle() external returns (address);
+    function pendle() external view returns (address);
 
     function redeemMarketReward() external;
 
-    function rewardData(address pool) external view returns (uint128 pendlePerSec, uint128, uint128, uint128);
+    function rewardData(
+        address market
+    )
+        external
+        view
+        returns (uint128 pendlePerSec, uint128 accumulatedPendle, uint128 lastUpdated, uint128 incentiveEndsAt);
 }

package/contracts/interfaces/IPMarket.sol

@@ -86,4 +86,16 @@ interface IPMarket is IPGauge, IERC20Metadata {
     function VERSION() external pure returns (uint256);
 
     function reentrancyGuardEntered() external view returns (bool);
+
+    /*///////////////////////////////////////////////////////////////
+                            LEGACY FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Kept for backward compatibility
+    /// @dev From version 7, this function returns `totalSupply()`.
+    function totalActiveSupply() external view returns (uint256);
+
+    /// @dev Kept for backward compatibility
+    /// @dev From version 7, this function returns `balanceOf(user)`.
+    function activeBalance(address user) external view returns (uint256);
 }

package/contracts/interfaces/IPStakedPendle.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+interface IPStakedPendle {
+    struct Call3 {
+        bool allowFailure;
+        bytes callData;
+    }
+
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    struct UserCooldown {
+        uint104 cooldownStart;
+        uint152 amount;
+    }
+
+    event CooldownDurationAndFeeUpdated(uint24 newDuration, uint64 instantUnstakeFeeRate);
+
+    event Staked(address indexed user, uint256 amount);
+
+    event Unstaked(address indexed user, uint256 amountAfterFee, uint256 fee);
+
+    event CooldownCanceled(address indexed user, uint256 amount);
+
+    event CooldownInitiated(address indexed user, uint256 amount, uint256 cooldownStart);
+
+    event FeeReceiverUpdated(address indexed feeReceiver);
+
+    // ======== Getters ========
+
+    function PENDLE() external view returns (address);
+
+    function cooldownDuration() external view returns (uint24);
+
+    function instantUnstakeFeeRate() external view returns (uint64);
+
+    function feeReceiver() external view returns (address);
+
+    // ======== Staking functions ========
+
+    function userCooldown(address user) external view returns (uint104 cooldownStart, uint152 amount);
+
+    function stake(uint256 amount) external;
+
+    function cooldown(uint256 amount) external;
+
+    function cancelCooldown() external;
+
+    // fee-free, after cooldown
+    function finalizeCooldown() external returns (uint256 amount);
+
+    // instant, but with fee
+    function instantUnstake(uint256 amount) external returns (uint256 amountAfterFee, uint256 fee);
+
+    // ======== Misc helper functions =======
+
+    function multicall(Call3[] calldata calls) external returns (Result[] memory res);
+
+    // ======== Admin functions ========
+
+    function setCooldownDurationAndFee(uint24 newDuration, uint64 newInstantUnstakeFeeRate) external;
+
+    function setFeeReceiver(address newFeeReceiver) external;
+}

package/contracts/offchain-helpers/BalanceReader.sol

@@ -6,6 +6,10 @@ import "../interfaces/IPMarket.sol";
 import "../interfaces/IStandardizedYield.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
+interface ILegacyMarket {
+    function activeBalance(address user) external view returns (uint256);
+}
+
 contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
     struct UserMarketInfo {
         uint256 lpBalance;
@@ -44,7 +48,13 @@ contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
             (, IPPrincipalToken PT, IPYieldToken YT) = market.readTokens();
 
             info.lpBalance = market.balanceOf(user);
-            info.lpActiveBalance = market.activeBalance(user);
+
+            try ILegacyMarket(address(market)).activeBalance(user) returns (uint256 activeBalance) {
+                info.lpActiveBalance = activeBalance;
+            } catch {
+                info.lpActiveBalance = 0;
+            }
+
             info.lpRewardsOut = _redeemRewards(market, user);
 
             info.ytBalance = YT.balanceOf(user);

package/contracts/offchain-helpers/MarketSweed.sol

@@ -2,10 +2,10 @@
 
 pragma solidity ^0.8.17;
 
+import "../interfaces/IMarketSweed.sol";
 import "../interfaces/IPMarket.sol";
-import "../router/math/MarketApproxLibOnchain.sol";
 import "../router/base/ActionBase.sol";
-import "../interfaces/IMarketSweed.sol";
+import "../router/math/MarketApproxLibOnchain.sol";
 
 contract MarketSweed is ActionBase, IMarketSweed {
     using PMath for uint256;
@@ -40,29 +40,31 @@ contract MarketSweed is ActionBase, IMarketSweed {
         (netPtOut, netYtOut, guessedAmountPtToSwap) = _swap(receiver, market, tokens, sweedParams);
 
         uint256 netYtFromSeed;
-        (netLpOut, netYtFromSeed, ) = _seed(receiver, market, tokens, _selfBalance(tokens.SY), netPtOut);
+        (netLpOut, netYtFromSeed,) = _seed(receiver, market, tokens, _selfBalance(tokens.SY), netPtOut);
         netYtOut += netYtFromSeed;
 
         if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
         if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
     }
 
-    function mintPYFromToken__noCall(
-        address YT,
-        TokenInput calldata input
-    ) external payable returns (uint256 netPYOut) {
+    function mintPYFromToken__noCall(address YT, TokenInput calldata input)
+        external
+        payable
+        returns (uint256 netPYOut)
+    {
         address SY = IPYieldToken(YT).SY();
         _mintSyFromToken(YT, SY, 1, input);
         netPYOut = IPYieldToken(YT).mintPY(msg.sender, msg.sender);
     }
 
-    function _seed(
-        address receiver,
-        address market,
-        MarketTokens memory tokens,
-        uint256 netSyIn,
-        uint256 netPtIn
-    ) internal returns (uint256 /*netLpOut*/, uint256 /*netYtOut*/, uint256 /*netSyMintPy*/) {
+    function _seed(address receiver, address market, MarketTokens memory tokens, uint256 netSyIn, uint256 netPtIn)
+        internal
+        returns (
+            uint256, /*netLpOut*/
+            uint256, /*netYtOut*/
+            uint256 /*netSyMintPy*/
+        )
+    {
         uint256 netSyMintPy = _calcSyToMintPYSeed(market, tokens, netSyIn, netPtIn);
 
         // transfer SY to mint PY
@@ -74,16 +76,14 @@ contract MarketSweed is ActionBase, IMarketSweed {
         _transferOut(address(tokens.SY), market, netSyAddLiquidity);
         _transferOut(address(tokens.PT), market, netPtIn);
 
-        (uint256 netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netPYMinted + netPtIn);
+        (uint256 netLpOut,,) = IPMarket(market).mint(receiver, netSyAddLiquidity, netPYMinted + netPtIn);
         return (netLpOut, netPYMinted, netSyMintPy);
     }
 
-    function _swap(
-        address receiver,
-        address market,
-        MarketTokens memory tokens,
-        ApproxSweedParams memory sweedParams
-    ) internal returns (uint256 amountPtToAccount, uint256 amountYTToAccount, int256 guessedSwap) {
+    function _swap(address receiver, address market, MarketTokens memory tokens, ApproxSweedParams memory sweedParams)
+        internal
+        returns (uint256 amountPtToAccount, uint256 amountYTToAccount, int256 guessedSwap)
+    {
         PYIndex index = _getPYIndex(market);
         MarketState memory state = _readMarket(market);
         MarketPreCompute memory comp = state.getMarketPreCompute(index, block.timestamp);
@@ -94,10 +94,8 @@ contract MarketSweed is ActionBase, IMarketSweed {
 
         if (state.lastLnImpliedRate > sweedParams.targetLnImpliedRate) {
             // Normalize maxPtToSwap
-            sweedParams.maxPtToSwap = PMath.min(
-                sweedParams.maxPtToSwap,
-                MarketApproxPtOutLibOnchain.calcMaxPtOut(comp, state.totalPt)
-            );
+            sweedParams.maxPtToSwap =
+                PMath.min(sweedParams.maxPtToSwap, MarketApproxPtOutLibOnchain.calcMaxPtOut(comp, state.totalPt));
 
             int256 amountSyToAccount;
 
@@ -108,10 +106,8 @@ contract MarketSweed is ActionBase, IMarketSweed {
             IPMarket(market).swapSyForExactPt(address(this), guessedSwap.abs(), EMPTY_BYTES);
         } else {
             // Normalize maxPtToSwap
-            sweedParams.maxPtToSwap = PMath.min(
-                sweedParams.maxPtToSwap,
-                MarketApproxPtInLibOnchain.calcSoftMaxPtIn(state, comp)
-            );
+            sweedParams.maxPtToSwap =
+                PMath.min(sweedParams.maxPtToSwap, MarketApproxPtInLibOnchain.calcSoftMaxPtIn(state, comp));
 
             guessedSwap = _calcAmountPtToSell(state, index, sweedParams);
 
@@ -128,11 +124,11 @@ contract MarketSweed is ActionBase, IMarketSweed {
         }
     }
 
-    function _calcAmountPtToBuy(
-        MarketState memory state,
-        PYIndex index,
-        ApproxSweedParams memory sweedParams
-    ) internal view returns (int256 amountPtToSwapToAccount, int256 amountSyToAccount) {
+    function _calcAmountPtToBuy(MarketState memory state, PYIndex index, ApproxSweedParams memory sweedParams)
+        internal
+        view
+        returns (int256 amountPtToSwapToAccount, int256 amountSyToAccount)
+    {
         int256 refAmt = sweedParams.maxPtToSwap.Int();
         int256 accPtToAccount = 0;
         MarketState memory localState;
@@ -148,7 +144,7 @@ contract MarketSweed is ActionBase, IMarketSweed {
 
             _makeACopyTo(state, localState);
             // Will not revert. maxPtToBuy should already be normalized
-            (int256 localAmountSyToAccount, , ) = localState.executeTradeCore(index, guess, block.timestamp);
+            (int256 localAmountSyToAccount,,) = localState.executeTradeCore(index, guess, block.timestamp);
 
             if (PMath.isAApproxB(localState.lastLnImpliedRate, sweedParams.targetLnImpliedRate, sweedParams.eps)) {
                 return (guess, localAmountSyToAccount);
@@ -161,11 +157,11 @@ contract MarketSweed is ActionBase, IMarketSweed {
         revert("_calcAmountPtToBuy: failed");
     }
 
-    function _calcAmountPtToSell(
-        MarketState memory state,
-        PYIndex index,
-        ApproxSweedParams memory sweedParams
-    ) internal view returns (int256 amountPtToSwapToAccount) {
+    function _calcAmountPtToSell(MarketState memory state, PYIndex index, ApproxSweedParams memory sweedParams)
+        internal
+        view
+        returns (int256 amountPtToSwapToAccount)
+    {
         int256 refAmt = sweedParams.maxPtToSwap.Int();
         int256 accPtToAccount = 0;
         MarketState memory localState;
@@ -195,19 +191,16 @@ contract MarketSweed is ActionBase, IMarketSweed {
         revert("_calcAmountPtToSell: failed");
     }
 
-    function _calcSyToMintPYSeed(
-        address market,
-        MarketTokens memory tokens,
-        uint256 netSyIn,
-        uint256 netPtIn
-    ) internal returns (uint256 /* netSyMintPy */) {
+    function _calcSyToMintPYSeed(address market, MarketTokens memory tokens, uint256 netSyIn, uint256 netPtIn)
+        internal
+        returns (
+            uint256 /* netSyMintPy */
+        )
+    {
         uint256 netSyMintPy = netSyIn;
         if (netPtIn > 0) {
-            (, , uint256 netSyDual, uint256 netPtDual) = _readMarket(market).addLiquidity(
-                netSyIn,
-                netPtIn,
-                block.timestamp
-            );
+            (,, uint256 netSyDual, uint256 netPtDual) =
+                _readMarket(market).addLiquidity(netSyIn, netPtIn, block.timestamp);
             if (netPtDual < netPtIn) {
                 revert("MS: Bought too much PT");
             }
@@ -217,14 +210,13 @@ contract MarketSweed is ActionBase, IMarketSweed {
         MarketState memory state = _readMarket(market);
         PYIndex pyIndex = tokens.YT.newIndex();
         netSyMintPy =
-            (netSyMintPy * state.totalPt.Uint()) /
-            (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
+            (netSyMintPy * state.totalPt.Uint()) / (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
 
         return netSyMintPy;
     }
 
     function _getPYIndex(address market) internal returns (PYIndex) {
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (,, IPYieldToken YT) = IPMarket(market).readTokens();
         return PYIndex.wrap(YT.pyIndexCurrent());
     }
 

package/contracts/offchain-helpers/PendleMerkleDepositor.sol

@@ -16,11 +16,10 @@ contract PendleMerkleDepositor {
     }
 
     /// @notice The `tokens` array must be sorted in strictly ascending order with no duplicates.
-    function depositToMerkleCampaign(
-        bytes32 campaignId,
-        address[] calldata tokens,
-        uint256[] calldata amounts
-    ) external payable {
+    function depositToMerkleCampaign(bytes32 campaignId, address[] calldata tokens, uint256[] calldata amounts)
+        external
+        payable
+    {
         uint256 length = tokens.length;
 
         require(length != 0, "PMD: empty array");
@@ -51,7 +50,7 @@ contract PendleMerkleDepositor {
 
     function _transferFrom(address token, address from, address to, uint256 amount) internal {
         if (token == NATIVE) {
-            (bool success, ) = to.call{value: amount}("");
+            (bool success,) = to.call{value: amount}("");
             require(success, "PMD: eth send failed");
         } else {
             IERC20(token).safeTransferFrom(from, to, amount);

package/contracts/router/ActionCrossChain.sol

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import {ActionBase} from "./base/ActionBase.sol";
-import {TokenOutput, IPActionCrossChain} from "../interfaces/IPActionCrossChain.sol";
+import {IPActionCrossChain, TokenOutput} from "../interfaces/IPActionCrossChain.sol";
 import {IPFixedPricePTAMM} from "../interfaces/IPFixedPricePTAMM.sol";
+import {ActionBase} from "./base/ActionBase.sol";
+import {IPSwapAggregator, SwapType} from "./swap-aggregator/IPSwapAggregator.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {SwapType, IPSwapAggregator} from "./swap-aggregator/IPSwapAggregator.sol";
 
 contract ActionCrossChain is ActionBase, IPActionCrossChain {
     function swapWithFixedPricePTAMM(
@@ -16,13 +16,8 @@ contract ActionCrossChain is ActionBase, IPActionCrossChain {
         TokenOutput calldata out
     ) external returns (uint256 netTokenOut) {
         _transferFrom(IERC20(PT), msg.sender, fixedPricePTAMM, exactPtIn);
-        uint256 tokenOut = IPFixedPricePTAMM(fixedPricePTAMM).swapExactPtForToken(
-            __swapDestination(receiver, out),
-            PT,
-            exactPtIn,
-            out.tokenRedeemSy,
-            EMPTY_BYTES
-        );
+        uint256 tokenOut = IPFixedPricePTAMM(fixedPricePTAMM)
+            .swapExactPtForToken(__swapDestination(receiver, out), PT, exactPtIn, out.tokenRedeemSy, EMPTY_BYTES);
         return __handleTokenOutput(receiver, tokenOut, out);
     }
 
@@ -41,15 +36,16 @@ contract ActionCrossChain is ActionBase, IPActionCrossChain {
         else return out.pendleSwap;
     }
 
-    /// @dev The caller must ensure that the address returned by `__swapDestination(...)` has `netTokenRedeemSy` amount of `out.tokenRedeemSy` tokens before calling this function.
-    function __handleTokenOutput(
-        address receiver,
-        uint256 netTokenRedeemSy,
-        TokenOutput calldata out
-    ) internal returns (uint256 netTokenOut) {
+    /// @dev The caller must ensure that the address returned by `__swapDestination(...)` has `netTokenRedeemSy` amount
+    /// of `out.tokenRedeemSy` tokens before calling this function.
+    function __handleTokenOutput(address receiver, uint256 netTokenRedeemSy, TokenOutput calldata out)
+        internal
+        returns (uint256 netTokenOut)
+    {
         SwapType swapType = out.swapData.swapType;
-        if (swapType == SwapType.NONE) netTokenOut = netTokenRedeemSy;
-        else if (swapType == SwapType.ETH_WETH) {
+        if (swapType == SwapType.NONE) {
+            netTokenOut = netTokenRedeemSy;
+        } else if (swapType == SwapType.ETH_WETH) {
             netTokenOut = netTokenRedeemSy; // ETH:WETH is 1:1
             _wrap_unwrap_ETH(out.tokenRedeemSy, out.tokenOut, netTokenOut);
             _transferOut(out.tokenOut, receiver, netTokenOut);

package/contracts/router/Reflector.sol

@@ -16,7 +16,7 @@ contract Reflector is TokenHelper, IPReflector {
     receive() external payable {}
 
     function reflect(bytes calldata inputData) external returns (bytes memory result) {
-        (uint256 value, bytes memory newCalldata) = _getNewCalldata(inputData);
+        (uint256 value, bytes memory newCalldata, address receiver, address market) = _getNewCalldata(inputData);
         bool success;
 
         (success, result) = ROUTER.call{value: value}(newCalldata);
@@ -26,9 +26,14 @@ contract Reflector is TokenHelper, IPReflector {
                 revert(add(32, result), mload(result))
             }
         }
+
+        if (market != address(0)) _sweepMarketDustBalance(receiver, market);
     }
 
-    function _getNewCalldata(bytes calldata inputData) internal returns (uint256 value, bytes memory newCalldata) {
+    function _getNewCalldata(bytes calldata inputData)
+        internal
+        returns (uint256 value, bytes memory newCalldata, address receiver, address market)
+    {
         bytes4 selector = bytes4(inputData[:4]);
         bytes calldata data = inputData[4:];
 
@@ -48,12 +53,14 @@ contract Reflector is TokenHelper, IPReflector {
 
             value = _scaleTokenInputAndGetValue(v5);
             newCalldata = abi.encodeWithSelector(selector, v1, v2, v3, v4, v5, v6);
+            (receiver, market) = (v1, v2);
         } else if (selector == IPActionAddRemoveLiqV3.addLiquiditySingleTokenKeepYt.selector) {
             (address v1, address v2, uint256 v3, uint256 v4, TokenInput memory v5) =
                 abi.decode(data, (address, address, uint256, uint256, TokenInput));
 
             value = _scaleTokenInputAndGetValue(v5);
             newCalldata = abi.encodeWithSelector(selector, v1, v2, v3, v4, v5);
+            (receiver, market) = (v1, v2);
         } else if (
             selector == IPActionAddRemoveLiqV3.addLiquiditySingleSy.selector
                 || selector == IPActionSwapPTV3.swapExactSyForPt.selector
@@ -63,11 +70,13 @@ contract Reflector is TokenHelper, IPReflector {
                 abi.decode(data, (address, address, uint256, uint256, ApproxParams, LimitOrderData));
 
             newCalldata = abi.encodeWithSelector(selector, v1, v2, _scaleSyInput(v2), v4, v5, v6);
+            (receiver, market) = (v1, v2);
         } else if (selector == IPActionAddRemoveLiqV3.addLiquiditySingleSyKeepYt.selector) {
             (address v1, address v2,, uint256 v4, uint256 v5) =
                 abi.decode(data, (address, address, uint256, uint256, uint256));
 
             newCalldata = abi.encodeWithSelector(selector, v1, v2, _scaleSyInput(v2), v4, v5);
+            (receiver, market) = (v1, v2);
         } else {
             revert("UNSUPPORTED_SELECTOR");
         }
@@ -97,4 +106,12 @@ contract Reflector is TokenHelper, IPReflector {
             approved[address(SY)] = true;
         }
     }
+
+    function _sweepMarketDustBalance(address receiver, address market) internal {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+
+        _transferOut(address(SY), receiver, _selfBalance(SY));
+        _transferOut(address(PT), receiver, _selfBalance(PT));
+        _transferOut(address(YT), receiver, _selfBalance(YT));
+    }
 }

package/deployments/1-core.json

@@ -46,7 +46,7 @@
     "poolDeployHelperV2": "0xF642d8Daa026B8aEd6dFE82FACbA2E077AF199E2",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
-    "reflector": "0x73d5DBF81A4f3bFa7b335e6a2d4638D6017a4fA8",
+    "reflector": "0x30544e00Cf296B34A9eE59E5540Ae2f9CCCD55DD",
     "commonDeploy": "0x2Ed473F528E5B320f850d17ADfe0e558f0298aA9",
     "syFactory": "0x466CeD3b33045Ea986B2f306C8D0aA8067961CF8",
     "sparkLinearDiscountOracleFactory": "0x34C91651A070664279866E5f3d6B4d5F65cbbFFb",
@@ -56,6 +56,7 @@
         "MarketSweed": "0x9205aCD8A2fFD56917d4b9139bA423b4f2a70EE5"
     },
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
+    "sPendle": "0x999999999991E178D52Cd95AFd4b00d066664144",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
     "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
@@ -71,4 +72,4 @@
         "ptOftAdapterFactory": "0x905aF80C4DE82E0075a19fDE2f5777f1A6636732"
     },
     "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4"
-}
+}