@pendle/core-v2 0.1.0

package/contracts/core/PendleMarket.sol

@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "./PendleBaseToken.sol";
+import "../interfaces/IPOwnershipToken.sol";
+import "../SuperComposableYield/ISuperComposableYield.sol";
+import "../interfaces/IPMarket.sol";
+import "../interfaces/IPMarketFactory.sol";
+import "../interfaces/IPMarketSwapCallback.sol";
+import "../interfaces/IPMarketAddRemoveCallback.sol";
+
+import "../libraries/math/LogExpMath.sol";
+import "../libraries/math/FixedPoint.sol";
+import "../libraries/math/MarketMathLib.sol";
+
+import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
+import "openzeppelin-solidity/contracts/security/ReentrancyGuard.sol";
+
+// solhint-disable reason-string
+contract PendleMarket is PendleBaseToken, IPMarket, ReentrancyGuard {
+    using FixedPoint for uint256;
+    using FixedPoint for int256;
+    using FixedPoint for uint128;
+    using LogExpMath for uint256;
+    using MarketMathLib for MarketParameters;
+    using SafeERC20 for IERC20;
+
+    string private constant NAME = "Pendle Market";
+    string private constant SYMBOL = "PENDLE-LPT";
+    uint256 private constant MINIMUM_LIQUIDITY = 10**3;
+    uint8 private constant DECIMALS = 18;
+    int256 internal constant RATE_PRECISION = 1e9;
+
+    address public immutable OT;
+    address public immutable SCY;
+    address public immutable YT;
+
+    int256 public immutable scalarRoot;
+    uint256 public immutable feeRateRoot; // allow fee to be changable?
+    int256 public immutable anchorRoot;
+
+    uint256 public immutable rateOracleTimeWindow;
+    int8 public immutable reserveFeePercent;
+
+    MarketStorage public marketStorage;
+
+    constructor(
+        address _OT,
+        uint256 _rateOracleTimeWindow,
+        uint256 _feeRateRoot,
+        int256 _scalarRoot,
+        int256 _anchorRoot,
+        uint8 _reserveFeePercent
+    ) PendleBaseToken(NAME, SYMBOL, 18, IPOwnershipToken(_OT).expiry()) {
+        OT = _OT;
+        SCY = IPOwnershipToken(_OT).SCY();
+        YT = IPOwnershipToken(_OT).YT();
+        feeRateRoot = _feeRateRoot;
+        scalarRoot = _scalarRoot;
+        rateOracleTimeWindow = _rateOracleTimeWindow;
+
+        require(_reserveFeePercent <= 100, "invalid fee rate");
+        reserveFeePercent = int8(_reserveFeePercent);
+        anchorRoot = _anchorRoot;
+    }
+
+    function addLiquidity(
+        address receiver,
+        uint256 scyDesired,
+        uint256 otDesired,
+        bytes calldata data
+    )
+        external
+        nonReentrant
+        returns (
+            uint256 lpToAccount,
+            uint256 scyUsed,
+            uint256 otUsed
+        )
+    {
+        MarketParameters memory market = readState();
+        SCYIndex index = SCYIndexLib.newIndex(SCY);
+
+        uint256 lpToReserve;
+        (lpToReserve, lpToAccount, scyUsed, otUsed) = market.addLiquidity(
+            index,
+            scyDesired,
+            otDesired
+        );
+
+        // initializing the market
+        if (lpToReserve != 0) {
+            market.setInitialImpliedRate(index, anchorRoot, block.timestamp);
+            _mint(address(1), lpToReserve);
+        }
+
+        _mint(receiver, lpToAccount);
+
+        if (data.length > 0) {
+            IPMarketAddRemoveCallback(msg.sender).addLiquidityCallback(
+                lpToAccount,
+                scyUsed,
+                otUsed,
+                data
+            );
+        }
+
+        require(market.totalOt.Uint() <= IERC20(OT).balanceOf(address(this)));
+        require(market.totalScy.Uint() <= IERC20(SCY).balanceOf(address(this)));
+
+        _writeState(market);
+    }
+
+    function removeLiquidity(
+        address receiver,
+        uint256 lpToRemove,
+        bytes calldata data
+    ) external nonReentrant returns (uint256 scyToAccount, uint256 otToAccount) {
+        MarketParameters memory market = readState();
+
+        (scyToAccount, otToAccount) = market.removeLiquidity(lpToRemove);
+
+        IERC20(SCY).safeTransfer(receiver, scyToAccount);
+        IERC20(OT).safeTransfer(receiver, otToAccount);
+
+        if (data.length > 0) {
+            IPMarketAddRemoveCallback(msg.sender).removeLiquidityCallback(
+                lpToRemove,
+                scyToAccount,
+                otToAccount,
+                data
+            );
+        }
+
+        _burn(address(this), lpToRemove);
+
+        _writeState(market);
+    }
+
+    function swapExactOtForScy(
+        address receiver,
+        uint256 exactOtIn,
+        uint256 minScyOut,
+        bytes calldata data
+    ) external nonReentrant returns (uint256 netScyOut, uint256 netScyToReserve) {
+        require(block.timestamp < expiry, "MARKET_EXPIRED");
+
+        MarketParameters memory market = readState();
+
+        (netScyOut, netScyToReserve) = market.swapExactOtForScy(
+            SCYIndexLib.newIndex(SCY),
+            exactOtIn,
+            block.timestamp
+        );
+        require(netScyOut >= minScyOut, "insufficient scy out");
+        IERC20(SCY).safeTransfer(receiver, netScyOut);
+        IERC20(SCY).safeTransfer(IPMarketFactory(factory).treasury(), netScyToReserve);
+
+        if (data.length > 0) {
+            IPMarketSwapCallback(msg.sender).swapCallback(exactOtIn.neg(), netScyOut.Int(), data);
+        }
+
+        // have received enough OT
+        require(market.totalOt.Uint() <= IERC20(OT).balanceOf(address(this)));
+        _writeState(market);
+    }
+
+    function swapScyForExactOt(
+        address receiver,
+        uint256 exactOtOut,
+        uint256 maxScyIn,
+        bytes calldata data
+    ) external nonReentrant returns (uint256 netScyIn, uint256 netScyToReserve) {
+        require(block.timestamp < expiry, "MARKET_EXPIRED");
+
+        MarketParameters memory market = readState();
+
+        (netScyIn, netScyToReserve) = market.swapScyForExactOt(
+            SCYIndexLib.newIndex(SCY),
+            exactOtOut,
+            block.timestamp
+        );
+        require(netScyIn <= maxScyIn, "scy in exceed limit");
+        IERC20(OT).safeTransfer(receiver, exactOtOut);
+        IERC20(SCY).safeTransfer(IPMarketFactory(factory).treasury(), netScyToReserve);
+
+        if (data.length > 0) {
+            IPMarketSwapCallback(msg.sender).swapCallback(exactOtOut.Int(), netScyIn.neg(), data);
+        }
+
+        // have received enough SCY
+        require(market.totalScy.Uint() <= IERC20(SCY).balanceOf(address(this)));
+        _writeState(market);
+    }
+
+    /// @dev this function is just a place holder. Later on the rewards will be transferred to the liquidity minining
+    /// instead
+    function redeemScyReward() external returns (uint256[] memory outAmounts) {
+        outAmounts = ISuperComposableYield(SCY).redeemReward(
+            address(this),
+            IPMarketFactory(factory).treasury()
+        );
+    }
+
+    /// the only non-view part in this function is the ISuperComposableYield(SCY).scyIndexCurrent()
+    function readState() public view returns (MarketParameters memory market) {
+        MarketStorage storage store = marketStorage;
+        market.totalOt = store.totalOt;
+        market.totalScy = store.totalScy;
+        market.totalLp = totalSupply().Int();
+        market.oracleRate = store.oracleRate;
+        market.reserveFeePercent = reserveFeePercent;
+
+        market.scalarRoot = scalarRoot;
+        market.feeRateRoot = feeRateRoot;
+        market.rateOracleTimeWindow = rateOracleTimeWindow;
+        market.expiry = expiry;
+
+        market.lastImpliedRate = store.lastImpliedRate;
+        market.lastTradeTime = store.lastTradeTime;
+
+        market.updateNewRateOracle(block.timestamp);
+    }
+
+    function _writeState(MarketParameters memory market) internal {
+        MarketStorage storage store = marketStorage;
+
+        store.totalOt = market.totalOt.Int128();
+        store.totalScy = market.totalScy.Int128();
+        store.lastImpliedRate = market.lastImpliedRate.Uint112();
+        store.oracleRate = market.oracleRate.Uint112();
+        store.lastTradeTime = market.lastTradeTime.Uint32();
+    }
+
+    function readTokens()
+        external
+        view
+        returns (
+            ISuperComposableYield _SCY,
+            IPOwnershipToken _OT,
+            IPYieldToken _YT
+        )
+    {
+        _SCY = ISuperComposableYield(SCY);
+        _OT = IPOwnershipToken(OT);
+        _YT = IPYieldToken(YT);
+    }
+}

