@pendle/core-v2 5.2.1-beta-1 → 5.2.2

package/contracts/interfaces/IPChainlinkOracleFactory.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "./IPChainlinkOracle.sol";
+
+interface IPChainlinkOracleFactory {
+    event OracleCreated(
+        address indexed market,
+        uint32 indexed twapDuration,
+        PendleOracleType indexed baseOracleType,
+        address oracle,
+        bytes32 oracleId
+    );
+    event OracleWithQuoteCreated(
+        address indexed market,
+        uint32 indexed twapDuration,
+        PendleOracleType indexed baseOracleType,
+        address quoteOracle,
+        address oracle,
+        bytes32 oracleId
+    );
+}

package/contracts/interfaces/IPChainlinkOracleWithQuote.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+interface IPChainlinkOracleWithQuote is AggregatorV2V3Interface {
+    function quoteOracle() external view returns (address);
+}

package/contracts/interfaces/IPLimitRouter.sol

@@ -60,12 +60,9 @@ struct FillOrderParams {
 }
 
 interface IPLimitRouterCallback is IPLimitOrderType {
-    function limitRouterCallback(
-        uint256 actualMaking,
-        uint256 actualTaking,
-        uint256 totalFee,
-        bytes memory data
-    ) external returns (bytes memory);
+    function limitRouterCallback(uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory data)
+        external
+        returns (bytes memory);
 }
 
 interface IPLimitRouter is IPLimitOrderType {
@@ -106,18 +103,31 @@ interface IPLimitRouter is IPLimitOrderType {
 
     function cancelBatch(Order[] calldata orders) external;
 
-    function orderStatusesRaw(
-        bytes32[] memory orderHashes
-    ) external view returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts);
+    function orderStatusesRaw(bytes32[] memory orderHashes)
+        external
+        view
+        returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts);
 
-    function orderStatuses(
-        bytes32[] memory orderHashes
-    ) external view returns (uint256[] memory remainings, uint256[] memory filledAmounts);
+    function orderStatuses(bytes32[] memory orderHashes)
+        external
+        view
+        returns (uint256[] memory remainings, uint256[] memory filledAmounts);
 
     function DOMAIN_SEPARATOR() external view returns (bytes32);
 
     function simulate(address target, bytes calldata data) external payable;
 
+    function _checkSig(Order memory order, bytes memory signature)
+        external
+        view
+        returns (
+            bytes32,
+            /*orderHash*/
+            uint256,
+            /*remainingMakerAmount*/
+            uint256
+        ); /*filledMakerAmount*/
+
     /* --- Deprecated events --- */
 
     // deprecate on 7/1/2024, prior to official launch

package/contracts/interfaces/IPPYLpOracle.sol

@@ -16,11 +16,10 @@ interface IPPYLpOracle {
 
     function getLpToSyRate(address market, uint32 duration) external view returns (uint256);
 
-    function getOracleState(
-        address market,
-        uint32 duration
-    )
+    function getOracleState(address market, uint32 duration)
         external
         view
         returns (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied);
+
+    function blockCycleNumerator() external view returns (uint16);
 }

package/contracts/interfaces/Lombard/ILBTCMinterBase.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+interface ILBTCMinterBase {
+    function swapCBBTCToLBTC(uint256 amount) external;
+
+    function relativeFee() external view returns (uint16);
+
+    function remainingStake() external view returns (uint256);
+
+    function stakeLimit() external view returns (uint256);
+}

package/contracts/oracles/{PendlePYLpOracle.sol → PtYtLpOracle/PendlePYLpOracle.sol}

@@ -3,8 +3,8 @@ pragma solidity ^0.8.17;
 
 import "./PendlePYOracleLib.sol";
 import "./PendleLpOracleLib.sol";
-import "../interfaces/IPPYLpOracle.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../interfaces/IPPYLpOracle.sol";
+import "../../core/libraries/BoringOwnableUpgradeable.sol";
 
 // This is a pre-deployed version of PendlePtOracleLib & PendleLpOracleLib with additional utility functions.
 // Use of this contract rather than direct library integration resulting in a smaller bytecode size and simpler structure

