@pendle/core-v2 2.23.1 → 2.23.3-mantle

package/contracts/core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/utils/Address.sol";
+import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+import "../../../../LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol";
+import "../../../../interfaces/ILayerZeroEndpoint.sol";
+import "../../../../interfaces/IWstETH.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+
+contract PendleChainlinkRelayer {
+    uint256 private constant DST_EXECUTION_GAS = 50000;
+
+    address public immutable lzEndpoint;
+    address public immutable dstAddress;
+    uint256 public immutable dstChainId;
+    address public immutable chainlinkFeed;
+
+    constructor(
+        address _lzEndpoint,
+        address _dstAddress,
+        uint256 _dstChainId,
+        address _chainlinkFeed
+    ) {
+        lzEndpoint = _lzEndpoint;
+        dstAddress = _dstAddress;
+        dstChainId = _dstChainId;
+        chainlinkFeed = _chainlinkFeed;
+    }
+
+    function run() external payable {
+        bytes memory path = abi.encodePacked(dstAddress, address(this));
+        ILayerZeroEndpoint(lzEndpoint).send{ value: msg.value }(
+            LayerZeroHelper._getLayerZeroChainIds(dstChainId),
+            path,
+            abi.encode(IChainlinkAggregator(chainlinkFeed).latestAnswer()),
+            payable(msg.sender),
+            address(0),
+            abi.encodePacked(uint16(1), DST_EXECUTION_GAS)
+        );
+    }
+}

package/contracts/core/StandardizedYield/implementations/MantleStakedEth/PendleMantleStakedEthSY.sol

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPOracleForSy.sol";
+
+contract PendleMantleStakedEthSY is SYBase {
+    using Math for int256;
+
+    address internal immutable underlyingAssetOnEthAddr;
+    uint8 internal immutable underlyingAssetOnEthDecimals;
+    address public immutable oracleAddress;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _token,
+        address _underlyingAssetOnEthAddr,
+        uint8 _underlyingAssetOnEthDecimals,
+        address _oracleAddress
+    ) SYBase(_name, _symbol, _token) {
+        underlyingAssetOnEthAddr = _underlyingAssetOnEthAddr;
+        underlyingAssetOnEthDecimals = _underlyingAssetOnEthDecimals;
+        oracleAddress = _oracleAddress;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address, uint256 amountDeposited)
+        internal
+        pure
+        override
+        returns (
+            uint256 /*amountSharesOut*/
+        )
+    {
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    )
+        internal
+        override
+        returns (
+            uint256 /*amountTokenOut*/
+        )
+    {
+        _transferOut(tokenOut, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IPOracleForSy(oracleAddress).latestAnswer().Uint();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address, uint256 amountTokenToDeposit)
+        internal
+        pure
+        override
+        returns (
+            uint256 /*amountSharesOut*/
+        )
+    {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(address, uint256 amountSharesToRedeem)
+        internal
+        pure
+        override
+        returns (
+            uint256 /*amountTokenOut*/
+        )
+    {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = yieldToken;
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = yieldToken;
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, underlyingAssetOnEthAddr, underlyingAssetOnEthDecimals);
+    }
+}

package/contracts/core/StandardizedYield/implementations/MantleStakedEth/PendleOracleForSyProxy.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPOracleForSy.sol";
+
+// the Owner of this will be a timelock
+contract PendleOracleForSyProxy is BoringOwnableUpgradeable, IPOracleForSy {
+    address public oracleAddress;
+
+    constructor(address _oracleAddress) initializer {
+        __BoringOwnable_init();
+        oracleAddress = _oracleAddress;
+    }
+
+    function latestAnswer() external view override returns (int256) {
+        return IPOracleForSy(oracleAddress).latestAnswer();
+    }
+
+    function setOracleAddress(address _oracleAddress) external onlyOwner {
+        oracleAddress = _oracleAddress;
+    }
+}

package/contracts/core/libraries/ArrayLib.sol

@@ -39,6 +39,38 @@ library ArrayLib {
         }
         out[length] = element;
     }