package/contracts/core/PendleMarketFactory.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+import "openzeppelin-solidity/contracts/utils/structs/EnumerableSet.sol";
+import "../interfaces/IPMarket.sol";
+import "../interfaces/IPYieldContractFactory.sol";
+import "../interfaces/IPMarketFactory.sol";
+import "../periphery/PermissionsV2.sol";
+import "./PendleMarket.sol";
+
+contract PendleMarketFactory is PermissionsV2, IPMarketFactory {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    mapping(address => EnumerableSet.AddressSet) internal otMarkets;
+    address public immutable yieldContractFactory;
+    address public treasury;
+
+    constructor(address _governanceManager, address _yieldContractFactory)
+        PermissionsV2(_governanceManager)
+    {
+        yieldContractFactory = _yieldContractFactory;
+    }
+
+    function createNewMarket(
+        address OT,
+        uint256 feeRateRoot,
+        int256 scalarRoot,
+        int256 anchorRoot,
+        uint8 reserveFeePercent,
+        uint256 rateOracleTimeWindow
+    ) external returns (address market) {
+        address SCY = IPOwnershipToken(OT).SCY();
+        uint256 expiry = IPOwnershipToken(OT).expiry();
+
+        require(
+            IPYieldContractFactory(yieldContractFactory).getOT(SCY, expiry) == OT,
+            "INVALID_OT"
+        );
+
+        market = address(
+            new PendleMarket(
+                OT,
+                rateOracleTimeWindow,
+                feeRateRoot,
+                scalarRoot,
+                anchorRoot,
+                reserveFeePercent
+            )
+        );
+        otMarkets[address(OT)].add(market);
+    }
+
+    function setTreasury(address newTreasury) external onlyGovernance {
+        treasury = newTreasury;
+    }
+
+    function isValidMarket(address market) external view returns (bool) {
+        address OT = IPMarket(market).OT();
+        return otMarkets[OT].contains(market);
+    }
+}

