@pendle/core-v2 0.16.6-testnet → 0.17.0-testnet

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -46,7 +46,8 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
 
     string private constant PT_PREFIX = "PT";
     string private constant YT_PREFIX = "YT";
-    string private constant SY_PREF = "SY-";
+    string private constant SY_SYMBOL_PREF = "SY-";
+    string private constant SY_NAME_PREF = "SY ";
 
     address public immutable ytCreationCodeContractA;
     uint256 public immutable ytCreationCodeSizeA;
@@ -62,11 +63,15 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     uint96 public expiryDivisor;
 
     // SY => expiry => address
+    // returns address(0) if not created
     mapping(address => mapping(uint256 => address)) public getPT;
     mapping(address => mapping(uint256 => address)) public getYT;
     mapping(address => bool) public isPT;
     mapping(address => bool) public isYT;
 
+    uint256 public constant maxInterestFeeRate = 2e17; // 20%
+    uint256 public constant maxRewardFeeRate = 2e17; // 20%
+
     constructor(
         address _ytCreationCodeContractA,
         uint256 _ytCreationCodeSizeA,
@@ -96,10 +101,11 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
      * @notice Create a pair of (PT, YT) from any SY and valid expiry. Anyone can create a yield contract
      * @dev It's intentional to make expiry an uint32 to guard against fat fingers. uint32.max is year 2106
      */
-    function createYieldContract(address SY, uint32 expiry)
-        external
-        returns (address PT, address YT)
-    {
+    function createYieldContract(
+        address SY,
+        uint32 expiry,
+        bool doCacheIndexSameBlock
+    ) external returns (address PT, address YT) {
         if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
             revert Errors.YCFactoryInvalidExpiry();
 
@@ -136,7 +142,8 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
                 YT_PREFIX.concat(syCoreName, expiry, " "),
                 YT_PREFIX.concat(syCoreSymbol, expiry, "-"),
                 assetDecimals,
-                expiry
+                expiry,
+                doCacheIndexSameBlock
             ),
             ytCreationCodeContractA,
             ytCreationCodeSizeA,
@@ -151,32 +158,43 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
         isPT[PT] = true;
         isYT[YT] = true;
 
-        emit CreateYieldContract(SY, PT, YT, expiry);
+        emit CreateYieldContract(SY, expiry, PT, YT);
     }
 
     function setExpiryDivisor(uint96 newExpiryDivisor) public onlyOwner {
+        if (newExpiryDivisor == 0) revert Errors.YCFactoryZeroExpiryDivisor();
+
         expiryDivisor = newExpiryDivisor;
         emit SetExpiryDivisor(newExpiryDivisor);
     }
 
     function setInterestFeeRate(uint128 newInterestFeeRate) public onlyOwner {
+        if (newInterestFeeRate > maxInterestFeeRate)
+            revert Errors.YCFactoryInterestFeeRateTooHigh(newInterestFeeRate, maxInterestFeeRate);
+
         interestFeeRate = newInterestFeeRate;
         emit SetInterestFeeRate(newInterestFeeRate);
     }
 
-    function setRewardFeeRate(uint128 newInterestFeeRate) public onlyOwner {
-        rewardFeeRate = newInterestFeeRate;
-        emit SetInterestFeeRate(newInterestFeeRate);
+    function setRewardFeeRate(uint128 newRewardFeeRate) public onlyOwner {
+        if (newRewardFeeRate > maxRewardFeeRate)
+            revert Errors.YCFactoryRewardFeeRateTooHigh(newRewardFeeRate, maxRewardFeeRate);
+
+        rewardFeeRate = newRewardFeeRate;
+        emit SetRewardFeeRate(newRewardFeeRate);
     }
 
     function setTreasury(address newTreasury) public onlyOwner {
+        if (newTreasury == address(0)) revert Errors.YCFactoryZeroTreasury();
+
         treasury = newTreasury;
         emit SetTreasury(newTreasury);
     }
 
     function _stripSYPrefix(string memory _str) internal pure returns (string memory) {
         StringLib.slice memory str = _str.toSlice();
-        StringLib.slice memory delim = SY_PREF.toSlice();
-        return str.beyond(delim).toString();
+        StringLib.slice memory delim_name = SY_NAME_PREF.toSlice();
+        StringLib.slice memory delim_symbol = SY_SYMBOL_PREF.toSlice();
+        return str.beyond(delim_name).beyond(delim_symbol).toString();
     }
 }

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -45,7 +45,11 @@ contract PendleYieldToken is
     address public immutable factory;
     uint256 public immutable expiry;
 
-    uint128 public syReserve;
+    bool public immutable doCacheIndexSameBlock;
+
+    uint256 public syReserve;
+
+    uint128 public pyIndexLastUpdatedBlock;
     uint128 internal _pyIndexStored;
 
     PostExpiryData public postExpiry;
@@ -61,21 +65,31 @@ contract PendleYieldToken is
         _;
     }
 
