@pendle/core-v2 6.1.0-cross-chain-pt → 6.1.0

package/contracts/cross-chain/FixedPricePTAMM.sol

@@ -3,16 +3,21 @@ pragma solidity ^0.8.19;
 
 import {IPFixedPricePTAMM, IPFixedPricePTAMMSwapCallback} from "../interfaces/IPFixedPricePTAMM.sol";
 import {IPChainlinkOracleEssential} from "../interfaces/IPChainlinkOracleEssential.sol";
-import {IPBridgedPrincipalToken} from "../interfaces/IPBridgedPrincipalToken.sol";
 
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
 
 import {PMath} from "../core/libraries/math/PMath.sol";
 import {BoringOwnableUpgradeableV2} from "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import {TokenHelper} from "../core/libraries/TokenHelper.sol";
-
-contract FixedPricePTAMM is IPFixedPricePTAMM, BoringOwnableUpgradeableV2, ReentrancyGuardUpgradeable, TokenHelper {
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+contract FixedPricePTAMM is
+    IPFixedPricePTAMM,
+    BoringOwnableUpgradeableV2,
+    ReentrancyGuardUpgradeable,
+    TokenHelper,
+    UUPSUpgradeable
+{
     // cast index-erc7201 "pendle.FixedPricePTAMM.storage"
     uint256 internal constant STORAGE_SLOT = 0xbbf04d9aae855c6bd76c8f4ba7a918994ad0d002f537323e58c83cbfe5249000;
 
@@ -29,10 +34,18 @@ contract FixedPricePTAMM is IPFixedPricePTAMM, BoringOwnableUpgradeableV2, Reent
 
     function initialize(address _owner) external initializer {
         __BoringOwnableV2_init(_owner);
+        __UUPSUpgradeable_init();
+    }
+
+    struct OracleData {
+        address oracle;
+        // @notice This can be seen as the price at maturity.
+        // @notice This can help with decimals conversion.
+        uint256 multiplier;
     }
 
     struct Storage {
-        mapping(address PT => mapping(address token => address oracle)) priceOracle;
+        mapping(address PT => mapping(address token => OracleData)) priceOracle;
         mapping(address token => uint256) totalToken;
     }
 
@@ -42,15 +55,38 @@ contract FixedPricePTAMM is IPFixedPricePTAMM, BoringOwnableUpgradeableV2, Reent
         }
     }
 
