@pendle/core-v2 0.7.0 → 0.7.1-beta-2

package/contracts/offchain-helpers/RouterStatic.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "../interfaces/ISuperComposableYield.sol";
 import "../interfaces/IRewardManager.sol";
@@ -7,11 +7,12 @@ import "../interfaces/IPRouterStatic.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IPYieldContractFactory.sol";
 import "../interfaces/IPMarketFactory.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
 /// EXCLUDED FROM ALL AUDITS, TO BE CALLED ONLY BY PENDLE's SDK
-contract RouterStatic is IPRouterStatic {
+contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, OwnableUpgradeable {
     using MarketMathCore for MarketState;
     using Math for uint256;
     using Math for int256;
@@ -20,17 +21,125 @@ contract RouterStatic is IPRouterStatic {
     IPYieldContractFactory public immutable yieldContractFactory;
     IPMarketFactory public immutable marketFactory;
 
-    constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory) {
+    constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory)
+        initializer
+    {
         yieldContractFactory = _yieldContractFactory;
         marketFactory = _marketFactory;
     }
 
+    function initialize() external initializer {
+        __UUPSUpgradeable_init();
+        __Ownable_init();
+    }
+
+    // ============= SYSTEM INFO =============
+
+    function getPYInfo(address py)
+        external
+        returns (
+            uint256 exchangeRate,
+            uint256 totalSupply,
+            RewardIndex[] memory rewardIndexes
+        )
+    {
+        (address yt, ) = getPY(py);
+        IPYieldToken YT = IPYieldToken(yt);
+        exchangeRate = YT.scyIndexCurrent();
+        totalSupply = YT.totalSupply();
+        address[] memory rewardTokens = YT.getRewardTokens();
+        rewardIndexes = new RewardIndex[](rewardTokens.length);
+
+        uint256[] memory indexes = YT.rewardIndexesCurrent();
+        for (uint256 i = 0; i < rewardTokens.length; ++i) {
+            address rewardToken = rewardTokens[i];
+            rewardIndexes[i].rewardToken = rewardToken;
+            rewardIndexes[i].index = indexes[i];
+        }
+    }
+
+    function getPendleTokenType(address token)
+        external
+        view
+        returns (
+            bool isPT,
+            bool isYT,
+            bool isMarket
+        )
+    {
+        if (yieldContractFactory.isPT(token)) isPT = true;
+        else if (yieldContractFactory.isYT(token)) isYT = true;
+        else if (marketFactory.isValidMarket(token)) isMarket = true;
+    }
+
+    function getMarketInfo(address market)
+        external
+        view
+        returns (
+            address pt,
+            address scy,
+            MarketState memory state,
+            int256 impliedYield
+        )
+    {
+        IPMarket _market = IPMarket(market);
+        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+
+        pt = address(PT);
+        scy = address(SCY);
+        state = _market.readState(true);
+        impliedYield = getPtImpliedYield(market);
+    }
+
+    // ============= USER INFO =============
+
+    function getUserPYPositionsByPYs(address user, address[] calldata pys)
+        external
+        view
+        returns (UserPYInfo[] memory userPYPositions)
+    {
+        userPYPositions = new UserPYInfo[](pys.length);
+        for (uint256 i = 0; i < pys.length; ++i) {
+            userPYPositions[i] = getUserPYInfo(pys[i], user);
+        }
+    }
+
+    function getUserMarketPositions(address user, address[] calldata markets)
+        external
+        view
+        returns (UserMarketInfo[] memory userMarketPositions)
+    {
+        userMarketPositions = new UserMarketInfo[](markets.length);
+        for (uint256 i = 0; i < markets.length; ++i) {
+            userMarketPositions[i] = getUserMarketInfo(markets[i], user);
+        }
+    }
+
+    function getUserSCYInfo(address scy, address user)
+        external
+        view
+        returns (uint256 balance, TokenAmount[] memory rewards)
+    {
+        ISuperComposableYield SCY = ISuperComposableYield(scy);
+        balance = SCY.balanceOf(scy);
+        address[] memory rewardTokens = SCY.getRewardTokens();
+        rewards = new TokenAmount[](rewardTokens.length);
+        for (uint256 i = 0; i < rewardTokens.length; ++i) {
+            address rewardToken = rewardTokens[i];
+            rewards[i].token = rewardToken;
+            (, rewards[i].amount) = IRewardManager(scy).userReward(rewardToken, user);
+        }
+    }
+
+    // ============= MARKET ACTIONS =============
+
     function addLiquidityStatic(
         address market,
         uint256 scyDesired,
         uint256 ptDesired
     )
         external
+        view
         returns (
             uint256 netLpOut,
             uint256 scyUsed,
@@ -57,6 +166,7 @@ contract RouterStatic is IPRouterStatic {
 
     function swapPtForScyStatic(address market, uint256 exactPtIn)
         external
+        view
         returns (uint256 netScyOut, uint256 netScyFee)
     {
         MarketState memory state = IPMarket(market).readState(false);
@@ -69,6 +179,7 @@ contract RouterStatic is IPRouterStatic {
 
     function swapScyForPtStatic(address market, uint256 exactPtOut)
         external
+        view
         returns (uint256 netScyIn, uint256 netScyFee)
     {
         MarketState memory state = IPMarket(market).readState(false);
@@ -79,12 +190,24 @@ contract RouterStatic is IPRouterStatic {
         );
     }
 
-    function scyIndex(address market) public returns (SCYIndex index) {
+    // ============= OTHER HELPERS =============
+
+    function scyIndex(address market) public view returns (SCYIndex index) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
         return SCYIndexLib.newIndex(SCY);
     }
 
+    function getPY(address py) public view returns (address pt, address yt) {
+        if (yieldContractFactory.isYT(py)) {
+            pt = IPYieldToken(py).PT();
+            yt = py;
+        } else {
+            pt = py;
+            yt = IPPrincipalToken(py).YT();
+        }
+    }
+
     function getPtImpliedYield(address market) public view returns (int256) {
         MarketState memory state = IPMarket(market).readState(false);
 
@@ -92,20 +215,6 @@ contract RouterStatic is IPRouterStatic {
         return lnImpliedRate.exp();
     }
 
-    function getPendleTokenType(address token)
-        external
-        view
-        returns (
-            bool isPT,
-            bool isYT,
-            bool isMarket
-        )
-    {
-        if (yieldContractFactory.isPT(token)) isPT = true;
-        else if (yieldContractFactory.isYT(token)) isYT = true;
-        else if (marketFactory.isValidMarket(token)) isMarket = true;
-    }
-
     function getUserPYInfo(address py, address user)
         public
         view
@@ -135,119 +244,39 @@ contract RouterStatic is IPRouterStatic {
         }
     }
 
-    function getPYInfo(address py)
-        external
-        returns (
-            uint256 exchangeRate,
-            uint256 totalSupply,
-            RewardIndex[] memory rewardIndexes
-        )
-    {
-        (address yt, ) = getPY(py);
-        IPYieldToken YT = IPYieldToken(yt);
-        exchangeRate = YT.getScyIndex();
-        totalSupply = YT.totalSupply();
-        address[] memory rewardTokens = YT.getRewardTokens();
-        rewardIndexes = new RewardIndex[](rewardTokens.length);
-
-        uint256[] memory indexes = YT.rewardIndexesCurrent();
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address rewardToken = rewardTokens[i];
-            rewardIndexes[i].rewardToken = rewardToken;
-            rewardIndexes[i].index = indexes[i];
-        }
-    }
-
-    function getPY(address py) public view returns (address pt, address yt) {
-        if (yieldContractFactory.isYT(py)) {
-            yt = py;
-            pt = IPYieldToken(py).PT();
-        } else {
-            yt = IPPrincipalToken(py).YT();
-            pt = py;
-        }
-    }
-
-    function getMarketInfo(address market)
-        external
-        view
-        returns (
-            address pt,
-            address scy,
-            MarketState memory state,
-            int256 impliedYield,
-            uint256 exchangeRate
-        )
-    {
-        IPMarket _market = IPMarket(market);
-        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
-
-        pt = address(PT);
-        scy = address(SCY);
-        state = _market.readState(true);
-        impliedYield = getPtImpliedYield(market);
-        exchangeRate = 0; // TODO: get the actual exchange rate
-    }
-
     function getUserMarketInfo(address market, address user)
         public
         view
         returns (UserMarketInfo memory userMarketInfo)
     {
         IPMarket _market = IPMarket(market);
+        uint256 userLp = _market.balanceOf(user);
+
         userMarketInfo.market = market;
-        userMarketInfo.lpBalance = _market.balanceOf(user);
-        // TODO: Is there a way to convert LP to PT and SCY?
-        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        userMarketInfo.lpBalance = userLp;
 
-        userMarketInfo.ptBalance = TokenAmount(address(PT), 0);
-        userMarketInfo.scyBalance = TokenAmount(address(SCY), 0);
-        // TODO: Get this from SCY once it is in the interface
-        userMarketInfo.assetBalance = TokenAmount(address(0), 0);
-    }
+        MarketState memory state = _market.readState(true);
+        uint256 totalLp = uint256(state.totalLp);
+        uint256 userPt = (userLp * uint256(state.totalPt)) / totalLp;
+        uint256 userScy = (userLp * uint256(state.totalScy)) / totalLp;
 
-    function getUserPYPositionsByPYs(address user, address[] calldata pys)
-        external
-        view
-        returns (UserPYInfo[] memory userPYPositions)
-    {
-        userPYPositions = new UserPYInfo[](pys.length);
-        for (uint256 i = 0; i < pys.length; ++i) {
-            userPYPositions[i] = getUserPYInfo(pys[i], user);
-        }
+        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = _market.readTokens();
+        userMarketInfo.ptBalance = TokenAmount(address(PT), userPt);
+        userMarketInfo.scyBalance = TokenAmount(address(SCY), userScy);
+        (userMarketInfo.assetBalance.assetType, userMarketInfo.assetBalance.assetAddress, ) = SCY
+            .assetInfo();
+        userMarketInfo.assetBalance.amount = (userScy * SCY.exchangeRate()) / Math.ONE;
     }
 
-    function getUserMarketPositions(address user, address[] calldata markets)
-        external
-        view
-        returns (UserMarketInfo[] memory userMarketPositions)
-    {
-        userMarketPositions = new UserMarketInfo[](markets.length);
-        for (uint256 i = 0; i < markets.length; ++i) {
-            userMarketPositions[i] = getUserMarketInfo(markets[i], user);
-        }
-    }
-
-    function hasPYPosition(UserPYInfo memory userPYInfo) public pure returns (bool hasPosition) {
+    function hasPYPosition(UserPYInfo calldata userPYInfo) public pure returns (bool hasPosition) {
         hasPosition = (userPYInfo.ytBalance > 0 ||
             userPYInfo.ptBalance > 0 ||
             userPYInfo.unclaimedInterest.amount > 0 ||
             userPYInfo.unclaimedRewards.length > 0);
     }
 
-    function getUserSCYInfo(address scy, address user)
-        external
-        view
-        returns (uint256 balance, TokenAmount[] memory rewards)
-    {
-        ISuperComposableYield SCY = ISuperComposableYield(scy);
-        balance = SCY.balanceOf(scy);
-        address[] memory rewardTokens = SCY.getRewardTokens();
-        rewards = new TokenAmount[](rewardTokens.length);
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address rewardToken = rewardTokens[i];
-            rewards[i].token = rewardToken;
-            (, rewards[i].amount) = IRewardManager(scy).userReward(rewardToken, user);
-        }
-    }
+    // ============= UPGRADES =============
+
+    // solhint-disable-next-line no-empty-blocks
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 }

package/contracts/periphery/PendleGovernanceManager.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 contract PendleGovernanceManager {
     address public governance;

package/contracts/periphery/PermissionsV2Upg.sol

@@ -1,12 +1,18 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "../interfaces/IPGovernanceManager.sol";
 import "../interfaces/IPPermissionsV2Upg.sol";
 
+/// This contract is upgradable because
+/// - its constructor only sets immutable variables
+/// - it has storage gaps for safe addition of future variables
+/// - it inherits only upgradable contract
 abstract contract PermissionsV2Upg is IPermissionsV2Upg {
     address public immutable governanceManager;
 
+    uint256[100] private __gap;
+
     modifier onlyGovernance() {
         require(msg.sender == _governance(), "ONLY_GOVERNANCE");
         _;

package/deployments/43113-benqi.json

@@ -0,0 +1,6 @@
+{
+    "USDC": "0x2018ecc38fbca2ce3A62f96f9F0D38F0DEE2f99D",
+    "QI": "0x5954237dFE8748fb3CD9fE3dBb2e440c4F0FbD40",
+    "qiUSDC": "0x8d4A91A0c51B6D2C0F833ef5BfA283F2aFC42bfB",
+    "fundKeeper": "0xeB259AAF297Bd149dB0d32b2d9666De17b3b8801"
+}

package/deployments/43113-core.json

@@ -0,0 +1,16 @@
+{
+    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "network": 43113,
+    "celerBus": "0xE9533976C590200E32d95C53f06AE12d292cFc47",
+    "treasury": "0x8c73eEef8A74223717c129e6F18Df27508dbCb23",
+    "governanceManager": "0xe8d12F4e6933107C797E369Dd577bfca9f412758",
+    "PENDLE": "0xd6403Ff542290C38EE4fCFf48552FA85fbe8539B",
+    "yieldContractFactory": "0x0EA46a4C257071352b57E9F6d054fC137F6E14b9",
+    "marketFactory": "0x9e7be80205815111617B9578157e130ECd9757e4",
+    "router": "0xb359F0A97Ca269Ae5574dc75be48b0e81eFD1dA2",
+    "routerStatic": "0x860D23ADA1652CEEE1e3c77210CCE068bB4BD4e1",
+    "startTime": 1656547200,
+    "vePendle": "0x5CA98fBE317f0165499E886286A2737FE5A913E7",
+    "votingController": "0xcb0d3d9147845C7F2B77DCFBE4dB8114d928DC93",
+    "gaugeController": "0x38F5320795CE3BeD55b87decca0A60e52f65c522"
+}

package/deployments/43113-markets/benqi-market.json

@@ -0,0 +1,7 @@
+{
+    "SCY": "0xb597dE4e247945A4D0e577ef65a32Bd4E459C3A7",
+    "expiry": 1672099200,
+    "PT": "0x43963e93a024f1131549C657116321a67e3004B8",
+    "YT": "0x8774E8D4A17f6DbDF93da23189df6026DD77aA34",
+    "market": "0x700E66aD6C98d04f7c426060211fd98f12E0F1b6"
+}

package/deployments/80001-benqi.json

@@ -0,0 +1,6 @@
+{
+    "USDC": "0x0059a72A5e545F6998AF038aBBB625FC702b1a97",
+    "QI": "0xC7565D2282198b4B50EC29dee7b942E2B9bbc203",
+    "qiUSDC": "0x439B4d66255eFf74e621FBacb00D7162b588Ff4b",
+    "fundKeeper": "0x67507f3E26E7e2Fd0A42c48FbC85069cCFCBD2FF"
+}

package/deployments/80001-core.json

@@ -0,0 +1,15 @@
+{
+    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "network": 80001,
+    "celerBus": "0x7d43AABC515C356145049227CeE54B608342c0ad",
+    "treasury": "0x3865D8a1Bd6D281f6c77d4e233d26Cd56380EF45",
+    "governanceManager": "0xFC7eC014280A98850F4167aF47c0272f0E7490A5",
+    "PENDLE": "0x53F435CEC95c597d905f0903a13F4dAbEA8491dB",
+    "yieldContractFactory": "0x4e5De6339FC7Ef63c176f9A7e7a8B2aC21744B8D",
+    "marketFactory": "0xCAd502Bb55d1A3F79952F969BFF3f011CF30a94a",
+    "router": "0xA972fB7828f0bff8a22f7f8C63b17cfB971BFC0a",
+    "routerStatic": "0x9a8Ff151BDA518ece44Cb1125F368F4C893D63b7",
+    "startTime": 1656547200,
+    "vePendle": "0x69A23F16974024A1b6A5362ac2A11BFeEEFd5827",
+    "gaugeController": "0x847da006F940833bB44709CBa241c99e3c531F38"
+}

package/deployments/80001-markets/benqi-market.json

@@ -0,0 +1,7 @@
+{
+    "SCY": "0x0fE14FEB320a8DFF7b2Ee47E6BBedF309eF4B0C8",
+    "expiry": 1672099200,
+    "PT": "0x10AfeBB063A3c1A4e8A1E9274c4c9EbDDC574f0a",
+    "YT": "0x52a59B51eb72E6c2e0F3FE4C2940123671a60DA5",
+    "market": "0x0c37E7E799c9A41008b3d246B86F944992660dD5"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.7.0",
+  "version": "0.7.1-beta-2",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -29,7 +29,7 @@
     "hardhat-contract-sizer": "^2.5.1",
     "prettier": "^2.6.2",
     "prettier-plugin-solidity": "^1.0.0-beta.19",
-    "solc": "^0.8.13",
+    "solc": "^0.8.15",
     "solhint": "^3.3.7",
     "ts-node": "^10.7.0",
     "typechain": "^8.0.0",

package/typechain-types/{CelerReceiver.ts → CelerReceiverUpg.ts}

@@ -23,8 +23,8 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface CelerReceiverInterface extends utils.Interface {
-  contractName: "CelerReceiver";
+export interface CelerReceiverUpgInterface extends utils.Interface {
+  contractName: "CelerReceiverUpg";
   functions: {
     "celerMessageBus()": FunctionFragment;
     "executeMessage(address,uint64,bytes,address)": FunctionFragment;
@@ -93,13 +93,13 @@ export interface CelerReceiverInterface extends utils.Interface {
   events: {};
 }
 
-export interface CelerReceiver extends BaseContract {
-  contractName: "CelerReceiver";
+export interface CelerReceiverUpg extends BaseContract {
+  contractName: "CelerReceiverUpg";
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: CelerReceiverInterface;
+  interface: CelerReceiverUpgInterface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,

package/typechain-types/{CelerSender.ts → CelerSenderUpg.ts}

@@ -23,10 +23,11 @@ import type {
   OnEvent,
 } from "./common";
 
-export interface CelerSenderInterface extends utils.Interface {
-  contractName: "CelerSender";
+export interface CelerSenderUpgInterface extends utils.Interface {
+  contractName: "CelerSenderUpg";
   functions: {
     "addSidechainContract(address,uint256)": FunctionFragment;
+    "celerMessageBus()": FunctionFragment;
     "getAllSidechainContracts()": FunctionFragment;
     "governanceManager()": FunctionFragment;
     "setCelerMessageBus(address)": FunctionFragment;
@@ -36,6 +37,10 @@ export interface CelerSenderInterface extends utils.Interface {
     functionFragment: "addSidechainContract",
     values: [string, BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "celerMessageBus",
+    values?: undefined
+  ): string;
   encodeFunctionData(
     functionFragment: "getAllSidechainContracts",
     values?: undefined
@@ -53,6 +58,10 @@ export interface CelerSenderInterface extends utils.Interface {
     functionFragment: "addSidechainContract",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "celerMessageBus",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "getAllSidechainContracts",
     data: BytesLike
@@ -69,13 +78,13 @@ export interface CelerSenderInterface extends utils.Interface {
   events: {};
 }
 
-export interface CelerSender extends BaseContract {
-  contractName: "CelerSender";
+export interface CelerSenderUpg extends BaseContract {
+  contractName: "CelerSenderUpg";
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: CelerSenderInterface;
+  interface: CelerSenderUpgInterface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,
@@ -103,6 +112,8 @@ export interface CelerSender extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    celerMessageBus(overrides?: CallOverrides): Promise<[string]>;
+
     getAllSidechainContracts(
       overrides?: CallOverrides
     ): Promise<
@@ -123,6 +134,8 @@ export interface CelerSender extends BaseContract {
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  celerMessageBus(overrides?: CallOverrides): Promise<string>;
+
   getAllSidechainContracts(
     overrides?: CallOverrides
   ): Promise<
@@ -143,6 +156,8 @@ export interface CelerSender extends BaseContract {
       overrides?: CallOverrides
     ): Promise<void>;
 
+    celerMessageBus(overrides?: CallOverrides): Promise<string>;
+
     getAllSidechainContracts(
       overrides?: CallOverrides
     ): Promise<
@@ -166,6 +181,8 @@ export interface CelerSender extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    celerMessageBus(overrides?: CallOverrides): Promise<BigNumber>;
+
     getAllSidechainContracts(overrides?: CallOverrides): Promise<BigNumber>;
 
     governanceManager(overrides?: CallOverrides): Promise<BigNumber>;
@@ -183,6 +200,8 @@ export interface CelerSender extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    celerMessageBus(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     getAllSidechainContracts(
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;