+    /**
+     * @param _doCacheIndexSameBlock if true, the PY index is cached for each block, and thus is 
+     * constant for all txs within the same block. Otherwise, the PY index is recalculated for 
+     * every tx.
+     */
     constructor(
         address _SY,
         address _PT,
         string memory _name,
         string memory _symbol,
         uint8 __decimals,
-        uint256 _expiry
+        uint256 _expiry,
+        bool _doCacheIndexSameBlock
     ) PendleERC20Permit(_name, _symbol, __decimals) {
         SY = _SY;
         PT = _PT;
         expiry = _expiry;
         factory = msg.sender;
+        doCacheIndexSameBlock = _doCacheIndexSameBlock;
     }
 
-    /// @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
+    /**
+     * @notice Tokenize SY into PT + YT of equal qty. Every unit of asset of SY will create 1 PT + 1 YT
+     * @dev SY must be transferred to this contract prior to calling
+     */
     function mintPY(address receiverPT, address receiverYT)
         external
         nonReentrant
@@ -97,7 +111,7 @@ contract PendleYieldToken is
         amountPYOut = amountPYOuts[0];
     }
 
-    /// @notice Tokenize SY into PT + YT of equal qty. Every unit of underlying of SY will create 1 PT + 1 YT
+    /// @notice Tokenize SY into PT + YT for multiple receivers. See `mintPY()` for more details
     function mintPYMulti(
         address[] calldata receiverPTs,
         address[] calldata receiverYTs,
@@ -116,7 +130,11 @@ contract PendleYieldToken is
         amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
     }
 
-    /// @dev this function converts PY tokens into sy, but interests & rewards are not redeemed at the same time
+    /**
+     * @notice converts PT(+YT) tokens into SY, but interests & rewards are not redeemed at the 
+     * same time
+     * @dev PT/YT must be transferred to this contract prior to calling
+     */
     function redeemPY(address receiver)
         external
         nonReentrant
@@ -133,9 +151,11 @@ contract PendleYieldToken is
         amountSyOut = amountSyOuts[0];
     }
 
-    /// @dev this function limit how much each receiver will receive. For example, if the totalOut is 100,
-    /// and the max are 50 30 INF, the first receiver will receive 50, the second will receive 30, and the third will receive 20.
-    /// @dev intended to mostly be used by Pendle router
+    /**
+     * @notice redeems PT(+YT) for multiple users. See `redeemPY()`
+     * @dev PT/YT must be transferred to this contract prior to calling
+     * @dev fails if unable to redeem the total PY amount in `amountPYToRedeems`
+     */
     function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
         external
         nonReentrant
