@pendle/core-v2 1.1.1-mainnet → 1.3.0-mainnet

package/contracts/interfaces/Balancer/IComposableStable.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./IBasePool.sol";
+import "./IRateProvider.sol";
+
+interface IComposableStable is IBasePool {
+    function getLastJoinExitData()
+        external
+        view
+        returns (uint256 lastJoinExitAmplification, uint256 lastPostJoinExitInvariant);
+
+    function getAmplificationParameter()
+        external
+        view
+        returns (
+            uint256 value,
+            bool isUpdating,
+            uint256 precision
+        );
+
+    function getProtocolFeePercentageCache(uint256 feeType) external view returns (uint256);
+
+    function isTokenExemptFromYieldProtocolFee(IERC20 token) external view returns (bool);
+
+    function getTokenRateCache(IERC20 token)
+        external
+        view
+        returns (
+            uint256 rate,
+            uint256 oldRate,
+            uint256 duration,
+            uint256 expires
+        );
+
+    function getRateProviders() external view returns (IRateProvider[] memory);
+
+    function getBptIndex() external view returns (uint256);
+}

package/contracts/interfaces/Balancer/IGauge.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IGauge {
+    function claim_rewards(address _addr, address _receiver) external;
+
+    function reward_count() external view returns (uint256);
+
+    function reward_tokens(uint256 arg0) external view returns (address);
+}

package/contracts/interfaces/Balancer/ILiquidityGaugeFactory.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface ILiquidityGaugeFactory {
+    function getPoolGauge(address poolAddress) external view returns (address);
+}

package/contracts/interfaces/Balancer/IMetaStablePool.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./IBasePool.sol";
+
+interface IMetaStablePool is IBasePool {
+    function getLastInvariant()
+        external
+        view
+        returns (uint256 lastInvariant, uint256 lastInvariantAmp);
+
+    function getAmplificationParameter()
+        external
+        view
+        returns (
+            uint256 value,
+            bool isUpdating,
+            uint256 precision
+        );
+
+    function getSwapFeePercentage() external view returns (uint256);
+
+    function getPriceRateCache(IERC20 token)
+        external
+        view
+        returns (
+            uint256 rate,
+            uint256 duration,
+            uint256 expires
+        );
+}

package/contracts/interfaces/Balancer/IRateProvider.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IRateProvider {
+    function getRate() external view returns (uint256);
+}

package/contracts/interfaces/Balancer/IVault.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./IAsset.sol";
+
+interface IVault {
+    struct JoinPoolRequest {
+        address[] assets;
+        uint256[] maxAmountsIn;
+        bytes userData;
+        bool fromInternalBalance;
+    }
+
+    function joinPool(
+        bytes32 poolId,
+        address sender,
+        address recipient,
+        JoinPoolRequest memory request
+    ) external payable;
+
+    struct ExitPoolRequest {
+        address[] assets;
+        uint256[] minAmountsOut;
+        bytes userData;
+        bool toInternalBalance;
+    }
+
+    function exitPool(
+        bytes32 poolId,
+        address sender,
+        address payable recipient,
+        ExitPoolRequest memory request
+    ) external;
+
+    enum SwapKind {
+        GIVEN_IN,
+        GIVEN_OUT
+    }
+
+    struct SingleSwap {
+        bytes32 poolId;
+        SwapKind kind;
+        IAsset assetIn;
+        IAsset assetOut;
+        uint256 amount;
+        bytes userData;
+    }
+
+    struct FundManagement {
+        address sender;
+        bool fromInternalBalance;
+        address payable recipient;
+        bool toInternalBalance;
+    }
+
+    function swap(
+        SingleSwap memory singleSwap,
+        FundManagement memory funds,
+        uint256 limit,
+        uint256 deadline
+    ) external payable returns (uint256);
+
+    function getPoolTokens(bytes32 poolId)
+        external
+        view
+        returns (
+            IERC20[] memory tokens,
+            uint256[] memory balances,
+            uint256 lastChangeBlock
+        );
+
+    function WETH() external view returns (IERC20);
+
+    function getPool(bytes32 poolId) external view returns (address, uint8);
+
+    function getProtocolFeesCollector() external view returns (address);
+}

package/contracts/interfaces/ConvexCurve/IRewards.sol