package/contracts/oracles/{PendlePYOracleLib.sol → PtYtLpOracle/PendlePYOracleLib.sol}

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../interfaces/IPMarket.sol";
-import "../core/libraries/math/PMath.sol";
+import "../../interfaces/IPMarket.sol";
+import "../../core/libraries/math/PMath.sol";
 
 // This library can & should be integrated directly for optimal gas usage.
 // If you prefer not to integrate it directly, the PendlePtOracle contract (a pre-deployed version of this contract) can be used.

package/contracts/oracles/PtYtLpOracle/chainlink/PendleChainlinkOracle.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../interfaces/IPChainlinkOracle.sol";
+import "../PendleLpOracleLib.sol";
+
+/**
+ * @dev The round data returned from this contract will follow:
+ * - There will be only one round (roundId=0)
+ * - startedAt=0, updatedAt=block.timestamp
+ */
+contract PendleChainlinkOracle is IPChainlinkOracle {
+    error InvalidRoundId();
+
+    // solhint-disable immutable-vars-naming
+    address public immutable factory;
+
+    address public immutable market;
+    uint32 public immutable twapDuration;
+    PendleOracleType public immutable baseOracleType;
+
+    uint256 public immutable fromTokenScale;
+    uint256 public immutable toTokenScale;
+
+    function(IPMarket, uint32) internal view returns (uint256) private immutable _getRawPendlePrice;
+
+    modifier roundIdIsZero(uint80 roundId) {
+        if (roundId != 0) {
+            revert InvalidRoundId();
+        }
+        _;
+    }
+
+    constructor(address _market, uint32 _twapDuration, PendleOracleType _baseOracleType) {
+        factory = msg.sender;
+        market = _market;
+        twapDuration = _twapDuration;
+        baseOracleType = _baseOracleType;
+        (uint256 fromTokenDecimals, uint256 toTokenDecimals) = _readDecimals(_market, _baseOracleType);
+        (fromTokenScale, toTokenScale) = (10 ** fromTokenDecimals, 10 ** toTokenDecimals);
+        _getRawPendlePrice = _getRawPendlePriceFunc();
+    }
+
+    // =================================================================
+    //                          CHAINLINK INTERFACE
+    // =================================================================
+
+    /**
+     * @notice The round data returned from this contract will follow:
+     * - answer will satisfy 1 natural unit of PendleToken = (answer/1e18) natural unit of OutputToken
+     * - In other words, 10**(PendleToken.decimals) = (answer/1e18) * 10**(OutputToken.decimals)
+     * @param roundId always 0 for this contract
+     * @param answer The answer (in 18 decimals)
+     * @param startedAt always 0 for this contract
+     * @param updatedAt always block.timestamp for this contract
+     * @param answeredInRound always 0 for this contract
+     */
+    function latestRoundData()
+        public
+        view
+        virtual
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
+    {
+        roundId = 0;
+        answer = _getPendleTokenPrice();
+        startedAt = 0;
+        updatedAt = block.timestamp;
+        answeredInRound = 0;
+    }
+
+    function getRoundData(
+        uint80 roundId
+    ) external view roundIdIsZero(roundId) returns (uint80, int256, uint256, uint256, uint80) {
+        return latestRoundData();
+    }
+
+    function decimals() external pure returns (uint8) {
+        return 18;
+    }
+
+    function description() external pure returns (string memory) {
+        return "Pendle Chainlink-compatible Oracle";
+    }
+
+    function version() external pure returns (uint256) {
+        return 1;
+    }
+
+    // =================================================================
+    //                          PRICING FUNCTIONS
+    // =================================================================
+
+    function _getPendleTokenPrice() internal view returns (int256) {
+        return _descalePrice(_getRawPendlePrice(IPMarket(market), twapDuration));
+    }
+
+    function _descalePrice(uint256 price) private view returns (int256 unwrappedPrice) {
+        return PMath.Int((price * fromTokenScale) / toTokenScale);
+    }
+
+    // =================================================================
+    //                          USE ONLY AT INITIALIZATION
+    // =================================================================
+
+    function _getRawPendlePriceFunc()
+        internal
+        view
+        returns (function(IPMarket, uint32) internal view returns (uint256))
+    {
+        if (baseOracleType == PendleOracleType.PT_TO_SY) {
+            return PendlePYOracleLib.getPtToSyRate;
+        } else if (baseOracleType == PendleOracleType.PT_TO_ASSET) {
+            return PendlePYOracleLib.getPtToAssetRate;
+        } else {
+            revert("not supported");
+        }
+    }
+
+    function _readDecimals(
+        address _market,
+        PendleOracleType _oracleType
+    ) internal view returns (uint8 _fromDecimals, uint8 _toDecimals) {
+        (IStandardizedYield SY, , ) = IPMarket(_market).readTokens();
+
+        uint8 syDecimals = SY.decimals();
+        (, , uint8 assetDecimals) = SY.assetInfo();
+
+        if (_oracleType == PendleOracleType.PT_TO_ASSET) {
+            return (assetDecimals, assetDecimals);
+        } else if (_oracleType == PendleOracleType.PT_TO_SY) {
+            return (assetDecimals, syDecimals);
+        }
+    }
+}

