Comparer le texte

Trouver la différence entre deux fichiers texte

Affichage

Vue

Éditeur liveMasquer les espacesCacher identiquesSans retour à la ligne

Niveau de précision

Syntaxe

Traitement

Diffchecker Desktop La façon la plus sécurisée d'utiliser Diffchecker. Obtenez l'application Diffchecker Desktop : vos diffs ne quittent jamais votre ordinateur !Obtenir Desktop

LRTOracle

Créé il y a 12 moisLe diff n'expire jamais

68 suppressions

Lignes
Total
Supprimé

Caractères
Total
Supprimé

Pour continuer à utiliser cette fonctionnalité, passez à Diffchecker Pro Voir les prix

215 lignes

180 ajouts

Lignes
Total
Ajouté

Caractères
Total
Ajouté

Pour continuer à utiliser cette fonctionnalité, passez à Diffchecker Pro Voir les prix

317 lignes

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.27;

import { UtilLib } from "./utils/UtilLib.sol";

import { LRTConstants } from "./utils/LRTConstants.sol";

import { LRTConfigRoleChecker, ILRTConfig } from "./utils/LRTConfigRoleChecker.sol";

import { WadMath } from "./utils/WadMath.sol";

import { IRSETH } from "./interfaces/IRSETH.sol";

import { IPriceFetcher } from "./interfaces/IPriceFetcher.sol";

import { ILRTOracle } from "./interfaces/ILRTOracle.sol";

import { ILRTDepositPool } from "./interfaces/ILRTDepositPool.sol";

import { IAccessControl } from "@openzeppelin/contracts/access/IAccessControl.sol";

import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

interface IPausable {

function pause() external;

function paused() external view returns (bool);

}

/// @title LRTOracle Contract

/// @notice oracle contract that calculates the exchange rate of assets