@@ -14,6 +14,11 @@ interface IRewards {
 
     function exit(address) external;
 
+    function getReward(
+        address, /*_account*/
+        bool /*_claimExtras*/
+    ) external;
+
     function getReward() external;
 
     function queueNewRewards(uint256) external;

package/contracts/interfaces/IPFeeDistributor.sol

@@ -2,18 +2,20 @@
 pragma solidity 0.8.17;
 
 interface IPFeeDistributor {
-    event Fund(uint256 indexed epoch, uint256 incentive);
+    event UpdateFee(address indexed pool, uint256 indexed wTime, uint256 amount);
 
-    event ClaimReward(
-        address indexed user,
-        address indexed rewardToken,
-        uint256 lastEpochClaimed,
-        uint256 totalReward
-    );
+    event ClaimReward(address indexed pool, address indexed user, uint256 wTime, uint256 amount);
 
-    function fund(uint256[] calldata rewardsForEpoch) external;
+    event PoolAdded(address indexed pool, uint256 indexed startWeek);
 
-    function claimReward(address user) external returns (uint256 amountRewardOut);
+    struct UserInfo {
+        uint128 firstUnclaimedWeek;
+        uint128 iter;
+    }
 
-    function incentivesForEpoch(uint256 epoch) external returns (uint256);
+    function claimReward(address user, address[] calldata pools)
+        external
+        returns (uint256[] memory amountRewardOut);
+
+    function getAllPools() external view returns (address[] memory);
 }

package/contracts/offchain-helpers/Multicall2.sol

@@ -0,0 +1,103 @@
+pragma solidity >=0.5.0;
+pragma experimental ABIEncoderV2;
+
+/// @title Multicall2 - Aggregate results from multiple read-only function calls
+/// @author Michael Elliot <mike@makerdao.com>
+/// @author Joshua Levine <joshua@makerdao.com>
+/// @author Nick Johnson <arachnid@notdot.net>
+
+contract Multicall2 {
+    struct Call {
+        address target;
+        bytes callData;
+    }
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    function aggregate(Call[] memory calls)
+        public
+        returns (uint256 blockNumber, bytes[] memory returnData)
+    {
+        blockNumber = block.number;
+        returnData = new bytes[](calls.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
+            require(success, "Multicall aggregate: call failed");
+            returnData[i] = ret;
+        }
+    }
+
+    function blockAndAggregate(Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
+    }
+
+    function getBlockHash(uint256 blockNumber) public view returns (bytes32 blockHash) {
+        blockHash = blockhash(blockNumber);
+    }
+
+    function getBlockNumber() public view returns (uint256 blockNumber) {
+        blockNumber = block.number;
+    }
+
+    function getCurrentBlockCoinbase() public view returns (address coinbase) {
+        coinbase = block.coinbase;
+    }
+
+    function getCurrentBlockDifficulty() public view returns (uint256 difficulty) {
+        difficulty = block.difficulty;
+    }
+
+    function getCurrentBlockGasLimit() public view returns (uint256 gaslimit) {
+        gaslimit = block.gaslimit;
+    }
+
+    function getCurrentBlockTimestamp() public view returns (uint256 timestamp) {
+        timestamp = block.timestamp;
+    }
+
+    function getEthBalance(address addr) public view returns (uint256 balance) {
+        balance = addr.balance;
+    }
+
+    function getLastBlockHash() public view returns (bytes32 blockHash) {
+        blockHash = blockhash(block.number - 1);
+    }
+
+    function tryAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (Result[] memory returnData)
+    {
+        returnData = new Result[](calls.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
+
+            if (requireSuccess) {
+                require(success, "Multicall2 aggregate: call failed");
+            }
+
+            returnData[i] = Result(success, ret);
+        }
+    }
+
+    function tryBlockAndAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        blockNumber = block.number;
+        blockHash = blockhash(block.number);
+        returnData = tryAggregate(requireSuccess, calls);
+    }
+}

package/contracts/router/kyberswap/AggregationRouterHelper.sol

@@ -1,9 +1,10 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-License-Identifier: MIT
 
 pragma solidity 0.8.17;
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "./IMultihopRouter.sol";
+import "./IMultihopRouterEthereum.sol";
 import "./IAggregatorRouterHelper.sol";
+import "../../interfaces/IWETH.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../../core/libraries/BoringOwnableUpgradeable.sol";
 
@@ -40,8 +41,7 @@ contract AggregationRouterHelper is
         BALANCERV2,
         KYBERRFQ,
         DODO,