-    function priceOracle(address PT, address token) public view returns (IPChainlinkOracleEssential) {
-        address res = $().priceOracle[PT][token];
-        if (res == address(0)) revert OracleNotSet(PT, token);
-        return IPChainlinkOracleEssential(res);
+    function priceOracle(
+        address PT,
+        address token
+    ) public view returns (IPChainlinkOracleEssential oracle, uint256 multiplier) {
+        oracle = IPChainlinkOracleEssential($().priceOracle[PT][token].oracle);
+        multiplier = $().priceOracle[PT][token].multiplier;
+
+        if (address(oracle) == address(0)) revert OracleNotSet(PT, token);
+    }
+
+    function previewSwapPtForExactToken(
+        address PT,
+        address token,
+        uint256 exactTokenOut
+    ) public view returns (uint256 amountPtIn) {
+        (IPChainlinkOracleEssential oracle, uint256 multiplier) = priceOracle(PT, token);
+        (, int256 rawPrice, , , ) = oracle.latestRoundData();
+
+        // ceil(exactTokenOut / (rawPrice * multiplier))
+        return (exactTokenOut * PMath.ONE * PMath.ONE).rawDivUp(rawPrice.Uint() * multiplier);
     }
 
-    function getPtToTokenPrice(address PT, address token) public view returns (uint256) {
-        (, int256 ptPrice, , , ) = priceOracle(PT, token).latestRoundData();
-        return ptPrice.Uint();
+    function previewSwapExactPtForToken(
+        address PT,
+        uint256 exactPtIn,
+        address token
+    ) public view returns (uint256 amountTokenOut) {
+        (IPChainlinkOracleEssential oracle, uint256 multiplier) = priceOracle(PT, token);
+        (, int256 rawPrice, , , ) = oracle.latestRoundData();
+
+        // exactPtIn * rawPrice * multiplier
+        return (exactPtIn * rawPrice.Uint() * multiplier) / (PMath.ONE * PMath.ONE);
     }
 
     function swapPtForExactToken(
@@ -59,8 +95,8 @@ contract FixedPricePTAMM is IPFixedPricePTAMM, BoringOwnableUpgradeableV2, Reent
         address token,
         uint256 exactTokenOut,
         bytes calldata data
-    ) external payable nonReentrant returns (uint256 netPtIn) {
-        netPtIn = exactTokenOut.divDown(getPtToTokenPrice(PT, token));
+    ) external nonReentrant returns (uint256 netPtIn) {
+        netPtIn = previewSwapPtForExactToken(PT, token, exactTokenOut);
         _swap(receiver, PT, netPtIn, token, exactTokenOut, data);
     }
 
@@ -70,8 +106,8 @@ contract FixedPricePTAMM is IPFixedPricePTAMM, BoringOwnableUpgradeableV2, Reent
         uint256 exactPtIn,
         address token,
         bytes calldata data
-    ) external payable nonReentrant returns (uint256 netTokenOut) {
-        netTokenOut = exactPtIn.mulDown(getPtToTokenPrice(PT, token));
+    ) external nonReentrant returns (uint256 netTokenOut) {
+        netTokenOut = previewSwapExactPtForToken(PT, exactPtIn, token);
         _swap(receiver, PT, exactPtIn, token, netTokenOut, data);
     }
 
@@ -102,8 +138,8 @@ contract FixedPricePTAMM is IPFixedPricePTAMM, BoringOwnableUpgradeableV2, Reent
 
     // Admin functions
 
-    function setPriceOracle(address PT, address token, address _priceOracle) external onlyOwner {
-        $().priceOracle[PT][token] = _priceOracle;
+    function setPriceOracle(address PT, address token, address _priceOracle, uint256 _multiplier) external onlyOwner {
+        $().priceOracle[PT][token] = OracleData(_priceOracle, _multiplier);
         emit PriceOracleUpdated(PT, token, _priceOracle);
     }
 
@@ -118,4 +154,6 @@ contract FixedPricePTAMM is IPFixedPricePTAMM, BoringOwnableUpgradeableV2, Reent
         $().totalToken[token] -= amount;
         emit Unseeded(token, amount);
     }
+
+    function _authorizeUpgrade(address) internal override onlyOwner {}
 }

package/contracts/cross-chain/factory/hub/PendlePTOFTAdapterFactory.sol

@@ -3,9 +3,11 @@ pragma solidity ^0.8.0;
 
 import {IPPTOFTAdapterFactory} from "../../../interfaces/IPPTOFTAdapterFactory.sol";
 import {BoringOwnableUpgradeableV2} from "../../../core/libraries/BoringOwnableUpgradeableV2.sol";
-import {OFTAdapterImpl} from "../..//oftImpl/hub/OFTAdapterImpl.sol";
+import {OFTAdapterImpl} from "../../oftImpl/hub/OFTAdapterImpl.sol";
 
-contract PendlePTOFTAdapterFactory is IPPTOFTAdapterFactory, BoringOwnableUpgradeableV2 {
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+contract PendlePTOFTAdapterFactory is IPPTOFTAdapterFactory, BoringOwnableUpgradeableV2, UUPSUpgradeable {
     error PTOFTAdapterExisted(address pt);
 
     address internal immutable _lzEndpoint;
@@ -17,6 +19,7 @@ contract PendlePTOFTAdapterFactory is IPPTOFTAdapterFactory, BoringOwnableUpgrad
 
     function initialize(address _owner) external initializer {
         __BoringOwnableV2_init(_owner);
+        __UUPSUpgradeable_init();
     }
 
     mapping(address pt => address) public ptAdapter;
@@ -30,4 +33,6 @@ contract PendlePTOFTAdapterFactory is IPPTOFTAdapterFactory, BoringOwnableUpgrad
 
         return ptAdapter[pt] = address(adapter);
     }
+
+    function _authorizeUpgrade(address) internal override onlyOwner {}
 }

package/contracts/cross-chain/oftImpl/spoke/PendleBridgedPrincipalToken.sol

@@ -6,56 +6,36 @@ import {OFT, OFTCore, IOFT} from "@layerzerolabs/oft-evm/contracts/OFT.sol";
 import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