package/contracts/core/PendleOwnershipToken.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "./PendleBaseToken.sol";
+import "../interfaces/IPOwnershipToken.sol";
+
+contract PendleOwnershipToken is PendleBaseToken, IPOwnershipToken {
+    address public immutable SCY;
+    address public YT;
+
+    modifier onlyYT() {
+        require(msg.sender == address(YT), "ONLY_YT");
+        _;
+    }
+
+    modifier onlyFactory() {
+        require(msg.sender == factory, "ONLY_FACTORY");
+        _;
+    }
+
+    constructor(
+        address _SCY,
+        string memory _name,
+        string memory _symbol,
+        uint8 __decimals,
+        uint256 _expiry
+    ) PendleBaseToken(_name, _symbol, __decimals, _expiry) {
+        SCY = _SCY;
+    }
+
+    function initialize(address _YT) external onlyFactory {
+        YT = _YT;
+    }
+
+    function burnByYT(address user, uint256 amount) external onlyYT {
+        _burn(user, amount);
+        emit Burn(user, amount);
+    }
+
+    function mintByYT(address user, uint256 amount) external onlyYT {
+        _mint(user, amount);
+        emit Mint(user, amount);
+    }
+}

package/contracts/core/PendleSCYImpl/AaveV3/PendleAaveV3SCY.sol