package/contracts/oracles/PtYtLpOracle/chainlink/PendleChainlinkOracleFactory.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendleChainlinkOracle.sol";
+import "./PendleChainlinkOracleWithQuote.sol";
+import "../../../interfaces/IPChainlinkOracleFactory.sol";
+import "../../../interfaces/IPPYLpOracle.sol";
+
+contract PendleChainlinkOracleFactory is IPChainlinkOracleFactory {
+    error OracleAlreadyExists();
+
+    error OracleIncreaseCardinalityRequired(uint32 cardinalityRequired);
+    error OracleOldestObservationNotSatisfied();
+
+    // [keccak256(market, duration, baseOracleType)]
+    mapping(bytes32 oracleId => address oracleAddr) internal oracles;
+
+    // [keccak256(market, duration, baseOracleType, quoteOracle)]
+    mapping(bytes32 oracleId => address oracleAddr) internal oraclesWithQuote;
+
+    address public immutable pyLpOracle;
+
+    constructor(address _pyLpOracle) {
+        pyLpOracle = _pyLpOracle;
+    }
+
+    // =================================================================
+    //                          CREATE ORACLE
+    // =================================================================
+
+    function createOracle(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType
+    ) external returns (address oracle) {
+        bytes32 oracleId = getOracleId(market, twapDuration, baseOracleType);
+        if (oracles[oracleId] != address(0)) revert OracleAlreadyExists();
+
+        checkMarketOracleState(market, twapDuration);
+
+        oracle = address(new PendleChainlinkOracle(market, twapDuration, baseOracleType));
+        oracles[oracleId] = oracle;
+        emit OracleCreated(market, twapDuration, baseOracleType, oracle, oracleId);
+    }
+
+    /**
+     * @dev quoteOracle must has Chainlink-compatible interface
+     */
+    function createOracleWithQuote(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType,
+        address quoteOracle
+    ) external returns (address oracle) {
+        bytes32 oracleId = getOracleWithQuoteId(market, twapDuration, baseOracleType, quoteOracle);
+        if (oraclesWithQuote[oracleId] != address(0)) revert OracleAlreadyExists();
+
+        checkMarketOracleState(market, twapDuration);
+
+        oracle = address(new PendleChainlinkOracleWithQuote(market, twapDuration, baseOracleType, quoteOracle));
+        oraclesWithQuote[oracleId] = oracle;
+        emit OracleWithQuoteCreated(market, twapDuration, baseOracleType, quoteOracle, oracle, oracleId);
+    }
+
+    // =================================================================
+    //                          GET ORACLE
+    // =================================================================
+
+    function getOracle(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType
+    ) public view returns (address) {
+        return oracles[getOracleId(market, twapDuration, baseOracleType)];
+    }
+
+    function getOracleWithQuote(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType,
+        address quoteOracle
+    ) public view returns (address) {
+        return oraclesWithQuote[getOracleWithQuoteId(market, twapDuration, baseOracleType, quoteOracle)];
+    }
+
+    function getOracleId(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType
+    ) public pure returns (bytes32) {
+        return keccak256(abi.encode(market, twapDuration, baseOracleType));
+    }
+
+    function getOracleWithQuoteId(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType,
+        address quoteOracle
+    ) public pure returns (bytes32) {
+        return keccak256(abi.encode(market, twapDuration, baseOracleType, quoteOracle));
+    }
+
+    // =================================================================
+    //                          CHECK ORACLE STATE
+    // =================================================================
+
+    function checkMarketOracleState(address market, uint32 twapDuration) public view {
+        (bool increaseCardinalityRequired, uint32 cardinalityRequired, bool oldestObservationSatisfied) = IPPYLpOracle(
+            pyLpOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired) {
+            // call IPMarket(market).increaseObservationsCardinalityNext(cardinalityRequired) then wait for twapDuration seconds
+            revert OracleIncreaseCardinalityRequired(cardinalityRequired);
+        }
+        if (!oldestObservationSatisfied) {
+            // wait for twapDuration seconds
+            revert OracleOldestObservationNotSatisfied();
+        }
+    }
+}

