Comparar texto

Encontre a diferença entre dois arquivos de texto

Exibição

Layout

Editor liveOcultar espaços em brancoRecolher inalteradasSem quebra de linha

Nível de detalhe

Sintaxe

Processamento

Diffchecker Desktop A maneira mais segura de usar o Diffchecker. Obtenha o aplicativo Diffchecker Desktop: seus diffs nunca saem do seu computador!Obter Desktop

LRTConfig diff

Criado há 11 mesesO diff nunca expira

2 remoções

Linhas
Total
Removido

Caracteres
Total
Removido

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

253 linhas

3 adições

Linhas
Total
Adicionado

Caracteres
Total
Adicionado

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

255 linhas

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.21;

pragma solidity 0.8.27;

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

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

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

import { IStrategy } from "./external/eigenlayer/interfaces/IStrategy.sol";

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

import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";

/// @title LRTConfig - LRT Config Contract

/// @notice Handles LRT configuration

contract LRTConfig is ILRTConfig, AccessControlUpgradeable {

mapping(bytes32 tokenKey => address tokenAddress) public tokenMap;

mapping(bytes32 contractKey => address contractAddress) public contractMap;

mapping(address token => bool isSupported) public isSupportedAsset;

mapping(address token => uint256 amount) public depositLimitByAsset;

mapping(address token => address strategy) public override assetStrategy;

address[] public supportedAssetList;

address public rsETH;

uint256 public protocolFeeInBPS;

address public eigenLayerRewardReceiver;

uint256 public maxNegligibleAmount;

modifier onlySupportedAsset(address asset) {

if (!isSupportedAsset[asset]) {

revert AssetNotSupported();

}

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

constructor() {

_disableInitializers();

}

/// @dev Initializes the contract

/// @param admin Admin address

/// @param stETH stETH address

/// @param ethX ETHX address

/// @param rsETH_ rsETH address

function initialize(address admin, address stETH, address ethX, address rsETH_) external initializer {

UtilLib.checkNonZeroAddress(admin);

UtilLib.checkNonZeroAddress(rsETH_);

__AccessControl_init();

_setToken(LRTConstants.ST_ETH_TOKEN, stETH);

_setToken(LRTConstants.ETHX_TOKEN, ethX);

_addNewSupportedAsset(stETH, 100_000 ether);

_addNewSupportedAsset(ethX, 100_000 ether);

_grantRole(DEFAULT_ADMIN_ROLE, admin);

rsETH = rsETH_;

}

/// @dev Removes a supported asset

/// @param asset The asset address

function removeSupportedAsset(

address asset,

uint256 tokenIndex

)

external

onlySupportedAsset(asset)

onlyRole(DEFAULT_ADMIN_ROLE)

{

UtilLib.checkNonZeroAddress(asset);

if (supportedAssetList[tokenIndex] != asset) {

revert TokenNotFoundError();

}

address depositPool = getContract(LRTConstants.LRT_DEPOSIT_POOL);

if (ILRTDepositPool(depositPool).getTotalAssetDeposits(asset) > maxNegligibleAmount) {

revert CannotRemoveAssetWithDeposits(asset);

}

delete isSupportedAsset[asset];

delete assetStrategy[asset];

depositLimitByAsset[asset] = 0;

supportedAssetList[tokenIndex] = supportedAssetList[supportedAssetList.length - 1];

supportedAssetList.pop();

emit RemovedSupportedAsset(asset);

}

/// @dev Adds a new supported asset

/// @param asset Asset address

/// @param depositLimit Deposit limit for the asset

function addNewSupportedAsset(address asset, uint256 depositLimit) external onlyRole(LRTConstants.TIME_LOCK_ROLE) {

_addNewSupportedAsset(asset, depositLimit);

}

/// @dev private function to add a new supported asset

/// @param asset Asset address

/// @param depositLimit Deposit limit for the asset

Diferenças salvas

Texto original

Abrir arquivo

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.21;

import { UtilLib } from "./utils/UtilLib.sol";
import { LRTConstants } from "./utils/LRTConstants.sol";
import { ILRTConfig } from "./interfaces/ILRTConfig.sol";
import { IStrategy } from "./external/eigenlayer/interfaces/IStrategy.sol";
import { ILRTDepositPool } from "./interfaces/ILRTDepositPool.sol";

import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";

/// @title LRTConfig - LRT Config Contract
/// @notice Handles LRT configuration
contract LRTConfig is ILRTConfig, AccessControlUpgradeable {
    mapping(bytes32 tokenKey => address tokenAddress) public tokenMap;
    mapping(bytes32 contractKey => address contractAddress) public contractMap;
    mapping(address token => bool isSupported) public isSupportedAsset;
    mapping(address token => uint256 amount) public depositLimitByAsset;
    mapping(address token => address strategy) public override assetStrategy;

address[] public supportedAssetList;
    address public rsETH;
    uint256 public protocolFeeInBPS;
    address public eigenLayerRewardReceiver;
    uint256 public maxNegligibleAmount;

modifier onlySupportedAsset(address asset) {
        if (!isSupportedAsset[asset]) {
            revert AssetNotSupported();
        }
        _;
    }

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

/// @dev Initializes the contract
    /// @param admin Admin address
    /// @param stETH stETH address
    /// @param ethX ETHX address
    /// @param rsETH_ rsETH address
    function initialize(address admin, address stETH, address ethX, address rsETH_) external initializer {
        UtilLib.checkNonZeroAddress(admin);
        UtilLib.checkNonZeroAddress(rsETH_);

__AccessControl_init();
        _setToken(LRTConstants.ST_ETH_TOKEN, stETH);
        _setToken(LRTConstants.ETHX_TOKEN, ethX);
        _addNewSupportedAsset(stETH, 100_000 ether);
        _addNewSupportedAsset(ethX, 100_000 ether);

_grantRole(DEFAULT_ADMIN_ROLE, admin);

rsETH = rsETH_;
    }

/// @dev Removes a supported asset
    /// @param asset The asset address
    function removeSupportedAsset(
        address asset,
        uint256 tokenIndex
    )
        external
        onlySupportedAsset(asset)
        onlyRole(DEFAULT_ADMIN_ROLE)
    {
        UtilLib.checkNonZeroAddress(asset);

if (supportedAssetList[tokenIndex] != asset) {
            revert TokenNotFoundError();
        }
        address depositPool = getContract(LRTConstants.LRT_DEPOSIT_POOL);

if (ILRTDepositPool(depositPool).getTotalAssetDeposits(asset) > maxNegligibleAmount) {
            revert CannotRemoveAssetWithDeposits(asset);
        }

delete isSupportedAsset[asset];
        delete assetStrategy[asset];
        depositLimitByAsset[asset] = 0;

supportedAssetList[tokenIndex] = supportedAssetList[supportedAssetList.length - 1];
        supportedAssetList.pop();
        emit RemovedSupportedAsset(asset);
    }

/// @dev Adds a new supported asset
    /// @param asset Asset address
    /// @param depositLimit Deposit limit for the asset
    function addNewSupportedAsset(address asset, uint256 depositLimit) external onlyRole(LRTConstants.TIME_LOCK_ROLE) {
        _addNewSupportedAsset(asset, depositLimit);
    }

/// @dev private function to add a new supported asset
    /// @param asset Asset address
    /// @param depositLimit Deposit limit for the asset
    function _addNewSupportedAsset(address asset, uint256 depositLimit) private {
        UtilLib.checkNonZeroAddress(asset);
        if (depositLimit == 0) {
            revert InvalidDepositLimit();
        }
        if (isSupportedAsset[asset]) {
            revert AssetAlreadySupported();
        }
        isSupportedAsset[asset] = true;
        supportedAssetList.push(asset);
        depositLimitByAsset[asset] = depositLimit;
        emit AddedNewSupportedAsset(asset, depositLimit);
    }

/// @dev Updates the deposit limit for an asset
    /// @param asset Asset address
    /// @param depositLimit New deposit limit
    function updateAssetDepositLimit(
        address asset,
        uint256 depositLimit
    )
        external
        onlyRole(LRTConstants.MANAGER)
        onlySupportedAsset(asset)
    {
        depositLimitByAsset[asset] = depositLimit;
        emit AssetDepositLimitUpdate(asset, depositLimit);
    }

/// @dev Updates the strategy for an asset
    /// @param asset Asset address
    /// @param strategy New strategy address
    function updateAssetStrategy(
        address asset,
        address strategy
    )
        external
        onlyRole(DEFAULT_ADMIN_ROLE)
        onlySupportedAsset(asset)
    {
        UtilLib.checkNonZeroAddress(strategy);
        if (assetStrategy[asset] == strategy) {
            revert ValueAlreadyInUse();
        }
        // if strategy is already set, check if it has any funds
        if (assetStrategy[asset] != address(0)) {
            // get ndcs
            address depositPool = getContract(LRTConstants.LRT_DEPOSIT_POOL);
            address[] memory ndcs = ILRTDepositPool(depositPool).getNodeDelegatorQueue();

uint256 length = ndcs.length;
            for (uint256 i = 0; i < length;) {
                uint256 ndcBalance = IStrategy(assetStrategy[asset]).userUnderlyingView(ndcs[i]);
                if (ndcBalance > 0) {
                    revert CannotUpdateStrategyAsItHasFundsNDCFunds(ndcs[i], ndcBalance);
                }

unchecked {
                    ++i;
                }
            }
        }

assetStrategy[asset] = strategy;
        emit AssetStrategyUpdate(asset, strategy);
    }

/*//////////////////////////////////////////////////////////////
                            GETTERS
    //////////////////////////////////////////////////////////////*/
    function getLSTToken(bytes32 tokenKey) external view override returns (address) {
        UtilLib.checkNonZeroAddress(tokenMap[tokenKey]);
        return tokenMap[tokenKey];
    }

function getContract(bytes32 contractKey) public view override returns (address) {
        UtilLib.checkNonZeroAddress(contractMap[contractKey]);
        return contractMap[contractKey];
    }

function getSupportedAssetList() external view override returns (address[] memory) {
        return supportedAssetList;
    }

/*//////////////////////////////////////////////////////////////
                            SETTERS
    //////////////////////////////////////////////////////////////*/

/// @dev Set the protocol fee bps
    /// @param _protocolFeeInBPS protocol fee bps
    function setProtocolFeeBps(uint256 _protocolFeeInBPS) external onlyRole(LRTConstants.MANAGER) {
        if (_protocolFeeInBPS > 1500) revert ProtocolFeeExceedsLimit();
        protocolFeeInBPS = _protocolFeeInBPS;
        emit UpdateFee(_protocolFeeInBPS);
    }

/// @dev Set the el reward receiver fee bps
    /// @param _eigenLayerRewardReceiver reciver of weekly el rewards
    function setEigenLayerRewardReceiver(address _eigenLayerRewardReceiver)
        external
        onlyRole(LRTConstants.DEFAULT_ADMIN_ROLE)
    {
        UtilLib.checkNonZeroAddress(_eigenLayerRewardReceiver);
        eigenLayerRewardReceiver = _eigenLayerRewardReceiver;
        emit SetEigenLayerRewardReceiver(_eigenLayerRewardReceiver);
    }

/// @dev Sets the rsETH contract address. Only callable by the admin
    /// @param rsETH_ rsETH contract address
    function setRSETH(address rsETH_) external onlyRole(DEFAULT_ADMIN_ROLE) {
        UtilLib.checkNonZeroAddress(rsETH_);
        rsETH = rsETH_;
        emit SetRSETH(rsETH_);
    }

function setToken(bytes32 tokenKey, address assetAddress) external onlyRole(DEFAULT_ADMIN_ROLE) {
        _setToken(tokenKey, assetAddress);
    }

/// @dev private function to set a token
    /// @param key Token key
    /// @param val Token address
    function _setToken(bytes32 key, address val) private {
        UtilLib.checkNonZeroAddress(val);
        if (tokenMap[key] == val) {
            revert ValueAlreadyInUse();
        }
        tokenMap[key] = val;
        emit SetToken(key, val);
    }

function setContract(bytes32 contractKey, address contractAddress) external onlyRole(DEFAULT_ADMIN_ROLE) {
        _setContract(contractKey, contractAddress);
    }

/// @dev private function to set a contract
    /// @param key Contract key
    /// @param val Contract address
    function _setContract(bytes32 key, address val) private {
        UtilLib.checkNonZeroAddress(val);
        if (contractMap[key] == val) {
            revert ValueAlreadyInUse();
        }
        contractMap[key] = val;
        emit SetContract(key, val);
    }

/// @notice maximum amount that can be ignored
    /// @dev only callable by LRT admin
    /// @param maxNegligibleAmount_ Maximum amount that can be ignored
    function setMaxNegligibleAmount(uint256 maxNegligibleAmount_) external onlyRole(DEFAULT_ADMIN_ROLE) {
        maxNegligibleAmount = maxNegligibleAmount_;
        emit MaxNegligibleAmountUpdated(maxNegligibleAmount_);
    }
}

Texto alterado

Abrir arquivo

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

import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";

address[] public supportedAssetList;
    address public rsETH;
    uint256 public protocolFeeInBPS;
    address public eigenLayerRewardReceiver;
    uint256 public maxNegligibleAmount;

modifier onlySupportedAsset(address asset) {
        if (!isSupportedAsset[asset]) {
            revert AssetNotSupported();
        }
        _;
    }

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

_grantRole(DEFAULT_ADMIN_ROLE, admin);

rsETH = rsETH_;
    }

if (supportedAssetList[tokenIndex] != asset) {
            revert TokenNotFoundError();
        }

address depositPool = getContract(LRTConstants.LRT_DEPOSIT_POOL);

if (ILRTDepositPool(depositPool).getTotalAssetDeposits(asset) > maxNegligibleAmount) {
            revert CannotRemoveAssetWithDeposits(asset);
        }

delete isSupportedAsset[asset];
        delete assetStrategy[asset];
        depositLimitByAsset[asset] = 0;

supportedAssetList[tokenIndex] = supportedAssetList[supportedAssetList.length - 1];
        supportedAssetList.pop();

emit RemovedSupportedAsset(asset);
    }

unchecked {
                    ++i;
                }
            }
        }

assetStrategy[asset] = strategy;
        emit AssetStrategyUpdate(asset, strategy);
    }

function getContract(bytes32 contractKey) public view override returns (address) {
        UtilLib.checkNonZeroAddress(contractMap[contractKey]);
        return contractMap[contractKey];
    }

function getSupportedAssetList() external view override returns (address[] memory) {
        return supportedAssetList;
    }

/*//////////////////////////////////////////////////////////////
                            SETTERS
    //////////////////////////////////////////////////////////////*/

function setToken(bytes32 tokenKey, address assetAddress) external onlyRole(DEFAULT_ADMIN_ROLE) {
        _setToken(tokenKey, assetAddress);
    }

function setContract(bytes32 contractKey, address contractAddress) external onlyRole(DEFAULT_ADMIN_ROLE) {
        _setContract(contractKey, contractAddress);
    }