-abstract contract BasePendleBridgedPrincipalToken is IPBridgedPrincipalToken, OFT {
+contract PendleBridgedPrincipalToken is IPBridgedPrincipalToken, OFT {
     uint256 public immutable expiry;
+    uint8 internal immutable LOCAL_DECIMALS;
+    uint8 internal immutable SHARED_DECIMALS;
 
     constructor(
         string memory _name,
         string memory _symbol,
         address _lzEndpoint,
         address _delegate,
-        uint256 _expiry
+        uint256 _expiry,
+        uint8 _localDecimals,
+        uint8 _sharedDecimals,
+        address initialOwner
     ) OFT(_name, _symbol, _lzEndpoint, _delegate) {
         expiry = _expiry;
-    }
-}
-
-/**
- * The below contracts only overrides the `decimals()` and `sharedDecimals()` function
- * - For Pendle PT, the decimals are based on the underlying asset. So we need
- *   to set the decimals correctly at **deployment**.
- * - For technical reason, in OFT's constructor, the `decimals()` function was
- *   invoked.
- *   (https://github.com/LayerZero-Labs/devtools/blob/feb000c1717ee89f965996cc9ab5a8a75effbcab/packages/oft-evm/contracts/OFT.sol#L25)
- * - The current best way to do this is to hard-code the decimals in the contracts.
- */
-
-// prettier-ignore
-contract PendleBridgedPrincipalToken_18Decimals is BasePendleBridgedPrincipalToken {
-    constructor(string memory _name, string memory _symbol, address _lzEndpoint, address _delegate, uint256 _expiry)
-        BasePendleBridgedPrincipalToken(_name, _symbol, _lzEndpoint, _delegate, _expiry)
-    {}
-
-    function decimals() public pure override(ERC20, IERC20Metadata) returns (uint8) { return 18; }
-    function sharedDecimals() public pure override(OFTCore, IOFT) returns (uint8) { return 6; }
-}
+        _transferOwnership(initialOwner);
 
-// prettier-ignore
-contract PendleBridgedPrincipalToken_6Decimals is BasePendleBridgedPrincipalToken {
-    constructor(string memory _name, string memory _symbol, address _lzEndpoint, address _delegate, uint256 _expiry)
-        BasePendleBridgedPrincipalToken(_name, _symbol, _lzEndpoint, _delegate, _expiry)
-    {}
+        LOCAL_DECIMALS = _localDecimals;
+        SHARED_DECIMALS = _sharedDecimals;
 
-    function decimals() public pure override(ERC20, IERC20Metadata) returns (uint8) { return 6; }
-    function sharedDecimals() public pure override(OFTCore, IOFT) returns (uint8) { return 6; }
-}
+        // override decimalConversionRate set in OFTCore constructor
+        decimalConversionRate = 10 ** (LOCAL_DECIMALS - SHARED_DECIMALS);
+    }
 
-// prettier-ignore
-contract PendleBridgedPrincipalToken_8Decimals is BasePendleBridgedPrincipalToken {
-    constructor(string memory _name, string memory _symbol, address _lzEndpoint, address _delegate, uint256 _expiry)
-        BasePendleBridgedPrincipalToken(_name, _symbol, _lzEndpoint, _delegate, _expiry)
-    {}
+    function decimals() public view override(ERC20, IERC20Metadata) returns (uint8) {
+        return LOCAL_DECIMALS;
+    }
 
-    function decimals() public pure override(ERC20, IERC20Metadata) returns (uint8) { return 8; }
-    function sharedDecimals() public pure override(OFTCore, IOFT) returns (uint8) { return 6; }
+    function sharedDecimals() public view override(OFTCore, IOFT) returns (uint8) {
+        return SHARED_DECIMALS;
+    }
 }

package/contracts/interfaces/ILPWrapper.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.0;
+
+interface ILPWrapper {
+    function LP() external view returns (address);
+
+    function factory() external view returns (address);
+
+    function isRewardRedemptionDisabled() external view returns (bool);
+
+    function setRewardRedemptionDisabled(bool _isRewardRedemptionDisabled) external;
+
+    function wrap(address receiver, uint256 netLpIn) external;
+
+    function unwrap(address receiver, uint256 netWrapIn) external;
+}

