diff --git a/src/contracts/BatchAaveV2DataRequest.sol b/src/contracts/BatchAaveV2DataRequest.sol new file mode 100644 index 0000000..7a06424 --- /dev/null +++ b/src/contracts/BatchAaveV2DataRequest.sol @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.23; + +import {Data, DataTypes, IIncentivesController, ILendingPool} from '../interfaces/aave-v2/IAaveV2.sol'; + +/** + * To calculate deposit apy/apr from this data + * https://docs.aave.com/developers/v/2.0/guides/apy-and-apr#compute-data + */ +contract BatchAaveV2DataRequest { + // This contract is used to fetch apy data points from aave + constructor(ILendingPool _lendingPool, IIncentivesController _incentivesController, address[] memory _assets) { + // create an array to store return data + Data[] memory _returnData = new Data[](_assets.length); + + for (uint256 i = 0; i < _assets.length; i++) { + DataTypes.ReserveData memory _reserveData = _lendingPool.getReserveData(_assets[i]); + uint256 currentLiquidityRate = _reserveData.currentLiquidityRate; + address aTokenAddress = _reserveData.aTokenAddress; + + // asset is the ERC20 supplied or borrowed, eg. DAI, WETH + (, uint256 aEmissionPerSecond,) = _incentivesController.getAssetData(aTokenAddress); + + _returnData[i] = Data({ + currentLiquidityRate: currentLiquidityRate, + aTokenAddress: aTokenAddress, + aEmissionPerSecond: aEmissionPerSecond + }); + } + + // encode return data + bytes memory _data = abi.encode(_returnData); + + // force constructor to return data via assembly + assembly { + // abi.encode adds an additional offset (32 bytes) that we need to skip + let _dataStart := add(_data, 32) + // msize() gets the size of active memory in bytes. + // if we subtract msize() from _dataStart, the output will be + // the amount of bytes from _dataStart to the end of memory + // which due to how the data has been laid out in memory, will coincide with + // where our desired data ends. + let _dataEnd := sub(msize(), _dataStart) + // starting from _dataStart, get all the data in memory. + return(_dataStart, _dataEnd) + } + } +} diff --git a/src/contracts/BatchRequest.sol b/src/contracts/BatchRequest.sol deleted file mode 100644 index f893fd1..0000000 --- a/src/contracts/BatchRequest.sol +++ /dev/null @@ -1,35 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.23; - -import {Data, IPoolManager} from '../interfaces/IPoolManager.sol'; - -contract BatchPoolManagerData { - // This contract is used to fetch multiple pools from the PoolManager contract - constructor(IPoolManager _poolManager) { - // create an array to store return data - uint256 _poolsToFetch = _poolManager.numPools(); - Data[] memory _returnData = new Data[](_poolsToFetch); - - // fetch pools - for (uint256 _i = 0; _i < _poolsToFetch; _i++) { - _returnData[_i] = _poolManager.queryPool(_i); - } - - // encode return data - bytes memory _data = abi.encode(_returnData); - - // force constructor to return data via assembly - assembly { - // abi.encode adds an additional offset (32 bytes) that we need to skip - let _dataStart := add(_data, 32) - // msize() gets the size of active memory in bytes. - // if we subtract msize() from _dataStart, the output will be - // the amount of bytes from _dataStart to the end of memory - // which due to how the data has been laid out in memory, will coincide with - // where our desired data ends. - let _dataEnd := sub(msize(), _dataStart) - // starting from _dataStart, get all the data in memory. - return(_dataStart, _dataEnd) - } - } -} diff --git a/src/contracts/PoolManager.sol b/src/contracts/PoolManager.sol deleted file mode 100644 index 7389835..0000000 --- a/src/contracts/PoolManager.sol +++ /dev/null @@ -1,19 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.23; - -import {Data, IPoolManager} from '../interfaces/IPoolManager.sol'; - -contract PoolManager is IPoolManager { - uint256 private constant _FAKE_LIQUIDITY = 10_000; - uint256 private constant _FAKE_NUM_POOLS = 50; - - /// @inheritdoc IPoolManager - function queryPool(uint256 _poolId) public pure returns (Data memory _pool) { - return Data({id: _poolId, liquidity: _FAKE_LIQUIDITY}); - } - - /// @inheritdoc IPoolManager - function numPools() external pure returns (uint256 _numPools) { - return _FAKE_NUM_POOLS; - } -} diff --git a/src/interfaces/aave-v2/DataTypes.sol b/src/interfaces/aave-v2/DataTypes.sol new file mode 100644 index 0000000..1b60f03 --- /dev/null +++ b/src/interfaces/aave-v2/DataTypes.sol @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: agpl-3.0 +pragma solidity 0.8.23; + +library DataTypes { + // refer to the whitepaper, section 1.1 basic concepts for a formal description of these properties. + struct ReserveData { + //stores the reserve configuration + ReserveConfigurationMap configuration; + //the liquidity index. Expressed in ray + uint128 liquidityIndex; + //variable borrow index. Expressed in ray + uint128 variableBorrowIndex; + //the current supply rate. Expressed in ray + uint128 currentLiquidityRate; + //the current variable borrow rate. Expressed in ray + uint128 currentVariableBorrowRate; + //the current stable borrow rate. Expressed in ray + uint128 currentStableBorrowRate; + uint40 lastUpdateTimestamp; + //tokens addresses + address aTokenAddress; + address stableDebtTokenAddress; + address variableDebtTokenAddress; + //address of the interest rate strategy + address interestRateStrategyAddress; + //the id of the reserve. Represents the position in the list of the active reserves + uint8 id; + } + + struct ReserveConfigurationMap { + //bit 0-15: LTV + //bit 16-31: Liq. threshold + //bit 32-47: Liq. bonus + //bit 48-55: Decimals + //bit 56: Reserve is active + //bit 57: reserve is frozen + //bit 58: borrowing is enabled + //bit 59: stable rate borrowing enabled + //bit 60-63: reserved + //bit 64-79: reserve factor + uint256 data; + } + + struct UserConfigurationMap { + uint256 data; + } + + enum InterestRateMode { + NONE, + STABLE, + VARIABLE + } +} diff --git a/src/interfaces/aave-v2/IAaveV2.sol b/src/interfaces/aave-v2/IAaveV2.sol new file mode 100644 index 0000000..5ce6b22 --- /dev/null +++ b/src/interfaces/aave-v2/IAaveV2.sol @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: agpl-3.0 +pragma solidity 0.8.23; + +import {DataTypes} from './DataTypes.sol'; +import {IIncentivesController} from './IIncentivesController.sol'; +import {ILendingPool} from './ILendingPool.sol'; + +struct Data { + uint256 currentLiquidityRate; + address aTokenAddress; + uint256 aEmissionPerSecond; +} diff --git a/src/interfaces/aave-v2/IIncentivesController.sol b/src/interfaces/aave-v2/IIncentivesController.sol new file mode 100644 index 0000000..adf37fe --- /dev/null +++ b/src/interfaces/aave-v2/IIncentivesController.sol @@ -0,0 +1,59 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +interface IIncentivesController { + event AssetConfigUpdated(address indexed asset, uint256 emission); + event AssetIndexUpdated(address indexed asset, uint256 index); + event ClaimerSet(address indexed user, address indexed claimer); + event DistributionEndUpdated(uint256 newDistributionEnd); + event RewardsAccrued(address indexed user, uint256 amount); + event RewardsClaimed(address indexed user, address indexed to, address indexed claimer, uint256 amount); + event UserIndexUpdated(address indexed user, address indexed asset, uint256 index); + + function DISTRIBUTION_END() external view returns (uint256); + + function EMISSION_MANAGER() external view returns (address); + + function PRECISION() external view returns (uint8); + + function REVISION() external view returns (uint256); + + function REWARD_TOKEN() external view returns (address); + + function STAKE_TOKEN() external view returns (address); + + function assets(address) external view returns (uint104 emissionPerSecond, uint104 index, uint40 lastUpdateTimestamp); + + function claimRewards(address[] memory assets, uint256 amount, address to) external returns (uint256); + + function claimRewardsOnBehalf( + address[] memory assets, + uint256 amount, + address user, + address to + ) external returns (uint256); + + function claimRewardsToSelf(address[] memory assets, uint256 amount) external returns (uint256); + + function configureAssets(address[] memory assets, uint256[] memory emissionsPerSecond) external; + + function getAssetData(address asset) external view returns (uint256, uint256, uint256); + + function getClaimer(address user) external view returns (address); + + function getDistributionEnd() external view returns (uint256); + + function getRewardsBalance(address[] memory assets, address user) external view returns (uint256); + + function getUserAssetData(address user, address asset) external view returns (uint256); + + function getUserUnclaimedRewards(address _user) external view returns (uint256); + + function handleAction(address user, uint256 totalSupply, uint256 userBalance) external; + + function initialize(address) external; + + function setClaimer(address user, address caller) external; + + function setDistributionEnd(uint256 distributionEnd) external; +} diff --git a/src/interfaces/aave-v2/ILendingPool.sol b/src/interfaces/aave-v2/ILendingPool.sol new file mode 100644 index 0000000..d526df6 --- /dev/null +++ b/src/interfaces/aave-v2/ILendingPool.sol @@ -0,0 +1,404 @@ +// SPDX-License-Identifier: agpl-3.0 +pragma solidity 0.8.23; +pragma experimental ABIEncoderV2; + +import {DataTypes} from './DataTypes.sol'; +import {ILendingPoolAddressesProvider} from './ILendingPoolAddressesProvider.sol'; + +interface ILendingPool { + /** + * @dev Emitted on deposit() + * @param reserve The address of the underlying asset of the reserve + * @param user The address initiating the deposit + * @param onBehalfOf The beneficiary of the deposit, receiving the aTokens + * @param amount The amount deposited + * @param referral The referral code used + * + */ + event Deposit( + address indexed reserve, address user, address indexed onBehalfOf, uint256 amount, uint16 indexed referral + ); + + /** + * @dev Emitted on withdraw() + * @param reserve The address of the underlyng asset being withdrawn + * @param user The address initiating the withdrawal, owner of aTokens + * @param to Address that will receive the underlying + * @param amount The amount to be withdrawn + * + */ + event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount); + + /** + * @dev Emitted on borrow() and flashLoan() when debt needs to be opened + * @param reserve The address of the underlying asset being borrowed + * @param user The address of the user initiating the borrow(), receiving the funds on borrow() or just + * initiator of the transaction on flashLoan() + * @param onBehalfOf The address that will be getting the debt + * @param amount The amount borrowed out + * @param borrowRateMode The rate mode: 1 for Stable, 2 for Variable + * @param borrowRate The numeric rate at which the user has borrowed + * @param referral The referral code used + * + */ + event Borrow( + address indexed reserve, + address user, + address indexed onBehalfOf, + uint256 amount, + uint256 borrowRateMode, + uint256 borrowRate, + uint16 indexed referral + ); + + /** + * @dev Emitted on repay() + * @param reserve The address of the underlying asset of the reserve + * @param user The beneficiary of the repayment, getting his debt reduced + * @param repayer The address of the user initiating the repay(), providing the funds + * @param amount The amount repaid + * + */ + event Repay(address indexed reserve, address indexed user, address indexed repayer, uint256 amount); + + /** + * @dev Emitted on swapBorrowRateMode() + * @param reserve The address of the underlying asset of the reserve + * @param user The address of the user swapping his rate mode + * @param rateMode The rate mode that the user wants to swap to + * + */ + event Swap(address indexed reserve, address indexed user, uint256 rateMode); + + /** + * @dev Emitted on setUserUseReserveAsCollateral() + * @param reserve The address of the underlying asset of the reserve + * @param user The address of the user enabling the usage as collateral + * + */ + event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user); + + /** + * @dev Emitted on setUserUseReserveAsCollateral() + * @param reserve The address of the underlying asset of the reserve + * @param user The address of the user enabling the usage as collateral + * + */ + event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user); + + /** + * @dev Emitted on rebalanceStableBorrowRate() + * @param reserve The address of the underlying asset of the reserve + * @param user The address of the user for which the rebalance has been executed + * + */ + event RebalanceStableBorrowRate(address indexed reserve, address indexed user); + + /** + * @dev Emitted on flashLoan() + * @param target The address of the flash loan receiver contract + * @param initiator The address initiating the flash loan + * @param asset The address of the asset being flash borrowed + * @param amount The amount flash borrowed + * @param premium The fee flash borrowed + * @param referralCode The referral code used + * + */ + event FlashLoan( + address indexed target, + address indexed initiator, + address indexed asset, + uint256 amount, + uint256 premium, + uint16 referralCode + ); + + /** + * @dev Emitted when the pause is triggered. + */ + event Paused(); + + /** + * @dev Emitted when the pause is lifted. + */ + event Unpaused(); + + /** + * @dev Emitted when a borrower is liquidated. This event is emitted by the LendingPool via + * LendingPoolCollateral manager using a DELEGATECALL + * This allows to have the events in the generated ABI for LendingPool. + * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation + * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation + * @param user The address of the borrower getting liquidated + * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover + * @param liquidatedCollateralAmount The amount of collateral received by the liiquidator + * @param liquidator The address of the liquidator + * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants + * to receive the underlying collateral asset directly + * + */ + event LiquidationCall( + address indexed collateralAsset, + address indexed debtAsset, + address indexed user, + uint256 debtToCover, + uint256 liquidatedCollateralAmount, + address liquidator, + bool receiveAToken + ); + + /** + * @dev Emitted when the state of a reserve is updated. NOTE: This event is actually declared + * in the ReserveLogic library and emitted in the updateInterestRates() function. Since the function is internal, + * the event will actually be fired by the LendingPool contract. The event is therefore replicated here so it + * gets added to the LendingPool ABI + * @param reserve The address of the underlying asset of the reserve + * @param liquidityRate The new liquidity rate + * @param stableBorrowRate The new stable borrow rate + * @param variableBorrowRate The new variable borrow rate + * @param liquidityIndex The new liquidity index + * @param variableBorrowIndex The new variable borrow index + * + */ + event ReserveDataUpdated( + address indexed reserve, + uint256 liquidityRate, + uint256 stableBorrowRate, + uint256 variableBorrowRate, + uint256 liquidityIndex, + uint256 variableBorrowIndex + ); + + /** + * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens. + * - E.g. User deposits 100 USDC and gets in return 100 aUSDC + * @param asset The address of the underlying asset to deposit + * @param amount The amount to be deposited + * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user + * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens + * is a different wallet + * @param referralCode Code used to register the integrator originating the operation, for potential rewards. + * 0 if the action is executed directly by the user, without any middle-man + * + */ + function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external; + + /** + * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned + * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC + * @param asset The address of the underlying asset to withdraw + * @param amount The underlying amount to be withdrawn + * - Send the value type(uint256).max in order to withdraw the whole aToken balance + * @param to Address that will receive the underlying, same as msg.sender if the user + * wants to receive it on his own wallet, or a different address if the beneficiary is a + * different wallet + * @return The final amount withdrawn + * + */ + function withdraw(address asset, uint256 amount, address to) external returns (uint256); + + /** + * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower + * already deposited enough collateral, or he was given enough allowance by a credit delegator on the + * corresponding debt token (StableDebtToken or VariableDebtToken) + * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet + * and 100 stable/variable debt tokens, depending on the `interestRateMode` + * @param asset The address of the underlying asset to borrow + * @param amount The amount to be borrowed + * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable + * @param referralCode Code used to register the integrator originating the operation, for potential rewards. + * 0 if the action is executed directly by the user, without any middle-man + * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself + * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator + * if he has been given credit delegation allowance + * + */ + function borrow( + address asset, + uint256 amount, + uint256 interestRateMode, + uint16 referralCode, + address onBehalfOf + ) external; + + /** + * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned + * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address + * @param asset The address of the borrowed underlying asset previously borrowed + * @param amount The amount to repay + * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode` + * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable + * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the + * user calling the function if he wants to reduce/remove his own debt, or the address of any other + * other borrower whose debt should be removed + * @return The final amount repaid + * + */ + function repay(address asset, uint256 amount, uint256 rateMode, address onBehalfOf) external returns (uint256); + + /** + * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa + * @param asset The address of the underlying asset borrowed + * @param rateMode The rate mode that the user wants to swap to + * + */ + function swapBorrowRateMode(address asset, uint256 rateMode) external; + + /** + * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve. + * - Users can be rebalanced if the following conditions are satisfied: + * 1. Usage ratio is above 95% + * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been + * borrowed at a stable rate and depositors are not earning enough + * @param asset The address of the underlying asset borrowed + * @param user The address of the user to be rebalanced + * + */ + function rebalanceStableBorrowRate(address asset, address user) external; + + /** + * @dev Allows depositors to enable/disable a specific deposited asset as collateral + * @param asset The address of the underlying asset deposited + * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise + * + */ + function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external; + + /** + * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1 + * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives + * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk + * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation + * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation + * @param user The address of the borrower getting liquidated + * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover + * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants + * to receive the underlying collateral asset directly + * + */ + function liquidationCall( + address collateralAsset, + address debtAsset, + address user, + uint256 debtToCover, + bool receiveAToken + ) external; + + /** + * @dev Allows smartcontracts to access the liquidity of the pool within one transaction, + * as long as the amount taken plus a fee is returned. + * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration. + * For further details please visit https://developers.aave.com + * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface + * @param assets The addresses of the assets being flash-borrowed + * @param amounts The amounts amounts being flash-borrowed + * @param modes Types of the debt to open if the flash loan is not returned: + * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver + * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address + * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address + * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2 + * @param params Variadic packed params to pass to the receiver as extra information + * @param referralCode Code used to register the integrator originating the operation, for potential rewards. + * 0 if the action is executed directly by the user, without any middle-man + * + */ + function flashLoan( + address receiverAddress, + address[] calldata assets, + uint256[] calldata amounts, + uint256[] calldata modes, + address onBehalfOf, + bytes calldata params, + uint16 referralCode + ) external; + + /** + * @dev Returns the user account data across all the reserves + * @param user The address of the user + * @return totalCollateralETH the total collateral in ETH of the user + * @return totalDebtETH the total debt in ETH of the user + * @return availableBorrowsETH the borrowing power left of the user + * @return currentLiquidationThreshold the liquidation threshold of the user + * @return ltv the loan to value of the user + * @return healthFactor the current health factor of the user + * + */ + function getUserAccountData(address user) + external + view + returns ( + uint256 totalCollateralETH, + uint256 totalDebtETH, + uint256 availableBorrowsETH, + uint256 currentLiquidationThreshold, + uint256 ltv, + uint256 healthFactor + ); + + function initReserve( + address reserve, + address aTokenAddress, + address stableDebtAddress, + address variableDebtAddress, + address interestRateStrategyAddress + ) external; + + function setReserveInterestRateStrategyAddress(address reserve, address rateStrategyAddress) external; + + function setConfiguration(address reserve, uint256 configuration) external; + + /** + * @dev Returns the configuration of the reserve + * @param asset The address of the underlying asset of the reserve + * @return The configuration of the reserve + * + */ + function getConfiguration(address asset) external view returns (DataTypes.ReserveConfigurationMap memory); + + /** + * @dev Returns the configuration of the user across all the reserves + * @param user The user address + * @return The configuration of the user + * + */ + function getUserConfiguration(address user) external view returns (DataTypes.UserConfigurationMap memory); + + /** + * @dev Returns the normalized income normalized income of the reserve + * @param asset The address of the underlying asset of the reserve + * @return The reserve's normalized income + */ + function getReserveNormalizedIncome(address asset) external view returns (uint256); + + /** + * @dev Returns the normalized variable debt per unit of asset + * @param asset The address of the underlying asset of the reserve + * @return The reserve normalized variable debt + */ + function getReserveNormalizedVariableDebt(address asset) external view returns (uint256); + + /** + * @dev Returns the state and configuration of the reserve + * @param asset The address of the underlying asset of the reserve + * @return The state of the reserve + * + */ + function getReserveData(address asset) external view returns (DataTypes.ReserveData memory); + + function finalizeTransfer( + address asset, + address from, + address to, + uint256 amount, + uint256 balanceFromAfter, + uint256 balanceToBefore + ) external; + + function getReservesList() external view returns (address[] memory); + + function getAddressesProvider() external view returns (ILendingPoolAddressesProvider); + + function setPause(bool val) external; + + function paused() external view returns (bool); +} diff --git a/src/interfaces/aave-v2/ILendingPoolAddressesProvider.sol b/src/interfaces/aave-v2/ILendingPoolAddressesProvider.sol new file mode 100644 index 0000000..88db7ae --- /dev/null +++ b/src/interfaces/aave-v2/ILendingPoolAddressesProvider.sol @@ -0,0 +1,61 @@ +// SPDX-License-Identifier: agpl-3.0 +pragma solidity 0.8.23; + +/** + * @title LendingPoolAddressesProvider contract + * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles + * - Acting also as factory of proxies and admin of those, so with right to change its implementations + * - Owned by the Aave Governance + * @author Aave + * + */ +interface ILendingPoolAddressesProvider { + event MarketIdSet(string newMarketId); + event LendingPoolUpdated(address indexed newAddress); + event ConfigurationAdminUpdated(address indexed newAddress); + event EmergencyAdminUpdated(address indexed newAddress); + event LendingPoolConfiguratorUpdated(address indexed newAddress); + event LendingPoolCollateralManagerUpdated(address indexed newAddress); + event PriceOracleUpdated(address indexed newAddress); + event LendingRateOracleUpdated(address indexed newAddress); + event ProxyCreated(bytes32 id, address indexed newAddress); + event AddressSet(bytes32 id, address indexed newAddress, bool hasProxy); + + function getMarketId() external view returns (string memory); + + function setMarketId(string calldata marketId) external; + + function setAddress(bytes32 id, address newAddress) external; + + function setAddressAsProxy(bytes32 id, address impl) external; + + function getAddress(bytes32 id) external view returns (address); + + function getLendingPool() external view returns (address); + + function setLendingPoolImpl(address pool) external; + + function getLendingPoolConfigurator() external view returns (address); + + function setLendingPoolConfiguratorImpl(address configurator) external; + + function getLendingPoolCollateralManager() external view returns (address); + + function setLendingPoolCollateralManager(address manager) external; + + function getPoolAdmin() external view returns (address); + + function setPoolAdmin(address admin) external; + + function getEmergencyAdmin() external view returns (address); + + function setEmergencyAdmin(address admin) external; + + function getPriceOracle() external view returns (address); + + function setPriceOracle(address priceOracle) external; + + function getLendingRateOracle() external view returns (address); + + function setLendingRateOracle(address lendingRateOracle) external; +}