@@ -148,12 +168,15 @@ contract PendleYieldToken is
     }
 
     /**
-    * @dev With YT yielding interest in the form of SY, which is redeemable by users, the reward
-    distribution should be based on the amount of SYs that their YT currently represent, plus their
-    dueInterest. It has been proven and tested that _rewardSharesUser will not change over time,
-    unless users redeem their dueInterest or redeemPY. Due to this, it is required to update users'
-    accruedReward STRICTLY BEFORE transferring out their interest.
-    */
+     * @notice Redeems interests and rewards for `user`
+     * @param redeemInterest will only transfer out interest for user if true
+     * @param redeemRewards will only transfer out rewards for user if true
+     * @dev With YT yielding interest in the form of SY, which is redeemable by users, the reward
+     * distribution should be based on the amount of SYs that their YT currently represent, plus 
+     * their dueInterest. It has been proven and tested that _rewardSharesUser will not change over 
+     * time, unless users redeem their dueInterest or redeemPY. Due to this, it is required to 
+     * update users' accruedReward STRICTLY BEFORE transferring out their interest.
+     */
     function redeemDueInterestAndRewards(
         address user,
         bool redeemInterest,
@@ -182,6 +205,10 @@ contract PendleYieldToken is
         }
     }
 
+    /**
+     * @dev All rewards and interests accrued post-expiry goes to the treasury.
+     * Reverts if called pre-expiry.
+     */
     function redeemInterestAndRewardsPostExpiryForTreasury()
         external
         nonReentrant
@@ -208,21 +235,46 @@ contract PendleYieldToken is
         _transferOut(SY, treasury, interestOut);
     }
 
+    /// @notice updates and returns the reward indexes
     function rewardIndexesCurrent() external override nonReentrant returns (uint256[] memory) {
         return IStandardizedYield(SY).rewardIndexesCurrent();
     }
 
-    /// @dev maximize the current rate with the previous rate to guarantee non-decreasing rate
+    /**
+     * @notice updates and returns the current PY index
+     * @dev this function maximizes the current PY index with the previous index, guaranteeing
+     * non-decreasing PY index
+     * @dev if `doCacheIndexSameBlock` is true, PY index only updates at most once per block,
+     * and has no state changes on the second call onwards (within the same block).
+     * @dev see `pyIndexStored()` for view function for cached value.
+     */
     function pyIndexCurrent() public nonReentrant returns (uint256 currentIndex) {
         currentIndex = _pyIndexCurrent();
     }
 
+    /// @notice returns the last-updated PY index
+    function pyIndexStored() public view returns (uint256) {
+        return _pyIndexStored;
+    }
+
+    /**
+     * @notice do a final rewards redeeming, and sets post-expiry data
+     * @dev has no effect if called pre-expiry
+     */
     function setPostExpiryData() external nonReentrant {
         if (isExpired()) {
             _setPostExpiryData();
         }
     }
 
+    /**
+     * @notice returns the current data post-expiry, if exists
+     * @dev reverts if post-expiry data not set (see `setPostExpiryData()`)
+     * @return firstPYIndex the earliest PY index post-expiry
+     * @return totalSyInterestForTreasury current amount of SY interests post-expiry for treasury
+     * @return firstRewardIndexes the earliest reward indices post-expiry, for each reward token
+     * @return userRewardOwed amount of unclaimed user rewards, for each reward token
+     */
     function getPostExpiryData()
         external
         view
@@ -273,10 +325,6 @@ contract PendleYieldToken is
         }
     }
 
-    function pyIndexStored() public view returns (uint256) {
-        return _pyIndexStored;
-    }
-
     function isExpired() public view returns (bool) {
         return MiniHelpers.isCurrentlyExpired(expiry);
     }
@@ -336,7 +384,7 @@ contract PendleYieldToken is
     }
 
     function _updateSyReserve() internal virtual {
-        syReserve = _selfBalance(SY).Uint128();
+        syReserve = _selfBalance(SY);
     }
 
     function _getFloatingSyAmount() internal view returns (uint256 amount) {
@@ -369,8 +417,17 @@ contract PendleYieldToken is
     }
 
     function _pyIndexCurrent() internal returns (uint256 currentIndex) {
-        currentIndex = Math.max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored);
-        _pyIndexStored = currentIndex.Uint128();
+        if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number)
+            return _pyIndexStored;
+
+        uint128 index128 = Math
+            .max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored)
+            .Uint128();
+
+        currentIndex = index128;
+        _pyIndexStored = index128;
+        pyIndexLastUpdatedBlock = uint128(block.number);
+
         emit NewInterestIndex(currentIndex);
     }
 

