@pendle/core-v2 5.10.2 → 5.12.0-cross-chain-pt

package/contracts/core/Market/v1/PendleMarket.sol

@@ -1,348 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../../interfaces/IPMarket.sol";
-import "../../../interfaces/IPMarketFactory.sol";
-import "../../../interfaces/IPMarketSwapCallback.sol";
-
-import "../../erc20/PendleERC20.sol";
-import "../PendleGauge.sol";
-import "../OracleLib.sol";
-
-/**
-Invariance to maintain:
-- Internal balances totalPt & totalSy not interfered by people transferring tokens in directly
-- address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
-    guaranteed by address(0) & address(this) check in each updateForTwo function
-*/
-contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
-    using PMath for uint256;
-    using PMath for int256;
-    using MarketMathCore for MarketState;
-    using SafeERC20 for IERC20;
-    using PYIndexLib for IPYieldToken;
-    using OracleLib for OracleLib.Observation[65535];
-
-    struct MarketStorage {
-        int128 totalPt;
-        int128 totalSy;
-        // 1 SLOT = 256 bits
-        uint96 lastLnImpliedRate;
-        uint16 observationIndex;
-        uint16 observationCardinality;
-        uint16 observationCardinalityNext;
-        // 1 SLOT = 144 bits
-    }
-
-    string private constant NAME = "Pendle Market";
-    string private constant SYMBOL = "PENDLE-LPT";
-
-    IPPrincipalToken internal immutable PT;
-    IStandardizedYield internal immutable SY;
-    IPYieldToken internal immutable YT;
-
-    address public immutable factory;
-    uint256 public immutable expiry;
-    int256 public immutable scalarRoot;
-    int256 public immutable initialAnchor;
-
-    MarketStorage public _storage;
-
-    OracleLib.Observation[65535] public observations;
-
-    modifier notExpired() {
-        if (isExpired()) revert Errors.MarketExpired();
-        _;
-    }
-
-    constructor(
-        address _PT,
-        int256 _scalarRoot,
-        int256 _initialAnchor,
-        address _vePendle,
-        address _gaugeController
-    ) PendleERC20(NAME, SYMBOL, 18) PendleGauge(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController) {
-        PT = IPPrincipalToken(_PT);
-        SY = IStandardizedYield(PT.SY());
-        YT = IPYieldToken(PT.YT());
-
-        (_storage.observationCardinality, _storage.observationCardinalityNext) = observations.initialize(
-            uint32(block.timestamp)
-        );
-
-        if (_scalarRoot <= 0) revert Errors.MarketScalarRootBelowZero(_scalarRoot);
-
-        scalarRoot = _scalarRoot;
-        initialAnchor = _initialAnchor;
-        expiry = IPPrincipalToken(_PT).expiry();
-        factory = msg.sender;
-    }
-
-    /**
-     * @notice PendleMarket allows users to provide in PT & SY in exchange for LPs, which
-     * will grant LP holders more exchange fee over time
-     * @dev will mint as much LP as possible such that the corresponding SY and PT used do
-     * not exceed `netSyDesired` and `netPtDesired`, respectively
-     * @dev PT and SY should be transferred to this contract prior to calling
-     * @dev will revert if PT is expired
-     */
-    function mint(
-        address receiver,
-        uint256 netSyDesired,
-        uint256 netPtDesired
-    ) external nonReentrant notExpired returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed) {
-        MarketState memory market = readState(msg.sender);
-        PYIndex index = YT.newIndex();
-
-        uint256 lpToReserve;
-
-        (lpToReserve, netLpOut, netSyUsed, netPtUsed) = market.addLiquidity(
-            netSyDesired,
-            netPtDesired,
-            block.timestamp
-        );
-
-        // initializing the market
-        if (lpToReserve != 0) {
-            market.setInitialLnImpliedRate(index, initialAnchor, block.timestamp);
-            _mint(address(1), lpToReserve);
-        }
-
-        _mint(receiver, netLpOut);
-
-        _writeState(market);
-
-        if (_selfBalance(SY) < market.totalSy.Uint())
-            revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
-        if (_selfBalance(PT) < market.totalPt.Uint())
-            revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
-
-        emit Mint(receiver, netLpOut, netSyUsed, netPtUsed);
-    }
-
-    /**
-     * @notice LP Holders can burn their LP to receive back SY & PT proportionally
-     * to their share of the market
-     */
-    function burn(
-        address receiverSy,
-        address receiverPt,
-        uint256 netLpToBurn
-    ) external nonReentrant returns (uint256 netSyOut, uint256 netPtOut) {
-        MarketState memory market = readState(msg.sender);
-
-        _burn(address(this), netLpToBurn);
-
-        (netSyOut, netPtOut) = market.removeLiquidity(netLpToBurn);
-
-        if (receiverSy != address(this)) IERC20(SY).safeTransfer(receiverSy, netSyOut);
-        if (receiverPt != address(this)) IERC20(PT).safeTransfer(receiverPt, netPtOut);
-
-        _writeState(market);
-
-        emit Burn(receiverSy, receiverPt, netLpToBurn, netSyOut, netPtOut);
-    }
-
-    /**
-     * @notice Pendle Market allows swaps between PT & SY it is holding. This function
-     * aims to swap an exact amount of PT to SY.
-     * @dev steps working of this contract
-       - The outcome amount of SY will be precomputed by MarketMathLib
-       - Release the calculated amount of SY to receiver
-       - Callback to msg.sender if data.length > 0
-       - Ensure exactPtIn amount of PT has been transferred to this address
-     * @dev will revert if PT is expired
-     * @param data bytes data to be sent in the callback (if any)
-     */
-    function swapExactPtForSy(
-        address receiver,
-        uint256 exactPtIn,
-        bytes calldata data
-    ) external nonReentrant notExpired returns (uint256 netSyOut, uint256 netSyFee) {
-        MarketState memory market = readState(msg.sender);
-
-        uint256 netSyToReserve;
-        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(YT.newIndex(), exactPtIn, block.timestamp);
-
-        if (receiver != address(this)) IERC20(SY).safeTransfer(receiver, netSyOut);
-        IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
-
-        _writeState(market);
-
-        if (data.length > 0) {
-            IPMarketSwapCallback(msg.sender).swapCallback(exactPtIn.neg(), netSyOut.Int(), data);
-        }
-
-        if (_selfBalance(PT) < market.totalPt.Uint())
-            revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
-
-        emit Swap(msg.sender, receiver, exactPtIn.neg(), netSyOut.Int(), netSyFee, netSyToReserve);
-    }
-
-    /**
-     * @notice Pendle Market allows swaps between PT & SY it is holding. This function
-     * aims to swap SY for an exact amount of PT.
-     * @dev steps working of this function
-       - The exact outcome amount of PT will be transferred to receiver
-       - Callback to msg.sender if data.length > 0
-       - Ensure the calculated required amount of SY is transferred to this address
-     * @dev will revert if PT is expired
-     * @param data bytes data to be sent in the callback (if any)
-     */
-    function swapSyForExactPt(
-        address receiver,
-        uint256 exactPtOut,
-        bytes calldata data
-    ) external nonReentrant notExpired returns (uint256 netSyIn, uint256 netSyFee) {
-        MarketState memory market = readState(msg.sender);
-
-        uint256 netSyToReserve;
-        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
-
-        if (receiver != address(this)) IERC20(PT).safeTransfer(receiver, exactPtOut);
-        IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
-
-        _writeState(market);
-
-        if (data.length > 0) {
-            IPMarketSwapCallback(msg.sender).swapCallback(exactPtOut.Int(), netSyIn.neg(), data);
-        }
-
-        // have received enough SY
-        if (_selfBalance(SY) < market.totalSy.Uint())
-            revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
-
-        emit Swap(msg.sender, receiver, exactPtOut.Int(), netSyIn.neg(), netSyFee, netSyToReserve);
-    }
-
-    /// @notice forces balances to match reserves
-    function skim() external nonReentrant {
-        MarketState memory market = readState(msg.sender);
-        uint256 excessPt = _selfBalance(PT) - market.totalPt.Uint();
-        uint256 excessSy = _selfBalance(SY) - market.totalSy.Uint();
-        if (excessPt != 0) IERC20(PT).safeTransfer(market.treasury, excessPt);
-        if (excessSy != 0) IERC20(SY).safeTransfer(market.treasury, excessSy);
-    }
-
-    /**
-     * @notice redeems the user's reward
-     * @return amount of reward token redeemed, in the same order as `getRewardTokens()`
-     */
-    function redeemRewards(address user) external nonReentrant returns (uint256[] memory) {
-        return _redeemRewards(user);
-    }
-
-    /// @notice returns the list of reward tokens
-    function getRewardTokens() external view returns (address[] memory) {
-        return _getRewardTokens();
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                                ORACLE
-    //////////////////////////////////////////////////////////////*/
-
-    function observe(uint32[] memory secondsAgos) external view returns (uint216[] memory lnImpliedRateCumulative) {
-        return
-            observations.observe(
-                uint32(block.timestamp),
-                secondsAgos,
-                _storage.lastLnImpliedRate,
-                _storage.observationIndex,
-                _storage.observationCardinality
-            );
-    }
-
-    function increaseObservationsCardinalityNext(uint16 cardinalityNext) external nonReentrant {
-        uint16 cardinalityNextOld = _storage.observationCardinalityNext;
-        uint16 cardinalityNextNew = observations.grow(cardinalityNextOld, cardinalityNext);
-        if (cardinalityNextOld != cardinalityNextNew) {
-            _storage.observationCardinalityNext = cardinalityNextNew;
-            emit IncreaseObservationCardinalityNext(cardinalityNextOld, cardinalityNextNew);
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                                READ/WRITE STATES
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @notice read the state of the market from storage into memory for gas-efficient manipulation
-     */
-    function readState(address router) public view returns (MarketState memory market) {
-        market.totalPt = _storage.totalPt;
-        market.totalSy = _storage.totalSy;
-        market.totalLp = totalSupply().Int();
-
-        (market.treasury, market.lnFeeRateRoot, market.reserveFeePercent) = IPMarketFactory(factory).getMarketConfig(
-            router
-        );
-
-        market.scalarRoot = scalarRoot;
-        market.expiry = expiry;
-
-        market.lastLnImpliedRate = _storage.lastLnImpliedRate;
-    }
-
-    /// @notice write back the state of the market from memory to storage
-    function _writeState(MarketState memory market) internal {
-        uint96 lastLnImpliedRate96 = market.lastLnImpliedRate.Uint96();
-        int128 totalPt128 = market.totalPt.Int128();
-        int128 totalSy128 = market.totalSy.Int128();
-
-        (uint16 observationIndex, uint16 observationCardinality) = observations.write(
-            _storage.observationIndex,
-            uint32(block.timestamp),
-            _storage.lastLnImpliedRate,
-            _storage.observationCardinality,
-            _storage.observationCardinalityNext
-        );
-
-        _storage.totalPt = totalPt128;
-        _storage.totalSy = totalSy128;
-        _storage.lastLnImpliedRate = lastLnImpliedRate96;
-        _storage.observationIndex = observationIndex;
-        _storage.observationCardinality = observationCardinality;
-
-        emit UpdateImpliedRate(block.timestamp, market.lastLnImpliedRate);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                            TRIVIAL FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    function readTokens() external view returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) {
-        _SY = SY;
-        _PT = PT;
-        _YT = YT;
-    }
-
-    function isExpired() public view returns (bool) {
-        return MiniHelpers.isCurrentlyExpired(expiry);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    PENDLE GAUGE - RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    function _stakedBalance(address user) internal view override returns (uint256) {
-        return balanceOf(user);
-    }
-
-    function _totalStaked() internal view override returns (uint256) {
-        return totalSupply();
-    }
-
-    // solhint-disable-next-line ordering
-    function _beforeTokenTransfer(
-        address from,
-        address to,
-        uint256 amount
-    ) internal override(PendleERC20, PendleGauge) {
-        PendleGauge._beforeTokenTransfer(from, to, amount);
-    }
-
-    // solhint-disable-next-line ordering
-    function _afterTokenTransfer(address from, address to, uint256 amount) internal override(PendleERC20, PendleGauge) {
-        PendleGauge._afterTokenTransfer(from, to, amount);
-    }
-}

package/contracts/core/Market/v1/PendleMarketFactory.sol

@@ -1,154 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
-
-import "../../../interfaces/IPMarket.sol";
-import "../../../interfaces/IPYieldContractFactory.sol";
-import "../../../interfaces/IPMarketFactory.sol";
-
-import "../../libraries/BaseSplitCodeFactory.sol";
-import "../../libraries/Errors.sol";
-import "../../libraries/BoringOwnableUpgradeable.sol";
-
-contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
-    using EnumerableSet for EnumerableSet.AddressSet;
-
-    address public immutable marketCreationCodeContractA;
-    uint256 public immutable marketCreationCodeSizeA;
-    address public immutable marketCreationCodeContractB;
-    uint256 public immutable marketCreationCodeSizeB;
-
-    address public immutable yieldContractFactory;
-    uint256 public immutable maxLnFeeRateRoot;
-    uint8 public constant maxReserveFeePercent = 100;
-    int256 public constant minInitialAnchor = PMath.IONE;
-
-    address public treasury;
-    FeeConfig public defaultFee;
-    /// 1 SLOT
-
-    // router -> overriddenFee
-    mapping(address => FeeConfig) public overriddenFee;
-
-    // PT -> scalarRoot -> initialAnchor
-    mapping(address => mapping(int256 => mapping(int256 => address))) internal markets;
-    EnumerableSet.AddressSet internal allMarkets;
-    address public vePendle;
-    address public gaugeController;
-
-    constructor(
-        address _yieldContractFactory,
-        address _marketCreationCodeContractA,
-        uint256 _marketCreationCodeSizeA,
-        address _marketCreationCodeContractB,
-        uint256 _marketCreationCodeSizeB
-    ) {
-        yieldContractFactory = _yieldContractFactory;
-        maxLnFeeRateRoot = uint256(LogExpMath.ln(int256((105 * PMath.IONE) / 100))); // ln(1.05)
-
-        marketCreationCodeContractA = _marketCreationCodeContractA;
-        marketCreationCodeSizeA = _marketCreationCodeSizeA;
-        marketCreationCodeContractB = _marketCreationCodeContractB;
-        marketCreationCodeSizeB = _marketCreationCodeSizeB;
-    }
-
-    function initialize(
-        address _treasury,
-        uint80 _defaultLnFeeRateRoot,
-        uint8 _defaultReserveFeePercent,
-        address newVePendle,
-        address newGaugeController
-    ) external initializer {
-        __BoringOwnable_init();
-        setTreasury(_treasury);
-        setDefaultFee(_defaultLnFeeRateRoot, _defaultReserveFeePercent);
-
-        vePendle = newVePendle;
-        gaugeController = newGaugeController;
-    }
-
-    /**
-     * @notice Create a market between PT and its corresponding SY with scalar & anchor config.
-     * Anyone is allowed to create a market on their own.
-     */
-    function createNewMarket(address PT, int256 scalarRoot, int256 initialAnchor) external returns (address market) {
-        if (!IPYieldContractFactory(yieldContractFactory).isPT(PT)) revert Errors.MarketFactoryInvalidPt();
-        if (IPPrincipalToken(PT).isExpired()) revert Errors.MarketFactoryExpiredPt();
-
-        if (markets[PT][scalarRoot][initialAnchor] != address(0)) revert Errors.MarketFactoryMarketExists();
-
-        if (initialAnchor < minInitialAnchor)
-            revert Errors.MarketFactoryInitialAnchorTooLow(initialAnchor, minInitialAnchor);
-
-        market = BaseSplitCodeFactory._create2(
-            0,
-            bytes32(block.chainid),
-            abi.encode(PT, scalarRoot, initialAnchor, vePendle, gaugeController),
-            marketCreationCodeContractA,
-            marketCreationCodeSizeA,
-            marketCreationCodeContractB,
-            marketCreationCodeSizeB
-        );
-
-        markets[PT][scalarRoot][initialAnchor] = market;
-
-        if (!allMarkets.add(market)) assert(false);
-
-        emit CreateNewMarket(market, PT, scalarRoot, initialAnchor);
-    }
-
-    function getMarketConfig(
-        address router
-    ) external view returns (address _treasury, uint80 _lnFeeRateRoot, uint8 _reserveFeePercent) {
-        (_treasury, _lnFeeRateRoot, _reserveFeePercent) = (
-            treasury,
-            defaultFee.lnFeeRateRoot,
-            defaultFee.reserveFeePercent
-        );
-
-        FeeConfig memory over = overriddenFee[router];
-        if (over.active) {
-            (_lnFeeRateRoot, _reserveFeePercent) = (over.lnFeeRateRoot, over.reserveFeePercent);
-        }
-    }
-
-    /// @dev for gas-efficient verification of market
-    function isValidMarket(address market) external view returns (bool) {
-        return allMarkets.contains(market);
-    }
-
-    function setTreasury(address newTreasury) public onlyOwner {
-        if (newTreasury == address(0)) revert Errors.MarketFactoryZeroTreasury();
-
-        treasury = newTreasury;
-        _emitNewMarketConfigEvent();
-    }
-
-    function setDefaultFee(uint80 newLnFeeRateRoot, uint8 newReserveFeePercent) public onlyOwner {
-        _verifyFeeConfig(newLnFeeRateRoot, newReserveFeePercent);
-        defaultFee = FeeConfig(newLnFeeRateRoot, newReserveFeePercent, true);
-        _emitNewMarketConfigEvent();
-    }
-
-    function setOverriddenFee(address router, uint80 newLnFeeRateRoot, uint8 newReserveFeePercent) public onlyOwner {
-        _verifyFeeConfig(newLnFeeRateRoot, newReserveFeePercent);
-        overriddenFee[router] = FeeConfig(newLnFeeRateRoot, newReserveFeePercent, true);
-        emit SetOverriddenFee(router, newLnFeeRateRoot, newReserveFeePercent);
-    }
-
-    function unsetOverriddenFee(address router) external onlyOwner {
-        delete overriddenFee[router];
-        emit UnsetOverriddenFee(router);
-    }
-
-    function _verifyFeeConfig(uint80 newLnFeeRateRoot, uint8 newReserveFeePercent) internal view {
-        if (newLnFeeRateRoot > maxLnFeeRateRoot)
-            revert Errors.MarketFactoryLnFeeRateRootTooHigh(newLnFeeRateRoot, maxLnFeeRateRoot);
-        if (newReserveFeePercent > maxReserveFeePercent)
-            revert Errors.MarketFactoryReserveFeePercentTooHigh(newReserveFeePercent, maxReserveFeePercent);
-    }
-
-    function _emitNewMarketConfigEvent() internal {
-        emit NewMarketConfig(treasury, defaultFee.lnFeeRateRoot, defaultFee.reserveFeePercent);
-    }
-}

package/contracts/core/libraries/BoringOwnableUpgradeable.sol

@@ -1,58 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
-
-contract BoringOwnableUpgradeableData {
-    address public owner;
-    address public pendingOwner;
-}
-
-abstract contract BoringOwnableUpgradeable is BoringOwnableUpgradeableData, Initializable {
-    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
-
-    function __BoringOwnable_init() internal onlyInitializing {
-        owner = msg.sender;
-    }
-
-    /// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
-    /// Can only be invoked by the current `owner`.
-    /// @param newOwner Address of the new owner.
-    /// @param direct True if `newOwner` should be set immediately. False if `newOwner` needs to use `claimOwnership`.
-    /// @param renounce Allows the `newOwner` to be `address(0)` if `direct` and `renounce` is True. Has no effect otherwise.
-    function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
-        if (direct) {
-            // Checks
-            require(newOwner != address(0) || renounce, "Ownable: zero address");
-
-            // Effects
-            emit OwnershipTransferred(owner, newOwner);
-            owner = newOwner;
-            pendingOwner = address(0);
-        } else {
-            // Effects
-            pendingOwner = newOwner;
-        }
-    }
-
-    /// @notice Needs to be called by `pendingOwner` to claim ownership.
-    function claimOwnership() public {
-        address _pendingOwner = pendingOwner;
-
-        // Checks
-        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
-
-        // Effects
-        emit OwnershipTransferred(owner, _pendingOwner);
-        owner = _pendingOwner;
-        pendingOwner = address(0);
-    }
-
-    /// @notice Only allows the `owner` to execute the function.
-    modifier onlyOwner() {
-        require(msg.sender == owner, "Ownable: caller is not the owner");
-        _;
-    }
-
-    uint256[48] private __gap;
-}