@pendle/core-v2 0.6.8 → 0.7.0

package/build/artifacts/contracts/interfaces/IVotingEscrowPendle.sol/IVotingEscrowPendle.json

@@ -1,167 +0,0 @@
-{
-  "_format": "hh-sol-artifact-1",
-  "contractName": "IVotingEscrowPendle",
-  "sourceName": "contracts/interfaces/IVotingEscrowPendle.sol",
-  "abi": [
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "user",
-          "type": "address"
-        }
-      ],
-      "name": "balanceOf",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "receiver",
-          "type": "address"
-        }
-      ],
-      "name": "increaseLockAmount",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "duration",
-          "type": "uint256"
-        }
-      ],
-      "name": "increaseLockDuration",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "expiry",
-          "type": "uint256"
-        }
-      ],
-      "name": "lock",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "user",
-          "type": "address"
-        }
-      ],
-      "name": "readUserInfo",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "lockedAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "expiry",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "totalSupply",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "gauge",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "weight",
-          "type": "uint256"
-        }
-      ],
-      "name": "vote",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "user",
-          "type": "address"
-        }
-      ],
-      "name": "withdraw",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    }
-  ],
-  "bytecode": "0x",
-  "deployedBytecode": "0x",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
-}

package/build/artifacts/contracts/libraries/JoeLibrary.sol/JoeLibrary.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/88454e13e5755d4eedd68a3511bda74a.json"
-}

package/build/artifacts/contracts/libraries/SCYIndex.sol/SCYIndexLib.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/88454e13e5755d4eedd68a3511bda74a.json"
-}

package/build/artifacts/contracts/libraries/math/MarketMathAux.sol/MarketMathAux.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/88454e13e5755d4eedd68a3511bda74a.json"
-}

package/build/artifacts/contracts/periphery/PendleJoeSwapHelperUpg.sol/PendleJoeSwapHelperUpg.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/88454e13e5755d4eedd68a3511bda74a.json"
-}

package/contracts/SuperComposableYield/ISuperComposableYield.sol

@@ -1,80 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-/*
- * MIT License
- * ===========
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- */
-
-pragma solidity 0.8.9;
-import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-
-interface ISuperComposableYield is IERC20Metadata {
-    function mintNoPull(
-        address receiver,
-        address baseTokenIn,
-        uint256 minAmountScyOut
-    ) external returns (uint256 amountScyOut);
-
-    function redeemNoPull(
-        address receiver,
-        address baseTokenOut,
-        uint256 minAmountBaseOut
-    ) external returns (uint256 amountBaseOut);
-
-    function mint(
-        address receiver,
-        address baseTokenIn,
-        uint256 amountBaseToPull,
-        uint256 minAmountScyOut
-    ) external returns (uint256 amountScyOut);
-
-    function redeem(
-        address receiver,
-        address baseTokenOut,
-        uint256 amountScyToPull,
-        uint256 minAmountBaseOut
-    ) external returns (uint256 amountBaseOut);
-
-    function updateGlobalReward() external;
-
-    function updateUserReward(address user) external;
-
-    function redeemReward(address user) external returns (uint256[] memory outAmounts);
-
-    /**
-    * @notice scyIndexCurrent.mulDown(scyBalance) must return the asset balance of the account
-    * @notice vice-versa, if a user uses some amount of tokens equivalent to X asset, the amount of scy
-    he can mint must be X.divDown(scyIndexCurrent)
-    * @dev SCYUtils's assetToScy & scyToAsset should be used instead of raw multiplication
-    & division
-    */
-    function scyIndexCurrent() external returns (uint256);
-
-    function scyIndexStored() external view returns (uint256);
-
-    function getBaseTokens() external view returns (address[] memory);
-
-    function isValidBaseToken(address token) external view returns (bool);
-
-    function getRewardTokens() external view returns (address[] memory);
-
-    function assetDecimals() external view returns (uint8);
-
-    function assetId() external view returns (bytes32);
-}

package/contracts/SuperComposableYield/SCYUtils.sol

@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-
-library SCYUtils {
-    uint256 internal constant ONE = 1e18;
-
-    function scyToAsset(uint256 scyIndex, uint256 scyAmount) internal pure returns (uint256) {
-        return (scyAmount * scyIndex) / ONE;
-    }
-
-    function assetToScy(uint256 scyIndex, uint256 assetAmount) internal pure returns (uint256) {
-        return (assetAmount * ONE) / scyIndex;
-    }
-}

package/contracts/SuperComposableYield/implementations/IRewardManager.sol

@@ -1,16 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-
-interface IRewardManager {
-    function getGlobalReward(address rewardToken)
-        external
-        view
-        returns (uint256 index, uint256 lastBalance);
-
-    function getUserReward(address user, address rewardToken)
-        external
-        view
-        returns (uint256 lastIndex, uint256 accruedReward);
-
-    function getRewardTokens() external view returns (address[] memory);
-}

package/contracts/SuperComposableYield/implementations/RewardManager.sol