package/contracts/interfaces/IPFixedPricePTAMM.sol

@@ -20,9 +20,22 @@ interface IPFixedPricePTAMM {
     event Seeded(address indexed token, uint256 amount);
     event Unseeded(address indexed token, uint256 amount);
 
-    function priceOracle(address PT, address token) external view returns (IPChainlinkOracleEssential);
+    function priceOracle(
+        address PT,
+        address token
+    ) external view returns (IPChainlinkOracleEssential, uint256 multiplier);
+
+    function previewSwapPtForExactToken(
+        address PT,
+        address token,
+        uint256 exactTokenOut
+    ) external view returns (uint256 amountPtIn);
 
-    function getPtToTokenPrice(address PT, address token) external view returns (uint256);
+    function previewSwapExactPtForToken(
+        address PT,
+        uint256 exactPtIn,
+        address token
+    ) external view returns (uint256 amountTokenOut);
 
     function swapPtForExactToken(
         address receiver,
@@ -30,7 +43,7 @@ interface IPFixedPricePTAMM {
         address token,
         uint256 exactTokenOut,
         bytes calldata data
-    ) external payable returns (uint256 netPtIn);
+    ) external returns (uint256 netPtIn);
 
     function swapExactPtForToken(
         address receiver,
@@ -38,11 +51,11 @@ interface IPFixedPricePTAMM {
         uint256 exactPtIn,
         address token,
         bytes calldata data
-    ) external payable returns (uint256 netTokenOut);
+    ) external returns (uint256 netTokenOut);
 
     // Admin functions
 
-    function setPriceOracle(address PT, address token, address priceOracle) external;
+    function setPriceOracle(address PT, address token, address priceOracle, uint256 multiplier) external;
 
     function addFund(address token, uint256 amount) external payable;
 

package/contracts/interfaces/IPLimitRouter.sol

@@ -76,6 +76,8 @@ interface IPLimitRouter is IPLimitOrderType {
 
     event OrderCanceled(address indexed maker, bytes32 indexed orderHash);
 
+    event OrderForceCanceled(bytes32 indexed orderHash);
+
     event OrderFilledV2(
         bytes32 indexed orderHash,
         OrderType indexed orderType,

package/contracts/interfaces/IPVotingController.sol

@@ -16,6 +16,10 @@ interface IPVotingController {
 
     event BroadcastResults(uint64 indexed chainId, uint128 indexed wTime, uint128 totalPendlePerSec);
 
+    event SetPoolCaps(address[] pools, uint256[] caps);
+
+    event SetGlobalCap(uint256 cap);
+
     function applyPoolSlopeChanges(address pool) external;
 
     /// @notice deprecated, only kept for compatibility reasons

package/contracts/limit/LimitRouterBase.sol

@@ -485,12 +485,17 @@ abstract contract LimitRouterBase is
         ownerHelper = _helper;
     }
 
-    function setLnFeeRateRoots(address[] memory YTs, uint256[] memory lnFeeRateRoots) public onlyHelperAndOwner {
+    /// @dev if zero fees are intended, it must be explicitly allowed again
+    function setLnFeeRateRoots(
+        address[] memory YTs,
+        uint256[] memory lnFeeRateRoots,
+        bool allowZeroFees
+    ) public onlyHelperAndOwner {
         uint256 len = YTs.length;
         require(len == lnFeeRateRoots.length, "LOP: length mismatch");
 
         for (uint256 i = 0; i < len; i++) {
-            require(lnFeeRateRoots[i] > 0, "LOP: zero fee not allowed");
+            require(lnFeeRateRoots[i] > 0 || allowZeroFees, "LOP: zero fee must be allowed explicitly");
             require(lnFeeRateRoots[i] <= MAX_LN_FEE_RATE_ROOT, "LOP: fee too high");
 
             __lnFeeRateRoot[YTs[i]] = lnFeeRateRoots[i];

package/contracts/limit/PendleLimitRouter.sol

@@ -29,6 +29,16 @@ contract PendleLimitRouter is LimitRouterBase {
         emit OrderCanceled(msg.sender, orderHash);
     }
 
+    /// @dev auto skip cancelled orders to avoid race conditions
+    function forceCancel(bytes32[] calldata orderHashes) public onlyHelperAndOwner {
+        for (uint256 i = 0; i < orderHashes.length; ++i) {
+            if (_status[orderHashes[i]].remaining == _ORDER_FILLED) continue;
+
+            _status[orderHashes[i]].remaining = _ORDER_FILLED;
+            emit OrderForceCanceled(orderHashes[i]);
+        }
+    }
+
     function orderStatusesRaw(
         bytes32[] memory orderHashes
     ) public view returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts) {

package/contracts/offchain-helpers/ExpiredLpPtRedeemer.sol

@@ -40,7 +40,7 @@ contract ExpiredLpPtRedeemer is TokenHelper, ReentrancyGuardUpgradeable, BoringO
         uint256 totalPtRedeem = 0;
 
         if (netPtIn > 0) {
-            _transferFrom(PT, msg.sender, address(this), netLpIn);
+            _transferFrom(PT, msg.sender, address(this), netPtIn);
             totalPtRedeem += netPtIn;
         }
 

package/contracts/offchain-helpers/PendleLPWrapper.sol

@@ -5,8 +5,9 @@ import "../core/erc20/PendleERC20.sol";
 import "../core/libraries/TokenHelper.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IPLPWrapperFactory.sol";
+import "../interfaces/ILPWrapper.sol";
 
-contract PendleLPWrapper is PendleERC20, TokenHelper {
+contract PendleLPWrapper is PendleERC20, TokenHelper, ILPWrapper {
     address public immutable LP;
     address public immutable factory;
     bool public isRewardRedemptionDisabled;

package/contracts/oracles/internal/PendleLpLinearDiscountOracle.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.19;
+
+/**
+ * @title PendleLpLinearDiscountOracle
+ * @notice Oracle for pricing Pendle LP tokens using a linear discount model based on time to maturity
+ * @dev Implements Chainlink-compatible price feed interface for LP tokens
+ * The oracle calculates LP price by applying a time-based linear discount to the PT component
+ */
+contract PendleLpLinearDiscountOracle {
+    uint256 private constant SECONDS_PER_YEAR = 365 days;
+    uint256 private constant ONE = 1e18;
+
+    /// @notice The LP token address (Pendle Market)
+    address public immutable LP;
+
+    /// @notice The maturity timestamp of the LP token
+    uint256 public immutable maturity;
+
+    /// @notice Annual discount rate for LP tokens (1e18 = 100%)
+    uint256 public immutable baseLpDiscountPerYear;
+
+    /// @notice Base price multiplier for LP tokens (1e18 = 1x)
+    uint256 public immutable lpMaturedPrice;
+
+    constructor(address _lp, uint256 _baseLpDiscountPerYear, uint256 _lpMaturedPrice) {
+        require(_lpMaturedPrice >= 1e18, "invalid price");
+
+        LP = _lp;
+        maturity = LPExpiry(LP).expiry();
+        baseLpDiscountPerYear = _baseLpDiscountPerYear;
+        lpMaturedPrice = _lpMaturedPrice;
+    }
+
+    function latestRoundData()
+        external
+        view
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
+    {
+        uint256 timeLeft = (maturity > block.timestamp) ? maturity - block.timestamp : 0;
+        uint256 lpPrice = getLpPrice(timeLeft);
+        return (0, int256(lpPrice), 0, 0, 0);
+    }
+
+    function getLpPrice(uint256 timeLeft) public view returns (uint256) {
+        uint256 lpDiscount = getLpDiscount(timeLeft);
+        require(lpDiscount <= ONE, "discount overflow");
+
+        uint256 lpPrice = ((ONE - lpDiscount) * lpMaturedPrice) / ONE;
+
+        return lpPrice;
+    }
+
+    function getLpDiscount(uint256 timeLeft) public view returns (uint256) {
+        return (timeLeft * baseLpDiscountPerYear) / SECONDS_PER_YEAR;
+    }
+
+    function decimals() external pure returns (uint8) {
+        return 18;
+    }
+}
+
+interface LPExpiry {
+    function expiry() external view returns (uint256);
+}

package/contracts/oracles/internal/PendleLpLinearDiscountOracleFactory.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.19;
+
+import {PendleLpLinearDiscountOracle} from "./PendleLpLinearDiscountOracle.sol";
+
+contract PendleLpLinearDiscountOracleFactory {
+    event OracleCreated(address indexed market, uint256 basePtDiscountPerYear, uint256 lpBasePrice, address oracle);
+
+    /**
+     * @notice Creates a new LP linear discount oracle
+     * @param market The Pendle Market address (LP token)
+     * @param basePtDiscountPerYear Annual discount rate for PT (max: 1e18 = 100%)
+     * @param lpBasePrice Base price multiplier for LP (min: 1e18 = 1x)
+     * @return res The address of the deployed oracle contract
+     */
+    function create(address market, uint256 basePtDiscountPerYear, uint256 lpBasePrice) external returns (address res) {
+        res = address(new PendleLpLinearDiscountOracle(market, basePtDiscountPerYear, lpBasePrice));
+        emit OracleCreated(market, basePtDiscountPerYear, lpBasePrice, res);
+    }
+}

package/contracts/router/ActionAddRemoveLiqV3.sol

@@ -15,6 +15,8 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
     using PYIndexLib for IPYieldToken;
     using PYIndexLib for PYIndex;
 
+    constructor(address _dustReceiver) ActionDelegateBase(_dustReceiver) {}
+
     // ------------------ ADD LIQUIDITY DUAL ------------------
 
     /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.

package/contracts/router/ActionMiscV3.sol

@@ -8,6 +8,8 @@ import "../interfaces/IPReflector.sol";
 contract ActionMiscV3 is IPActionMiscV3, ActionBase {
     uint256 private constant NOT_FOUND = type(uint256).max;
 
+    constructor(address _dustReceiver) ActionBase(_dustReceiver) {}
+
     function mintSyFromToken(
         address receiver,
         address SY,

package/contracts/router/ActionSimple.sol

@@ -24,6 +24,8 @@ contract ActionSimple is ActionBase, IPActionSimple {
     using PYIndexLib for PYIndex;
     using PMath for uint256;
 
+    constructor(address _dustReceiver) ActionBase(_dustReceiver) {}
+
     // ------------------ SWAP TOKEN FOR PT ------------------
     /// @notice This function is for internal router use only and should not be called directly.
     /// @dev Use swapExactTokenForPt from the main router instead.

package/contracts/router/ActionSwapPTV3.sol

@@ -8,6 +8,8 @@ import {ActionDelegateBase} from "./base/ActionDelegateBase.sol";
 contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase, ActionDelegateBase {
     using PMath for uint256;
 
+    constructor(address _dustReceiver) ActionDelegateBase(_dustReceiver) {}
+
     // ------------------ SWAP TOKEN FOR PT ------------------
     /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactTokenForPt(

package/contracts/router/ActionSwapYTV3.sol

@@ -12,6 +12,8 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase, ActionD
     using MarketApproxPtOutLibV2 for MarketState;
     using PYIndexLib for IPYieldToken;
 
+    constructor(address _dustReceiver) ActionDelegateBase(_dustReceiver) {}
+
     // ------------------ SWAP TOKEN FOR YT ------------------
 
     /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.

package/contracts/router/base/ActionBase.sol

@@ -19,6 +19,11 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
     using PYIndexLib for PYIndex;
 
     bytes internal constant EMPTY_BYTES = abi.encode();
+    address internal immutable DUST_RECEIVER;
+
+    constructor(address _dustReceiver) {
+        DUST_RECEIVER = _dustReceiver;
+    }
 
     // ----------------- MINT REDEEM SY PY -----------------
 
@@ -158,6 +163,10 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         return IPMarket(market).readState(address(this));
     }
 
+    function _sweepDust(address token) internal {
+        _transferOut(token, DUST_RECEIVER, _selfBalance(token));
+    }
+
     // ----------------- PT SWAP -----------------
 
     function _entry_swapExactPtForSy(address market, LimitOrderData calldata limit) internal view returns (address) {
@@ -184,8 +193,6 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             (netPtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, PT, netPtLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(PT), market, netPtLeft);
-            } else {
-                _transferOut(address(PT), receiver, netPtLeft);
             }
         }
 
@@ -200,6 +207,8 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             netSyFee += netSyFeeMarket;
         }
 
+        _sweepDust(address(PT));
+
         if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
     }
 
@@ -227,8 +236,6 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             (netSyLeft, netPtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(SY), market, netSyLeft);
-            } else {
-                _transferOut(address(SY), receiver, netSyLeft);
             }
         }
 
@@ -246,6 +253,8 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             netSyFee += netSyFeeMarket;
         }
 
+        _sweepDust(address(SY));
+
         if (netPtOut < minPtOut) revert("Slippage: INSUFFICIENT_PT_OUT");
     }
 
@@ -275,8 +284,6 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             (netYtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, YT, netYtLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(YT), address(YT), netYtLeft);
-            } else {
-                _transferOut(address(YT), receiver, netYtLeft);
             }
         }
 
@@ -294,6 +301,8 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             netSyOut += SY.balanceOf(receiver) - preSyBalance;
         }
 
+        _sweepDust(address(YT));
+
         if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
     }
 
@@ -322,8 +331,6 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             (netSyLeft, netYtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(SY), address(YT), netSyLeft);
-            } else {
-                _transferOut(address(SY), receiver, netSyLeft);
             }
         }
 
