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

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/factory/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/factory/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/factory/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/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;
 

package/contracts/router/ActionMiscV3.sol

@@ -205,6 +205,20 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         }
     }
 
+    /// @dev Deprecated, please use swapTokensToTokens which support unwrapping ETH too
+    function swapTokenToToken(
+        address receiver,
+        uint256 minTokenOut,
+        TokenInput calldata inp
+    ) external payable returns (uint256 netTokenOut) {
+        _swapTokenInput(inp);
+
+        netTokenOut = _selfBalance(inp.tokenMintSy);
+        if (netTokenOut < minTokenOut) revert("Slippage: INSUFFICIENT_TOKEN_OUT");
+
+        _transferOut(inp.tokenMintSy, receiver, netTokenOut);
+    }
+
     /// @dev The interface might change in the future, check with Pendle team before use
     function swapTokenToTokenViaSy(
         address receiver,
@@ -225,7 +239,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         uint256 netYtIn,
         uint256 netLpIn,
         TokenOutput calldata output,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 totalTokenOut, ExitPreExpReturnParams memory params) {
         IStandardizedYield SY;
 
@@ -243,7 +257,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         uint256 netYtIn,
         uint256 netLpIn,
         uint256 minSyOut,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (ExitPreExpReturnParams memory params) {
         (, params) = _exitPreExpToSy(false, receiver, market, netPtIn, netYtIn, netLpIn, limit);
         require(params.totalSyOut >= minSyOut, "Slippage: INSUFFICIENT_SY_OUT");
@@ -258,7 +272,7 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         uint256 netPtIn,
         uint256 netYtIn,
         uint256 netLpIn,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) internal returns (IStandardizedYield SY, ExitPreExpReturnParams memory p) {
         IPPrincipalToken PT;
         IPYieldToken YT;

package/contracts/router/ActionSwapPTV3.sol

@@ -16,7 +16,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase, ActionDelegateBase {
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
         TokenInput calldata input,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm) {
         if (canUseOnchainApproximation(guessPtOut, limit)) {
             return delegateToSwapExactTokenForPtSimple(receiver, market, minPtOut, input);
@@ -44,7 +44,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase, ActionDelegateBase {
         uint256 exactSyIn,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
         if (canUseOnchainApproximation(guessPtOut, limit)) {
             return delegateToSwapExactSyForPtSimple(receiver, market, exactSyIn, minPtOut);
@@ -63,7 +63,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase, ActionDelegateBase {
         address market,
         uint256 exactPtIn,
         TokenOutput calldata output,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
         _transferFrom(PT, msg.sender, _entry_swapExactPtForSy(market, limit), exactPtIn);
@@ -89,7 +89,7 @@ contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase, ActionDelegateBase {
         address market,
         uint256 exactPtIn,
         uint256 minSyOut,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
         (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
         _transferFrom(PT, msg.sender, _entry_swapExactPtForSy(market, limit), exactPtIn);

package/contracts/router/ActionSwapYTV3.sol

@@ -21,7 +21,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase, ActionD
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
         TokenInput calldata input,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm) {
         if (canUseOnchainApproximation(guessYtOut, limit)) {
             return delegateToSwapExactTokenForYtSimple(receiver, market, minYtOut, input);
@@ -50,7 +50,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase, ActionD
         uint256 exactSyIn,
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 netYtOut, uint256 netSyFee) {
         if (canUseOnchainApproximation(guessYtOut, limit)) {
             return delegateToSwapExactSyForYtSimple(receiver, market, exactSyIn, minYtOut);
@@ -71,7 +71,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase, ActionD
         address market,
         uint256 exactYtIn,
         TokenOutput calldata output,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), exactYtIn);
@@ -97,7 +97,7 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase, ActionD
         address market,
         uint256 exactYtIn,
         uint256 minSyOut,
-        LimitOrderData memory limit
+        LimitOrderData calldata limit
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
         _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), exactYtIn);