@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+pragma abicoder v2;
+import "../../../SuperComposableYield/implementations/SCYBaseWithRewards.sol";
+import "../../../interfaces/IAToken.sol";
+import "../../../interfaces/IAavePool.sol";
+import "../../../interfaces/IAaveRewardsController.sol";
+import "./WadRayMath.sol";
+
+contract PendleAaveV3SCY is SCYBaseWithRewards {
+    using WadRayMath for uint256;
+    using SafeERC20 for IERC20;
+
+    address public immutable underlying;
+    address public immutable pool;
+    address public immutable rewardsController;
+    address public immutable aToken;
+
+    uint256 public lastScyIndex;
+
+    // WIP: Aave reward controller can config to have more rewardsToken,
+    // hence rewardsLength should not be immutable
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint8 __scydecimals,
+        uint8 __assetDecimals,
+        address _aavePool,
+        address _underlying,
+        address _aToken,
+        address _rewardsController
+    ) SCYBaseWithRewards(_name, _symbol, __scydecimals, __assetDecimals) {
+        aToken = _aToken;
+        pool = _aavePool;
+        underlying = _underlying;
+        rewardsController = _rewardsController;
+        IERC20(underlying).safeIncreaseAllowance(aToken, type(uint256).max);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address token, uint256 amountBase)
+        internal
+        virtual
+        override
+        returns (uint256 amountScyOut)
+    {
+        // aTokenScaled -> scy is 1:1
+        if (token == aToken) {
+            amountScyOut = amountBase.rayDiv(scyIndexCurrent());
+        } else {
+            IAavePool(pool).supply(underlying, amountBase, address(this), 0);
+            _afterSendToken(underlying);
+            amountScyOut = _afterReceiveToken(aToken);
+        }
+    }
+
+    function _redeem(address token, uint256 amountScy)
+        internal
+        virtual
+        override
+        returns (uint256 amountBaseOut)
+    {
+        if (token == aToken) {
+            amountBaseOut = amountScy.rayMul(scyIndexCurrent());
+        } else {
+            uint256 amountBaseExpected = amountScy.rayMul(scyIndexCurrent());
+            IAavePool(pool).withdraw(underlying, amountBaseExpected, address(this));
+            _afterSendToken(aToken);
+            amountBaseOut = _afterReceiveToken(token);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               SCY-INDEX
+    //////////////////////////////////////////////////////////////*/
+
+    function scyIndexCurrent() public virtual override returns (uint256 res) {
+        res = IAavePool(pool).getReserveNormalizedIncome(underlying);
+        lastScyIndex = res;
+        return res;
+    }
+
+    function scyIndexStored() public view override returns (uint256 res) {
+        res = lastScyIndex;
+    }
+
+    function getRewardTokens() public view override returns (address[] memory res) {
+        return IAaveRewardsController(rewardsController).getRewardsByAsset(aToken);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function getBaseTokens() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = aToken;
+    }
+
+    function isValidBaseToken(address token) public view virtual override returns (bool res) {
+        res = (token == underlying || token == aToken);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _redeemExternalReward() internal override {
+        address[] memory assets = new address[](1);
+        assets[0] = aToken;
+
+        IAaveRewardsController(rewardsController).claimAllRewards(assets, address(this));
+    }
+
+    /// @dev balance of aToken is saved by scaledBalanceOf instead
+    function _afterReceiveToken(address token) internal virtual override returns (uint256 res) {
+        if (token == aToken) {
+            uint256 curBalance = IAToken(aToken).scaledBalanceOf(address(this));
+            res = (curBalance - lastBalanceOf[token]).rayMul(scyIndexCurrent());
+            lastBalanceOf[token] = curBalance;
+        } else {
+            uint256 curBalance = IERC20(token).balanceOf(address(this));
+            res = curBalance - lastBalanceOf[token];
+            lastBalanceOf[token] = curBalance;
+        }
+    }
+
+    function _afterSendToken(address token) internal virtual override {
+        if (token == aToken) {
+            lastBalanceOf[token] = IAToken(aToken).scaledBalanceOf(address(this));
+        } else {
+            lastBalanceOf[token] = IERC20(token).balanceOf(address(this));
+        }
+    }
+}

package/contracts/core/PendleSCYImpl/AaveV3/WadRayMath.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.9;
+
+/**
+ * @title WadRayMath library
+ * @author Aave
+ * @notice Provides functions to perform calculations with Wad and Ray units
+ * @dev Provides mul and div function for wads (decimal numbers with 18 digits of precision) and rays (decimal numbers
+ * with 27 digits of precision)
+ * @dev Operations are rounded. If a value is >=.5, will be rounded up, otherwise rounded down.
+ **/
+library WadRayMath {
+    // HALF_WAD and HALF_RAY expressed with extended notation as constant with operations are not supported in Yul assembly
+    uint256 internal constant WAD = 1e18;
+    uint256 internal constant HALF_WAD = 0.5e18;
+
+    uint256 internal constant RAY = 1e27;
+    uint256 internal constant HALF_RAY = 0.5e27;
+
+    uint256 internal constant WAD_RAY_RATIO = 1e9;
+
+    /**
+     * @dev Multiplies two wad, rounding half up to the nearest wad
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Wad
+     * @param b Wad
+     * @return c = a*b, in wad
+     **/
+    function wadMul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        // to avoid overflow, a <= (type(uint256).max - HALF_WAD) / b
+        assembly {
+            if iszero(or(iszero(b), iszero(gt(a, div(sub(not(0), HALF_WAD), b))))) {
+                revert(0, 0)
+            }
+
+            c := div(add(mul(a, b), HALF_WAD), WAD)
+        }
+    }
+
+    /**
+     * @dev Divides two wad, rounding half up to the nearest wad
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Wad
+     * @param b Wad
+     * @return c = a/b, in wad
+     **/
+    function wadDiv(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        // to avoid overflow, a <= (type(uint256).max - halfB) / WAD
+        assembly {
+            if or(iszero(b), iszero(iszero(gt(a, div(sub(not(0), div(b, 2)), WAD))))) {
+                revert(0, 0)
+            }
+
+            c := div(add(mul(a, WAD), div(b, 2)), b)
+        }
+    }
+
+    /**
+     * @notice Multiplies two ray, rounding half up to the nearest ray
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Ray
+     * @param b Ray
+     * @return c = a raymul b
+     **/
+    function rayMul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        // to avoid overflow, a <= (type(uint256).max - HALF_RAY) / b
+        assembly {
+            if iszero(or(iszero(b), iszero(gt(a, div(sub(not(0), HALF_RAY), b))))) {
+                revert(0, 0)
+            }
+
+            c := div(add(mul(a, b), HALF_RAY), RAY)
+        }
+    }
+
+    /**
+     * @notice Divides two ray, rounding half up to the nearest ray
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Ray
+     * @param b Ray
+     * @return c = a raydiv b
+     **/
+    function rayDiv(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        // to avoid overflow, a <= (type(uint256).max - halfB) / RAY
+        assembly {
+            if or(iszero(b), iszero(iszero(gt(a, div(sub(not(0), div(b, 2)), RAY))))) {
+                revert(0, 0)
+            }
+
+            c := div(add(mul(a, RAY), div(b, 2)), b)
+        }
+    }
+
+    /**
+     * @dev Casts ray down to wad
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Ray
+     * @return b = a converted to wad, rounded half up to the nearest wad
+     **/
+    function rayToWad(uint256 a) internal pure returns (uint256 b) {
+        assembly {
+            b := div(a, WAD_RAY_RATIO)
+            let remainder := mod(a, WAD_RAY_RATIO)
+            if iszero(lt(remainder, div(WAD_RAY_RATIO, 2))) {
+                b := add(b, 1)
+            }
+        }
+    }
+
+    /**
+     * @dev Converts wad up to ray
+     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
+     * @param a Wad
+     * @return b = a converted in ray
+     **/
+    function wadToRay(uint256 a) internal pure returns (uint256 b) {
+        // to avoid overflow, b/WAD_RAY_RATIO == a
+        assembly {
+            b := mul(a, WAD_RAY_RATIO)
+
+            if iszero(eq(div(b, WAD_RAY_RATIO), a)) {
+                revert(0, 0)
+            }
+        }
+    }
+}