package/contracts/oracles/PtYtLpOracle/chainlink/PendleChainlinkOracleWithQuote.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendleChainlinkOracle.sol";
+
+/**
+ * @dev The round data returned from this contract will follow:
+ * - There will be only one round (roundId=0)
+ * - startedAt=0, updatedAt=quoteOracle.updatedAt()
+ */
+contract PendleChainlinkOracleWithQuote is PendleChainlinkOracle {
+    // solhint-disable immutable-vars-naming
+    address public immutable quoteOracle;
+    int256 public immutable quoteScale;
+
+    constructor(
+        address _market,
+        uint32 _twapDuration,
+        PendleOracleType _baseOracleType,
+        address _quoteOracle
+    ) PendleChainlinkOracle(_market, _twapDuration, _baseOracleType) {
+        quoteOracle = _quoteOracle;
+        quoteScale = PMath.Int(10 ** AggregatorV3Interface(_quoteOracle).decimals());
+    }
+
+    /**
+     * @notice The round data returned from this contract will follow:
+     * - answer will satisfy 1 natural unit of PendleToken = (answer/1e18) natural unit of quoteToken
+     * - In other words, 10**(PendleToken.decimals) = (answer/1e18) * 10**(quoteToken.decimals)
+     * @return roundId always 0 for this contract
+     * @return answer The answer (in 18 decimals)
+     * @return startedAt always 0 for this contract
+     * @return updatedAt will be the same as quoteOracle.updatedAt()
+     * @return answeredInRound always 0 for this contract
+     */
+    function latestRoundData()
+        public
+        view
+        override
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
+    {
+        (, int256 quoteAnswer, , uint256 quoteUpdatedAt, ) = AggregatorV3Interface(quoteOracle).latestRoundData();
+
+        roundId = 0;
+        answer = (_getPendleTokenPrice() * quoteAnswer) / quoteScale;
+        updatedAt = quoteUpdatedAt;
+        startedAt = 0;
+        answeredInRound = 0;
+    }
+}

package/contracts/oracles/{samples → PtYtLpOracle/samples}/BoringLpGlpOracle.sol

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.17;
 
 import "../PendleLpOracleLib.sol";
