@pendle/core-v2 0.2.3 → 0.4.0

package/contracts/libraries/math/MarketMathCore.sol

@@ -0,0 +1,423 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "./Math.sol";
+import "./LogExpMath.sol";
+import "../SCYIndex.sol";
+
+struct MarketState {
+    int256 totalOt;
+    int256 totalScy;
+    int256 totalLp;
+    uint256 oracleRate;
+    /// immutable variables ///
+    int256 scalarRoot;
+    uint256 feeRateRoot;
+    uint256 rateOracleTimeWindow;
+    uint256 expiry;
+    int256 reserveFeePercent; // base 100
+    /// last trade data ///
+    uint256 lastImpliedRate;
+    uint256 lastTradeTime;
+}
+
+// params that are expensive to compute, therefore we pre-compute them
+struct MarketPreCompute {
+    int256 rateScalar;
+    int256 totalAsset;
+    int256 rateAnchor;
+    int256 feeRate;
+}
+
+struct MarketStorage {
+    int128 totalOt;
+    int128 totalScy;
+    uint112 lastImpliedRate;
+    uint112 oracleRate;
+    uint32 lastTradeTime;
+}
+
+// solhint-disable ordering
+library MarketMathCore {
+    using Math for uint256;
+    using Math for int256;
+    using LogExpMath for int256;
+    using SCYIndexLib for SCYIndex;
+
+    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;
+
+    int256 internal constant MAX_MARKET_PROPORTION = (1e18 * 96) / 100;
+
+    function addLiquidityCore(
+        MarketState memory market,
+        SCYIndex index,
+        int256 scyDesired,
+        int256 otDesired,
+        bool updateState
+    )
+        internal
+        pure
+        returns (
+            int256 lpToReserve,
+            int256 lpToAccount,
+            int256 scyUsed,
+            int256 otUsed
+        )
+    {
+        /// ------------------------------------------------------------
+        /// CHECKS
+        /// ------------------------------------------------------------
+        require(scyDesired > 0 && otDesired > 0, "ZERO_AMOUNTS");
+
+        /// ------------------------------------------------------------
+        /// MATH
+        /// ------------------------------------------------------------
+        if (market.totalLp == 0) {
+            lpToAccount = index.scyToAsset(scyDesired).subNoNeg(MINIMUM_LIQUIDITY);
+            lpToReserve = MINIMUM_LIQUIDITY;
+            scyUsed = scyDesired;
+            otUsed = otDesired;
+        } else {
+            int256 netLpByOt = (otDesired * market.totalLp) / market.totalOt;
+            int256 netLpByScy = (scyDesired * market.totalLp) / market.totalScy;
+            if (netLpByOt < netLpByScy) {
+                lpToAccount = netLpByOt;
+                otUsed = otDesired;
+                scyUsed = (market.totalScy * lpToAccount) / market.totalLp;
+            } else {
+                lpToAccount = netLpByScy;
+                scyUsed = scyDesired;
+                otUsed = (market.totalOt * lpToAccount) / market.totalLp;
+            }
+        }
+
+        require(lpToAccount > 0, "INSUFFICIENT_LIQUIDITY_MINTED");
+
+        /// ------------------------------------------------------------
+        /// WRITE
+        /// ------------------------------------------------------------
+        if (updateState) {
+            market.totalScy += scyUsed;
+            market.totalOt += otUsed;
+            market.totalLp += lpToAccount + lpToReserve;
+        }
+    }
+
+    function removeLiquidityCore(
+        MarketState memory market,
+        int256 lpToRemove,
+        bool updateState
+    ) internal pure returns (int256 scyToAccount, int256 netOtToAccount) {
+        /// ------------------------------------------------------------
+        /// CHECKS
+        /// ------------------------------------------------------------
+        require(lpToRemove > 0, "invalid lp amount");
+
+        /// ------------------------------------------------------------
+        /// MATH
+        /// ------------------------------------------------------------
+        scyToAccount = (lpToRemove * market.totalScy) / market.totalLp;
+        netOtToAccount = (lpToRemove * market.totalOt) / market.totalLp;
+
+        /// ------------------------------------------------------------
+        /// WRITE
+        /// ------------------------------------------------------------
+        if (updateState) {
+            market.totalLp = market.totalLp.subNoNeg(lpToRemove);
+            market.totalOt = market.totalOt.subNoNeg(netOtToAccount);
+            market.totalScy = market.totalScy.subNoNeg(scyToAccount);
+        }
+    }
+
+    function executeTradeCore(
+        MarketState memory market,
+        SCYIndex index,
+        int256 netOtToAccount,
+        uint256 blockTime,
+        bool updateState
+    ) internal pure returns (int256 netScyToAccount, int256 netScyToReserve) {
+        /// ------------------------------------------------------------
+        /// CHECKS
+        /// ------------------------------------------------------------
+        require(blockTime < market.expiry, "market expired");
+        require(market.totalOt > netOtToAccount, "insufficient liquidity");
+
+        /// ------------------------------------------------------------
+        /// MATH
+        /// ------------------------------------------------------------
+        MarketPreCompute memory comp = getMarketPreCompute(market, index, blockTime);
+
+        (int256 netAssetToAccount, int256 netAssetToReserve) = calcTrade(
+            market,
+            comp,
+            netOtToAccount
+        );
+
+        netScyToAccount = index.assetToScy(netAssetToAccount);
+        netScyToReserve = index.assetToScy(netAssetToReserve);
+
+        /// ------------------------------------------------------------
+        /// WRITE
+        /// ------------------------------------------------------------
+        if (updateState) {
+            _setNewMarketStateTrade(
+                market,
+                comp,
+                index,
+                netOtToAccount,
+                netScyToAccount,
+                blockTime
+            );
+        }
+    }
+
+    function getMarketPreCompute(
+        MarketState memory market,
+        SCYIndex index,
+        uint256 blockTime
+    ) internal pure returns (MarketPreCompute memory res) {
+        require(blockTime < market.expiry, "market expired");
+
+        uint256 timeToExpiry = market.expiry - blockTime;
+
+        res.rateScalar = _getRateScalar(market, timeToExpiry);
+        res.totalAsset = index.scyToAsset(market.totalScy);
+
+        require(market.totalOt != 0 && res.totalAsset != 0, "invalid market state");
+
+        res.rateAnchor = _getRateAnchor(
+            market.totalOt,
+            market.lastImpliedRate,
+            res.totalAsset,
+            res.rateScalar,
+            timeToExpiry
+        );
+        res.feeRate = _getExchangeRateFromImpliedRate(market.feeRateRoot, timeToExpiry);
+    }
+
+    function calcTrade(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        int256 netOtToAccount
+    ) internal pure returns (int256 netAssetToAccount, int256 netAssetToReserve) {
+        int256 preFeeExchangeRate = _getExchangeRate(
+            market.totalOt,
+            comp.totalAsset,
+            comp.rateScalar,
+            comp.rateAnchor,
+            netOtToAccount
+        );
+
+        int256 preFeeAssetToAccount = netOtToAccount.divDown(preFeeExchangeRate).neg();
+        int256 fee = comp.feeRate;
+
+        if (netOtToAccount > 0) {
+            int256 postFeeExchangeRate = preFeeExchangeRate.divDown(fee);
+            require(postFeeExchangeRate >= Math.IONE, "exchange rate below 1");
+            fee = preFeeAssetToAccount.mulDown(Math.IONE - fee);
+        } else {
+            fee = ((preFeeAssetToAccount * (Math.IONE - fee)) / fee).neg();
+        }
+
+        netAssetToReserve = (fee * market.reserveFeePercent) / PERCENTAGE_DECIMALS;
+        netAssetToAccount = preFeeAssetToAccount - fee;
+        // netAssetToMarket = (preFeeAssetToAccount - fee + netAssetToReserve)
+        //     .neg();
+    }
+
+    function _setNewMarketStateTrade(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        SCYIndex index,
+        int256 netOtToAccount,
+        int256 netScyToAccount,
+        uint256 blockTime
+    ) internal pure {
+        uint256 timeToExpiry = market.expiry - blockTime;
+
+        market.lastTradeTime = blockTime;
+
+        market.totalOt = market.totalOt.subNoNeg(netOtToAccount);
+        market.totalScy = market.totalScy.subNoNeg(netScyToAccount);
+
+        market.lastImpliedRate = _getImpliedRate(
+            market.totalOt,
+            index.scyToAsset(market.totalScy),
+            comp.rateScalar,
+            comp.rateAnchor,
+            timeToExpiry
+        );
+        require(market.lastImpliedRate != 0, "zero impliedRate");
+    }
+
+    function _getRateAnchor(
+        int256 totalOt,
+        uint256 lastImpliedRate,
+        int256 totalAsset,
+        int256 rateScalar,
+        uint256 timeToExpiry
+    ) internal pure returns (int256 rateAnchor) {
+        // This is the exchange rate at the new time to expiry
+        int256 newExchangeRate = _getExchangeRateFromImpliedRate(lastImpliedRate, timeToExpiry);
+
+        require(newExchangeRate >= Math.IONE, "exchange rate below 1");
+
+        {
+            // totalOt / (totalOt + totalAsset)
+            int256 proportion = totalOt.divDown(totalOt + totalAsset);
+
+            int256 lnProportion = _logProportion(proportion);
+
+            // newExchangeRate - ln(proportion / (1 - proportion)) / rateScalar
+            rateAnchor = newExchangeRate - lnProportion.divDown(rateScalar);
+        }
+    }
+
+    /// @notice Calculates the current market implied rate.
+    /// @return impliedRate the implied rate
+    function _getImpliedRate(
+        int256 totalOt,
+        int256 totalAsset,
+        int256 rateScalar,
+        int256 rateAnchor,
+        uint256 timeToExpiry
+    ) internal pure returns (uint256 impliedRate) {
+        // This will check for exchange rates < Math.IONE
+        int256 exchangeRate = _getExchangeRate(totalOt, totalAsset, rateScalar, rateAnchor, 0);
+
+        // exchangeRate >= 1 so its ln >= 0
+        uint256 lnRate = exchangeRate.ln().Uint();
+
+        impliedRate = (lnRate * IMPLIED_RATE_TIME) / timeToExpiry;
+    }
+
+    /// @notice Converts an implied rate to an exchange rate given a time to expiry. The
+    /// formula is E = e^rt
+    function _getExchangeRateFromImpliedRate(uint256 impliedRate, uint256 timeToExpiry)
+        internal
+        pure
+        returns (int256 exchangeRate)
+    {
+        uint256 rt = (impliedRate * timeToExpiry) / IMPLIED_RATE_TIME;
+
+        exchangeRate = LogExpMath.exp(rt.Int());
+    }
+
+    /// @notice Returns the exchange rate between OT and Asset for the given market
+    /// Calculates the following exchange rate:
+    ///     (1 / rateScalar) * ln(proportion / (1 - proportion)) + rateAnchor
+    /// where:
+    ///     proportion = totalOt / (totalOt + totalUnderlyingAsset)
+    function _getExchangeRate(
+        int256 totalOt,
+        int256 totalAsset,
+        int256 rateScalar,
+        int256 rateAnchor,
+        int256 netOtToAccount
+    ) internal pure returns (int256 exchangeRate) {
+        int256 numerator = totalOt.subNoNeg(netOtToAccount);
+
+        // This is the proportion scaled by Math.IONE
+        // (totalOt - netOtToAccount) / (totalOt + totalAsset)
+        int256 proportion = (numerator.divDown(totalOt + totalAsset));
+
+        // This limit is here to prevent the market from reaching extremely high interest rates via an
+        // excessively large proportion (high amounts of OT relative to Asset).
+        // Market proportion can only increase via swapping OT to SCY (OT is added to the market and SCY is
+        // removed). Over time, the yield from SCY will slightly decrease the proportion (the
+        // amount of Asset in the market must be monotonically increasing). Therefore it is not
+        // possible for the proportion to go over max market proportion unless borrowing occurs.
+        require(proportion <= MAX_MARKET_PROPORTION, "max proportion exceeded");
+
+        int256 lnProportion = _logProportion(proportion);
+
+        // lnProportion / rateScalar + rateAnchor
+        exchangeRate = lnProportion.divDown(rateScalar) + rateAnchor;
+
+        // Do not succeed if interest rates fall below 1
+        require(exchangeRate >= Math.IONE, "exchange rate below 1");
+    }
+
+    function _logProportion(int256 proportion) internal pure returns (int256 res) {
+        // This will result in divide by zero, short circuit
+        require(proportion != Math.IONE, "proportion must not be one");
+
+        // Convert proportion to what is used inside the logit function (p / (1-p))
+        int256 logitP = proportion.divDown(Math.IONE - proportion);
+
+        res = logitP.ln();
+    }
+
+    function _getRateScalar(MarketState memory market, uint256 timeToExpiry)
+        internal
+        pure
+        returns (int256 rateScalar)
+    {
+        rateScalar = (market.scalarRoot * IMPLIED_RATE_TIME.Int()) / timeToExpiry.Int();
+        require(rateScalar > 0, "rateScalar underflow");
+    }
+
+    function setInitialImpliedRate(
+        MarketState memory market,
+        SCYIndex index,
+        int256 initialAnchor,
+        uint256 blockTime
+    ) internal pure {
+        /// ------------------------------------------------------------
+        /// CHECKS
+        /// ------------------------------------------------------------
+        require(blockTime < market.expiry, "market expired");
+
+        /// ------------------------------------------------------------
+        /// MATH
+        /// ------------------------------------------------------------
+        int256 totalAsset = index.scyToAsset(market.totalScy);
+        uint256 timeToExpiry = market.expiry - blockTime;
+        int256 rateScalar = _getRateScalar(market, timeToExpiry);
+
+        /// ------------------------------------------------------------
+        /// WRITE
+        /// ------------------------------------------------------------
+        market.lastImpliedRate = _getImpliedRate(
+            market.totalOt,
+            totalAsset,
+            rateScalar,
+            initialAnchor,
+            market.expiry - blockTime
+        );
+    }
+
+    function updateNewRateOracle(MarketState memory market, uint256 blockTime)
+        internal
+        pure
+        returns (uint256)
+    {
+        // This can occur when using a view function get to a market state in the past
+        if (market.lastTradeTime > blockTime) {
+            market.oracleRate = market.lastImpliedRate;
+            return market.oracleRate;
+        }
+
+        uint256 timeDiff = blockTime - market.lastTradeTime;
+        if (timeDiff > market.rateOracleTimeWindow) {
+            // If past the time window just return the market.lastImpliedRate
+            market.oracleRate = market.lastImpliedRate;
+            return market.oracleRate;
+        }
+
+        // (currentTs - previousTs) / timeWindow
+        uint256 lastTradeWeight = timeDiff.divDown(market.rateOracleTimeWindow);
+
+        // 1 - (currentTs - previousTs) / timeWindow
+        uint256 oracleWeight = Math.ONE - lastTradeWeight;
+
+        uint256 newOracleRate = market.lastTradeTime.mulDown(lastTradeWeight) +
+            market.oracleRate.mulDown(oracleWeight);
+
+        market.oracleRate = newOracleRate;
+        return market.oracleRate;
+    }
+}