-        VELODROME,
-        PLATYPUS
+        WSTETH
     }
 
     struct SwapDescription {
@@ -65,7 +65,7 @@ contract AggregationRouterHelper is
     }
 
     struct SwapExecutorDescription {
-        IMultihopRouter.Swap[][] swapSequences;
+        IMultihopRouterEthereum.Swap[][] swapSequences;
         address tokenIn;
         address tokenOut;
         uint256 minTotalAmountOut;
@@ -80,6 +80,15 @@ contract AggregationRouterHelper is
         returns (bytes memory)
     {
         bytes4 selector = bytes4(kybercall[:4]);
+
+        if (selector == IWETH.deposit.selector) {
+            return kybercall; // no scaling needed
+        }
+
+        if (selector == IWETH.withdraw.selector) {
+            return abi.encodeWithSelector(selector, newAmount);
+        }
+
         (
             address caller,
             SwapDescription memory desc,
@@ -178,7 +187,7 @@ contract AggregationRouterHelper is
 
         uint256 newTotalSwapAmount;
         for (uint256 i = 0; i < swapExecutorDescription.swapSequences.length; i++) {
-            IMultihopRouter.Swap memory swap = swapExecutorDescription.swapSequences[i][0];
+            IMultihopRouterEthereum.Swap memory swap = swapExecutorDescription.swapSequences[i][0];
             uint8 dexType = uint8(swap.dexOption >> 8);
             uint256 value;
             if (i == swapExecutorDescription.swapSequences.length - 1)
@@ -200,8 +209,8 @@ contract AggregationRouterHelper is
                 revert("kyber: can't scale kyberrfq");
             } else if (dexType == uint8(DexType.DODO)) {
                 (swap.data, value) = _newDODOSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.VELODROME)) {
-                (swap.data, value) = _newVelodromeSwap(swap.data, value, oldAmount, newAmount);
+            } else if (dexType == uint8(DexType.WSTETH)) {
+                (swap.data, value) = _newWrappedstETHSwap(swap.data, value, oldAmount, newAmount);
             } else {
                 revert("AggregationExecutor: Dex type not supported");
             }
@@ -216,7 +225,10 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory uniSwap = abi.decode(data, (IMultihopRouter.UniSwap));
+        IMultihopRouterEthereum.UniSwap memory uniSwap = abi.decode(
+            data,
+            (IMultihopRouterEthereum.UniSwap)
+        );
         if (value > 0) uniSwap.collectAmount = value;
         else uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
         return (abi.encode(uniSwap), uniSwap.collectAmount);
@@ -228,9 +240,9 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.StableSwap memory stableSwap = abi.decode(
+        IMultihopRouterEthereum.StableSwap memory stableSwap = abi.decode(
             data,
-            (IMultihopRouter.StableSwap)
+            (IMultihopRouterEthereum.StableSwap)
         );
         if (value > 0) stableSwap.dx = value;
         else stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
@@ -243,7 +255,10 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.CurveSwap memory curveSwap = abi.decode(data, (IMultihopRouter.CurveSwap));
+        IMultihopRouterEthereum.CurveSwap memory curveSwap = abi.decode(
+            data,
+            (IMultihopRouterEthereum.CurveSwap)
+        );
         if (value > 0) curveSwap.dx = value;
         else curveSwap.dx = (curveSwap.dx * newAmount) / oldAmount;
         return (abi.encode(curveSwap), curveSwap.dx);
@@ -255,7 +270,10 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory kyberDMMSwap = abi.decode(data, (IMultihopRouter.UniSwap));
+        IMultihopRouterEthereum.UniSwap memory kyberDMMSwap = abi.decode(
+            data,
+            (IMultihopRouterEthereum.UniSwap)
+        );
         if (value > 0) kyberDMMSwap.collectAmount = value;
         else kyberDMMSwap.collectAmount = (kyberDMMSwap.collectAmount * newAmount) / oldAmount;
         return (abi.encode(kyberDMMSwap), kyberDMMSwap.collectAmount);
@@ -267,9 +285,9 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
+        IMultihopRouterEthereum.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
             data,
-            (IMultihopRouter.UniSwapV3ProMM)
+            (IMultihopRouterEthereum.UniSwapV3ProMM)
         );
         if (value > 0) uniSwapV3ProMM.swapAmount = value;
         else uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
@@ -282,9 +300,9 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.BalancerV2 memory balancerV2 = abi.decode(
+        IMultihopRouterEthereum.BalancerV2 memory balancerV2 = abi.decode(
             data,
-            (IMultihopRouter.BalancerV2)
+            (IMultihopRouterEthereum.BalancerV2)
         );
         if (value > 0) balancerV2.amount = value;
         else balancerV2.amount = (balancerV2.amount * newAmount) / oldAmount;
@@ -297,21 +315,27 @@ contract AggregationRouterHelper is
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.DODO memory dodo = abi.decode(data, (IMultihopRouter.DODO));
+        IMultihopRouterEthereum.DODO memory dodo = abi.decode(
+            data,
+            (IMultihopRouterEthereum.DODO)
+        );
         if (value > 0) dodo.amount = value;
         else dodo.amount = (dodo.amount * newAmount) / oldAmount;
         return (abi.encode(dodo), dodo.amount);
     }
 
-    function _newVelodromeSwap(
+    function _newWrappedstETHSwap(
         bytes memory data,
         uint256 value,
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory velodrome = abi.decode(data, (IMultihopRouter.UniSwap));
-        if (value > 0) velodrome.collectAmount = value;
-        else velodrome.collectAmount = (velodrome.collectAmount * newAmount) / oldAmount;
-        return (abi.encode(velodrome), velodrome.collectAmount);
+        IMultihopRouterEthereum.WSTETH memory wstEthData = abi.decode(
+            data,
+            (IMultihopRouterEthereum.WSTETH)
+        );
+        if (value > 0) wstEthData.amount = value;
+        else wstEthData.amount = (wstEthData.amount * newAmount) / oldAmount;
+        return (abi.encode(wstEthData), wstEthData.amount);
     }
 }

package/contracts/router/kyberswap/{IMultihopRouter.sol → IMultihopRouterEthereum.sol}

@@ -1,10 +1,8 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-License-Identifier: MIT
 
-pragma solidity >=0.7.6;
+pragma solidity 0.8.17;
 
-pragma abicoder v2;
-
-interface IMultihopRouter {
+interface IMultihopRouterEthereum {
     enum DexType {
         UNI,
         STABLESWAP,
@@ -15,8 +13,7 @@ interface IMultihopRouter {
         BALANCERV2,
         KYBERRFQ,
         DODO,
-        VELODROME,
-        PLATYPUS
+        WSTETH
     }
 
     event Exchange(address pair, uint256 amountOut, address output);
@@ -32,13 +29,18 @@ interface IMultihopRouter {
         //  6: balancerv2
         //  7: kyber RFQ
         //  8: dodo
-        //  9: velodrome
-        //  10: platypus
+        //  9: wstETH: Lido wrapped stETH
         //dexId:
         //  0: firebird
         uint16 dexOption; //dexType(8bit) + dexId(8bit)
     }
 
+    struct WSTETH {
+        address pool;
+        uint256 amount;
+        bool isWrapping;
+    }
+
     struct UniSwap {
         address pool;
         address tokenIn;

package/deployments/1-core.json

@@ -25,5 +25,6 @@
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
-    "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57"
+    "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
+    "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2"
 }

package/deployments/1-markets/BALANCER-LP-AURA-RETH-WETH-28DEC.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY rETH-WETH_BalancerLP Aura",
+    "SY": "0xdf7083f2A0F8a191ab5eEAFebE92ED21cD3Dd915",
+    "YT": "0x0F28A763198035825dFAdF3455cB5b8473a7c140",
+    "PT": "0xfbd85BF7A1E1bec0da6D12964B8c05471aE8f048",
+    "market": "0x5546d0f27BEd4075eA03a22c58F7016E24c94EA7",
+    "expiry": 1703721600,
+    "bulkSeller": "0xB2075aeEd11C2D261c3D80c957F495D18cF874ed",
+    "scalarRoot": "27500000000000000000",
+    "initAnchor": "1067325733000000000"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "1.1.1-mainnet",
+  "version": "1.3.0-mainnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -25,16 +25,16 @@
   "devDependencies": {
     "@typechain/ethers-v5": "^9.0.0",
     "@typechain/hardhat": "^4.0.0",
-    "hardhat": "^2.12.2",
+    "hardhat": "^2.12.5",
     "hardhat-contract-sizer": "^2.6.1",
     "hardhat-storage-layout-diff": "^0.0.4",
-    "prettier": "^2.7.1",
-    "prettier-plugin-solidity": "^1.0.0-rc.1",
+    "prettier": "^2.8.2",
+    "prettier-plugin-solidity": "^1.1.1",
     "solc": "^0.8.17",
     "solhint": "^3.3.7",
     "ts-node": "^10.9.1",
     "typechain": "^8.1.1",
-    "typescript": "^4.9.3"
+    "typescript": "^4.9.4"
   },
   "scripts": {
     "compile": "yarn hardhat compile",
@@ -42,7 +42,7 @@
     "clean": "yarn hardhat clean",
     "fcompile": "yarn clean && yarn compile"
   },
-  "packageManager": "yarn@3.2.2",
+  "packageManager": "yarn@3.3.1",
   "dependencies": {
     "@openzeppelin/contracts": "4.7.3",
     "@openzeppelin/contracts-upgradeable": "4.7.3"