@pendle/core-v2 6.0.0 → 6.1.0

package/contracts/cross-chain/FixedPricePTAMM.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.19;
+
+import {IPFixedPricePTAMM, IPFixedPricePTAMMSwapCallback} from "../interfaces/IPFixedPricePTAMM.sol";
+import {IPChainlinkOracleEssential} from "../interfaces/IPChainlinkOracleEssential.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";
+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;
+
+    error OracleNotSet(address PT, address token);
+    error InsufficientTokenForTrade(address token, uint256 actualAmount, uint256 requiredAmount);
+    error InsufficientPtReceived(address PT, uint256 actualAmount, uint256 requiredAmount);
+
+    using PMath for uint256;
+    using PMath for int256;
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    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 => OracleData)) priceOracle;
+        mapping(address token => uint256) totalToken;
+    }
+
+    function $() internal pure returns (Storage storage res) {
+        assembly ("memory-safe") {
+            res.slot := STORAGE_SLOT
+        }
+    }
+
+    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 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(
+        address receiver,
+        address PT,
+        address token,
+        uint256 exactTokenOut,
+        bytes calldata data
+    ) external nonReentrant returns (uint256 netPtIn) {
+        netPtIn = previewSwapPtForExactToken(PT, token, exactTokenOut);
+        _swap(receiver, PT, netPtIn, token, exactTokenOut, data);
+    }
+
+    function swapExactPtForToken(
+        address receiver,
+        address PT,
+        uint256 exactPtIn,
+        address token,
+        bytes calldata data
+    ) external nonReentrant returns (uint256 netTokenOut) {
+        netTokenOut = previewSwapExactPtForToken(PT, exactPtIn, token);
+        _swap(receiver, PT, exactPtIn, token, netTokenOut, data);
+    }
+
+    function _swap(
+        address receiver,
+        address PT,
+        uint256 exactPtIn,
+        address token,
+        uint256 exactTokenOut,
+        bytes calldata data
+    ) internal {
+        if ($().totalToken[token] < exactTokenOut)
+            revert InsufficientTokenForTrade(token, $().totalToken[token], exactTokenOut);
+
+        _transferOut(token, receiver, exactTokenOut);
+        $().totalToken[token] -= exactTokenOut;
+
+        if (data.length > 0) {
+            IPFixedPricePTAMMSwapCallback(msg.sender).swapCallback(exactTokenOut, exactPtIn, data);
+        }
+
+        $().totalToken[PT] += exactPtIn;
+        if (_selfBalance(PT) < $().totalToken[PT])
+            revert InsufficientPtReceived(PT, _selfBalance(PT), $().totalToken[PT]);
+
+        emit Swap(msg.sender, receiver, PT, exactPtIn, token, exactTokenOut);
+    }
+
+    // Admin functions
+
+    function setPriceOracle(address PT, address token, address _priceOracle, uint256 _multiplier) external onlyOwner {
+        $().priceOracle[PT][token] = OracleData(_priceOracle, _multiplier);
+        emit PriceOracleUpdated(PT, token, _priceOracle);
+    }
+
+    function addFund(address token, uint256 amount) external payable onlyOwner {
+        _transferIn(token, owner, amount);
+        $().totalToken[token] += amount;
+        emit Seeded(token, amount);
+    }
+
+    function removeFund(address token, uint256 amount) external onlyOwner {
+        _transferOut(token, owner, amount);
+        $().totalToken[token] -= amount;
+        emit Unseeded(token, amount);
+    }
+
+    function _authorizeUpgrade(address) internal override onlyOwner {}
+}

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

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+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 {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+contract PendlePTOFTAdapterFactory is IPPTOFTAdapterFactory, BoringOwnableUpgradeableV2, UUPSUpgradeable {
+    error PTOFTAdapterExisted(address pt);
+
+    address internal immutable _lzEndpoint;
+
+    constructor(address lzEndpoint) {
+        _disableInitializers();
+        _lzEndpoint = lzEndpoint;
+    }
+
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
+        __UUPSUpgradeable_init();
+    }
+
+    mapping(address pt => address) public ptAdapter;
+
+    function createPtAdapter(address pt) external override onlyOwner returns (address) {
+        if (ptAdapter[pt] != address(0)) revert PTOFTAdapterExisted(pt);
+
+        OFTAdapterImpl adapter = new OFTAdapterImpl(pt, _lzEndpoint, owner);
+        adapter.transferOwnership(owner);
+        emit PtAdapterCreated(pt, address(adapter));
+
+        return ptAdapter[pt] = address(adapter);
+    }
+
+    function _authorizeUpgrade(address) internal override onlyOwner {}
+}