package/contracts/libraries/math/Math.sol

@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// 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";
+
+/* solhint-disable private-vars-leading-underscore, reason-string */
+
+library Math {
+    uint256 internal constant ONE = 1e18; // 18 decimal places
+    int256 internal constant IONE = 1e18; // 18 decimal places
+
+    uint256 internal constant MAX_POW_RELATIVE_ERROR = 10000; // 10^(-14)
+
+    function subMax0(uint256 a, uint256 b) internal pure returns (uint256) {
+        unchecked {
+            return (a >= b ? a - b : 0);
+        }
+    }
+
+    function subNoNeg(int256 a, int256 b) internal pure returns (int256) {
+        require(a >= b, "NEGATIVE");
+        unchecked {
+            return a - b;
+        }
+    }
+
+    function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 product = a * b;
+        unchecked {
+            return product / ONE;
+        }
+    }
+
+    function mulDown(int256 a, int256 b) internal pure returns (int256) {
+        int256 product = a * b;
+        unchecked {
+            return product / IONE;
+        }
+    }
+
+    function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 aInflated = a * ONE;
+        unchecked {
+            return aInflated / b;
+        }
+    }
+
+    function divDown(int256 a, int256 b) internal pure returns (int256) {
+        int256 aInflated = a * IONE;
+        unchecked {
+            return aInflated / b;
+        }
+    }
+
+    function abs(int256 x) internal pure returns (uint256) {
+        return uint256(x > 0 ? x : -x);
+    }
+
+    function neg(int256 x) internal pure returns (int256) {
+        return -x;
+    }
+
+    function neg(uint256 x) internal pure returns (int256) {
+        return -Int(x);
+    }
+
+    function max(uint256 x, uint256 y) internal pure returns (uint256) {
+        return (x > y ? x : y);
+    }
+
+    function max(int256 x, int256 y) internal pure returns (int256) {
+        return (x > y ? x : y);
+    }
+
+    function min(uint256 x, uint256 y) internal pure returns (uint256) {
+        return (x < y ? x : y);
+    }
+
+    function min(int256 x, int256 y) internal pure returns (int256) {
+        return (x < y ? x : y);
+    }
+
+    function Uint(int256 x) internal pure returns (uint256) {
+        require(x >= 0);
+        return uint256(x);
+    }
+
+    function Int(uint256 x) internal pure returns (int256) {
+        require(x < (1 << 255)); // signed, lim = bit-1
+        return int256(x);
+    }
+
+    function Int128(int256 x) internal pure returns (int128) {
+        require(x < (1 << 127)); // signed, lim = bit-1
+        return int128(x);
+    }
+
+    function Uint32(uint256 x) internal pure returns (uint32) {
+        require(x < (1 << 32)); // unsigned, lim = bit
+        return uint32(x);
+    }
+
+    function Uint112(uint256 x) internal pure returns (uint112) {
+        require(x < (1 << 112)); // unsigned, lim = bit
+        return uint112(x);
+    }
+
+    function isAApproxB(
+        uint256 a,
+        uint256 b,
+        uint256 eps
+    ) internal pure returns (bool) {
+        return (isAGreaterApproxB(a, b, eps) || isASmallerApproxB(a, b, eps));
+    }
+
+    function isAGreaterApproxB(
+        uint256 a,
+        uint256 b,
+        uint256 eps
+    ) internal pure returns (bool) {
+        return a >= b && a <= mulDown(b, Math.ONE + eps);
+    }
+
+    function isASmallerApproxB(
+        uint256 a,
+        uint256 b,
+        uint256 eps
+    ) internal pure returns (bool) {
+        return a <= b && a >= mulDown(b, Math.ONE - eps);
+    }
+}