+    /**
+     * @dev This function assumes a and b each contains unidentical elements
+     * @param a array of addresses a
+     * @param b array of addresses b
+     * @return out Concatenation of a and b containing unidentical elements
+     */
+    function merge(
+        address[] memory a,
+        address[] memory b
+    ) internal pure returns (address[] memory out) {
+        unchecked {
+            uint256 countUnidenticalB = 0;
+            bool[] memory isUnidentical = new bool[](b.length);
+            for(uint256 i = 0; i < b.length; ++i) {
+                if (!contains(a, b[i])) {
+                    countUnidenticalB++;
+                    isUnidentical[i] = true;
+                }
+            }
+
+            out = new address[](a.length + countUnidenticalB);
+            for(uint256 i = 0; i < a.length; ++i) {
+                out[i] = a[i];
+            }
+            uint256 id = a.length;
+            for(uint256 i = 0; i < b.length; ++i) {
+                if (isUnidentical[i]) {
+                    out[id++] = b[i];
+                }
+            }
+        }
+    }
 
     // various version of contains
     function contains(address[] memory array, address element) internal pure returns (bool) {

package/contracts/core/libraries/Errors.sol

@@ -118,6 +118,8 @@ library Errors {
 
     error SYBalancerReentrancy();
 
+    error NotFromTrustedRemote(uint16 srcChainId, bytes path);
+
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);

package/contracts/interfaces/Balancer/IPComposableStablePreview.sol

@@ -0,0 +1,23 @@
+pragma solidity 0.8.17;
+
+import "./IBalancerStablePreview.sol";
+
+interface IPComposableStablePreview is IBalancerStablePreview {
+    struct ImmutableData {
+        address[] poolTokens;
+        address[] rateProviders;
+        uint256[] rawScalingFactors;
+        bool[] isExemptFromYieldProtocolFee;
+        //
+        address LP;
+        bool noTokensExempt;
+        bool allTokensExempt;
+        uint256 bptIndex;
+        uint256 totalTokens;
+    }
+
+    struct TokenRateCache {
+        uint256 currentRate;
+        uint256 oldRate;
+    }
+}

package/contracts/interfaces/Balancer/IVersion.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+/**
+ * @notice Simple interface to retrieve the version of a deployed contract.
+ */
+interface IVersion {
+    /**
+     * @dev Returns a JSON representation of the contract version containing name, version number and task ID.
+     */
+    function version() external view returns (string memory);
+}

package/contracts/interfaces/IPExternalRewardDistributor.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPExternalRewardDistributor {
+    struct MarketRewardData {
+        uint128 rewardPerSec;
+        uint128 accumulatedReward;
+        uint128 lastUpdated;
+        uint128 incentiveEndsAt;
+    }
+
+    event DistributeReward(address indexed market, address indexed rewardToken, uint256 amount);
+
+    event AddRewardToMarket(address indexed market, address indexed token, MarketRewardData data);
+
+    function getRewardTokens(address market) external view returns (address[] memory);
+
+    function redeemRewards() external;
+}

package/contracts/interfaces/IPMarketFactoryV2.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./IPMarketFactory.sol";
+
+interface IPMarketFactoryV2 is IPMarketFactory {
+    function rewardDistributor() external view returns (address);
+}

package/contracts/interfaces/IPOracleForSy.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+interface IPOracleForSy {
+    function latestAnswer() external view returns (int256);
+}

package/contracts/offchain-helpers/AutomateReady.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.14;
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+    enum Module {
+        RESOLVER,
+        TIME,
+        PROXY,
+        SINGLE_EXEC
+    }
+
+    struct ModuleData {
+        Module[] modules;
+        bytes[] args;
+    }
+
+interface IAutomate {
+    function createTask(
+        address execAddress,
+        bytes calldata execDataOrSelector,
+        ModuleData calldata moduleData,
+        address feeToken
+    ) external returns (bytes32 taskId);
+
+    function cancelTask(bytes32 taskId) external;
+
+    function getFeeDetails() external view returns (uint256, address);
+
+    function gelato() external view returns (address payable);
+
+    function taskTreasury() external view returns (ITaskTreasuryUpgradable);
+}
+
+interface ITaskTreasuryUpgradable {
+    function depositFunds(
+        address receiver,
+        address token,
+        uint256 amount
+    ) external payable;
+
+    function withdrawFunds(
+        address payable receiver,
+        address token,
+        uint256 amount
+    ) external;
+}
+
+interface IOpsProxyFactory {
+    function getProxyOf(address account) external view returns (address, bool);
+}
+
+/**
+ * @dev Inherit this contract to allow your smart contract to
+ * - Make synchronous fee payments.
+ * - Have call restrictions for functions to be automated.
+ */
+// solhint-disable private-vars-leading-underscore
+abstract contract AutomateReady {
+    IAutomate public immutable automate;
+    address public immutable dedicatedMsgSender;
+    address private immutable _gelato;
+    address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+    address private constant OPS_PROXY_FACTORY =
+    0xC815dB16D4be6ddf2685C201937905aBf338F5D7;
+
+    /**
+     * @dev
+     * Only tasks created by _taskCreator defined in constructor can call
+     * the functions with this modifier.
+     */
+    modifier onlyDedicatedMsgSender() {
+        require(msg.sender == dedicatedMsgSender, "Only dedicated msg.sender");
+        _;
+    }
+
+    /**
+     * @dev
+     * _taskCreator is the address which will create tasks for this contract.
+     */
+    constructor(address _automate, address _taskCreator) {
+        automate = IAutomate(_automate);
+        _gelato = IAutomate(_automate).gelato();
+        (dedicatedMsgSender,) = IOpsProxyFactory(OPS_PROXY_FACTORY).getProxyOf(
+            _taskCreator
+        );
+    }
+
+    /**
+     * @dev
+     * Transfers fee to gelato for synchronous fee payments.
+     *
+     * _fee & _feeToken should be queried from IAutomate.getFeeDetails()
+     */
+    function _transfer(uint256 _fee, address _feeToken) internal {
+        if (_feeToken == ETH) {
+            (bool success,) = _gelato.call{value: _fee}("");
+            require(success, "_transfer: ETH transfer failed");
+        } else {
+            SafeERC20.safeTransfer(IERC20(_feeToken), _gelato, _fee);
+        }
+    }
+
+    function _getFeeDetails()
+    internal
+    view
+    returns (uint256 fee, address feeToken)
+    {
+        (fee, feeToken) = automate.getFeeDetails();
+    }
+}

package/contracts/offchain-helpers/ChainlinkRelayerAutomation.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol";
+import "@chainlink/contracts/src/v0.8/AutomationCompatible.sol";
+
+contract ChainlinkRelayerAutomation is AutomationCompatible, BoringOwnableUpgradeable {
+    PendleChainlinkRelayer internal immutable relayer;
+    bytes32 internal constant ZERO_BYTES = bytes32(0);
+
+    int256 public answerLastSent;
+
+    constructor(PendleChainlinkRelayer _relayer) initializer {
+        __BoringOwnable_init();
+        relayer = _relayer;
+    }
+
+    receive() external payable {}
+
+    function withdraw() external onlyOwner {
+        payable(owner).transfer(address(this).balance);
+    }
+
+    function checkUpkeep(
+        bytes calldata /*checkData*/
+    )
+        public
+        view
+        returns (
+            bool upkeepNeeded,
+            bytes memory /*performData*/
+        )
+    {
+        (upkeepNeeded, ) = _checkUpkeep();
+    }
+
+    function performUpkeep(
+        bytes calldata /*performData*/
+    ) public {
+        (bool upkeepNeeded, int256 latestAnswer) = _checkUpkeep();
+        require(upkeepNeeded, "no upkeep needed");
+
+        relayer.run{ value: address(this).balance }();
+        answerLastSent = latestAnswer;
+    }
+
+    function _checkUpkeep() internal view returns (bool upkeepNeeded, int256 latestAnswer) {
+        latestAnswer = IChainlinkAggregator(relayer.chainlinkFeed()).latestAnswer();
+        return (latestAnswer != answerLastSent, latestAnswer);
+    }
+}

package/contracts/offchain-helpers/ChainlinkRelayerGelato.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "./AutomateReady.sol";
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+import "../core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol";
+
+contract ChainlinkRelayerGelato is AutomateReady, BoringOwnableUpgradeable {
+    PendleChainlinkRelayer public immutable relayer;
+
+    int256 public lastSentAnswer;
+
+    constructor(address _automate, address _taskCreator, PendleChainlinkRelayer _relayer) initializer
+    AutomateReady(_automate, _taskCreator) {
+        __BoringOwnable_init();
+        relayer = _relayer;
+    }
+
+    receive() external payable {}
+
+    function withdraw() external onlyOwner {
+        payable(owner).transfer(address(this).balance);
+    }
+
+    function run() external {
+        int256 latestAnswer = IChainlinkAggregator(relayer.chainlinkFeed()).latestAnswer();
+        require(lastSentAnswer != latestAnswer, "answer not new");
+
+        (uint256 fee, address feeToken) = _getFeeDetails();
+        _transfer(fee, feeToken);
+
+        relayer.run{value: address(this).balance}();
+        lastSentAnswer = latestAnswer;
+    }
+}
+

package/contracts/offchain-helpers/errors/SDKErrorsDirectory.sol

@@ -0,0 +1,149 @@
+pragma solidity 0.8.17;
+
+library SDKErrorsDirectory {
+    error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error BulkNotMaintainer();
+    error BulkNotAdmin();
+    error BulkSellerAlreadyExisted(address token, address SY, address bulk);
+    error BulkSellerInvalidToken(address token, address SY);
+    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error ApproxFail();
+    error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
+    error ApproxBinarySearchInputInvalid(
+        uint256 approxGuessMin,
+        uint256 approxGuessMax,
+        uint256 minGuessMin,
+        uint256 maxGuessMax
+    );
+    error MarketExpired();
+    error MarketZeroAmountsInput();
+    error MarketZeroAmountsOutput();
+    error MarketZeroLnImpliedRate();
+    error MarketInsufficientPtForTrade(int256 currentAmount, int256 requiredAmount);
+    error MarketInsufficientPtReceived(uint256 actualBalance, uint256 requiredBalance);
+    error MarketInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error MarketZeroTotalPtOrTotalAsset(int256 totalPt, int256 totalAsset);
+    error MarketExchangeRateBelowOne(int256 exchangeRate);
+    error MarketProportionMustNotEqualOne();
+    error MarketRateScalarBelowZero(int256 rateScalar);
+    error MarketScalarRootBelowZero(int256 scalarRoot);
+    error MarketProportionTooHigh(int256 proportion, int256 maxProportion);
+    error OracleUninitialized();
+    error OracleTargetTooOld(uint32 target, uint32 oldest);
+    error OracleZeroCardinality();
+    error MarketFactoryExpiredPt();
+    error MarketFactoryInvalidPt();
+    error MarketFactoryMarketExists();
+    error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
+    error MarketFactoryReserveFeePercentTooHigh(
+        uint8 reserveFeePercent,
+        uint8 maxReserveFeePercent
+    );
+    error MarketFactoryZeroTreasury();
+    error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
+    error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
+    error RouterInsufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error RouterInsufficientPtOut(uint256 actualPtOut, uint256 requiredPtOut);
+    error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
+    error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
+    error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error RouterExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
+    error RouterExceededLimitPtIn(uint256 actualPtIn, uint256 limitPtIn);
+    error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
+    error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
+    error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
+    error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
+    error RouterTimeRangeZero();
+    error RouterCallbackNotPendleMarket(address caller);
+    error RouterInvalidAction(bytes4 selector);
+    error RouterInvalidFacet(address facet);
+    error RouterKyberSwapDataZero();
+    error YCExpired();
+    error YCNotExpired();
+    error YieldContractInsufficientSy(uint256 actualSy, uint256 requiredSy);
+    error YCNothingToRedeem();
+    error YCPostExpiryDataNotSet();
+    error YCNoFloatingSy();
+    error YCFactoryInvalidExpiry();
+    error YCFactoryYieldContractExisted();
+    error YCFactoryZeroExpiryDivisor();
+    error YCFactoryZeroTreasury();
+    error YCFactoryInterestFeeRateTooHigh(uint256 interestFeeRate, uint256 maxInterestFeeRate);
+    error YCFactoryRewardFeeRateTooHigh(uint256 newRewardFeeRate, uint256 maxRewardFeeRate);
+    error SYInvalidTokenIn(address token);
+    error SYInvalidTokenOut(address token);
+    error SYZeroDeposit();
+    error SYZeroRedeem();
+    error SYInsufficientSharesOut(uint256 actualSharesOut, uint256 requiredSharesOut);
+    error SYInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error SYQiTokenMintFailed(uint256 errCode);
+    error SYQiTokenRedeemFailed(uint256 errCode);
+    error SYQiTokenRedeemRewardsFailed(uint256 rewardAccruedType0, uint256 rewardAccruedType1);
+    error SYQiTokenBorrowRateTooHigh(uint256 borrowRate, uint256 borrowRateMax);
+    error SYCurveInvalidPid();
+    error SYCurve3crvPoolNotFound();
+    error SYApeDepositAmountTooSmall(uint256 amountDeposited);
+    error SYBalancerInvalidPid();
+    error SYInvalidRewardToken(address token);
+    error SYStargateRedeemCapExceeded(uint256 amountLpDesired, uint256 amountLpRedeemable);
+    error SYBalancerReentrancy();
+    error NotFromTrustedRemote(uint16 srcChainId, bytes path);
+    error VCInactivePool(address pool);
+    error VCPoolAlreadyActive(address pool);
+    error VCZeroVePendle(address user);
+    error VCExceededMaxWeight(uint256 totalWeight, uint256 maxWeight);
+    error VCEpochNotFinalized(uint256 wTime);
+    error VCPoolAlreadyAddAndRemoved(address pool);
+    error VEInvalidNewExpiry(uint256 newExpiry);
+    error VEExceededMaxLockTime();
+    error VEInsufficientLockTime();
+    error VENotAllowedReduceExpiry();
+    error VEZeroAmountLocked();
+    error VEPositionNotExpired();
+    error VEZeroPosition();
+    error VEZeroSlope(uint128 bias, uint128 slope);
+    error VEReceiveOldSupply(uint256 msgTime);
+    error GCNotPendleMarket(address caller);
+    error GCNotVotingController(address caller);
+    error InvalidWTime(uint256 wTime);
+    error ExpiryInThePast(uint256 expiry);
+    error ChainNotSupported(uint256 chainId);
+    error FDTotalAmountFundedNotMatch(uint256 actualTotalAmount, uint256 expectedTotalAmount);
+    error FDEpochLengthMismatch();
+    error FDInvalidPool(address pool);
+    error FDPoolAlreadyExists(address pool);
+    error FDInvalidNewFinishedEpoch(uint256 oldFinishedEpoch, uint256 newFinishedEpoch);
+    error FDInvalidStartEpoch(uint256 startEpoch);
+    error FDInvalidWTimeFund(uint256 lastFunded, uint256 wTime);
+    error FDFutureFunding(uint256 lastFunded, uint256 currentWTime);
+    error BDInvalidEpoch(uint256 epoch, uint256 startTime);
+    error MsgNotFromSendEndpoint(uint16 srcChainId, bytes path);
+    error MsgNotFromReceiveEndpoint(address sender);
+    error InsufficientFeeToSendMsg(uint256 currentFee, uint256 requiredFee);
+    error ApproxDstExecutionGasNotSet();
+    error InvalidRetryData();
+    error ArrayLengthMismatch();
+    error ArrayEmpty();
+    error ArrayOutOfBounds();
+    error ZeroAddress();
+    error FailedToSendEther();
+    error InvalidMerkleProof();
+    error OnlyLayerZeroEndpoint();
+    error OnlyYT();
+    error OnlyYCFactory();
+    error OnlyWhitelisted();
+    error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
+    error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
+    error MinimumStakeAmountNotReached(uint256 amountToStake, uint256 minimumStakeAmount);
+    error MinimumRedeemAmountNotReached(uint256 amountToRedeem, uint256 minimumRedeemAmount);
+    error UnstakeCapacityTooLow(uint256 amountBondToRedeem, uint256 unstakeCapacity);
+    error InvalidTokenId(uint256 tokenId, uint256 positionId);
+    error InvalidBlockRate(uint256 blockCycleNumerator);
+    error TwapDurationTooLarge(uint32 duration, uint32 cardinalityRequired);
+    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
+}

package/contracts/router/swap-aggregator/PendleSwap.sol

@@ -4,9 +4,14 @@ pragma solidity 0.8.17;
 import "../../core/libraries/TokenHelper.sol";
 import "./IPSwapAggregator.sol";
 import "./kyberswap/KyberInputScalingHelper.sol";
-import "./1inch/OneInchAggregationRouterHelper.sol";
+import "./oneinch/OneInchAggregationRouterHelper.sol";
 
-contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper, OneInchAggregationRouterHelper {
+contract PendleSwap is
+    IPSwapAggregator,
+    TokenHelper,
+    KyberInputScalingHelper,
+    OneInchAggregationRouterHelper
+{
     using Address for address;
 
     function swap(