-import "../../interfaces/IPPYLpOracle.sol";
-import "../../interfaces/GMX/IGlpManager.sol";
-import "../../core/libraries/math/PMath.sol";
+import "../../../interfaces/IPPYLpOracle.sol";
+import "../../../interfaces/GMX/IGlpManager.sol";
+import "../../../core/libraries/math/PMath.sol";
 
 /**
  * @notice The LP/GLP price gotten from the market using the LpOracleLib is multiplied with the USD price of GLP read from

package/contracts/oracles/{samples → PtYtLpOracle/samples}/BoringLpSeller.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
-import "../../interfaces/IPMarket.sol";
+import "../../../interfaces/IPMarket.sol";
 
 abstract contract BoringLpSeller {
     bytes internal constant EMPTY_BYTES = abi.encode();

package/contracts/oracles/{samples → PtYtLpOracle/samples}/BoringPYUsdChainlinkAssetOracle.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../interfaces/IPPYLpOracle.sol";
-import "../../interfaces/IPMarket.sol";
-import "../../core/libraries/math/PMath.sol";
+import "../../../interfaces/IPPYLpOracle.sol";
+import "../../../interfaces/IPMarket.sol";
+import "../../../core/libraries/math/PMath.sol";
 import "../PendleLpOracleLib.sol";
 
 import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";

package/contracts/oracles/{samples → PtYtLpOracle/samples}/BoringPYUsdChainlinkSYOracle.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../interfaces/IPPYLpOracle.sol";
-import "../../interfaces/IPMarket.sol";
-import "../../core/libraries/math/PMath.sol";
+import "../../../interfaces/IPPYLpOracle.sol";
+import "../../../interfaces/IPMarket.sol";
+import "../../../core/libraries/math/PMath.sol";
 import "../PendleLpOracleLib.sol";
 
 import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";

package/contracts/oracles/{samples → PtYtLpOracle/samples}/BoringPtSeller.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
-import "../../interfaces/IPMarket.sol";
+import "../../../interfaces/IPMarket.sol";
 
 abstract contract BoringPtSeller {
     bytes internal constant EMPTY_BYTES = abi.encode();

package/contracts/oracles/{PendleBoringOneracle.sol → internal/PendleBoringOneracle.sol}

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.17;
 
-import "../core/libraries/math/PMath.sol";
-import "../interfaces/IPExchangeRateOracle.sol";
+import "../../core/libraries/math/PMath.sol";
+import "../../interfaces/IPExchangeRateOracle.sol";
 
 contract PendleBoringOneracle is IPExchangeRateOracle {
     function getExchangeRate() external pure returns (uint256) {

package/contracts/oracles/{PendleBoringSolvBTCOneracle.sol → internal/PendleBoringSolvBTCOneracle.sol}

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.17;
 
-import "../core/libraries/math/PMath.sol";
-import "../interfaces/IPExchangeRateOracle.sol";
+import "../../core/libraries/math/PMath.sol";
+import "../../interfaces/IPExchangeRateOracle.sol";
 
 contract PendleBoringSolvBTCOneracle is IPExchangeRateOracle {
     function getExchangeRate() external pure returns (uint256) {

package/contracts/oracles/{PendleRedStoneRateOracleAdapter.sol → internal/PendleRedStoneRateOracleAdapter.sol}

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.17;
 
-import "../core/libraries/math/PMath.sol";
-import "../interfaces/IPExchangeRateOracle.sol";
-import "../interfaces/IRedstonePriceFeed.sol";
+import "../../core/libraries/math/PMath.sol";
+import "../../interfaces/IPExchangeRateOracle.sol";
+import "../../interfaces/IRedstonePriceFeed.sol";
 
 contract PendleRedStoneRateOracleAdapter is IPExchangeRateOracle {
     using PMath for int256;

package/contracts/router/ActionAddRemoveLiqV3.sol

@@ -88,7 +88,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         uint256 netPtIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtSwapToSy,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 netLpOut, uint256 netSyFee) {
         if (canUseOnchainApproximation(guessPtSwapToSy, limit)) {
             return delegateToAddLiquiditySinglePtSimple(receiver, market, netPtIn, minLpOut);
@@ -140,7 +140,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromSy,
         TokenInput calldata input,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external payable returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm) {
         if (canUseOnchainApproximation(guessPtReceivedFromSy, limit)) {
             return delegateToAddLiquiditySingleTokenSimple(receiver, market, minLpOut, input);
@@ -179,7 +179,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         uint256 netSyIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromSy,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 netLpOut, uint256 netSyFee) {
         if (canUseOnchainApproximation(guessPtReceivedFromSy, limit)) {
             return delegateToAddLiquiditySingleSySimple(receiver, market, netSyIn, minLpOut);
@@ -211,7 +211,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         uint256 netSyIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromSy,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) internal returns (uint256 netLpOut, uint256 netSyFee) {
         uint256 netSyLeft = netSyIn;
         uint256 netPtReceived;
@@ -397,7 +397,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         uint256 netLpToRemove,
         uint256 minPtOut,
         ApproxParams calldata guessPtReceivedFromSy,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
         if (canUseOnchainApproximation(guessPtReceivedFromSy, limit)) {
             return delegateToRemoveLiquiditySinglePtSimple(receiver, market, netLpToRemove, minPtOut);
@@ -439,7 +439,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         address market,
         uint256 netLpToRemove,
         TokenOutput calldata output,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
 
@@ -466,7 +466,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         address market,
         uint256 netLpToRemove,
         uint256 minSyOut,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
         _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
 
@@ -481,7 +481,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         address market,
         uint256 netLpToRemove,
         uint256 minSyOut,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) internal returns (uint256 netSyOut, uint256 netSyFee) {
         if (IPMarket(market).isExpired()) {
             netSyOut = __removeLpToSyAfterExpiry(receiver, market, netLpToRemove);
@@ -505,7 +505,7 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
         address receiver,
         address market,
         uint256 netLpToRemove,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) internal returns (uint256 netSyOut, uint256 netSyFee) {
         uint256 netPtLeft;