contract LRTOracle is ILRTOracle, LRTConfigRoleChecker, Initializable {

using WadMath for uint256;

mapping(address asset => address priceOracle) public override assetPriceOracle;

uint256 public override rsETHPrice;

uint256 public pricePercentageLimit;

uint256 public highestRsethPrice;

// legacy variables

// Daily fee minting limit variables

uint256 public legacy_cooldownPeriodInTimestamp;

uint256 public currentPeriodMintedFeeAmount;

uint256 public legacy_lastUpdatedCoolDownTimestamp;

uint256 public feePeriodStartTime;

uint256 public maxFeeMintAmountPerDay;

/// @notice New variable added for pausable functionality

bool public paused;

modifier onlySupportedOracle(address asset) {

if (assetPriceOracle[asset] == address(0)) {

revert AssetOracleNotSupported();

}

modifier whenNotPaused() {

if (paused) revert ContractPaused();

}

modifier whenPaused() {

if (!paused) revert ContractNotPaused();

}

/// @custom:oz-upgrades-unsafe-allow constructor

constructor() {

_disableInitializers();

}

/// @dev Initializes the contract

/// @param lrtConfigAddr LRT config address

function initialize(address lrtConfigAddr) external initializer {

UtilLib.checkNonZeroAddress(lrtConfigAddr);

lrtConfig = ILRTConfig(lrtConfigAddr);

emit UpdatedLRTConfig(lrtConfigAddr);

}

/*//////////////////////////////////////////////////////////////

write functions

//////////////////////////////////////////////////////////////*/

/// @notice updates RSETH/ETH exchange rate

/// @dev calculates based on stakedAsset value received from eigen layer

/// @dev calculates rsETH price based on stakedAsset value received from EigenLayer

function updateRSETHPrice() public {

function updateRSETHPrice() public whenNotPaused {

_updateRsETHPrice();

}

/// @dev update rsETH price as an manager account

/// @dev main benefit is to be able to update the price in case of the price going above the threshold

/// @dev only LRT manager is allowed to call this function

function updateRSETHPriceAsManager() external onlyLRTManager {

_updateRsETHPrice();

}

/// @dev add/update the price oracle of any asset

/// @dev only onlyLRTAdmin is allowed

/// @param asset asset address for which oracle price needs to be added/updated

function updatePriceOracleForValidated(address asset, address priceOracle) external onlyLRTAdmin {

// Sanity check: oracle price must have precision between 1e16 and 1e19

uint256 price = IPriceFetcher(priceOracle).getAssetPrice(asset);

if (price > 1e19 || price < 1e16) {

revert InvalidPriceOracle();

}

updatePriceOracleFor(asset, priceOracle);

}

/// @dev add/update the price oracle of any asset

/// @dev only onlyLRTAdmin is allowed

/// @param asset asset address for which oracle price needs to be added/updated

function updatePriceOracleFor(address asset, address priceOracle) public onlyLRTAdmin {

if (lrtConfig.isSupportedAsset(asset)) {

UtilLib.checkNonZeroAddress(priceOracle);

}

Text moved from lines 168-180

assetPriceOracle[asset] = priceOracle;

emit AssetPriceOracleUpdate(asset, priceOracle);

}

/// @dev set the price percentage limit. Only onlyLRTAdmin is allowed

/// @dev PricePercentageLimit for 1% is 1e16

/// @dev Price Percentage Limit for 100% is 1e18

/// @param _pricePercentageLimit price percentage limit

function setPricePercentageLimit(uint256 _pricePercentageLimit) external onlyLRTAdmin {

pricePercentageLimit = _pricePercentageLimit;

emit PricePercentageLimitUpdate(_pricePercentageLimit);

}

/// @dev set the maximum fee minting amount per day. Only onlyLRTManager is allowed

/// @param _maxFeeMintAmountPerDay maximum amount of fee that can be minted per day

function setMaxFeeMintAmountPerDay(uint256 _maxFeeMintAmountPerDay) external onlyLRTManager {

maxFeeMintAmountPerDay = _maxFeeMintAmountPerDay;

emit MaxFeeMintAmountPerDayUpdated(_maxFeeMintAmountPerDay);

}

/// @dev Pauses the pausable methods in the contract

function pause() external onlyLRTManager whenNotPaused {

_pause();

}

/// @dev Unpauses the pausable methods in the contract

function unpause() external onlyLRTAdmin whenPaused {

paused = false;

emit Unpaused(msg.sender);

}

/*//////////////////////////////////////////////////////////////

view functions

//////////////////////////////////////////////////////////////*/

/// @notice Provides Asset/ETH exchange rate

/// @dev reads from priceFetcher interface which may fetch price from any supported oracle

/// @param asset the asset for which exchange rate is required

/// @return assetPrice exchange rate of asset

function getAssetPrice(address asset) public view onlySupportedOracle(asset) returns (uint256) {

return IPriceFetcher(assetPriceOracle[asset]).getAssetPrice(asset);

}

/*//////////////////////////////////////////////////////////////

internal functions

//////////////////////////////////////////////////////////////*/

/// @dev Checks and updates daily fee minting limits

/// @param feeAmount The amount of fee to be minted

function _checkAndUpdateDailyFeeMintLimit(uint256 feeAmount) internal {

// Reset or initialize the period if it's unset or a day has passed

if (feePeriodStartTime == 0 || block.timestamp >= feePeriodStartTime + 1 days) {

currentPeriodMintedFeeAmount = 0;

feePeriodStartTime = block.timestamp;

}

// Check if minting would exceed the daily limit

if (currentPeriodMintedFeeAmount + feeAmount > maxFeeMintAmountPerDay) {

revert DailyFeeMintLimitExceeded(currentPeriodMintedFeeAmount + feeAmount, maxFeeMintAmountPerDay);

}

currentPeriodMintedFeeAmount += feeAmount;

}

/// @dev Internal function to update rsETH price

// solhint-disable-next-line code-complexity

function _updateRsETHPrice() internal {

address rsETHTokenAddress = lrtConfig.rsETH();

uint256 rsethSupply = IRSETH(rsETHTokenAddress).totalSupply();

if (rsethSupply == 0) {

rsETHPrice = 1 ether;

highestRsethPrice = 1 ether;

return;

}

if (highestRsethPrice == 0) {

highestRsethPrice = rsETHPrice;

}

uint256 previousPrice = rsETHPrice;

// get total ETH in the protocol

// get total ETH in the protocol (normalized to 1e18)

uint256 totalETHInProtocol = _getTotalEthInProtocol();

// calculate previousTVL using rsethSupply multiplied by rsETHPrice

uint256 previousTVL = rsethSupply * rsETHPrice;

uint256 previousTVL = rsethSupply.mulWad(rsETHPrice);

// only take fee if TVL increased

IPausable lrtDepositPool = IPausable(lrtConfig.getContract(LRTConstants.LRT_DEPOSIT_POOL));

IPausable withdrawalManager = IPausable(lrtConfig.getContract(LRTConstants.LRT_WITHDRAW_MANAGER));

// determine if the protocol is active (not paused)

bool protocolPaused = lrtDepositPool.paused() || withdrawalManager.paused() || paused;

// only take fee if TVL increased and protocol is not paused

uint256 protocolFeeInETH = 0;

if (totalETHInProtocol > previousTVL) {

if (!protocolPaused && totalETHInProtocol > previousTVL) {

uint256 rewardAmount = totalETHInProtocol - previousTVL;

protocolFeeInETH = (rewardAmount * lrtConfig.protocolFeeInBPS()) / 10_000;

}

// compute new rsETH price based on total ETH minus fee

uint256 newRsETHPrice = (totalETHInProtocol - protocolFeeInETH) / rsethSupply;

uint256 newRsETHPrice = (totalETHInProtocol - protocolFeeInETH).divWad(rsethSupply);

if (newRsETHPrice > highestRsethPrice) {

// check if the price is above the threshold

uint256 priceDifference = newRsETHPrice - highestRsethPrice;

// pricePercentageLimit is in 1e18 precision (100% = 1e18, 1% = 1e16)

bool isPriceIncreaseOffLimit =

pricePercentageLimit > 0 && priceDifference > (pricePercentageLimit * highestRsethPrice) / 1e18;

pricePercentageLimit > 0 && priceDifference > pricePercentageLimit.mulWad(highestRsethPrice);

// check if the price difference is above the threshold

if (isPriceIncreaseOffLimit) {

// if sender has a manager role, this doesn't revert.

Différences enregistrées

Texte d'origine

Ouvrir un fichier

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.27;

import { UtilLib } from "./utils/UtilLib.sol";
import { LRTConstants } from "./utils/LRTConstants.sol";
import { LRTConfigRoleChecker, ILRTConfig } from "./utils/LRTConfigRoleChecker.sol";

import { IRSETH } from "./interfaces/IRSETH.sol";
import { IPriceFetcher } from "./interfaces/IPriceFetcher.sol";
import { ILRTOracle } from "./interfaces/ILRTOracle.sol";
import { ILRTDepositPool } from "./interfaces/ILRTDepositPool.sol";
import { IAccessControl } from "@openzeppelin/contracts/access/IAccessControl.sol";
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

interface IPausable {
    function pause() external;
}

/// @title LRTOracle Contract
/// @notice oracle contract that calculates the exchange rate of assets
contract LRTOracle is ILRTOracle, LRTConfigRoleChecker, Initializable {
    mapping(address asset => address priceOracle) public override assetPriceOracle;

uint256 public override rsETHPrice;
    uint256 public pricePercentageLimit;
    uint256 public highestRsethPrice;

// legacy variables
    uint256 public legacy_cooldownPeriodInTimestamp;
    uint256 public legacy_lastUpdatedCoolDownTimestamp;

modifier onlySupportedOracle(address asset) {
        if (assetPriceOracle[asset] == address(0)) {
            revert AssetOracleNotSupported();
        }
        _;
    }

/// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }

/// @dev Initializes the contract
    /// @param lrtConfigAddr LRT config address
    function initialize(address lrtConfigAddr) external initializer {
        UtilLib.checkNonZeroAddress(lrtConfigAddr);
        lrtConfig = ILRTConfig(lrtConfigAddr);
        emit UpdatedLRTConfig(lrtConfigAddr);
    }

/*//////////////////////////////////////////////////////////////
                            write functions
    //////////////////////////////////////////////////////////////*/

/// @notice updates RSETH/ETH exchange rate
    /// @dev calculates based on stakedAsset value received from eigen layer
    function updateRSETHPrice() public {
        address rsETHTokenAddress = lrtConfig.rsETH();
        uint256 rsethSupply = IRSETH(rsETHTokenAddress).totalSupply();

if (rsethSupply == 0) {
            rsETHPrice = 1 ether;
            highestRsethPrice = 1 ether;
            return;
        }

if (highestRsethPrice == 0) {
            highestRsethPrice = rsETHPrice;
        }

uint256 previousPrice = rsETHPrice;

// get total ETH in the protocol
        uint256 totalETHInProtocol = _getTotalEthInProtocol();

// calculate previousTVL using rsethSupply multiplied by rsETHPrice
        uint256 previousTVL = rsethSupply * rsETHPrice;

// only take fee if TVL increased
        uint256 protocolFeeInETH = 0;
        if (totalETHInProtocol > previousTVL) {
            uint256 rewardAmount = totalETHInProtocol - previousTVL;
            protocolFeeInETH = (rewardAmount * lrtConfig.protocolFeeInBPS()) / 10_000;
        }

// compute new rsETH price based on total ETH minus fee
        uint256 newRsETHPrice = (totalETHInProtocol - protocolFeeInETH) / rsethSupply;

if (newRsETHPrice > highestRsethPrice) {
            // check if the price is above the threshold
            uint256 priceDifference = newRsETHPrice - highestRsethPrice;
            bool isPriceIncreaseOffLimit =
                pricePercentageLimit > 0 && priceDifference > (pricePercentageLimit * highestRsethPrice) / 1e18;

// check if the price difference is above the threshold
            if (isPriceIncreaseOffLimit) {
                // if sender has a manager role, this doesn't revert.
                // if not, it reverts as price went above the threshold
                if (!IAccessControl(address(lrtConfig)).hasRole(LRTConstants.MANAGER, msg.sender)) {
                    revert PriceAboveDailyThreshold();
                }
            }
        }

// downside protection — pause if price drops too far
        if (newRsETHPrice < highestRsethPrice) {
            uint256 diff = highestRsethPrice - newRsETHPrice;
            bool isPriceDecreaseOffLimit =
                pricePercentageLimit > 0 && diff > (pricePercentageLimit * highestRsethPrice) / 1e18;

emit RsETHPriceDecrease(highestRsethPrice, newRsETHPrice);

if (isPriceDecreaseOffLimit) {
                IPausable lrtDepositPool = IPausable(lrtConfig.getContract(LRTConstants.LRT_DEPOSIT_POOL));
                IPausable withdrawalManager = IPausable(lrtConfig.getContract(LRTConstants.LRT_WITHDRAW_MANAGER));
                lrtDepositPool.pause();
                withdrawalManager.pause();
                return;
            }
        }

// update highest price if new price exceeds it
        if (newRsETHPrice > highestRsethPrice) {
            highestRsethPrice = newRsETHPrice;
        }

// mint protocol fee as rsETH if there's a fee to take
        if (protocolFeeInETH > 0) {
            uint256 rsethAmountToMintAsProtocolFee = protocolFeeInETH / newRsETHPrice;

if (rsethAmountToMintAsProtocolFee > 0) {
                address treasury = lrtConfig.getContract(LRTConstants.PROTOCOL_TREASURY);
                IRSETH(rsETHTokenAddress).mint(treasury, rsethAmountToMintAsProtocolFee);
                emit FeeMinted(treasury, rsethAmountToMintAsProtocolFee);
            }
        }

rsETHPrice = newRsETHPrice;

emit RsETHPriceUpdate(rsETHPrice, previousPrice);
    }

/// @dev update rseth price as an manager account
    /// @dev main benefit is to be able to update the price in case of the price going above the threshold
    /// @dev only onlyLRTManager is allowed
    function updateRSETHPriceAsManager() external onlyLRTManager {
        updateRSETHPrice();
    }

/// @dev add/update the price oracle of any asset
    /// @dev only onlyLRTAdmin is allowed
    /// @param asset asset address for which oracle price needs to be added/updated
    function updatePriceOracleForValidated(address asset, address priceOracle) external onlyLRTAdmin {
        //sanity check that oracle has 1e18 precision
        uint256 price = IPriceFetcher(priceOracle).getAssetPrice(asset);
        if (price > 1e19 || price < 1e18) {
            revert InvalidPriceOracle();
        }
        updatePriceOracleFor(asset, priceOracle);
    }

/// @dev add/update the price oracle of any asset
    /// @dev only onlyLRTAdmin is allowed
    /// @param asset asset address for which oracle price needs to be added/updated
    function updatePriceOracleFor(address asset, address priceOracle) public onlyLRTAdmin {
        UtilLib.checkNonZeroAddress(priceOracle);
        assetPriceOracle[asset] = priceOracle;
        emit AssetPriceOracleUpdate(asset, priceOracle);
    }

/// @dev set the price percentage limit. Only onlyLRTAdmin is allowed
    /// @dev PricePercentageLimit for 1% is 1e16
    /// @dev Price Percentage Limit for 100% is 1e18
    /// @param _pricePercentageLimit price percentage limit
    function setPricePercentageLimit(uint256 _pricePercentageLimit) external onlyLRTAdmin {
        pricePercentageLimit = _pricePercentageLimit;
        emit PricePercentageLimitUpdate(_pricePercentageLimit);
    }

/*//////////////////////////////////////////////////////////////
                            view functions
    //////////////////////////////////////////////////////////////*/

/// @notice Provides Asset/ETH exchange rate
    /// @dev reads from priceFetcher interface which may fetch price from any supported oracle
    /// @param asset the asset for which exchange rate is required
    /// @return assetPrice exchange rate of asset
    function getAssetPrice(address asset) public view onlySupportedOracle(asset) returns (uint256) {
        return IPriceFetcher(assetPriceOracle[asset]).getAssetPrice(asset);
    }

/*//////////////////////////////////////////////////////////////
                            private functions
    //////////////////////////////////////////////////////////////*/

/// @notice get total ETH in protocol
    /// @return totalETHInProtocol total ETH in protocol
    function _getTotalEthInProtocol() private view returns (uint256 totalETHInProtocol) {
        address lrtDepositPoolAddr = lrtConfig.getContract(LRTConstants.LRT_DEPOSIT_POOL);
        address[] memory supportedAssets = lrtConfig.getSupportedAssetList();
        uint256 supportedAssetCount = supportedAssets.length;

for (uint16 assetIdx; assetIdx < supportedAssetCount;) {
            address asset = supportedAssets[assetIdx];
            uint256 assetER = getAssetPrice(asset);
            uint256 totalAssetAmt = ILRTDepositPool(lrtDepositPoolAddr).getTotalAssetDeposits(asset);
            totalETHInProtocol += totalAssetAmt * assetER;

unchecked {
                ++assetIdx;
            }
        }
    }
}

Texte modifié

Ouvrir un fichier

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.27;

import { UtilLib } from "./utils/UtilLib.sol";
import { LRTConstants } from "./utils/LRTConstants.sol";
import { LRTConfigRoleChecker, ILRTConfig } from "./utils/LRTConfigRoleChecker.sol";
import { WadMath } from "./utils/WadMath.sol";

interface IPausable {
    function pause() external;
    function paused() external view returns (bool);
}

mapping(address asset => address priceOracle) public override assetPriceOracle;

uint256 public override rsETHPrice;
    uint256 public pricePercentageLimit;
    uint256 public highestRsethPrice;

// Daily fee minting limit variables
    uint256 public currentPeriodMintedFeeAmount;
    uint256 public feePeriodStartTime;
    uint256 public maxFeeMintAmountPerDay;

/// @notice New variable added for pausable functionality
    bool public paused;

modifier onlySupportedOracle(address asset) {
        if (assetPriceOracle[asset] == address(0)) {
            revert AssetOracleNotSupported();
        }
        _;
    }

modifier whenNotPaused() {
        if (paused) revert ContractPaused();
        _;
    }

modifier whenPaused() {
        if (!paused) revert ContractNotPaused();
        _;
    }

/// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }

/*//////////////////////////////////////////////////////////////
                            write functions
    //////////////////////////////////////////////////////////////*/

/// @notice updates RSETH/ETH exchange rate
    /// @dev calculates rsETH price based on stakedAsset value received from EigenLayer
    function updateRSETHPrice() public whenNotPaused {
        _updateRsETHPrice();
    }

/// @dev update rsETH price as an manager account
    /// @dev main benefit is to be able to update the price in case of the price going above the threshold
    /// @dev only LRT manager is allowed to call this function
    function updateRSETHPriceAsManager() external onlyLRTManager {
        _updateRsETHPrice();
    }

/// @dev add/update the price oracle of any asset
    /// @dev only onlyLRTAdmin is allowed
    /// @param asset asset address for which oracle price needs to be added/updated
    function updatePriceOracleForValidated(address asset, address priceOracle) external onlyLRTAdmin {
        // Sanity check: oracle price must have precision between 1e16 and 1e19
        uint256 price = IPriceFetcher(priceOracle).getAssetPrice(asset);
        if (price > 1e19 || price < 1e16) {
            revert InvalidPriceOracle();
        }
        updatePriceOracleFor(asset, priceOracle);
    }

/// @dev add/update the price oracle of any asset
    /// @dev only onlyLRTAdmin is allowed
    /// @param asset asset address for which oracle price needs to be added/updated
    function updatePriceOracleFor(address asset, address priceOracle) public onlyLRTAdmin {
        if (lrtConfig.isSupportedAsset(asset)) {
            UtilLib.checkNonZeroAddress(priceOracle);
        }
        assetPriceOracle[asset] = priceOracle;
        emit AssetPriceOracleUpdate(asset, priceOracle);
    }

/// @dev set the maximum fee minting amount per day. Only onlyLRTManager is allowed
    /// @param _maxFeeMintAmountPerDay maximum amount of fee that can be minted per day
    function setMaxFeeMintAmountPerDay(uint256 _maxFeeMintAmountPerDay) external onlyLRTManager {
        maxFeeMintAmountPerDay = _maxFeeMintAmountPerDay;
        emit MaxFeeMintAmountPerDayUpdated(_maxFeeMintAmountPerDay);
    }

/// @dev Pauses the pausable methods in the contract
    function pause() external onlyLRTManager whenNotPaused {
        _pause();
    }

/// @dev Unpauses the pausable methods in the contract
    function unpause() external onlyLRTAdmin whenPaused {
        paused = false;
        emit Unpaused(msg.sender);
    }

/*//////////////////////////////////////////////////////////////
                            view functions
    //////////////////////////////////////////////////////////////*/

/*//////////////////////////////////////////////////////////////
                            internal functions
    //////////////////////////////////////////////////////////////*/

/// @dev Checks and updates daily fee minting limits
    /// @param feeAmount The amount of fee to be minted
    function _checkAndUpdateDailyFeeMintLimit(uint256 feeAmount) internal {
        // Reset or initialize the period if it's unset or a day has passed
        if (feePeriodStartTime == 0 || block.timestamp >= feePeriodStartTime + 1 days) {
            currentPeriodMintedFeeAmount = 0;
            feePeriodStartTime = block.timestamp;
        }

// Check if minting would exceed the daily limit
        if (currentPeriodMintedFeeAmount + feeAmount > maxFeeMintAmountPerDay) {
            revert DailyFeeMintLimitExceeded(currentPeriodMintedFeeAmount + feeAmount, maxFeeMintAmountPerDay);
        }

currentPeriodMintedFeeAmount += feeAmount;
    }

/// @dev Internal function to update rsETH price
    // solhint-disable-next-line code-complexity
    function _updateRsETHPrice() internal {
        address rsETHTokenAddress = lrtConfig.rsETH();
        uint256 rsethSupply = IRSETH(rsETHTokenAddress).totalSupply();

if (rsethSupply == 0) {
            rsETHPrice = 1 ether;
            highestRsethPrice = 1 ether;
            return;
        }

if (highestRsethPrice == 0) {
            highestRsethPrice = rsETHPrice;
        }

uint256 previousPrice = rsETHPrice;

// get total ETH in the protocol (normalized to 1e18)
        uint256 totalETHInProtocol = _getTotalEthInProtocol();

// calculate previousTVL using rsethSupply multiplied by rsETHPrice
        uint256 previousTVL = rsethSupply.mulWad(rsETHPrice);

IPausable lrtDepositPool = IPausable(lrtConfig.getContract(LRTConstants.LRT_DEPOSIT_POOL));
        IPausable withdrawalManager = IPausable(lrtConfig.getContract(LRTConstants.LRT_WITHDRAW_MANAGER));

// determine if the protocol is active (not paused)
        bool protocolPaused = lrtDepositPool.paused() || withdrawalManager.paused() || paused;

// only take fee if TVL increased and protocol is not paused
        uint256 protocolFeeInETH = 0;
        if (!protocolPaused && totalETHInProtocol > previousTVL) {
            uint256 rewardAmount = totalETHInProtocol - previousTVL;
            protocolFeeInETH = (rewardAmount * lrtConfig.protocolFeeInBPS()) / 10_000;
        }

// compute new rsETH price based on total ETH minus fee
        uint256 newRsETHPrice = (totalETHInProtocol - protocolFeeInETH).divWad(rsethSupply);

if (newRsETHPrice > highestRsethPrice) {
            // check if the price is above the threshold
            uint256 priceDifference = newRsETHPrice - highestRsethPrice;
            // pricePercentageLimit is in 1e18 precision (100% = 1e18, 1% = 1e16)
            bool isPriceIncreaseOffLimit =
                pricePercentageLimit > 0 && priceDifference > pricePercentageLimit.mulWad(highestRsethPrice);

// downside protection — pause if price drops too far
        if (newRsETHPrice < highestRsethPrice) {
            uint256 diff = highestRsethPrice - newRsETHPrice;
            // normalizing to 1e18
            bool isPriceDecreaseOffLimit =
                pricePercentageLimit > 0 && diff > pricePercentageLimit.mulWad(highestRsethPrice);

// if price decrease is off limit, pause the protocol (unless it's already paused)
            if (isPriceDecreaseOffLimit) {
                if (!lrtDepositPool.paused()) lrtDepositPool.pause();
                if (!withdrawalManager.paused()) withdrawalManager.pause();
                _pause();
                return;
            }

// if price has decreased compared to the previous price, emit an event to reflect that
            if (previousPrice > newRsETHPrice) {
                emit RsETHPriceDecrease(newRsETHPrice, previousPrice);
            }

// emit an event to notify that the price is currently below the peak (all time high) price
            emit RsETHPriceBelowPeak(highestRsethPrice, newRsETHPrice);
        }

// update highest price if new price exceeds it
        if (newRsETHPrice > highestRsethPrice) {
            highestRsethPrice = newRsETHPrice;
        }

// mint protocol fee as rsETH if there's a fee to take
        if (protocolFeeInETH > 0) {
            // Calculate rsETH amount to mint as protocol fee
            uint256 rsethAmountToMintAsProtocolFee = protocolFeeInETH.divWad(newRsETHPrice);

// Calculate TVL increase in rsETH
            uint256 tvlIncreaseInRsETH = (totalETHInProtocol - previousTVL).divWad(newRsETHPrice);

// invariant ensures protocol fee doesn't exceed TVL increase
            // this prevents taking more fees than the actual gains in the protocol
            if (rsethAmountToMintAsProtocolFee > tvlIncreaseInRsETH) {
                revert ProtocolFeeExceededTVLIncrease();
            }
            _checkAndUpdateDailyFeeMintLimit(rsethAmountToMintAsProtocolFee);
            if (rsethAmountToMintAsProtocolFee > 0) {
                address treasury = lrtConfig.getContract(LRTConstants.PROTOCOL_TREASURY);
                IRSETH(rsETHTokenAddress).mint(treasury, rsethAmountToMintAsProtocolFee);
                emit FeeMinted(treasury, rsethAmountToMintAsProtocolFee);
            }
        } else {
            _checkAndUpdateDailyFeeMintLimit(0);
        }

rsETHPrice = newRsETHPrice;

emit RsETHPriceUpdate(rsETHPrice, previousPrice);
    }

/// @dev Internal function to pause the contract
    function _pause() internal {
        if (paused) return;
        paused = true;
        emit Paused(msg.sender);
    }

/*//////////////////////////////////////////////////////////////
                            private functions
    //////////////////////////////////////////////////////////////*/

/// @notice get total ETH in protocol
    /// @return totalETHInProtocol total ETH in protocol (normalized to 1e18)
    function _getTotalEthInProtocol() private view returns (uint256 totalETHInProtocol) {
        address lrtDepositPoolAddr = lrtConfig.getContract(LRTConstants.LRT_DEPOSIT_POOL);
        address[] memory supportedAssets = lrtConfig.getSupportedAssetList();
        uint256 supportedAssetCount = supportedAssets.length;

for (uint16 assetIdx; assetIdx < supportedAssetCount;) {
            address asset = supportedAssets[assetIdx];
            // assetER is in 1e18 precision (1.0 = 1e18)
            uint256 assetER = getAssetPrice(asset);
            // totalAssetAmt is in 1e18 precision (standard token decimals)
            uint256 totalAssetAmt = ILRTDepositPool(lrtDepositPoolAddr).getTotalAssetDeposits(asset);

totalETHInProtocol += totalAssetAmt.mulWad(assetER);

unchecked {
                ++assetIdx;
            }
        }
    }
}