package/contracts/core/erc20/PendleERC20.sol

@@ -13,7 +13,7 @@ import "@openzeppelin/contracts/utils/Context.sol";
  * - comes with built-in reentrancy protection, storage-packed with totalSupply variable
  * - delete increaseAllowance / decreaseAllowance
  * - add nonReentrancy protection to transfer / transferFrom functions
- * - allow decimals to by passed in
+ * - allow decimals to be passed in
  * - block self-transfer by default
  */
 // solhint-disable
@@ -26,7 +26,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     mapping(address => mapping(address => uint256)) private _allowances;
 
     uint248 private _totalSupply;
-    uint8 private _status;
+    uint8 private _status; 
 
     string private _name;
     string private _symbol;
@@ -54,12 +54,9 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     }
 
     /**
-     * @dev Sets the values for {name} and {symbol}.
+     * @dev Sets the values for {name}, {symbol} and {decimals}.
      *
-     * The default value of {decimals} is 18. To select a different value for
-     * {decimals} you should overload it.
-     *
-     * All two of these values are immutable: they can only be set once during
+     * All three of these values are immutable: they can only be set once during
      * construction.
      */
     constructor(

package/contracts/core/libraries/BaseSplitCodeFactory.sol

@@ -164,7 +164,7 @@ library BaseSplitCodeFactory {
         uint256 creationCodeSizeA,
         address creationCodeContractB,
         uint256 creationCodeSizeB
-    ) public view returns (bytes memory) {
+    ) internal view returns (bytes memory) {
         return
             _getCreationCodeWithArgs(
                 "",

package/contracts/core/libraries/BoringOwnableUpgradeable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.17;
 
-import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 contract BoringOwnableUpgradeableData {
     address public owner;

package/contracts/core/libraries/Errors.sol

@@ -51,8 +51,13 @@ library Errors {
     error MarketFactoryInvalidPt();
     error MarketFactoryMarketExists();
 
-    error MFactoryLnFeeRateRootTooHigh(uint88 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
-    error MFactoryReserveFeePercentTooHigh(uint8 reserveFeePercent, uint8 maxReserveFeePercent);
+    error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
+    error MarketFactoryReserveFeePercentTooHigh(
+        uint8 reserveFeePercent,
+        uint8 maxReserveFeePercent
+    );
+    error MarketFactoryZeroTreasury();
+    error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
 
     // ROUTER
     error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
@@ -85,6 +90,10 @@ library Errors {
     // YieldFactory
     error YCFactoryInvalidExpiry();
     error YCFactoryYieldContractExisted();
+    error YCFactoryZeroExpiryDivisor();
+    error YCFactoryZeroTreasury();
+    error YCFactoryInterestFeeRateTooHigh(uint256 interestFeeRate, uint256 maxInterestFeeRate);
+    error YCFactoryRewardFeeRateTooHigh(uint256 newRewardFeeRate, uint256 maxRewardFeeRate);
 
     // SY
     error SYInvalidTokenIn(address token);
@@ -119,6 +128,7 @@ library Errors {
     error VEPositionNotExpired();
     error VEZeroPosition();
     error VEZeroSlope(uint128 bias, uint128 slope);
+    error VEReceiveOldSupply(uint256 msgTime);
 
     error GCNotPendleMarket(address caller);
     error GCNotVotingController(address caller);

package/contracts/interfaces/ConvexCurve/IBooster.sol

@@ -10,7 +10,7 @@ interface IBooster {
         external
         view
         returns (
-            address,
+            address lpToken,
             address,
             address,
             address,

package/contracts/interfaces/Curve/ICrvPool.sol

@@ -22,20 +22,19 @@ interface ICrvPool {
         int128 i,
         int128 j,
         uint256 dx,
-        uint256 min_dy, // The amount of i being exchanged.
-        address _receiver
+        uint256 min_dy // The amount of i being exchanged.
     ) external returns (uint256);
 
     function add_liquidity(
         uint256[2] memory _deposit_amount,
         uint256 _min_amount
-    ) external;
+    ) external returns (uint256 lpOut);
 
     function remove_liquidity_one_coin(
         uint256 _burn_amount,
         int128 i,
         uint256 _min_amount
-    ) external;
+    ) external returns (uint256 tokenOut);
 
     function calc_token_amount(uint256[2] memory _amounts, bool _is_deposit)
         external

package/contracts/interfaces/Curve/ITriCrvPool.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface ITriCrvPool {
+    function coins(uint256 i) external view returns (address);
+
+    function get_virtual_price() external view returns (uint256);
+
+    function lp_token() external view returns (address);
+
+    function fee() external view returns (uint256);
+
+    function admin_fee() external view returns (uint256);
+
+    function exchange(
+        int128 i,
+        int128 j,
+        uint256 dx,
+        uint256 min_dy // The amount of i being exchanged.
+    ) external returns (uint256);
+
+    function add_liquidity(
+        uint256[3] memory _deposit_amount,
+        uint256 _min_amount
+    ) external;
+
+    function remove_liquidity_one_coin(
+        uint256 _burn_amount,
+        int128 i,
+        uint256 _min_amount
+    ) external;
+
+    function calc_withdraw_one_coin(uint256 _burn_amount, int128 i)
+        external
+        view
+        returns (uint256);
+
+    function balances(uint256 i) external view returns (uint256);
+
+    function A() external view returns (uint256);
+}

package/contracts/interfaces/IERC4626.sol

@@ -30,7 +30,7 @@ interface IERC4626 is IERC20Metadata {
     function deposit(uint256 assets, address receiver) external returns (uint256);
 
     function redeem(
-        uint256 assets,
+        uint256 shares,
         address receiver,
         address owner
     ) external returns (uint256);

package/contracts/interfaces/ILooksFeeSharing.sol

@@ -0,0 +1,5 @@
+pragma solidity 0.8.17;
+
+interface ILooksFeeSharing {
+    function calculateSharesValueInLOOKS(address user) external view returns (uint256);
+}

package/contracts/interfaces/ILooksStaking.sol

@@ -0,0 +1,13 @@
+pragma solidity 0.8.17;
+
+interface ILooksStaking {
+    function totalShares() external view returns (uint256);
+
+    function deposit(uint256 amount) external;
+
+    function userInfo(address user) external view returns (uint256);
+
+    function withdraw(uint256 shares) external;
+
+    function harvestAndSellAndCompound() external;
+}

package/contracts/interfaces/IPActionAddRemoveLiq.sol

@@ -17,8 +17,8 @@ interface IPActionAddRemoveLiq {
     event AddLiquidityDualTokenAndPt(
         address indexed caller,
         address indexed market,
-        address indexed receiver,
-        address tokenIn,
+        address indexed tokenIn,
+        address receiver,
         uint256 netTokenUsed,
         uint256 netPtUsed,
         uint256 netLpOut
@@ -61,10 +61,10 @@ interface IPActionAddRemoveLiq {
     event RemoveLiquidityDualTokenAndPt(
         address indexed caller,
         address indexed market,
-        address indexed receiver,
+        address indexed tokenOut,
+        address receiver,
         uint256 netLpToRemove,
         uint256 netPtOut,
-        address tokenOut,
         uint256 netTokenOut
     );
 

package/contracts/interfaces/IPActionMintRedeem.sol

@@ -7,19 +7,19 @@ import "../router/kyberswap/KyberSwapHelper.sol";
 interface IPActionMintRedeem {
     event MintSyFromToken(
         address indexed caller,
-        address indexed receiver,
+        address indexed tokenIn,
         address indexed SY,
-        address tokenIn,
+        address receiver,
         uint256 netTokenIn,
         uint256 netSyOut
     );
 
     event RedeemSyToToken(
         address indexed caller,
-        address indexed receiver,
+        address indexed tokenOut,
         address indexed SY,
+        address receiver,
         uint256 netSyIn,
-        address tokenOut,
         uint256 netTokenOut
     );
 
@@ -41,19 +41,19 @@ interface IPActionMintRedeem {
 
     event MintPyFromToken(
         address indexed caller,
-        address indexed receiver,
+        address indexed tokenIn,
         address indexed YT,
-        address tokenIn,
+        address receiver,
         uint256 netTokenIn,
         uint256 netPyOut
     );
 
     event RedeemPyToToken(
         address indexed caller,
-        address indexed receiver,
+        address indexed tokenOut,
         address indexed YT,
+        address receiver,
         uint256 netPyIn,
-        address tokenOut,
         uint256 netTokenOut
     );
 

package/contracts/interfaces/IPActionSwapYT.sol

@@ -16,8 +16,8 @@ interface IPActionSwapYT {
     event SwapYtAndToken(
         address indexed caller,
         address indexed market,
-        address indexed receiver,
-        address token,
+        address indexed token,
+        address receiver,
         int256 netYtToAccount,
         int256 netTokenToAccount
     );

package/contracts/interfaces/IPMarket.sol

@@ -24,7 +24,13 @@ interface IPMarket is IERC20Metadata, IPGauge {
         uint256 netPtOut
     );
 
-    event Swap(address indexed receiver, int256 netPtOut, int256 netSyOut, uint256 netSyToReserve);
+    event Swap(
+        address indexed receiver,
+        int256 netPtOut,
+        int256 netSyOut,
+        uint256 netSyFee,
+        uint256 netSyToReserve
+    );
 
     event UpdateImpliedRate(uint256 indexed timestamp, uint256 lnLastImpliedRate);
 
@@ -55,17 +61,27 @@ interface IPMarket is IERC20Metadata, IPGauge {
         address receiver,
         uint256 exactPtIn,
         bytes calldata data
-    ) external returns (uint256 netSyOut, uint256 netSyToReserve);
+    )
+        external
+        returns (
+            uint256 netSyOut,
+            uint256 netSyFee
+        );
 
     function swapSyForExactPt(
         address receiver,
         uint256 exactPtOut,
         bytes calldata data
-    ) external returns (uint256 netSyIn, uint256 netSyToReserve);
+    )
+        external
+        returns (
+            uint256 netSyIn,
+            uint256 netSyFee
+        );
 
     function redeemRewards(address user) external returns (uint256[] memory);
 
-    function readState() external view returns (MarketState memory market);
+    function readState(address router) external view returns (MarketState memory market);
 
     function observe(uint32[] memory secondsAgos)
         external

package/contracts/interfaces/IPMarketFactory.sol

@@ -2,7 +2,19 @@
 pragma solidity 0.8.17;
 
 interface IPMarketFactory {
-    event NewMarketConfig(address indexed treasury, uint96 lnFeeRateRoot, uint8 reserveFeePercent);
+    struct FeeConfig {
+        uint80 lnFeeRateRoot;
+        uint8 reserveFeePercent;
+        bool active;
+    }
+
+    event NewMarketConfig(
+        address indexed treasury,
+        uint80 defaultLnFeeRateRoot,
+        uint8 reserveFeePercent
+    );
+    event SetOverriddenFee(address indexed router, uint80 lnFeeRateRoot, uint8 reserveFeePercent);
+    event UnsetOverriddenFee(address indexed router);
 
     event CreateNewMarket(
         address indexed market,
@@ -13,15 +25,13 @@ interface IPMarketFactory {
 
     function isValidMarket(address market) external view returns (bool);
 
-    function treasury() external view returns (address);
-
     // If this is changed, change the readState function in market as well
-    function marketConfig()
+    function getMarketConfig(address router)
         external
         view
         returns (
             address treasury,
-            uint88 lnFeeRateRoot,
+            uint80 lnFeeRateRoot,
             uint8 reserveFeePercent
         );
 }