package/contracts/{core/misc → periphery}/PendleJoeSwapHelperUpg.sol

@@ -22,8 +22,8 @@
  */
 
 pragma solidity 0.8.9;
-import "../../interfaces/IJoeRouter01.sol";
-import "../../libraries/JoeLibrary.sol";
+import "../interfaces/IJoeRouter01.sol";
+import "../libraries/JoeLibrary.sol";
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 

package/contracts/periphery/{PermissionsV2.sol → PermissionsV2Upg.sol}

@@ -2,9 +2,9 @@
 pragma solidity 0.8.9;
 
 import "../interfaces/IPGovernanceManager.sol";
-import "../interfaces/IPPermissionsV2.sol";
+import "../interfaces/IPPermissionsV2Upg.sol";
 
-abstract contract PermissionsV2 is IPermissionsV2 {
+abstract contract PermissionsV2Upg is IPermissionsV2Upg {
     address public immutable governanceManager;
 
     modifier onlyGovernance() {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.2.3",
+  "version": "0.4.0",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/IPMarket.ts

@@ -22,7 +22,7 @@ import type {
   OnEvent,
 } from "./common";
 
-export type MarketParametersStruct = {
+export type MarketStateStruct = {
   totalOt: BigNumberish;
   totalScy: BigNumberish;
   totalLp: BigNumberish;
@@ -36,7 +36,7 @@ export type MarketParametersStruct = {
   lastTradeTime: BigNumberish;
 };
 
-export type MarketParametersStructOutput = [
+export type MarketStateStructOutput = [
   BigNumber,
   BigNumber,
   BigNumber,
@@ -76,7 +76,7 @@ export interface IPMarketInterface extends utils.Interface {
     "expiry()": FunctionFragment;
     "isExpired()": FunctionFragment;
     "name()": FunctionFragment;
-    "readState()": FunctionFragment;
+    "readState(bool)": FunctionFragment;
     "readTokens()": FunctionFragment;
     "removeLiquidity(address,uint256,bytes)": FunctionFragment;
     "swapExactOtForScy(address,uint256,uint256,bytes)": FunctionFragment;
@@ -107,7 +107,7 @@ export interface IPMarketInterface extends utils.Interface {
   encodeFunctionData(functionFragment: "expiry", values?: undefined): string;
   encodeFunctionData(functionFragment: "isExpired", values?: undefined): string;
   encodeFunctionData(functionFragment: "name", values?: undefined): string;
-  encodeFunctionData(functionFragment: "readState", values?: undefined): string;
+  encodeFunctionData(functionFragment: "readState", values: [boolean]): string;
   encodeFunctionData(
     functionFragment: "readTokens",
     values?: undefined
@@ -265,10 +265,9 @@ export interface IPMarket extends BaseContract {
     name(overrides?: CallOverrides): Promise<[string]>;
 
     readState(
+      updateRateOracle: boolean,
       overrides?: CallOverrides
-    ): Promise<
-      [MarketParametersStructOutput] & { market: MarketParametersStructOutput }
-    >;
+    ): Promise<[MarketStateStructOutput] & { market: MarketStateStructOutput }>;
 
     readTokens(
       overrides?: CallOverrides
@@ -353,7 +352,10 @@ export interface IPMarket extends BaseContract {
 
   name(overrides?: CallOverrides): Promise<string>;
 
-  readState(overrides?: CallOverrides): Promise<MarketParametersStructOutput>;
+  readState(
+    updateRateOracle: boolean,
+    overrides?: CallOverrides
+  ): Promise<MarketStateStructOutput>;
 
   readTokens(
     overrides?: CallOverrides
@@ -444,7 +446,10 @@ export interface IPMarket extends BaseContract {
 
     name(overrides?: CallOverrides): Promise<string>;
 
-    readState(overrides?: CallOverrides): Promise<MarketParametersStructOutput>;
+    readState(
+      updateRateOracle: boolean,
+      overrides?: CallOverrides
+    ): Promise<MarketStateStructOutput>;
 
     readTokens(
       overrides?: CallOverrides
@@ -569,7 +574,10 @@ export interface IPMarket extends BaseContract {
 
     name(overrides?: CallOverrides): Promise<BigNumber>;
 
-    readState(overrides?: CallOverrides): Promise<BigNumber>;
+    readState(
+      updateRateOracle: boolean,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
 
     readTokens(overrides?: CallOverrides): Promise<BigNumber>;
 
@@ -654,7 +662,10 @@ export interface IPMarket extends BaseContract {
 
     name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    readState(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    readState(
+      updateRateOracle: boolean,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
 
     readTokens(overrides?: CallOverrides): Promise<PopulatedTransaction>;