@pendle/core-v2 0.6.9 → 0.7.1-beta

package/contracts/libraries/math/MarketMathCore.sol

@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.15;
 
 import "./Math.sol";
 import "./LogExpMath.sol";
-import "../SCYIndex.sol";
+import "../SCY/SCYIndex.sol";
+import "../helpers/MiniHelpers.sol";
 
 struct MarketState {
     int256 totalPt;
@@ -27,7 +28,7 @@ struct MarketPreCompute {
     int256 rateScalar;
     int256 totalAsset;
     int256 rateAnchor;
-    int256 lnFeeRate;
+    int256 feeRate;
 }
 
 // solhint-disable ordering
@@ -40,10 +41,99 @@ library MarketMathCore {
     int256 internal constant MINIMUM_LIQUIDITY = 10**3;
     int256 internal constant PERCENTAGE_DECIMALS = 100;
     uint256 internal constant DAY = 86400;
-    uint256 internal constant IMPLIED_RATE_TIME = 360 * DAY;
+    uint256 internal constant IMPLIED_RATE_TIME = 365 * DAY;
 
     int256 internal constant MAX_MARKET_PROPORTION = (1e18 * 96) / 100;
 
+    using Math for uint256;
+    using Math for int256;
+
+    /*///////////////////////////////////////////////////////////////
+                UINT FUNCTIONS TO PROXY TO CORE FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function addLiquidity(
+        MarketState memory market,
+        SCYIndex index,
+        uint256 scyDesired,
+        uint256 ptDesired,
+        bool updateState
+    )
+        internal
+        pure
+        returns (
+            uint256 lpToReserve,
+            uint256 lpToAccount,
+            uint256 scyUsed,
+            uint256 ptUsed
+        )
+    {
+        (
+            int256 _lpToReserve,
+            int256 _lpToAccount,
+            int256 _scyUsed,
+            int256 _otUsed
+        ) = addLiquidityCore(market, index, scyDesired.Int(), ptDesired.Int(), updateState);
+
+        lpToReserve = _lpToReserve.Uint();
+        lpToAccount = _lpToAccount.Uint();
+        scyUsed = _scyUsed.Uint();
+        ptUsed = _otUsed.Uint();
+    }
+
+    function removeLiquidity(
+        MarketState memory market,
+        uint256 lpToRemove,
+        bool updateState
+    ) internal pure returns (uint256 scyToAccount, uint256 netPtToAccount) {
+        (int256 _scyToAccount, int256 _ptToAccount) = removeLiquidityCore(
+            market,
+            lpToRemove.Int(),
+            updateState
+        );
+
+        scyToAccount = _scyToAccount.Uint();
+        netPtToAccount = _ptToAccount.Uint();
+    }
+
+    function swapExactPtForScy(
+        MarketState memory market,
+        SCYIndex index,
+        uint256 exactPtToMarket,
+        uint256 blockTime
+    ) internal pure returns (uint256 netScyToAccount, uint256 netScyToReserve) {
+        (int256 _netScyToAccount, int256 _netScyToReserve) = executeTradeCore(
+            market,
+            index,
+            exactPtToMarket.neg(),
+            blockTime
+        );
+
+        netScyToAccount = _netScyToAccount.Uint();
+        netScyToReserve = _netScyToReserve.Uint();
+    }
+
+    function swapScyForExactPt(
+        MarketState memory market,
+        SCYIndex index,
+        uint256 exactPtToAccount,
+        uint256 blockTime
+    ) internal pure returns (uint256 netScyToMarket, uint256 netScyToReserve) {
+        (int256 _netScyToAccount, int256 _netScyToReserve) = executeTradeCore(
+            market,
+            index,
+            exactPtToAccount.Int(),
+            blockTime
+        );
+
+        netScyToMarket = _netScyToAccount.neg().Uint();
+        netScyToReserve = _netScyToReserve.Uint();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    CORE FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
     function addLiquidityCore(
         MarketState memory market,
         SCYIndex index,
@@ -103,7 +193,7 @@ library MarketMathCore {
         MarketState memory market,
         int256 lpToRemove,
         bool updateState
-    ) internal pure returns (int256 scyToAccount, int256 netPtToAccount) {
+    ) internal pure returns (int256 netScyToAccount, int256 netPtToAccount) {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
@@ -112,16 +202,17 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// MATH
         /// ------------------------------------------------------------
-        scyToAccount = (lpToRemove * market.totalScy) / market.totalLp;
+        netScyToAccount = (lpToRemove * market.totalScy) / market.totalLp;
         netPtToAccount = (lpToRemove * market.totalPt) / market.totalLp;
 
+        require(netScyToAccount > 0 || netPtToAccount > 0, "zero amounts out");
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
         if (updateState) {
             market.totalLp = market.totalLp.subNoNeg(lpToRemove);
             market.totalPt = market.totalPt.subNoNeg(netPtToAccount);
-            market.totalScy = market.totalScy.subNoNeg(scyToAccount);
+            market.totalScy = market.totalScy.subNoNeg(netScyToAccount);
         }
     }
 
@@ -129,13 +220,12 @@ library MarketMathCore {
         MarketState memory market,
         SCYIndex index,
         int256 netPtToAccount,
-        uint256 blockTime,
-        bool updateState
+        uint256 blockTime
     ) internal pure returns (int256 netScyToAccount, int256 netScyToReserve) {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
-        require(blockTime < market.expiry, "market expired");
+        require(!MiniHelpers.isExpired(market.expiry, blockTime), "market expired");
         require(market.totalPt > netPtToAccount, "insufficient liquidity");
 
         /// ------------------------------------------------------------
@@ -155,16 +245,7 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
-        if (updateState) {
-            _setNewMarketStateTrade(
-                market,
-                comp,
-                index,
-                netPtToAccount,
-                netScyToAccount,
-                blockTime
-            );
-        }
+        _setNewMarketStateTrade(market, comp, index, netPtToAccount, netScyToAccount, blockTime);
     }
 
     function getMarketPreCompute(
@@ -172,7 +253,7 @@ library MarketMathCore {
         SCYIndex index,
         uint256 blockTime
     ) internal pure returns (MarketPreCompute memory res) {
-        require(blockTime < market.expiry, "market expired");
+        require(!MiniHelpers.isExpired(market.expiry, blockTime), "market expired");
 
         uint256 timeToExpiry = market.expiry - blockTime;
 
@@ -188,7 +269,7 @@ library MarketMathCore {
             res.rateScalar,
             timeToExpiry
         );
-        res.lnFeeRate = _getExchangeRateFromImpliedRate(market.lnFeeRateRoot, timeToExpiry);
+        res.feeRate = _getExchangeRateFromImpliedRate(market.lnFeeRateRoot, timeToExpiry);
     }
 
     function calcTrade(
@@ -205,7 +286,7 @@ library MarketMathCore {
         );
 
         int256 preFeeAssetToAccount = netPtToAccount.divDown(preFeeExchangeRate).neg();
-        int256 fee = comp.lnFeeRate;
+        int256 fee = comp.feeRate;
 
         if (netPtToAccount > 0) {
             int256 postFeeExchangeRate = preFeeExchangeRate.divDown(fee);
@@ -359,7 +440,7 @@ library MarketMathCore {
             totalAsset,
             rateScalar,
             initialAnchor,
-            market.expiry - blockTime
+            timeToExpiry
         );
     }
 
@@ -385,7 +466,7 @@ library MarketMathCore {
         // 1 - (currentTs - previousTs) / timeWindow
         uint256 oracleWeight = Math.ONE - lastTradeWeight;
 
-        uint256 newOracleRate = market.lastTradeTime.mulDown(lastTradeWeight) +
+        uint256 newOracleRate = market.lastLnImpliedRate.mulDown(lastTradeWeight) +
             market.oracleRate.mulDown(oracleWeight);
 
         return newOracleRate;

package/contracts/libraries/math/Math.sol

@@ -12,9 +12,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-pragma solidity 0.8.9;
-
-import "./LogExpMath.sol";
+pragma solidity 0.8.15;
 
 /* solhint-disable private-vars-leading-underscore, reason-string */
 
@@ -29,10 +27,8 @@ library Math {
     }
 
     function subNoNeg(int256 a, int256 b) internal pure returns (int256) {
-        require(a >= b, "NEGATIVE");
-        unchecked {
-            return a - b;
-        }
+        require(a >= b, "negative");
+        return a - b; // no unchecked since if b is very negative, a - b might overflow
     }
 
     function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
@@ -66,9 +62,7 @@ library Math {
     function rawDivUp(uint256 a, uint256 b) internal pure returns (uint256) {
         if (a == 0) return 0;
         else {
-            unchecked {
-                return (a + b - 1) / b;
-            }
+            return (a + b - 1) / b;
         }
     }
 
@@ -77,11 +71,11 @@ library Math {
     }
 
     function neg(int256 x) internal pure returns (int256) {
-        return -x;
+        return x * (-1);
     }
 
     function neg(uint256 x) internal pure returns (int256) {
-        return -Int(x);
+        return Int(x) * (-1);
     }
 
     function max(uint256 x, uint256 y) internal pure returns (uint256) {
@@ -100,36 +94,49 @@ library Math {
         return (x < y ? x : y);
     }
 
-    function Uint(int256 x) internal pure returns (uint256) {
-        require(x >= 0);
-        return uint256(x);
-    }
+    /*///////////////////////////////////////////////////////////////
+                               SIGNED CASTS
+    //////////////////////////////////////////////////////////////*/
 
     function Int(uint256 x) internal pure returns (int256) {
-        require(x < (1 << 255)); // signed, lim = bit-1
+        require(x <= uint256(type(int256).max));
         return int256(x);
     }
 
     function Int128(int256 x) internal pure returns (int128) {
-        require(x < (1 << 127)); // signed, lim = bit-1
+        require(type(int128).min <= x && x <= type(int128).max);
         return int128(x);
     }
 
+    /*///////////////////////////////////////////////////////////////
+                               UNSIGNED CASTS
+    //////////////////////////////////////////////////////////////*/
+
+    function Uint(int256 x) internal pure returns (uint256) {
+        require(x >= 0);
+        return uint256(x);
+    }
+
     function Uint32(uint256 x) internal pure returns (uint32) {
-        require(x < (1 << 32)); // unsigned, lim = bit
+        require(x <= type(uint32).max);
         return uint32(x);
     }
 
     function Uint112(uint256 x) internal pure returns (uint112) {
-        require(x < (1 << 112)); // unsigned, lim = bit
+        require(x <= type(uint112).max);
         return uint112(x);
     }
 
     function Uint96(uint256 x) internal pure returns (uint96) {
-        require(x < (1 << 96)); // unsigned, lim = bit
+        require(x <= type(uint96).max);
         return uint96(x);
     }
 
+    function Uint128(uint256 x) internal pure returns (uint128) {
+        require(x <= type(uint128).max);
+        return uint128(x);
+    }
+
     function isAApproxB(
         uint256 a,
         uint256 b,

package/contracts/libraries/math/WeekMath.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.15;
+
+library WeekMath {
+    uint128 internal constant WEEK = 7 days;
+
+    function getWeekStartTimestamp(uint128 timestamp) internal pure returns (uint128) {
+        return (timestamp / WEEK) * WEEK;
+    }
+
+    function getCurrentWeekStart() internal view returns (uint128) {
+        return getWeekStartTimestamp(uint128(block.timestamp));
+    }
+
+    function isValidWTime(uint128 time) internal pure returns (bool) {
+        return time % WEEK == 0;
+    }
+}

package/contracts/libraries/solmate/Bytes32AddressLib.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity >=0.8.0;
+
+/// @notice Library for converting between addresses and bytes32 values.
+/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/Bytes32AddressLib.sol)
+library Bytes32AddressLib {
+    function fromLast20Bytes(bytes32 bytesValue) internal pure returns (address) {
+        return address(uint160(uint256(bytesValue)));
+    }
+
+    function fillLast12Bytes(address addressValue) internal pure returns (bytes32) {
+        return bytes32(bytes20(addressValue));
+    }
+}

package/contracts/libraries/solmate/SSTORE2.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity >=0.8.0;
+
+/// @notice Read and write to persistent storage at a fraction of the cost.
+/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/SSTORE2.sol)
+/// @author Modified from 0xSequence (https://github.com/0xSequence/sstore2/blob/master/contracts/SSTORE2.sol)
+library SSTORE2 {
+    uint256 internal constant DATA_OFFSET = 1; // We skip the first byte as it's a STOP opcode to ensure the contract can't be called.
+
+    /*//////////////////////////////////////////////////////////////
+                               WRITE LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function write(bytes memory data) internal returns (address pointer) {
+        // Prefix the bytecode with a STOP opcode to ensure it cannot be called.
+        bytes memory runtimeCode = abi.encodePacked(hex"00", data);
+
+        bytes memory creationCode = abi.encodePacked(
+            //---------------------------------------------------------------------------------------------------------------//
+            // Opcode  | Opcode + Arguments  | Description  | Stack View                                                     //
+            //---------------------------------------------------------------------------------------------------------------//
+            // 0x60    |  0x600B             | PUSH1 11     | codeOffset                                                     //
+            // 0x59    |  0x59               | MSIZE        | 0 codeOffset                                                   //
+            // 0x81    |  0x81               | DUP2         | codeOffset 0 codeOffset                                        //
+            // 0x38    |  0x38               | CODESIZE     | codeSize codeOffset 0 codeOffset                               //
+            // 0x03    |  0x03               | SUB          | (codeSize - codeOffset) 0 codeOffset                           //
+            // 0x80    |  0x80               | DUP          | (codeSize - codeOffset) (codeSize - codeOffset) 0 codeOffset   //
+            // 0x92    |  0x92               | SWAP3        | codeOffset (codeSize - codeOffset) 0 (codeSize - codeOffset)   //
+            // 0x59    |  0x59               | MSIZE        | 0 codeOffset (codeSize - codeOffset) 0 (codeSize - codeOffset) //
+            // 0x39    |  0x39               | CODECOPY     | 0 (codeSize - codeOffset)                                      //
+            // 0xf3    |  0xf3               | RETURN       |                                                                //
+            //---------------------------------------------------------------------------------------------------------------//
+            hex"60_0B_59_81_38_03_80_92_59_39_F3", // Returns all code in the contract except for the first 11 (0B in hex) bytes.
+            runtimeCode // The bytecode we want the contract to have after deployment. Capped at 1 byte less than the code size limit.
+        );
+
+        assembly {
+            // Deploy a new contract with the generated creation code.
+            // We start 32 bytes into the code to avoid copying the byte length.
+            pointer := create(0, add(creationCode, 32), mload(creationCode))
+        }
+
+        require(pointer != address(0), "DEPLOYMENT_FAILED");
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                               READ LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function read(address pointer) internal view returns (bytes memory) {
+        return readBytecode(pointer, DATA_OFFSET, pointer.code.length - DATA_OFFSET);
+    }
+
+    function read(address pointer, uint256 start) internal view returns (bytes memory) {
+        start += DATA_OFFSET;
+
+        return readBytecode(pointer, start, pointer.code.length - start);
+    }
+
+    function read(
+        address pointer,
+        uint256 start,
+        uint256 end
+    ) internal view returns (bytes memory) {
+        start += DATA_OFFSET;
+        end += DATA_OFFSET;
+
+        require(pointer.code.length >= end, "OUT_OF_BOUNDS");
+
+        return readBytecode(pointer, start, end - start);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                          INTERNAL HELPER LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function readBytecode(
+        address pointer,
+        uint256 start,
+        uint256 size
+    ) private view returns (bytes memory data) {
+        assembly {
+            // Get a pointer to some free memory.
+            data := mload(0x40)
+
+            // Update the free memory pointer to prevent overriding our data.
+            // We use and(x, not(31)) as a cheaper equivalent to sub(x, mod(x, 32)).
+            // Adding 31 to size and running the result through the logic above ensures
+            // the memory pointer remains word-aligned, following the Solidity convention.
+            mstore(0x40, add(data, and(add(add(size, 32), 31), not(31))))
+
+            // Store the size of the data in the first 32 byte chunk of free memory.
+            mstore(data, size)
+
+            // Copy the code into memory right after the 32 bytes we used to store the size.
+            extcodecopy(pointer, add(data, 32), start, size)
+        }
+    }
+}

package/contracts/libraries/{JoeLibrary.sol → traderjoe/JoeLibrary.sol}

@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.15;
 
-import "../interfaces/IJoePair.sol";
+import "../../interfaces/IJoePair.sol";
 
+// almost-copied from TraderJoe
 library JoeLibrary {
     // returns sorted token addresses, used to handle return values from pairs sorted in this order
     function sortTokens(address tokenA, address tokenB)

package/contracts/{periphery → libraries/traderjoe}/PendleJoeSwapHelperUpg.sol

@@ -21,27 +21,21 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.9;
-import "../interfaces/IJoeRouter01.sol";
-import "../libraries/JoeLibrary.sol";
+pragma solidity 0.8.15;
+import "../../interfaces/IJoeRouter01.sol";
+import "./JoeLibrary.sol";
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 abstract contract PendleJoeSwapHelperUpg {
     using SafeERC20 for IERC20;
-    address public immutable joeRouter;
     address public immutable joeFactory;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _joeRouter, address _joeFactory) {
-        joeRouter = _joeRouter;
+    constructor(address _joeFactory) {
         joeFactory = _joeFactory;
     }
 
-    function _getFirstPair(address[] memory path) internal view returns (address pair) {
-        return JoeLibrary.pairFor(joeFactory, path[0], path[1]);
-    }
-
     /**
      * @notice swap tokens with no limit on amountOut. Tokens must have been transferred to the first pair
      */
@@ -79,4 +73,8 @@ abstract contract PendleJoeSwapHelperUpg {
             );
         }
     }
+
+    function _getFirstPair(address[] memory path) internal view returns (address pair) {
+        return JoeLibrary.pairFor(joeFactory, path[0], path[1]);
+    }
 }

package/contracts/{core → offchain-helpers}/RouterStatic.sol

@@ -1,19 +1,18 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.15;
 
-import "../SuperComposableYield/ISuperComposableYield.sol";
-import "../SuperComposableYield/implementations/IRewardManager.sol";
+import "../interfaces/ISuperComposableYield.sol";
+import "../interfaces/IRewardManager.sol";
 import "../interfaces/IPRouterStatic.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IPYieldContractFactory.sol";
 import "../interfaces/IPMarketFactory.sol";
-import "../libraries/math/MarketMathAux.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 {
     using MarketMathCore for MarketState;
-    using MarketMathAux for MarketState;
     using Math for uint256;
     using Math for int256;
     using LogExpMath for int256;
@@ -64,8 +63,7 @@ contract RouterStatic is IPRouterStatic {
         (netScyOut, netScyFee) = state.swapExactPtForScy(
             scyIndex(market),
             exactPtIn,
-            block.timestamp,
-            false
+            block.timestamp
         );
     }
 
@@ -77,13 +75,14 @@ contract RouterStatic is IPRouterStatic {
         (netScyIn, netScyFee) = state.swapScyForExactPt(
             scyIndex(market),
             exactPtOut,
-            block.timestamp,
-            false
+            block.timestamp
         );
     }
 
-    function scyIndex(address market) public returns (SCYIndex index) {
-        return SCYIndexLib.newIndex(IPMarket(market).SCY());
+    function scyIndex(address market) public view returns (SCYIndex index) {
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+
+        return SCYIndexLib.newIndex(SCY);
     }
 
     function getPtImpliedYield(address market) public view returns (int256) {
@@ -117,13 +116,13 @@ contract RouterStatic is IPRouterStatic {
         userPYInfo.ytBalance = YT.balanceOf(user);
         userPYInfo.ptBalance = IPPrincipalToken(userPYInfo.pt).balanceOf(user);
         userPYInfo.unclaimedInterest.token = YT.SCY();
-        (, userPYInfo.unclaimedInterest.amount) = YT.getInterestData(user);
+        (, userPYInfo.unclaimedInterest.amount) = YT.userInterest(user);
         address[] memory rewardTokens = YT.getRewardTokens();
         TokenAmount[] memory unclaimedRewards = new TokenAmount[](rewardTokens.length);
         uint256 length = 0;
         for (uint256 i = 0; i < rewardTokens.length; ++i) {
             address rewardToken = rewardTokens[i];
-            (, uint256 amount) = YT.getUserReward(user, rewardToken);
+            (, uint256 amount) = YT.userReward(rewardToken, user);
             if (amount > 0) {
                 unclaimedRewards[length].token = rewardToken;
                 unclaimedRewards[length].amount = amount;
@@ -146,14 +145,16 @@ contract RouterStatic is IPRouterStatic {
     {
         (address yt, ) = getPY(py);
         IPYieldToken YT = IPYieldToken(yt);
-        (, exchangeRate) = YT.getScyIndex();
+        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) = YT.getGlobalReward(rewardToken);
+            rewardIndexes[i].index = indexes[i];
         }
     }
 
@@ -179,8 +180,10 @@ contract RouterStatic is IPRouterStatic {
         )
     {
         IPMarket _market = IPMarket(market);
-        pt = _market.PT();
-        scy = _market.SCY();
+        (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
@@ -195,8 +198,10 @@ contract RouterStatic is IPRouterStatic {
         userMarketInfo.market = market;
         userMarketInfo.lpBalance = _market.balanceOf(user);
         // TODO: Is there a way to convert LP to PT and SCY?
-        userMarketInfo.ptBalance = TokenAmount(_market.PT(), 0);
-        userMarketInfo.scyBalance = TokenAmount(_market.SCY(), 0);
+        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+
+        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);
     }
@@ -242,7 +247,7 @@ contract RouterStatic is IPRouterStatic {
         for (uint256 i = 0; i < rewardTokens.length; ++i) {
             address rewardToken = rewardTokens[i];
             rewards[i].token = rewardToken;
-            (, rewards[i].amount) = IRewardManager(scy).getUserReward(user, rewardToken);
+            (, rewards[i].amount) = IRewardManager(scy).userReward(rewardToken, user);
         }
     }
 }

package/contracts/periphery/PendleGovernanceManager.sol

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