package/contracts/cross-chain/oftImpl/hub/OFTAdapterImpl.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import {OFTAdapter} from "@layerzerolabs/oft-evm/contracts/OFTAdapter.sol";
+
+// @notice Base OFT contract, without any additional functionality (like RateLimiter).
+// @dev This contract inherits Ownable from OpenZeppelin v4.
+// @dev Sender is set as the contract owner at deployment.
+contract OFTAdapterImpl is OFTAdapter {
+    constructor(address _token, address _endpoint, address _delegate) OFTAdapter(_token, _endpoint, _delegate) {}
+}

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

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.19;
+
+import {IPBridgedPrincipalToken} from "../../../interfaces/IPBridgedPrincipalToken.sol";
+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";
+
+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,
+        uint8 _localDecimals,
+        uint8 _sharedDecimals,
+        address initialOwner
+    ) OFT(_name, _symbol, _lzEndpoint, _delegate) {
+        expiry = _expiry;
+        _transferOwnership(initialOwner);
+
+        LOCAL_DECIMALS = _localDecimals;
+        SHARED_DECIMALS = _sharedDecimals;
+
+        // override decimalConversionRate set in OFTCore constructor
+        decimalConversionRate = 10 ** (LOCAL_DECIMALS - SHARED_DECIMALS);
+    }
+
+    function decimals() public view override(ERC20, IERC20Metadata) returns (uint8) {
+        return LOCAL_DECIMALS;
+    }
+
+    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/IPBridgedPrincipalToken.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IOFT} from "@layerzerolabs/oft-evm/contracts/interfaces/IOFT.sol";
+import {IOAppCore} from "@layerzerolabs/oapp-evm/contracts/oapp/interfaces/IOAppCore.sol";
+import {IOAppOptionsType3} from "@layerzerolabs/oapp-evm/contracts/oapp/interfaces/IOAppOptionsType3.sol";
+
+interface IPBridgedPrincipalToken is IOFT, IOAppCore, IOAppOptionsType3, IERC20Metadata {
+    function expiry() external view returns (uint256);
+}

package/contracts/interfaces/IPChainlinkOracleEssential.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPChainlinkOracleEssential {
+    function decimals() external view returns (uint8);
+
+    function latestRoundData()
+        external
+        view
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
+}

package/contracts/interfaces/IPFixedPricePTAMM.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.19;
+
+import {IPBridgedPrincipalToken} from "./IPBridgedPrincipalToken.sol";
+import {IPChainlinkOracleEssential} from "../interfaces/IPChainlinkOracleEssential.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IPFixedPricePTAMM {
+    event Swap(
+        address indexed caller,
+        address indexed receiver,
+        address PT,
+        uint256 netPtIn,
+        address token,
+        uint256 netTokenOut
+    );
+
+    event PriceOracleUpdated(address indexed PT, address indexed token, address indexed priceOracle);
+
+    event Seeded(address indexed token, uint256 amount);
+    event Unseeded(address indexed token, uint256 amount);
+
+    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 previewSwapExactPtForToken(
+        address PT,
+        uint256 exactPtIn,
+        address token
+    ) external view returns (uint256 amountTokenOut);
+
+    function swapPtForExactToken(
+        address receiver,
+        address PT,
+        address token,
+        uint256 exactTokenOut,
+        bytes calldata data
+    ) external returns (uint256 netPtIn);
+
+    function swapExactPtForToken(
+        address receiver,
+        address PT,
+        uint256 exactPtIn,
+        address token,
+        bytes calldata data
+    ) external returns (uint256 netTokenOut);
+
+    // Admin functions
+
+    function setPriceOracle(address PT, address token, address priceOracle, uint256 multiplier) external;
+
+    function addFund(address token, uint256 amount) external payable;
+
+    function removeFund(address token, uint256 amount) external;
+}
+
+interface IPFixedPricePTAMMSwapCallback {
+    function swapCallback(uint256 exactTokenOut, uint256 netPtIn, bytes calldata data) external;
+}

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/IPPTOFTAdapterFactory.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPPTOFTAdapterFactory {
+    event PtAdapterCreated(address indexed pt, address indexed adapter);
+
+    function initialize(address _owner) external;
+
+    function createPtAdapter(address pt) external returns (address);
+
+    function ptAdapter(address pt) external view returns (address);
+}

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/oracles/internal/PendleSparkLinearDiscountOracle.sol

@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: SEE LICENSE IN LICENSE
 pragma solidity ^0.8.19;
 
-contract PendleSparkLinearDiscountOracle {
+import {IPChainlinkOracleEssential} from "../../interfaces/IPChainlinkOracleEssential.sol";
+
+contract PendleSparkLinearDiscountOracle is IPChainlinkOracleEssential {
     uint256 private constant SECONDS_PER_YEAR = 365 days;
     uint256 private constant ONE = 1e18;
 

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.