@pendle/core-v2 1.0.2-mainnet → 1.1.0-testnet

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/interfaces/IMetaAggregationRouterV2.sol/IMetaAggregationRouterV2.json

@@ -0,0 +1,215 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "IMetaAggregationRouterV2",
+  "sourceName": "contracts/router/swap-aggregator/kyberswap/interfaces/IMetaAggregationRouterV2.sol",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "address",
+              "name": "callTarget",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "approveTarget",
+              "type": "address"
+            },
+            {
+              "internalType": "bytes",
+              "name": "targetData",
+              "type": "bytes"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IERC20",
+                  "name": "srcToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "contract IERC20",
+                  "name": "dstToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address[]",
+                  "name": "srcReceivers",
+                  "type": "address[]"
+                },
+                {
+                  "internalType": "uint256[]",
+                  "name": "srcAmounts",
+                  "type": "uint256[]"
+                },
+                {
+                  "internalType": "address[]",
+                  "name": "feeReceivers",
+                  "type": "address[]"
+                },
+                {
+                  "internalType": "uint256[]",
+                  "name": "feeAmounts",
+                  "type": "uint256[]"
+                },
+                {
+                  "internalType": "address",
+                  "name": "dstReceiver",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "minReturnAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "flags",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "permit",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct IMetaAggregationRouterV2.SwapDescriptionV2",
+              "name": "desc",
+              "type": "tuple"
+            },
+            {
+              "internalType": "bytes",
+              "name": "clientData",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IMetaAggregationRouterV2.SwapExecutionParams",
+          "name": "execution",
+          "type": "tuple"
+        }
+      ],
+      "name": "swap",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IAggregationExecutor",
+          "name": "caller",
+          "type": "address"
+        },
+        {
+          "components": [
+            {
+              "internalType": "contract IERC20",
+              "name": "srcToken",
+              "type": "address"
+            },
+            {
+              "internalType": "contract IERC20",
+              "name": "dstToken",
+              "type": "address"
+            },
+            {
+              "internalType": "address[]",
+              "name": "srcReceivers",
+              "type": "address[]"
+            },
+            {
+              "internalType": "uint256[]",
+              "name": "srcAmounts",
+              "type": "uint256[]"
+            },
+            {
+              "internalType": "address[]",
+              "name": "feeReceivers",
+              "type": "address[]"
+            },
+            {
+              "internalType": "uint256[]",
+              "name": "feeAmounts",
+              "type": "uint256[]"
+            },
+            {
+              "internalType": "address",
+              "name": "dstReceiver",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "amount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "minReturnAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "flags",
+              "type": "uint256"
+            },
+            {
+              "internalType": "bytes",
+              "name": "permit",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IMetaAggregationRouterV2.SwapDescriptionV2",
+          "name": "desc",
+          "type": "tuple"
+        },
+        {
+          "internalType": "bytes",
+          "name": "executorData",
+          "type": "bytes"
+        },
+        {
+          "internalType": "bytes",
+          "name": "clientData",
+          "type": "bytes"
+        }
+      ],
+      "name": "swapSimpleMode",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/contracts/LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol

@@ -5,20 +5,18 @@ library LayerZeroHelper {
     uint256 constant EVM_ADDRESS_SIZE = 20;
 
     function _getLayerZeroChainIds(uint256 chainId) internal pure returns (uint16) {
-        if (chainId == 43113) return 10106;
-        // fuji testnet
-        else if (chainId == 80001) return 10109;
-        // mumbai testnet
-        else if (chainId == 43114) return 106; // avax mainnet
+        if (chainId == 43113) return 10106; // fuji testnet
+        else if (chainId == 80001) return 10109; // mumbai testnet
+        else if (chainId == 43114) return 106;  // avax mainnet
+        else if (chainId == 42161) return 110; // arbitrum one
         assert(false);
     }
 
     function _getOriginalChainIds(uint16 chainId) internal pure returns (uint256) {
-        if (chainId == 10106) return 43113;
-        // fuji testnet
-        else if (chainId == 10109) return 80001;
-        // mumbai testnet
+        if (chainId == 10106) return 43113; // fuji testnet
+        else if (chainId == 10109) return 80001; // mumbai testnet
         else if (chainId == 106) return 43114; // avax mainnet
+        else if (chainId == 110) return 42161; // arbitrum one
         assert(false);
     }
 

package/contracts/LiquidityMining/VeDistributor/PendleFeeDistributor.sol

@@ -0,0 +1,224 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../core/libraries/Errors.sol";
+import "../../interfaces/IPFeeDistributor.sol";
+import "../../interfaces/IPVotingEscrowMainchain.sol";
+import "../../interfaces/IPVotingController.sol";
+import "../libraries/WeekMath.sol";
+import "../libraries/VeHistoryLib.sol";
+import "../../core/libraries/ArrayLib.sol";
+
+contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFeeDistributor {
+    using SafeERC20 for IERC20;
+    using VeBalanceLib for VeBalance;
+    using ArrayLib for uint256[];
+
+    address public immutable votingController;
+    address public immutable vePendle;
+    address public immutable token;
+
+    address[] public allPools;
+
+    // [pool] => lastFundedWeek
+    mapping(address => uint256) public lastFundedWeek;
+
+    // [pool, user] => UserInfo
+    mapping(address => mapping(address => UserInfo)) public userInfo;
+
+    // [pool, epoch] => [fee]
+    mapping(address => mapping(uint256 => uint256)) public fees;
+
+    modifier ensureValidPool(address pool) {
+        if (lastFundedWeek[pool] == 0) revert Errors.FDInvalidPool(pool);
+        _;
+    }
+
+    constructor(
+        address _votingController,
+        address _vePendle,
+        address _rewardToken
+    ) initializer {
+        votingController = _votingController;
+        vePendle = _vePendle;
+        token = _rewardToken;
+    }
+
+    function addPool(address pool, uint256 _startWeek) external onlyOwner {
+        if (!WeekMath.isValidWTime(_startWeek) || _startWeek == 0)
+            revert Errors.FDInvalidStartEpoch(_startWeek);
+
+        if (lastFundedWeek[pool] != 0) revert Errors.FDPoolAlreadyExists(pool);
+
+        lastFundedWeek[pool] = _startWeek - WeekMath.WEEK;
+        allPools.push(pool);
+
+        emit PoolAdded(pool, _startWeek);
+    }
+
+    function getAllPools() external view returns (address[] memory) {
+        return allPools;
+    }
+
+    function fund(
+        address[] calldata pools,
+        uint256[][] calldata wTimes,
+        uint256[][] calldata amounts,
+        uint256 totalAmountToFund
+    ) external onlyOwner {
+        uint256 length = pools.length;
+        if (wTimes.length != length || amounts.length != length)
+            revert Errors.ArrayLengthMismatch();
+
+        uint256 totalFunded = 0;
+        for (uint256 i = 0; i < length; ++i) {
+            _fund(pools[i], wTimes[i], amounts[i]);
+            totalFunded += amounts[i].sum();
+        }
+
+        if (totalFunded != totalAmountToFund)
+            revert Errors.FDTotalAmountFundedNotMatch(totalFunded, totalAmountToFund);
+
+        IERC20(token).transferFrom(msg.sender, address(this), totalFunded);
+    }
+
+    function _fund(
+        address pool,
+        uint256[] calldata wTimes,
+        uint256[] calldata amounts
+    ) internal ensureValidPool(pool) {
+        if (wTimes.length != amounts.length) revert Errors.FDEpochLengthMismatch();
+
+        uint256 lastFunded = lastFundedWeek[pool];
+
+        uint256 curWeek = WeekMath.getCurrentWeekStart();
+
+        for (uint256 i = 0; i < amounts.length; ++i) {
+            uint256 wTime = wTimes[i];
+            uint256 amount = amounts[i];
+
+            if (wTime != lastFunded + WeekMath.WEEK)
+                revert Errors.FDInvalidWTimeFund(lastFunded, wTime);
+
+            fees[pool][wTime] += amount;
+            lastFunded += WeekMath.WEEK;
+
+            emit UpdateFee(pool, wTime, amount);
+        }
+
+        if (lastFunded >= curWeek) revert Errors.FDInvalidWTimeFund(lastFunded, curWeek);
+
+        lastFundedWeek[pool] = lastFunded;
+    }
+
+    function claimReward(address user, address[] calldata pools)
+        external
+        returns (uint256[] memory amountRewardOut)
+    {
+        amountRewardOut = new uint256[](pools.length);
+        for (uint256 i = 0; i < pools.length; ) {
+            amountRewardOut[i] = _accumulateUserReward(pools[i], user);
+            unchecked {
+                i++;
+            }
+        }
+        IERC20(token).safeTransfer(user, amountRewardOut.sum());
+    }
+
+    function getAllActivePools() external view returns (address[] memory) {
+        return allPools;
+    }
+
+    function _accumulateUserReward(address pool, address user)
+        internal
+        ensureValidPool(pool)
+        returns (uint256 totalReward)
+    {
+        uint256 length = _getUserCheckpointLength(pool, user);
+        if (length == 0) return 0;
+
+        uint256 lastWeek = lastFundedWeek[pool];
+        uint256 curWeek = userInfo[pool][user].firstUnclaimedWeek;
+        uint256 iter = userInfo[pool][user].iter;
+
+        if (curWeek > lastWeek) return 0; // nothing to account
+
+        Checkpoint memory checkpoint = _getUserCheckpointAt(pool, user, iter);
+        Checkpoint memory nextCheckpoint = checkpoint;
+
+        if (curWeek == 0) curWeek = checkpoint.timestamp + WeekMath.WEEK;
+
+        while (curWeek <= lastWeek) {
+            // we have at most one checkpoint per week
+            if (iter + 1 < length) {
+                if (nextCheckpoint.timestamp == checkpoint.timestamp) {
+                    // next have been assigned to current checkpoint, so we need to get the next one
+                    nextCheckpoint = _getUserCheckpointAt(pool, user, iter + 1);
+                }
+
+                if (nextCheckpoint.timestamp < curWeek) {
+                    iter++;
+                    checkpoint = nextCheckpoint;
+                }
+                // Important invariant: checkpoint[iter] < curWeek <= checkpoint[iter+1]
+            }
+
+            // assert(checkpoint.timestamp < curWeek); should always hold
+
+            uint256 userShare = checkpoint.value.getValueAt(uint128(curWeek));
+            if (userShare != 0) {
+                uint256 totalShare = _getPoolTotalSharesAt(pool, uint128(curWeek));
+                // userShare != 0 => totalShare != 0
+                uint256 amountRewardOut = (userShare * fees[pool][curWeek]) / totalShare;
+                totalReward += amountRewardOut;
+                emit ClaimReward(pool, user, curWeek, amountRewardOut);
+            }
+
+            curWeek += WeekMath.WEEK;
+        }
+
+        userInfo[pool][user] = UserInfo({
+            firstUnclaimedWeek: uint128(curWeek),
+            iter: uint128(iter)
+        });
+    }
+
+    function _getPoolTotalSharesAt(address pool, uint128 wTime) internal view returns (uint256) {
+        if (pool == vePendle) {
+            return IPVotingEscrowMainchain(vePendle).totalSupplyAt(wTime);
+        } else {
+            return IPVotingController(votingController).getPoolTotalVoteAt(pool, wTime);
+        }
+    }
+
+    function _getUserCheckpointAt(
+        address pool,
+        address user,
+        uint256 index
+    ) internal view returns (Checkpoint memory) {
+        if (pool == vePendle) {
+            return IPVotingEscrowMainchain(vePendle).getUserHistoryAt(user, index);
+        } else {
+            return IPVotingController(votingController).getUserPoolHistoryAt(user, pool, index);
+        }
+    }
+
+    function _getUserCheckpointLength(address pool, address user) internal view returns (uint256) {
+        if (pool == vePendle) {
+            return IPVotingEscrowMainchain(vePendle).getUserHistoryLength(user);
+        } else {
+            return IPVotingController(votingController).getUserPoolHistoryLength(user, pool);
+        }
+    }
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    // ----------------- upgrade-related -----------------
+
+    function _authorizeUpgrade(address) internal override onlyOwner {}
+}

package/contracts/core/BulkSeller/BulkSeller.sol

@@ -83,7 +83,7 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         else {
             uint256 netSyReceived = _selfBalance(SY) - state.totalSy;
             if (netSyReceived < exactSyIn)
-                revert Errors.BulkInsufficientSyReceived(exactSyIn, netSyReceived);
+                revert Errors.BulkInsufficientSyReceived(netSyReceived, exactSyIn);
         }
 
         netTokenOut = state.swapExactSyForToken(exactSyIn);

package/contracts/core/StandardizedYield/SYBase.sol

@@ -1,13 +1,22 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
-
 import "../../interfaces/IStandardizedYield.sol";
+
 import "../erc20/PendleERC20Permit.sol";
+
 import "../libraries/math/Math.sol";
 import "../libraries/TokenHelper.sol";
 import "../libraries/Errors.sol";
-
-abstract contract SYBase is IStandardizedYield, PendleERC20Permit, TokenHelper {
+import "../libraries/BoringOwnableUpgradeable.sol";
+import "@openzeppelin/contracts/security/Pausable.sol";
+
+abstract contract SYBase is
+    IStandardizedYield,
+    PendleERC20Permit,
+    TokenHelper,
+    BoringOwnableUpgradeable,
+    Pausable
+{
     using Math for uint256;
 
     address public immutable yieldToken;
@@ -16,8 +25,9 @@ abstract contract SYBase is IStandardizedYield, PendleERC20Permit, TokenHelper {
         string memory _name,
         string memory _symbol,
         address _yieldToken
-    ) PendleERC20Permit(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) {
+    ) PendleERC20Permit(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) initializer {
         yieldToken = _yieldToken;
+        __BoringOwnable_init();
     }
 
     // solhint-disable no-empty-blocks
@@ -179,11 +189,19 @@ abstract contract SYBase is IStandardizedYield, PendleERC20Permit, TokenHelper {
         return _previewRedeem(tokenOut, amountSharesToRedeem);
     }
 
+    function pause() external onlyOwner {
+        _pause();
+    }
+
+    function unpause() external onlyOwner {
+        _unpause();
+    }
+
     function _beforeTokenTransfer(
         address,
         address,
         uint256
-    ) internal virtual override {}
+    ) internal virtual override whenNotPaused {}
 
     function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
         internal

package/contracts/core/StandardizedYield/StEthHelper.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../interfaces/IWstETH.sol";
+import "../../interfaces/IWETH.sol";
+import "../../interfaces/IStETH.sol";
+import "../libraries/TokenHelper.sol";
+
+abstract contract StEthHelper is TokenHelper {
+    address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+    address internal constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
+    address internal constant STETH = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;
+
+    constructor() {
+        _safeApproveInf(STETH, WSTETH);
+    }
+
+    /// @dev tokenIn must be either ETH, WETH or STETH
+    function _depositWstETH(address tokenIn, uint256 amountDep)
+        internal
+        virtual
+        returns (uint256 amountOut)
+    {
+        uint256 amountStETH;
+        if (tokenIn == STETH) {
+            amountStETH = amountDep;
+        } else {
+            if (tokenIn == WETH) IWETH(WETH).withdraw(amountDep);
+
+            uint256 amountStEthSharesOut = IStETH(STETH).submit{ value: amountDep }(address(0));
+            amountStETH = IStETH(STETH).getPooledEthByShares(amountStEthSharesOut);
+        }
+        amountOut = IWstETH(WSTETH).wrap(amountStETH);
+    }
+
+    function _redeemWstETH(address receiver, uint256 amountRedeem)
+        internal
+        virtual
+        returns (uint256 amountTokenOut)
+    {
+        amountTokenOut = IWstETH(WSTETH).unwrap(amountRedeem);
+        if (receiver != address(this)) _transferOut(STETH, receiver, amountTokenOut);
+    }
+
+    /// @dev tokenIn must be either ETH, WETH or STETH
+    function _previewDepositWstETH(address tokenIn, uint256 amountDep)
+        internal
+        view
+        virtual
+        returns (uint256 amountOut)
+    {
+        if (tokenIn != STETH) {
+            assert(tokenIn == WETH || tokenIn == NATIVE);
+            uint256 totalShares = IStETH(STETH).getTotalShares();
+            uint256 totalPooledEth = IStETH(STETH).getTotalPooledEther();
+            uint256 amountStEthSharesOut = IStETH(STETH).getSharesByPooledEth(amountDep);
+
+            totalShares += amountStEthSharesOut;
+            totalPooledEth += amountDep;
+
+            uint256 stEthBalance = (amountStEthSharesOut * totalPooledEth) / totalShares;
+            amountOut = (stEthBalance * totalShares) / totalPooledEth;
+        } else {
+            amountOut = IStETH(STETH).getSharesByPooledEth(amountDep);
+        }
+    }
+
+    function _previewRedeemWstETH(uint256 amountRedeem) internal view returns (uint256 amountOut) {
+        amountOut = IStETH(STETH).getPooledEthByShares(amountRedeem);
+    }
+}