@@ -1,151 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-import "../ISuperComposableYield.sol";
-import "./IRewardManager.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "../../libraries/math/Math.sol";
-
-abstract contract RewardManager is IRewardManager {
-    using SafeERC20 for IERC20;
-    using Math for uint256;
-
-    struct GlobalReward {
-        uint256 index;
-        uint256 lastBalance;
-    }
-
-    struct UserReward {
-        uint256 lastIndex;
-        uint256 accruedReward;
-    }
-
-    uint256 public lastRewardUpdateBlock;
-
-    uint256 internal constant INITIAL_REWARD_INDEX = 1;
-
-    mapping(address => GlobalReward) internal globalReward;
-    mapping(address => mapping(address => UserReward)) internal userReward;
-
-    function getGlobalReward(address rewardToken)
-        external
-        view
-        returns (uint256 index, uint256 lastBalance)
-    {
-        GlobalReward memory reward = globalReward[rewardToken];
-        return (reward.index, reward.lastBalance);
-    }
-
-    function getUserReward(address user, address rewardToken)
-        external
-        view
-        returns (uint256 lastIndex, uint256 accruedReward)
-    {
-        UserReward memory reward = userReward[user][rewardToken];
-        return (reward.lastIndex, reward.accruedReward);
-    }
-
-    function getRewardTokens() public view virtual override returns (address[] memory);
-
-    function _doTransferOutRewardsForUser(address user, address receiver)
-        internal
-        virtual
-        returns (uint256[] memory outAmounts)
-    {
-        address[] memory rewardTokens = getRewardTokens();
-
-        outAmounts = new uint256[](rewardTokens.length);
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address token = rewardTokens[i];
-
-            outAmounts[i] = userReward[user][token].accruedReward;
-            userReward[user][token].accruedReward = 0;
-
-            globalReward[token].lastBalance -= outAmounts[i];
-
-            if (outAmounts[i] != 0) {
-                IERC20(token).safeTransfer(receiver, outAmounts[i]);
-            }
-        }
-    }
-
-    function _updateUserReward(address user) internal virtual {
-        _updateGlobalReward();
-        _updateUserRewardSkipGlobal(user);
-    }
-
-    function _updateGlobalReward() internal virtual {
-        if (!_shouldUpdateGlobalReward()) return;
-        _redeemExternalReward();
-
-        uint256 totalShares = _rewardSharesTotal();
-
-        address[] memory rewardTokens = getRewardTokens();
-        _initGlobalReward(rewardTokens);
-
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address token = rewardTokens[i];
-
-            uint256 currentRewardBalance = IERC20(token).balanceOf(address(this));
-
-            if (totalShares != 0) {
-                globalReward[token].index += (currentRewardBalance -
-                    globalReward[token].lastBalance).divDown(totalShares);
-            }
-
-            globalReward[token].lastBalance = currentRewardBalance;
-        }
-    }
-
-    function _updateUserRewardSkipGlobal(address user) internal virtual {
-        address[] memory rewardTokens = getRewardTokens();
-
-        uint256 userShares = _rewardSharesUser(user);
-
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address token = rewardTokens[i];
-
-            uint256 userLastIndex = userReward[user][token].lastIndex;
-
-            if (userLastIndex == globalReward[token].index) continue;
-
-            if (userLastIndex == 0) {
-                // first time receiving this reward
-                userReward[user][token].lastIndex = globalReward[token].index;
-                continue;
-            }
-
-            uint256 rewardAmountPerUnit = globalReward[token].index - userLastIndex;
-            uint256 rewardFromUnit = userShares.mulDown(rewardAmountPerUnit);
-
-            userReward[user][token].accruedReward += rewardFromUnit;
-            userReward[user][token].lastIndex = globalReward[token].index;
-        }
-    }
-
-    function _initGlobalReward(address[] memory rewardTokens) internal virtual {
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            if (globalReward[rewardTokens[i]].index == 0) {
-                globalReward[rewardTokens[i]].index = INITIAL_REWARD_INDEX;
-            }
-        }
-    }
-
-    function _shouldUpdateGlobalReward() internal virtual returns (bool) {
-        if (lastRewardUpdateBlock == block.number) {
-            return false;
-        }
-        lastRewardUpdateBlock = block.number;
-        return true;
-    }
-
-    /// @dev to be overriden if there is rewards
-    function _redeemExternalReward() internal virtual;
-
-    /// @dev to be overriden if there is rewards
-    function _rewardSharesTotal() internal virtual returns (uint256);
-
-    /// @dev to be overriden if there is rewards
-    function _rewardSharesUser(
-        address /*user*/
-    ) internal virtual returns (uint256);
-}

package/contracts/SuperComposableYield/implementations/SCYBase.sol