@@ -344,6 +351,7 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             netYtOut += netYtOutMarket;
             netSyFee += netSyFeeMarket;
         }
+        _sweepDust(address(SY));
 
         if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
     }

package/contracts/router/base/ActionDelegateBase.sol

@@ -6,6 +6,8 @@ import {IPActionSimple} from "../../interfaces/IPActionSimple.sol";
 import {ApproxParams, TokenInput, LimitOrderData} from "../../interfaces/IPAllActionTypeV3.sol";
 
 contract ActionDelegateBase is ActionBase {
+    constructor(address _dustReceiver) ActionBase(_dustReceiver) {}
+
     function delegateToAddLiquiditySinglePtSimple(
         address receiver,
         address market,

package/deployments/1-core.json

@@ -61,5 +61,9 @@
     "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9",
     "lpWrapperFactory": "0x12930Bd944bb34B0A21CCc2E7d32a6834Bd58e19",
     "decimalsFactory": "0x992ec6a490a4b7f256bd59e63746951d98b29be9",
-    "ptOftAdapterFactory": "0x6f2a9b773778188727cc1f49c57213b1a758555e"
+    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
+    "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5",
+    "cross-chain": {
+        "ptOftAdapterFactory": "0x905aF80C4DE82E0075a19fDE2f5777f1A6636732"
+    }
 }

package/deployments/10-core.json

@@ -4,7 +4,7 @@
         "chainId": 10,
         "treasury": "0xE972D450ec5b11b99D97760422e0E054Afbc8042",
         "governance": "0xa06C863fcf17cA6f24AA81aeA75E23953193fF6A",
-        "devMultisig": "0x79d7a5e8b130eEf1e022b3EDEE4DAF226DC168CA",
+        "devMultisig": "0xE6F0489ED91dc27f40f9dbe8f81fccbFC16b9cb1",
         "pendle": "0xBC7B1Ff1c6989f006a1185318eD4E7b5796e66E1",
         "lzEndpoint": "0x3c2269811836af69497E5F486A85D7316753cf62",
         "wrappedNative": "0x4200000000000000000000000000000000000006",
@@ -53,5 +53,13 @@
     },
     "receiverEndpoint": "0xED18de5442297a4Ec1ce59C7c7d9427Adc2A012b",
     "vePendle": "0xd5C47D2383Fddc19596489280C0A33AC42b2bB18",
-    "gaugeController": "0x6875e4A945E498FE1B90BbB13CFbAF0b68658C9C"
-}
+    "gaugeController": "0x6875e4A945E498FE1B90BbB13CFbAF0b68658C9C",
+    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
+    "expiredRedeemer": "0x8267fdabd1b8C8645138f2dE5B0fe24988DC9820",
+    "lpWrapperFactory": "0xeCfEB97D7F070DA5b93c5DC274183F1D7f68532F",
+    "decimalsFactory": "0x992ec6a490a4b7f256bd59e63746951d98b29be9",
+    "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5",
+    "cross-chain": {
+        "ptOftAdapterFactory": "0x45Dd4aEcc425b01bf98C567407aB4a4fF3C7d349"
+    }
+}