@@ -1,166 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-import "../ISuperComposableYield.sol";
-import "./RewardManager.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
-import "../../libraries/math/Math.sol";
-import "../SCYUtils.sol";
-
-abstract contract SCYBase is ERC20, ISuperComposableYield, ReentrancyGuard {
-    using SafeERC20 for IERC20;
-    using Math for uint256;
-
-    event UpdateScyIndex(uint256 scyIndex);
-
-    uint8 private immutable _scyDecimals;
-    uint8 private immutable _assetDecimals;
-    bytes32 private immutable _assetId;
-
-    mapping(address => uint256) internal lastBalanceOf;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        uint8 __scyDecimals,
-        uint8 __assetDecimals,
-        bytes32 __assetId
-    ) ERC20(_name, _symbol) {
-        _scyDecimals = __scyDecimals;
-        _assetDecimals = __assetDecimals;
-        _assetId = __assetId;
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    function mint(
-        address receiver,
-        address baseTokenIn,
-        uint256 amountBaseToPull,
-        uint256 minAmountScyOut
-    ) external nonReentrant returns (uint256 amountScyOut) {
-        IERC20(baseTokenIn).safeTransferFrom(msg.sender, address(this), amountBaseToPull);
-        amountScyOut = _mintFresh(receiver, baseTokenIn, minAmountScyOut);
-    }
-
-    function redeem(
-        address receiver,
-        address baseTokenOut,
-        uint256 amountScyToPull,
-        uint256 minAmountBaseOut
-    ) external nonReentrant returns (uint256 amountBaseOut) {
-        transferFrom(msg.sender, address(this), amountScyToPull);
-        amountBaseOut = _redeemFresh(receiver, baseTokenOut, minAmountBaseOut);
-    }
-
-    function mintNoPull(
-        address receiver,
-        address baseTokenIn,
-        uint256 minAmountScyOut
-    ) external virtual override nonReentrant returns (uint256) {
-        return _mintFresh(receiver, baseTokenIn, minAmountScyOut);
-    }
-
-    function redeemNoPull(
-        address receiver,
-        address baseTokenOut,
-        uint256 minAmountBaseOut
-    ) external virtual override nonReentrant returns (uint256) {
-        return _redeemFresh(receiver, baseTokenOut, minAmountBaseOut);
-    }
-
-    function _mintFresh(
-        address receiver,
-        address baseTokenIn,
-        uint256 minAmountScyOut
-    ) internal virtual returns (uint256 amountScyOut) {
-        require(isValidBaseToken(baseTokenIn), "invalid base token");
-
-        uint256 amountBaseIn = _afterReceiveToken(baseTokenIn);
-
-        amountScyOut = _deposit(baseTokenIn, amountBaseIn);
-
-        require(amountScyOut >= minAmountScyOut, "insufficient out");
-
-        _mint(receiver, amountScyOut);
-    }
-
-    function _redeemFresh(
-        address receiver,
-        address baseTokenOut,
-        uint256 minAmountBaseOut
-    ) internal virtual returns (uint256 amountBaseOut) {
-        require(isValidBaseToken(baseTokenOut), "invalid base token");
-
-        uint256 amountScyRedeem = balanceOf(address(this));
-
-        _burn(address(this), amountScyRedeem);
-
-        amountBaseOut = _redeem(baseTokenOut, amountScyRedeem);
-
-        require(amountBaseOut >= minAmountBaseOut, "insufficient out");
-
-        IERC20(baseTokenOut).safeTransfer(receiver, amountBaseOut);
-        _afterSendToken(baseTokenOut);
-    }
-
-    function _deposit(address token, uint256 amountBase)
-        internal
-        virtual
-        returns (uint256 amountScyOut);
-
-    function _redeem(address token, uint256 amountScy)
-        internal
-        virtual
-        returns (uint256 amountBaseOut);
-
-    /*///////////////////////////////////////////////////////////////
-                               SCY-INDEX
-    //////////////////////////////////////////////////////////////*/
-
-    function scyIndexCurrent() external virtual override returns (uint256 res);
-
-    function scyIndexStored() external view virtual override returns (uint256 res);
-
-    /*///////////////////////////////////////////////////////////////
-                MISC METADATA FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    function decimals() public view virtual override(ERC20, IERC20Metadata) returns (uint8) {
-        return _scyDecimals;
-    }
-
-    function assetDecimals() external view virtual returns (uint8) {
-        return _assetDecimals;
-    }
-
-    function assetId() external view returns (bytes32) {
-        return _assetId;
-    }
-
-    function getBaseTokens() external view virtual override returns (address[] memory res);
-
-    function isValidBaseToken(address token) public view virtual override returns (bool);
-
-    /// @dev token should not be address(this) since it's expected that all scy in this contract
-    /// are for redemption, so updating the mapping is redundant
-    function _afterReceiveToken(address token) internal virtual returns (uint256 res) {
-        assert(token != address(this));
-        uint256 curBalance = IERC20(token).balanceOf(address(this));
-        res = curBalance - lastBalanceOf[token];
-        lastBalanceOf[token] = curBalance;
-    }
-
-    /// @dev token should not be address(this)
-    function _afterSendToken(address token) internal virtual {
-        assert(token != address(this));
-        lastBalanceOf[token] = IERC20(token).balanceOf(address(this));
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                            TRANSFER HOOKS
-    //////////////////////////////////////////////////////////////*/
-}