Morpho Optimizers V1

What are Morpho Optimizers?

Morpho Optimizers improve the capital efficiency of positions on existing lending pools by seamlessly matching users peer-to-peer.

• Morpho's rates stay between the supply rate and the borrow rate of the pool, reducing the interest paid by the borrowers while increasing the interest earned by the suppliers. It means that you are getting boosted peer-to-peer rates or, in the worst-case scenario, the APY of the pool.
• Morpho also preserves the same experience, the same liquidity, and the same parameters (collateral factors, oracles, …) as the underlying pool.

TL;DR: Instead of borrowing or lending on your favorite pool like Compound or Aave, you would be better off using Morpho Optimizers.

Contracts overview

Morpho Optimizers are designed at their core with a set of contracts delegating calls to implementation contracts (to overcome the contract size limit).

Here is a brief overview of the Morpho Optimizers' contracts interactions:

The main user's entry points are exposed in the Morpho contract. It inherits from MorphoGovernance, which contains all the admin functions of the DAO, MorphoUtils, and MorphoStorage, where the protocol's storage is located. This contract delegates call to other contracts that have the same storage layout:

• PositionsManager: logic of basic supply, borrow, withdraw, repay, and liquidate functions. The Morpho-AaveV2 Optimizer is separated into two contracts, EntryPositionsManager and ExitPositionsManager. These contracts inherit from MatchingEngine, which contains the matching engine's internal functions.
• InterestRatesManager: logic of indexes computation.

It also interacts with RewardsManager, which manages the underlying pool's rewards, if any.

Documentation

• White Paper
• Yellow Paper
• Morpho Documentation
• Morpho Developers Documentation

Audits

All audits are stored in the audits' folder.

Bug bounty

A bug bounty is open on Immunefi. The rewards and scope are defined here. You can email security@morpho.org if you find something worrying.

Deployment Addresses

Morpho-Compound Optimizer on Ethereum

• Morpho Proxy: 0x8888882f8f843896699869179fb6e4f7e3b58888
• Morpho Implementation: 0xe3d7a242614174ccf9f96bd479c42795d666fc81
• PositionsManager: 0x79a1b5888009bB4887E00EA27CF52551aAf2A004
• InterestRatesManager: 0xD9B7209eD2936b5c06990A8356D155c3665d43Ab
• RewardsManager Proxy: 0x78681e63b6f3ad81ecd64aecc404d765b529c80d
• RewardsManager Implementation: 0x581c3816589ad0de7f9c76bc242c97fe96c9f100
• Lens Proxy: 0x930f1b46e1d081ec1524efd95752be3ece51ef67
• Lens Implementation: 0x834632a7c70ddd7badd3d21ba9d885a9da66b0de
• Lens Extension: 0xc5c3bB32c70d1d547023346BD1E32a6c5BC7FD1e
• CompRewardsLens: 0x9e977f745d5ae26c6d47ac5417ee112312873ba7

Morpho-AaveV2 Optimizer on Ethereum

• Morpho Proxy: 0x777777c9898d384f785ee44acfe945efdff5f3e0
• Morpho Implementation: 0xFBc7693f114273739C74a3FF028C13769C49F2d0
• EntryPositionsManager: 0x029Ee1AF5BafC481f9E8FBeD5164253f1266B968
• ExitPositionsManager: 0xfd9b1Ad429667D27cE666EA800f828B931A974D2
• InterestRatesManager: 0x22a4ecf5195c87605ae6bad413ae79d5c4170ff1
• Lens Proxy: 0x507fa343d0a90786d86c7cd885f5c49263a91ff4
• Lens Implementation: 0x4bf26012b64312b462bf70f2e42d1be8881d0f84

Common Ethereum

• ProxyAdmin: 0x99917ca0426fbc677e84f873fb0b726bb4799cd8

Importing package

Using npm:

npm install @morpho-dao/morpho-v1

Using forge:

forge install @morpho-dao/morpho-v1@v2.0.0

Using git submodules:

git submodule add @morpho-dao/morpho-v1@v2.0.0 lib/morpho-v1

Testing with Foundry 🔨

Tests are run against a fork of real networks, allowing us to interact directly with Compound or Aave liquidity pools. Note that you need an RPC provider with access to Ethereum or Polygon.

For testing, make sure yarn and foundry are installed and install dependencies (node_modules, git submodules) with:

make install

Alternatively, if you only want to set up

Refer to the env.example for the required environment variable.

To run tests on different protocols, navigate a Unix terminal to the root folder of the project and run the command of your choice:

To run every test of a specific protocol (e.g. for the Morpho-Compound Optimizer):

make test PROTOCOL=compound

or to run only a specific set of tests of a specific protocol (e.g. for the Morpho-AaveV2 Optimizer):

make c-TestBorrow PROTOCOL=aave-v2

or to run an individual test of a specific protocol (e.g. for the Morpho-AaveV2 Optimizer):

make test-testBorrow1 PROTOCOL=aave-v2

For the other commands, check the Makefile.

If you want to call a custom forge command and not have to edit the Makefile, you can source the export_env.sh script by calling . ./export_env.sh.

:warning: The export_env.sh script exports environment variables in the current shell, meaning that subsequent calls to make or forge will use those variables. Variables defined in the .env.local file will still override those if you run make later. If you don't want to change variables in the current shell, you can always create a new shell in one of the following ways:

• use ( . ./export_env.sh && forge test ) if the command you want to run is forge test
• use bash and then . ./export_env.sh followed by your commands and then exit to return to the parent shell and clear the environment variables.

Testing with Hardhat

Only tests for the RewardsDistributor are run with Hardhat.

Just run:

yarn test

Test coverage

Test coverage is reported using foundry coverage with lcov report formatting (and optionally, genhtml transformer).

To generate the lcov report, run the following:

make coverage

The report is then usable either:

• via Coverage Gutters following this tutorial
• via HTML, using make lcov-html to transform the report and opening coverage/index.html

:warning: Test coverage is not available on the Morpho-AaveV2 Optimizer for this reason

Storage seatbelt

2 CI pipelines are currently running on every PR to check that the changes introduced are not modifying the storage layout of proxied smart contracts in an unsafe way:

• storage-layout.sh checks that the latest foundry storage layout snapshot is identical to the committed storage layout snapshot
• foundry-storage-check is in test phase and will progressively replace the snapshot check

In the case the storage layout snapshots checked by storage-layout.sh are not identical, the developer must commit the updated storage layout snapshot stored under snapshots/ by running:

• make storage-layout-generate with the appropriate protocol parameters

Deployment & Upgrades

Network mode (default)

Run the Foundry deployment script with:

make script-Deploy PROTOCOL=compound NETWORK=goerli

Local mode

First start a local EVM:

make anvil NETWORK=goerli

Then run the Foundry deployment script in a separate shell, using SMODE=local:

make script-Deploy PROTOCOL=compound NETWORK=goerli SMODE=local

Questions & Feedback

For any questions or feedback, you can send an email to merlin@morpho.org.

Licensing

The code is under the GNU AFFERO GENERAL PUBLIC LICENSE v3.0, see LICENSE.

Contents

• interfaces
• lens
• libraries
• EntryPositionsManager
• ExitPositionsManager
• InterestRatesManager
• MatchingEngine
• Morpho
• MorphoGovernance
• MorphoStorage
• MorphoUtils
• PositionsManagerUtils

Contents

• aave
• lido
• IEntryPositionsManager
• IExitPositionsManager
• IGetterUnderlyingAsset
• IInterestRatesManager
• IMorpho
• IOracle

Contents

• IAToken
• IERC20
• ILendingPool
• ILendingPoolAddressesProvider
• IPriceOracleGetter
• IReserveInterestRateStrategy
• IScaledBalanceToken
• IStableDebtToken
• IVariableDebtToken

IAToken

Git Source

Inherits: IERC20, IScaledBalanceToken

Functions

mint

Mints amount aTokens to user

function mint(address user, uint256 amount, uint256 index) external returns (bool);

Parameters

Returns

burn

Burns aTokens from user and sends the equivalent amount of underlying to receiverOfUnderlying

function burn(address user, address receiverOfUnderlying, uint256 amount, uint256 index) external;

Parameters

mintToTreasury

Mints aTokens to the reserve treasury

function mintToTreasury(uint256 amount, uint256 index) external;

Parameters

transferOnLiquidation

Transfers aTokens in the event of a borrow being liquidated, in case the liquidators reclaims the aToken

function transferOnLiquidation(address from, address to, uint256 value) external;

Parameters

transferUnderlyingTo

Transfers the underlying asset to target. Used by the LendingPool to transfer assets in borrow(), withdraw() and flashLoan()

function transferUnderlyingTo(address user, uint256 amount) external returns (uint256);

Parameters

Returns

UNDERLYING_ASSET_ADDRESS

function UNDERLYING_ASSET_ADDRESS() external view returns (address);

Events

Mint

Emitted after the mint action

event Mint(address indexed from, uint256 value, uint256 index);

Burn

Emitted after aTokens are burned

event Burn(address indexed from, address indexed target, uint256 value, uint256 index);

BalanceTransfer

Emitted during the transfer action

event BalanceTransfer(address indexed from, address indexed to, uint256 value, uint256 index);

IERC20

Git Source

Interface of the ERC20 standard as defined in the EIP.

Functions

totalSupply

Returns the amount of tokens in existence.

function totalSupply() external view returns (uint256);

balanceOf

Returns the amount of tokens owned by account.

function balanceOf(address account) external view returns (uint256);

transfer

Moves amount tokens from the caller's account to recipient. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.

function transfer(address recipient, uint256 amount) external returns (bool);

allowance

Returns the remaining number of tokens that spender will be allowed to spend on behalf of owner through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.

function allowance(address owner, address spender) external view returns (uint256);

approve

Sets amount as the allowance of spender over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.

function approve(address spender, uint256 amount) external returns (bool);

transferFrom

Moves amount tokens from sender to recipient using the allowance mechanism. amount is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.

function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

Events

Transfer

Emitted when value tokens are moved from one account (from) to another (to). Note that value may be zero.

event Transfer(address indexed from, address indexed to, uint256 value);

Approval

Emitted when the allowance of a spender for an owner is set by a call to {approve}. value is the new allowance.

event Approval(address indexed owner, address indexed spender, uint256 value);

ILendingPool

Git Source

Functions

deposit

*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*

function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;

Parameters

withdraw

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

function withdraw(address asset, uint256 amount, address to) external returns (uint256);

Parameters

Returns

borrow

*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*

function borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf)
    external;

Parameters

repay

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

function repay(address asset, uint256 amount, uint256 rateMode, address onBehalfOf) external returns (uint256);

Parameters

Returns

swapBorrowRateMode

Allows a borrower to swap his debt between stable and variable mode, or viceversa

function swapBorrowRateMode(address asset, uint256 rateMode) external;

Parameters

rebalanceStableBorrowRate

*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*

function rebalanceStableBorrowRate(address asset, address user) external;

Parameters

setUserUseReserveAsCollateral

Allows depositors to enable/disable a specific deposited asset as collateral

function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;

Parameters

liquidationCall

*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*

function liquidationCall(
    address collateralAsset,
    address debtAsset,
    address user,
    uint256 debtToCover,
    bool receiveAToken
) external;

Parameters

flashLoan

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

function flashLoan(
    address receiverAddress,
    address[] calldata assets,
    uint256[] calldata amounts,
    uint256[] calldata modes,
    address onBehalfOf,
    bytes calldata params,
    uint16 referralCode
) external;

Parameters

getUserAccountData

Returns the user account data across all the reserves

function getUserAccountData(address user)
    external
    view
    returns (
        uint256 totalCollateralETH,
        uint256 totalDebtETH,
        uint256 availableBorrowsETH,
        uint256 currentLiquidationThreshold,
        uint256 ltv,
        uint256 healthFactor
    );

Parameters

Returns

initReserve

function initReserve(
    address reserve,
    address aTokenAddress,
    address stableDebtAddress,
    address variableDebtAddress,
    address interestRateStrategyAddress
) external;

setReserveInterestRateStrategyAddress

function setReserveInterestRateStrategyAddress(address reserve, address rateStrategyAddress) external;

setConfiguration

function setConfiguration(address reserve, uint256 configuration) external;

getConfiguration

Returns the configuration of the reserve

function getConfiguration(address asset) external view returns (DataTypes.ReserveConfigurationMap memory);

Parameters

Returns

getUserConfiguration

Returns the configuration of the user across all the reserves

function getUserConfiguration(address user) external view returns (DataTypes.UserConfigurationMap memory);

Parameters

Returns

getReserveNormalizedIncome

Returns the normalized income normalized income of the reserve

function getReserveNormalizedIncome(address asset) external view returns (uint256);

Parameters

Returns

getReserveNormalizedVariableDebt

Returns the normalized variable debt per unit of asset

function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);

Parameters

Returns

getReserveData

Returns the state and configuration of the reserve

function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);

Parameters

Returns

finalizeTransfer

function finalizeTransfer(
    address asset,
    address from,
    address to,
    uint256 amount,
    uint256 balanceFromAfter,
    uint256 balanceToBefore
) external;

getReservesList

function getReservesList() external view returns (address[] memory);

getAddressesProvider

function getAddressesProvider() external view returns (ILendingPoolAddressesProvider);

setPause

function setPause(bool val) external;

paused

function paused() external view returns (bool);

FLASHLOAN_PREMIUM_TOTAL

function FLASHLOAN_PREMIUM_TOTAL() external view returns (uint256);

Events

Deposit

Emitted on deposit()

event Deposit(
    address indexed reserve, address user, address indexed onBehalfOf, uint256 amount, uint16 indexed referral
);

Withdraw

Emitted on withdraw()

event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount);

Borrow

Emitted on borrow() and flashLoan() when debt needs to be opened

event Borrow(
    address indexed reserve,
    address user,
    address indexed onBehalfOf,
    uint256 amount,
    uint256 borrowRateMode,
    uint256 borrowRate,
    uint16 indexed referral
);

Repay

Emitted on repay()

event Repay(address indexed reserve, address indexed user, address indexed repayer, uint256 amount);

Swap

Emitted on swapBorrowRateMode()

event Swap(address indexed reserve, address indexed user, uint256 rateMode);

ReserveUsedAsCollateralEnabled

Emitted on setUserUseReserveAsCollateral()

event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);

ReserveUsedAsCollateralDisabled

Emitted on setUserUseReserveAsCollateral()

event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);

RebalanceStableBorrowRate

Emitted on rebalanceStableBorrowRate()

event RebalanceStableBorrowRate(address indexed reserve, address indexed user);

FlashLoan

Emitted on flashLoan()

event FlashLoan(
    address indexed target,
    address indexed initiator,
    address indexed asset,
    uint256 amount,
    uint256 premium,
    uint16 referralCode
);

Paused

Emitted when the pause is triggered.

event Paused();

Unpaused

Emitted when the pause is lifted.

event Unpaused();

LiquidationCall

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.

event LiquidationCall(
    address indexed collateralAsset,
    address indexed debtAsset,
    address indexed user,
    uint256 debtToCover,
    uint256 liquidatedCollateralAmount,
    address liquidator,
    bool receiveAToken
);

ReserveDataUpdated

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

event ReserveDataUpdated(
    address indexed reserve,
    uint256 liquidityRate,
    uint256 stableBorrowRate,
    uint256 variableBorrowRate,
    uint256 liquidityIndex,
    uint256 variableBorrowIndex
);

ILendingPoolAddressesProvider

Git Source

Author: Aave

*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*

Functions

getMarketId

function getMarketId() external view returns (string memory);

setMarketId

function setMarketId(string calldata marketId) external;

setAddress

function setAddress(bytes32 id, address newAddress) external;

setAddressAsProxy

function setAddressAsProxy(bytes32 id, address impl) external;

getAddress

function getAddress(bytes32 id) external view returns (address);

getLendingPool

function getLendingPool() external view returns (address);

setLendingPoolImpl

function setLendingPoolImpl(address pool) external;

getLendingPoolConfigurator

function getLendingPoolConfigurator() external view returns (address);

setLendingPoolConfiguratorImpl

function setLendingPoolConfiguratorImpl(address configurator) external;

getLendingPoolCollateralManager

function getLendingPoolCollateralManager() external view returns (address);

setLendingPoolCollateralManager

function setLendingPoolCollateralManager(address manager) external;

getPoolAdmin

function getPoolAdmin() external view returns (address);

setPoolAdmin

function setPoolAdmin(address admin) external;

getEmergencyAdmin

function getEmergencyAdmin() external view returns (address);

setEmergencyAdmin

function setEmergencyAdmin(address admin) external;

getPriceOracle

function getPriceOracle() external view returns (address);

setPriceOracle

function setPriceOracle(address priceOracle) external;

getLendingRateOracle

function getLendingRateOracle() external view returns (address);

setLendingRateOracle

function setLendingRateOracle(address lendingRateOracle) external;

Events

MarketIdSet

event MarketIdSet(string newMarketId);

LendingPoolUpdated

event LendingPoolUpdated(address indexed newAddress);

ConfigurationAdminUpdated

event ConfigurationAdminUpdated(address indexed newAddress);

EmergencyAdminUpdated

event EmergencyAdminUpdated(address indexed newAddress);

LendingPoolConfiguratorUpdated

event LendingPoolConfiguratorUpdated(address indexed newAddress);

LendingPoolCollateralManagerUpdated

event LendingPoolCollateralManagerUpdated(address indexed newAddress);

PriceOracleUpdated

event PriceOracleUpdated(address indexed newAddress);

LendingRateOracleUpdated

event LendingRateOracleUpdated(address indexed newAddress);

ProxyCreated

event ProxyCreated(bytes32 id, address indexed newAddress);

AddressSet

event AddressSet(bytes32 id, address indexed newAddress, bool hasProxy);

IPriceOracleGetter

Git Source

Interface for the Aave price oracle.

Functions

getAssetPrice

returns the asset price in ETH

function getAssetPrice(address _asset) external view returns (uint256);

IReserveInterestRateStrategy

Git Source

Functions

baseVariableBorrowRate

function baseVariableBorrowRate() external view returns (uint256);

getMaxVariableBorrowRate

function getMaxVariableBorrowRate() external view returns (uint256);

calculateInterestRates

function calculateInterestRates(
    address reserve,
    uint256 utilizationRate,
    uint256 totalStableDebt,
    uint256 totalVariableDebt,
    uint256 averageStableBorrowRate,
    uint256 reserveFactor
) external view returns (uint256 liquidityRate, uint256 stableBorrowRate, uint256 variableBorrowRate);

IScaledBalanceToken

Git Source

Functions

scaledBalanceOf

Returns the scaled balance of the user. The scaled balance is the sum of all the updated stored balance divided by the reserve's liquidity index at the moment of the update

function scaledBalanceOf(address user) external view returns (uint256);

Parameters

Returns

getScaledUserBalanceAndSupply

Returns the scaled balance of the user and the scaled total supply.

function getScaledUserBalanceAndSupply(address user) external view returns (uint256, uint256);

Parameters

Returns

scaledTotalSupply

Returns the scaled total supply of the variable debt token. Represents sum(debt/index)

function scaledTotalSupply() external view returns (uint256);

Returns

IStableDebtToken

Git Source

Author: Aave

Defines the interface for the stable debt token

Functions

mint

Mints debt token to the onBehalfOf address.

The resulting rate is the weighted average between the rate of the new debt and the rate of the previous debt

function mint(address user, address onBehalfOf, uint256 amount, uint256 rate)
    external
    returns (bool, uint256, uint256);

Parameters

Returns

burn

Burns debt of user

The resulting rate is the weighted average between the rate of the new debt and the rate of the previous debt

In some instances, a burn transaction will emit a mint event if the amount to burn is less than the interest the user earned

function burn(address from, uint256 amount) external returns (uint256, uint256);

Parameters

Returns

getAverageStableRate

Returns the average rate of all the stable rate loans.

function getAverageStableRate() external view returns (uint256);

Returns

getUserStableRate

Returns the stable rate of the user debt

function getUserStableRate(address user) external view returns (uint256);

Parameters

Returns

getUserLastUpdated

Returns the timestamp of the last update of the user

function getUserLastUpdated(address user) external view returns (uint40);

Parameters

Returns

getSupplyData

Returns the principal, the total supply, the average stable rate and the timestamp for the last update

function getSupplyData() external view returns (uint256, uint256, uint256, uint40);

Returns

getTotalSupplyLastUpdated

Returns the timestamp of the last update of the total supply

function getTotalSupplyLastUpdated() external view returns (uint40);

Returns

getTotalSupplyAndAvgRate

Returns the total supply and the average stable rate

function getTotalSupplyAndAvgRate() external view returns (uint256, uint256);

Returns

principalBalanceOf

Returns the principal debt balance of the user

function principalBalanceOf(address user) external view returns (uint256);

Returns

UNDERLYING_ASSET_ADDRESS

Returns the address of the underlying asset of this stableDebtToken (E.g. WETH for stableDebtWETH)

function UNDERLYING_ASSET_ADDRESS() external view returns (address);

Returns

Events

Mint

Emitted when new stable debt is minted

event Mint(
    address indexed user,
    address indexed onBehalfOf,
    uint256 amount,
    uint256 currentBalance,
    uint256 balanceIncrease,
    uint256 newRate,
    uint256 avgStableRate,
    uint256 newTotalSupply
);

Burn

Emitted when new stable debt is burned

event Burn(
    address indexed from,
    uint256 amount,
    uint256 currentBalance,
    uint256 balanceIncrease,
    uint256 avgStableRate,
    uint256 newTotalSupply
);

IVariableDebtToken

Git Source

Inherits: IScaledBalanceToken

Author: Aave

Defines the basic interface for a variable debt token.

Functions

approveDelegation

delegates borrowing power to a user on the specific debt token

function approveDelegation(address delegatee, uint256 amount) external;

Parameters

borrowAllowance

returns the borrow allowance of the user

function borrowAllowance(address fromUser, address toUser) external view returns (uint256);

Parameters

Returns

mint

Mints debt token to the onBehalfOf address

function mint(address user, address onBehalfOf, uint256 amount, uint256 index) external returns (bool);

Parameters

Returns

burn

Burns user variable debt

function burn(address user, uint256 amount, uint256 index) external;

Parameters

balanceOf

Returns the debt balance of the user

function balanceOf(address user) external view returns (uint256);

Returns

Events

Mint

Emitted after the mint action

event Mint(address indexed from, address indexed onBehalfOf, uint256 value, uint256 index);

Burn

Emitted when variable debt is burnt

event Burn(address indexed user, uint256 amount, uint256 index);

Contents

• ILido

ILido

Git Source

Functions

getPooledEthByShares

function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);

submit

function submit(address _referral) external payable returns (uint256);

IEntryPositionsManager

Git Source

Functions

supplyLogic

function supplyLogic(
    address _poolToken,
    address _supplier,
    address _onBehalf,
    uint256 _amount,
    uint256 _maxGasForMatching
) external;

borrowLogic

function borrowLogic(address _poolToken, uint256 _amount, uint256 _maxGasForMatching) external;

IExitPositionsManager

Git Source

Functions

withdrawLogic

function withdrawLogic(
    address _poolToken,
    uint256 _amount,
    address _supplier,
    address _receiver,
    uint256 _maxGasForMatching
) external;

repayLogic

function repayLogic(
    address _poolToken,
    address _repayer,
    address _onBehalf,
    uint256 _amount,
    uint256 _maxGasForMatching
) external;

liquidateLogic

function liquidateLogic(address _poolTokenBorrowed, address _poolTokenCollateral, address _borrower, uint256 _amount)
    external;

increaseP2PDeltasLogic

function increaseP2PDeltasLogic(address _poolToken, uint256 _amount) external;

IGetterUnderlyingAsset

Git Source

Functions

UNDERLYING_ASSET_ADDRESS

function UNDERLYING_ASSET_ADDRESS() external view returns (address);

IInterestRatesManager

Git Source

Functions

updateIndexes

function updateIndexes(address _marketAddress) external;

IMorpho

Git Source

Functions

NO_REFERRAL_CODE

STORAGE ///

function NO_REFERRAL_CODE() external view returns (uint8);

VARIABLE_INTEREST_MODE

function VARIABLE_INTEREST_MODE() external view returns (uint8);

MAX_BASIS_POINTS

function MAX_BASIS_POINTS() external view returns (uint16);

DEFAULT_LIQUIDATION_CLOSE_FACTOR

function DEFAULT_LIQUIDATION_CLOSE_FACTOR() external view returns (uint256);

HEALTH_FACTOR_LIQUIDATION_THRESHOLD

function HEALTH_FACTOR_LIQUIDATION_THRESHOLD() external view returns (uint256);

MAX_NB_OF_MARKETS

function MAX_NB_OF_MARKETS() external view returns (uint256);

BORROWING_MASK

function BORROWING_MASK() external view returns (bytes32);

ONE

function ONE() external view returns (bytes32);

ST_ETH

function ST_ETH() external view returns (address);

ST_ETH_BASE_REBASE_INDEX

function ST_ETH_BASE_REBASE_INDEX() external view returns (uint256);

isClaimRewardsPaused

function isClaimRewardsPaused() external view returns (bool);

defaultMaxGasForMatching

function defaultMaxGasForMatching() external view returns (Types.MaxGasForMatching memory);

maxSortedUsers

function maxSortedUsers() external view returns (uint256);

supplyBalanceInOf

function supplyBalanceInOf(address, address) external view returns (Types.SupplyBalance memory);

borrowBalanceInOf

function borrowBalanceInOf(address, address) external view returns (Types.BorrowBalance memory);

deltas

function deltas(address) external view returns (Types.Delta memory);

market

function market(address) external view returns (Types.Market memory);

marketPauseStatus

function marketPauseStatus(address) external view returns (Types.MarketPauseStatus memory);

p2pSupplyIndex

function p2pSupplyIndex(address) external view returns (uint256);

p2pBorrowIndex

function p2pBorrowIndex(address) external view returns (uint256);

poolIndexes

function poolIndexes(address) external view returns (Types.PoolIndexes memory);

interestRatesManager

function interestRatesManager() external view returns (IInterestRatesManager);

entryPositionsManager

function entryPositionsManager() external view returns (IEntryPositionsManager);

exitPositionsManager

function exitPositionsManager() external view returns (IExitPositionsManager);

addressesProvider

function addressesProvider() external view returns (ILendingPoolAddressesProvider);

pool

function pool() external view returns (ILendingPool);

treasuryVault

function treasuryVault() external view returns (address);

borrowMask

function borrowMask(address) external view returns (bytes32);

userMarkets

function userMarkets(address) external view returns (bytes32);

updateIndexes

UTILS ///

function updateIndexes(address _poolToken) external;

getMarketsCreated

GETTERS ///

function getMarketsCreated() external view returns (address[] memory marketsCreated_);

getHead

function getHead(address _poolToken, Types.PositionType _positionType) external view returns (address head);

getNext

function getNext(address _poolToken, Types.PositionType _positionType, address _user)
    external
    view
    returns (address next);

setMaxSortedUsers

GOVERNANCE ///

function setMaxSortedUsers(uint256 _newMaxSortedUsers) external;

setDefaultMaxGasForMatching

function setDefaultMaxGasForMatching(Types.MaxGasForMatching memory _maxGasForMatching) external;

setExitPositionsManager

function setExitPositionsManager(IExitPositionsManager _exitPositionsManager) external;

setEntryPositionsManager

function setEntryPositionsManager(IEntryPositionsManager _entryPositionsManager) external;

setInterestRatesManager

function setInterestRatesManager(IInterestRatesManager _interestRatesManager) external;

setTreasuryVault

function setTreasuryVault(address _newTreasuryVaultAddress) external;

setIsP2PDisabled

function setIsP2PDisabled(address _poolToken, bool _isP2PDisabled) external;

setReserveFactor

function setReserveFactor(address _poolToken, uint256 _newReserveFactor) external;

setP2PIndexCursor

function setP2PIndexCursor(address _poolToken, uint16 _p2pIndexCursor) external;

setIsPausedForAllMarkets

function setIsPausedForAllMarkets(bool _isPaused) external;

setIsSupplyPaused

function setIsSupplyPaused(address _poolToken, bool _isPaused) external;

setIsBorrowPaused

function setIsBorrowPaused(address _poolToken, bool _isPaused) external;

setIsWithdrawPaused

function setIsWithdrawPaused(address _poolToken, bool _isPaused) external;

setIsRepayPaused

function setIsRepayPaused(address _poolToken, bool _isPaused) external;

setIsLiquidateCollateralPaused

function setIsLiquidateCollateralPaused(address _poolToken, bool _isPaused) external;

setIsLiquidateBorrowPaused

function setIsLiquidateBorrowPaused(address _poolToken, bool _isPaused) external;

claimToTreasury

function claimToTreasury(address[] calldata _poolTokens, uint256[] calldata _amounts) external;

createMarket

function createMarket(address _underlyingToken, uint16 _reserveFactor, uint16 _p2pIndexCursor) external;

increaseP2PDeltas

function increaseP2PDeltas(address _poolToken, uint256 _amount) external;

supply

USERS ///

function supply(address _poolToken, uint256 _amount) external;

supply

function supply(address _poolToken, address _onBehalf, uint256 _amount) external;

supply

function supply(address _poolToken, address _onBehalf, uint256 _amount, uint256 _maxGasForMatching) external;

borrow

function borrow(address _poolToken, uint256 _amount) external;

borrow

function borrow(address _poolToken, uint256 _amount, uint256 _maxGasForMatching) external;

withdraw

function withdraw(address _poolToken, uint256 _amount) external;

withdraw

function withdraw(address _poolToken, uint256 _amount, address _receiver) external;

repay

function repay(address _poolToken, uint256 _amount) external;

repay

function repay(address _poolToken, address _onBehalf, uint256 _amount) external;

liquidate

function liquidate(address _poolTokenBorrowed, address _poolTokenCollateral, address _borrower, uint256 _amount)
    external;

IOracle

Git Source

Functions

consult

function consult(uint256 _amountIn) external returns (uint256);

Contents

• interfaces
• IndexesLens
• Lens
• LensStorage
• MarketsLens
• RatesLens
• UsersLens

Contents

• ILens

ILens

Git Source

Functions

DEFAULT_LIQUIDATION_CLOSE_FACTOR

STORAGE ///

function DEFAULT_LIQUIDATION_CLOSE_FACTOR() external view returns (uint16);

HEALTH_FACTOR_LIQUIDATION_THRESHOLD

function HEALTH_FACTOR_LIQUIDATION_THRESHOLD() external view returns (uint256);

ST_ETH

function ST_ETH() external view returns (address);

ST_ETH_BASE_REBASE_INDEX

function ST_ETH_BASE_REBASE_INDEX() external view returns (uint256);

morpho

function morpho() external view returns (IMorpho);

addressesProvider

function addressesProvider() external view returns (ILendingPoolAddressesProvider);

pool

function pool() external view returns (ILendingPool);

getTotalSupply

GENERAL ///

function getTotalSupply()
    external
    view
    returns (uint256 p2pSupplyAmount, uint256 poolSupplyAmount, uint256 totalSupplyAmount);

getTotalBorrow

function getTotalBorrow()
    external
    view
    returns (uint256 p2pBorrowAmount, uint256 poolBorrowAmount, uint256 totalBorrowAmount);

isMarketCreated

MARKETS ///

function isMarketCreated(address _poolToken) external view returns (bool);

isMarketCreatedAndNotPaused

Deprecated.

function isMarketCreatedAndNotPaused(address _poolToken) external view returns (bool);

isMarketCreatedAndNotPausedNorPartiallyPaused

Deprecated.

function isMarketCreatedAndNotPausedNorPartiallyPaused(address _poolToken) external view returns (bool);

getAllMarkets

function getAllMarkets() external view returns (address[] memory marketsCreated_);

getMainMarketData

function getMainMarketData(address _poolToken)
    external
    view
    returns (
        uint256 avgSupplyRatePerYear,
        uint256 avgBorrowRatePerYear,
        uint256 p2pSupplyAmount,
        uint256 p2pBorrowAmount,
        uint256 poolSupplyAmount,
        uint256 poolBorrowAmount
    );

getAdvancedMarketData

function getAdvancedMarketData(address _poolToken)
    external
    view
    returns (Types.Indexes memory indexes, uint32 lastUpdateTimestamp, uint256 p2pSupplyDelta, uint256 p2pBorrowDelta);

getMarketConfiguration

function getMarketConfiguration(address _poolToken)
    external
    view
    returns (
        address underlying,
        bool isCreated,
        bool isP2PDisabled,
        bool isPaused,
        bool isPartiallyPaused,
        uint16 reserveFactor,
        uint16 p2pIndexCursor,
        uint256 loanToValue,
        uint256 liquidationThreshold,
        uint256 liquidationBonus,
        uint256 decimals
    );

getMarketPauseStatus

function getMarketPauseStatus(address _poolToken) external view returns (Types.MarketPauseStatus memory);

getTotalMarketSupply

function getTotalMarketSupply(address _poolToken)
    external
    view
    returns (uint256 p2pSupplyAmount, uint256 poolSupplyAmount);

getTotalMarketBorrow

function getTotalMarketBorrow(address _poolToken)
    external
    view
    returns (uint256 p2pBorrowAmount, uint256 poolBorrowAmount);

getCurrentP2PSupplyIndex

INDEXES ///

function getCurrentP2PSupplyIndex(address _poolToken) external view returns (uint256);

getCurrentP2PBorrowIndex

function getCurrentP2PBorrowIndex(address _poolToken) external view returns (uint256);

getIndexes

function getIndexes(address _poolToken) external view returns (Types.Indexes memory indexes);

getEnteredMarkets

USERS ///

function getEnteredMarkets(address _user) external view returns (address[] memory enteredMarkets);

getUserHealthFactor

function getUserHealthFactor(address _user) external view returns (uint256 healthFactor);

getUserBalanceStates

function getUserBalanceStates(address _user) external view returns (Types.LiquidityData memory assetData);

getCurrentSupplyBalanceInOf

function getCurrentSupplyBalanceInOf(address _poolToken, address _user)
    external
    view
    returns (uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

getCurrentBorrowBalanceInOf

function getCurrentBorrowBalanceInOf(address _poolToken, address _user)
    external
    view
    returns (uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

getUserMaxCapacitiesForAsset

function getUserMaxCapacitiesForAsset(address _user, address _poolToken)
    external
    view
    returns (uint256 withdrawable, uint256 borrowable);

getUserHypotheticalBalanceStates

function getUserHypotheticalBalanceStates(
    address _user,
    address _poolToken,
    uint256 _withdrawnAmount,
    uint256 _borrowedAmount
) external view returns (Types.LiquidityData memory assetData);

getUserHypotheticalHealthFactor

function getUserHypotheticalHealthFactor(
    address _user,
    address _poolToken,
    uint256 _withdrawnAmount,
    uint256 _borrowedAmount
) external view returns (uint256 healthFactor);

getUserLiquidityDataForAsset

function getUserLiquidityDataForAsset(address _user, address _poolToken, IPriceOracleGetter _oracle)
    external
    view
    returns (Types.AssetLiquidityData memory assetData);

isLiquidatable

function isLiquidatable(address _user) external view returns (bool);

isLiquidatable

function isLiquidatable(address _user, address _poolToken) external view returns (bool);

computeLiquidationRepayAmount

function computeLiquidationRepayAmount(address _user, address _poolTokenBorrowed, address _poolTokenCollateral)
    external
    view
    returns (uint256 toRepay);

getNextUserSupplyRatePerYear

RATES ///

function getNextUserSupplyRatePerYear(address _poolToken, address _user, uint256 _amount)
    external
    view
    returns (uint256 nextSupplyRatePerYear, uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

getNextUserBorrowRatePerYear

function getNextUserBorrowRatePerYear(address _poolToken, address _user, uint256 _amount)
    external
    view
    returns (uint256 nextBorrowRatePerYear, uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

getCurrentUserSupplyRatePerYear

function getCurrentUserSupplyRatePerYear(address _poolToken, address _user) external view returns (uint256);

getCurrentUserBorrowRatePerYear

function getCurrentUserBorrowRatePerYear(address _poolToken, address _user) external view returns (uint256);

getAverageSupplyRatePerYear

function getAverageSupplyRatePerYear(address _poolToken)
    external
    view
    returns (uint256 avgSupplyRatePerYear, uint256 p2pSupplyAmount, uint256 poolSupplyAmount);

getAverageBorrowRatePerYear

function getAverageBorrowRatePerYear(address _poolToken)
    external
    view
    returns (uint256 avgBorrowRatePerYear, uint256 p2pBorrowAmount, uint256 poolBorrowAmount);

getRatesPerYear

function getRatesPerYear(address _poolToken)
    external
    view
    returns (uint256 p2pSupplyRate, uint256 p2pBorrowRate, uint256 poolSupplyRate, uint256 poolBorrowRate);

IndexesLens

Git Source

Inherits: LensStorage

Author: Morpho Labs.

Intermediary layer exposing endpoints to query live data related to the Morpho Protocol market indexes & rates.

Functions

getCurrentP2PSupplyIndex

EXTERNAL ///

Returns the updated peer-to-peer supply index.

function getCurrentP2PSupplyIndex(address _poolToken) external view returns (uint256 p2pSupplyIndex);

Parameters

Returns

getCurrentP2PBorrowIndex

Returns the updated peer-to-peer borrow index.

function getCurrentP2PBorrowIndex(address _poolToken) external view returns (uint256 p2pBorrowIndex);

Parameters

Returns

getIndexes

Returns the updated peer-to-peer and pool indexes.

function getIndexes(address _poolToken) external view returns (Types.Indexes memory indexes);

Parameters

Returns

_getIndexes

INTERNAL ///

Returns the updated peer-to-peer and pool indexes.

function _getIndexes(address _poolToken)
    internal
    view
    returns (Types.Market memory market, Types.Delta memory delta, Types.Indexes memory indexes);

Parameters

Returns

_getPoolIndexes

Returns the current pool indexes.

function _getPoolIndexes(address _underlyingToken)
    internal
    view
    returns (uint256 poolSupplyIndex, uint256 poolBorrowIndex);

Parameters

Returns

Lens

Git Source

Inherits: MarketsLens

Author: Morpho Labs.

This contract exposes an API to query on-chain data related to the Morpho Protocol, its markets and its users.

Functions

constructor

CONSTRUCTOR ///

Constructs the contract.

constructor(address _morpho) LensStorage(_morpho);

Parameters

getTotalSupply

EXTERNAL ///

Computes and returns the total distribution of supply through Morpho, using virtually updated indexes.

function getTotalSupply()
    external
    view
    returns (uint256 p2pSupplyAmount, uint256 poolSupplyAmount, uint256 totalSupplyAmount);

Returns

getTotalBorrow

Computes and returns the total distribution of borrows through Morpho, using virtually updated indexes.

function getTotalBorrow()
    external
    view
    returns (uint256 p2pBorrowAmount, uint256 poolBorrowAmount, uint256 totalBorrowAmount);

Returns

LensStorage

Git Source

Inherits: ILens

Author: Morpho Labs.

Base layer to the Morpho Protocol Lens, managing the upgradeable storage layout.

State Variables

DEFAULT_LIQUIDATION_CLOSE_FACTOR

CONSTANTS ///

uint16 public constant DEFAULT_LIQUIDATION_CLOSE_FACTOR = 50_00;

HEALTH_FACTOR_LIQUIDATION_THRESHOLD

uint256 public constant HEALTH_FACTOR_LIQUIDATION_THRESHOLD = 1e18;

ST_ETH

address public constant ST_ETH = 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84;

ST_ETH_BASE_REBASE_INDEX

IMMUTABLES ///

uint256 public immutable ST_ETH_BASE_REBASE_INDEX;

morpho

IMorpho public immutable morpho;

addressesProvider

ILendingPoolAddressesProvider public immutable addressesProvider;

pool

ILendingPool public immutable pool;

Functions

constructor

CONSTRUCTOR ///

Constructs the contract.

constructor(address _morpho);

Parameters

MarketsLens

Git Source

Inherits: RatesLens

Author: Morpho Labs.

Intermediary layer exposing endpoints to query live data related to the Morpho Protocol markets.

Functions

isMarketCreated

EXTERNAL ///

Checks if a market is created.

function isMarketCreated(address _poolToken) external view returns (bool);

Parameters

Returns

isMarketCreatedAndNotPaused

Deprecated.

function isMarketCreatedAndNotPaused(address) external pure returns (bool);

isMarketCreatedAndNotPausedNorPartiallyPaused

Deprecated.

function isMarketCreatedAndNotPausedNorPartiallyPaused(address) external pure returns (bool);

getAllMarkets

Returns all created markets.

function getAllMarkets() external view returns (address[] memory marketsCreated);

Returns

getMainMarketData

For a given market, returns the average supply/borrow rates and amounts of underlying asset supplied and borrowed through Morpho, on the underlying pool and matched peer-to-peer.

The returned values are not updated.

function getMainMarketData(address _poolToken)
    external
    view
    returns (
        uint256 avgSupplyRatePerYear,
        uint256 avgBorrowRatePerYear,
        uint256 p2pSupplyAmount,
        uint256 p2pBorrowAmount,
        uint256 poolSupplyAmount,
        uint256 poolBorrowAmount
    );

Parameters

Returns

getAdvancedMarketData

Returns non-updated indexes, the block at which they were last updated and the total deltas of a given market.

function getAdvancedMarketData(address _poolToken)
    external
    view
    returns (Types.Indexes memory indexes, uint32 lastUpdateTimestamp, uint256 p2pSupplyDelta, uint256 p2pBorrowDelta);

Parameters

Returns

getMarketConfiguration

Returns the given market's configuration.

function getMarketConfiguration(address _poolToken)
    external
    view
    returns (
        address underlying,
        bool isCreated,
        bool isP2PDisabled,
        bool isPaused,
        bool isPartiallyPaused,
        uint16 reserveFactor,
        uint16 p2pIndexCursor,
        uint256 loanToValue,
        uint256 liquidationThreshold,
        uint256 liquidationBonus,
        uint256 decimals
    );

Parameters

Returns

getMarketPauseStatus

Returns the given market's pause statuses.

function getMarketPauseStatus(address _poolToken) external view returns (Types.MarketPauseStatus memory);

Parameters

Returns

getTotalMarketSupply

Computes and returns the total distribution of supply for a given market, using virtually updated indexes.

function getTotalMarketSupply(address _poolToken)
    external
    view
    returns (uint256 p2pSupplyAmount, uint256 poolSupplyAmount);

Parameters

Returns

getTotalMarketBorrow

Computes and returns the total distribution of borrows for a given market, using virtually updated indexes.

function getTotalMarketBorrow(address _poolToken)
    external
    view
    returns (uint256 p2pBorrowAmount, uint256 poolBorrowAmount);

Parameters

Returns

_getTotalMarketSupply

INTERNAL ///

Computes and returns the total distribution of supply for a given market, using virtually updated indexes.

function _getTotalMarketSupply(address _poolToken)
    internal
    view
    returns (address underlyingToken, uint256 p2pSupplyAmount, uint256 poolSupplyAmount);

Parameters

Returns

_getTotalMarketBorrow

Computes and returns the total distribution of borrows for a given market, using virtually updated indexes.

function _getTotalMarketBorrow(address _poolToken)
    internal
    view
    returns (address underlyingToken, uint256 p2pBorrowAmount, uint256 poolBorrowAmount);

Parameters

Returns

RatesLens

Git Source

Inherits: UsersLens

Author: Morpho Labs.

Intermediary layer exposing endpoints to query live data related to the Morpho Protocol users and their positions.

Functions

getNextUserSupplyRatePerYear

EXTERNAL ///

Returns the supply rate per year experienced on a market after having supplied the given amount on behalf of the given user.

Note: the returned supply rate is a low estimate: when supplying through Morpho-Aave, a supplier could be matched more than once instantly or later and thus benefit from a higher supply rate.

function getNextUserSupplyRatePerYear(address _poolToken, address _user, uint256 _amount)
    external
    view
    returns (uint256 nextSupplyRatePerYear, uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

Parameters

Returns

getNextUserBorrowRatePerYear

Returns the borrow rate per year experienced on a market after having supplied the given amount on behalf of the given user.

Note: the returned borrow rate is a high estimate: when borrowing through Morpho-Aave, a borrower could be matched more than once instantly or later and thus benefit from a lower borrow rate.

function getNextUserBorrowRatePerYear(address _poolToken, address _user, uint256 _amount)
    external
    view
    returns (uint256 nextBorrowRatePerYear, uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

Parameters

Returns

getCurrentUserSupplyRatePerYear

Returns the supply rate per year a given user is currently experiencing on a given market.

function getCurrentUserSupplyRatePerYear(address _poolToken, address _user)
    external
    view
    returns (uint256 supplyRatePerYear);

Parameters

Returns

getCurrentUserBorrowRatePerYear

Returns the borrow rate per year a given user is currently experiencing on a given market.

function getCurrentUserBorrowRatePerYear(address _poolToken, address _user)
    external
    view
    returns (uint256 borrowRatePerYear);

Parameters

Returns

getAverageSupplyRatePerYear

PUBLIC ///

Computes and returns the current supply rate per year experienced on average on a given market.

function getAverageSupplyRatePerYear(address _poolToken)
    public
    view
    returns (uint256 avgSupplyRatePerYear, uint256 p2pSupplyAmount, uint256 poolSupplyAmount);

Parameters

Returns

getAverageBorrowRatePerYear

Computes and returns the current average borrow rate per year experienced on a given market.

function getAverageBorrowRatePerYear(address _poolToken)
    public
    view
    returns (uint256 avgBorrowRatePerYear, uint256 p2pBorrowAmount, uint256 poolBorrowAmount);

Parameters

Returns

getRatesPerYear

Computes and returns peer-to-peer and pool rates for a specific market.

Note: prefer using getAverageSupplyRatePerYear & getAverageBorrowRatePerYear to get the actual experienced supply/borrow rate.

function getRatesPerYear(address _poolToken) public view returns (uint256, uint256, uint256, uint256);

Parameters

Returns

_getRatesPerYear

INTERNAL ///

Computes and returns peer-to-peer and pool rates for a specific market.

function _getRatesPerYear(
    address _poolToken,
    uint256 _suppliedOnPool,
    uint256 _borrowedFromPool,
    uint256 _withdrawnFromPool,
    uint256 _repaidOnPool
)
    internal
    view
    returns (uint256 p2pSupplyRate, uint256 p2pBorrowRate, uint256 poolSupplyRate, uint256 poolBorrowRate);

Parameters

Returns

_getPoolRatesPerYear

Computes and returns the underlying pool rates for a specific market.

function _getPoolRatesPerYear(
    address _underlying,
    uint256 _supplied,
    uint256 _borrowed,
    uint256 _withdrawn,
    uint256 _repaid
) internal view returns (uint256 poolSupplyRate, uint256 poolBorrowRate);

Parameters

Returns

_getMarketSupply

Computes and returns the total distribution of supply for a given market, using virtually updated indexes.

function _getMarketSupply(
    address _poolToken,
    uint256 _p2pSupplyIndex,
    uint256 _poolSupplyIndex,
    Types.Delta memory _delta
) internal view returns (uint256 p2pSupplyAmount, uint256 poolSupplyAmount);

Parameters

Returns

_getMarketBorrow

Computes and returns the total distribution of borrows for a given market, using virtually updated indexes.

function _getMarketBorrow(
    DataTypes.ReserveData memory reserve,
    uint256 _p2pBorrowIndex,
    uint256 _poolBorrowIndex,
    Types.Delta memory _delta
) internal view returns (uint256 p2pBorrowAmount, uint256 poolBorrowAmount);

Parameters

Returns

_getUserSupplyRatePerYear

Returns the supply rate per year experienced on a market based on a given position distribution. The calculation takes into account the change in pool rates implied by an hypothetical supply and/or repay.

function _getUserSupplyRatePerYear(
    address _poolToken,
    uint256 _balanceInP2P,
    uint256 _balanceOnPool,
    uint256 _suppliedOnPool,
    uint256 _repaidToPool
) internal view returns (uint256, uint256);

Parameters

Returns

_getUserBorrowRatePerYear

Returns the borrow rate per year experienced on a market based on a given position distribution. The calculation takes into account the change in pool rates implied by an hypothetical borrow and/or withdraw.

function _getUserBorrowRatePerYear(
    address _poolToken,
    uint256 _balanceInP2P,
    uint256 _balanceOnPool,
    uint256 _borrowedFromPool,
    uint256 _withdrawnFromPool
) internal view returns (uint256, uint256);

Parameters

Returns

_getWeightedRate

Returns the rate experienced based on a given pool & peer-to-peer distribution.

function _getWeightedRate(uint256 _p2pRate, uint256 _poolRate, uint256 _balanceInP2P, uint256 _balanceOnPool)
    internal
    pure
    returns (uint256 weightedRate, uint256 totalBalance);

Parameters

Returns

UsersLens

Git Source

Inherits: IndexesLens

Author: Morpho Labs.

Intermediary layer exposing endpoints to query live data related to the Morpho Protocol users and their positions.

Functions

getEnteredMarkets

EXTERNAL ///

Returns all markets entered by a given user.

function getEnteredMarkets(address _user) external view returns (address[] memory enteredMarkets);

Parameters

Returns

getUserMaxCapacitiesForAsset

Returns the maximum amount available to withdraw & borrow for a given user, on a given market.

function getUserMaxCapacitiesForAsset(address _user, address _poolToken)
    external
    view
    returns (uint256 withdrawable, uint256 borrowable);

Parameters

Returns

computeLiquidationRepayAmount

Computes the maximum repayable amount for a potential liquidation.

function computeLiquidationRepayAmount(address _user, address _poolTokenBorrowed, address _poolTokenCollateral)
    external
    view
    returns (uint256);

Parameters

Returns

getCurrentSupplyBalanceInOf

Returns the balance in underlying of a given user in a given market.

function getCurrentSupplyBalanceInOf(address _poolToken, address _user)
    external
    view
    returns (uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

Parameters

Returns

getCurrentBorrowBalanceInOf

Returns the borrow balance in underlying of a given user in a given market.

function getCurrentBorrowBalanceInOf(address _poolToken, address _user)
    external
    view
    returns (uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

Parameters

Returns

getUserBalanceStates

PUBLIC ///

Returns the collateral value, debt value and max debt value of a given user.

function getUserBalanceStates(address _user) public view returns (Types.LiquidityData memory);

Parameters

Returns

getUserHypotheticalBalanceStates

Returns the aggregated position of a given user, following an hypothetical borrow/withdraw on a given market, using virtually updated pool & peer-to-peer indexes for all markets.

function getUserHypotheticalBalanceStates(
    address _user,
    address _poolToken,
    uint256 _withdrawnAmount,
    uint256 _borrowedAmount
) public view returns (Types.LiquidityData memory liquidityData);

Parameters

Returns

getUserLiquidityDataForAsset

Returns the data related to _poolToken for the _user.

function getUserLiquidityDataForAsset(address _user, address _poolToken, IPriceOracleGetter _oracle)
    public
    view
    returns (Types.AssetLiquidityData memory);

Parameters

Returns

getUserHealthFactor

Returns the health factor of a given user, using virtually updated pool & peer-to-peer indexes for all markets.

function getUserHealthFactor(address _user) public view returns (uint256);

Parameters

Returns

getUserHypotheticalHealthFactor

Returns the hypothetical health factor of a user, following an hypothetical borrow/withdraw on a given market, using virtually updated pool & peer-to-peer indexes for all markets.

function getUserHypotheticalHealthFactor(
    address _user,
    address _poolToken,
    uint256 _withdrawnAmount,
    uint256 _borrowedAmount
) public view returns (uint256 healthFactor);

Parameters

Returns

isLiquidatable

Returns whether a liquidation can be performed on a given user, based on their health factor.

This function checks for the user's health factor, without treating borrow positions from deprecated market as instantly liquidatable.

function isLiquidatable(address _user) public view returns (bool);

Parameters

Returns

isLiquidatable

Returns whether a liquidation can be performed on a given user borrowing from a given market.

This function checks for the user's health factor as well as whether the given market is deprecated & the user is borrowing from it.

function isLiquidatable(address _user, address _poolToken) public view returns (bool);

Parameters

Returns

_isBorrowing

INTERNAL ///

Returns wheter the given user is borrowing from the given market.

function _isBorrowing(address _user, address _market) internal view returns (bool);

Parameters

Returns

_isSupplyingOrBorrowing

Returns whether the given user is borrowing or supplying on the given market.

function _isSupplyingOrBorrowing(bytes32 _userMarkets, address _market) internal view returns (bool);

Parameters

Returns

_getCurrentSupplyBalanceInOf

Returns the balance in underlying of a given user in a given market.

function _getCurrentSupplyBalanceInOf(address _poolToken, address _user)
    internal
    view
    returns (address underlyingToken, uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

Parameters

Returns

_getCurrentBorrowBalanceInOf

Returns the borrow balance in underlying of a given user in a given market.

function _getCurrentBorrowBalanceInOf(address _poolToken, address _user)
    internal
    view
    returns (address underlyingToken, uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

Parameters

Returns

_getSupplyBalanceInOf

Returns the supply balance of _user in the _poolToken market.

Note: Computes the result with the stored indexes, which are not always the most up to date ones.

function _getSupplyBalanceInOf(address _poolToken, address _user, uint256 _p2pSupplyIndex, uint256 _poolSupplyIndex)
    internal
    view
    returns (uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

Parameters

Returns

_getBorrowBalanceInOf

Returns the borrow balance of _user in the _poolToken market.

function _getBorrowBalanceInOf(address _poolToken, address _user, uint256 _p2pBorrowIndex, uint256 _poolBorrowIndex)
    internal
    view
    returns (uint256 balanceInP2P, uint256 balanceOnPool, uint256 totalBalance);

Parameters

Returns

_getUserHypotheticalLiquidityDataForAsset

Returns the data related to _poolToken for the _user.

function _getUserHypotheticalLiquidityDataForAsset(
    address _user,
    address _poolToken,
    IPriceOracleGetter _oracle,
    uint256 _withdrawnAmount,
    uint256 _borrowedAmount
) internal view returns (Types.AssetLiquidityData memory assetData);

Parameters

Returns

Contents

• aave
• InterestRatesModel
• Types

Contents

• DataTypes
• Errors
• ReserveConfiguration
• UserConfiguration

DataTypes

Git Source

Structs

ReserveData

struct ReserveData {
    ReserveConfigurationMap configuration;
    uint128 liquidityIndex;
    uint128 variableBorrowIndex;
    uint128 currentLiquidityRate;
    uint128 currentVariableBorrowRate;
    uint128 currentStableBorrowRate;
    uint40 lastUpdateTimestamp;
    address aTokenAddress;
    address stableDebtTokenAddress;
    address variableDebtTokenAddress;
    address interestRateStrategyAddress;
    uint8 id;
}

ReserveConfigurationMap

struct ReserveConfigurationMap {
    uint256 data;
}

UserConfigurationMap

struct UserConfigurationMap {
    uint256 data;
}

Enums

InterestRateMode

enum InterestRateMode {
    NONE,
    STABLE,
    VARIABLE
}

Errors

Git Source

Author: Aave

Defines the error messages emitted by the different contracts of the Aave protocol

*Error messages prefix glossary:

• VL = ValidationLogic
• MATH = Math libraries
• CT = Common errors between tokens (AToken, VariableDebtToken and StableDebtToken)
• AT = AToken
• SDT = StableDebtToken
• VDT = VariableDebtToken
• LP = LendingPool
• LPAPR = LendingPoolAddressesProviderRegistry
• LPC = LendingPoolConfiguration
• RL = ReserveLogic
• LPCM = LendingPoolCollateralManager
• P = Pausable*

State Variables

CALLER_NOT_POOL_ADMIN

string public constant CALLER_NOT_POOL_ADMIN = "33";

BORROW_ALLOWANCE_NOT_ENOUGH

string public constant BORROW_ALLOWANCE_NOT_ENOUGH = "59";

VL_INVALID_AMOUNT

string public constant VL_INVALID_AMOUNT = "1";

VL_NO_ACTIVE_RESERVE

string public constant VL_NO_ACTIVE_RESERVE = "2";

VL_RESERVE_FROZEN

string public constant VL_RESERVE_FROZEN = "3";

VL_CURRENT_AVAILABLE_LIQUIDITY_NOT_ENOUGH

string public constant VL_CURRENT_AVAILABLE_LIQUIDITY_NOT_ENOUGH = "4";

VL_NOT_ENOUGH_AVAILABLE_USER_BALANCE

string public constant VL_NOT_ENOUGH_AVAILABLE_USER_BALANCE = "5";

VL_TRANSFER_NOT_ALLOWED

string public constant VL_TRANSFER_NOT_ALLOWED = "6";

VL_BORROWING_NOT_ENABLED

string public constant VL_BORROWING_NOT_ENABLED = "7";

VL_INVALID_INTEREST_RATE_MODE_SELECTED

string public constant VL_INVALID_INTEREST_RATE_MODE_SELECTED = "8";

VL_COLLATERAL_BALANCE_IS_0

string public constant VL_COLLATERAL_BALANCE_IS_0 = "9";

VL_HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD

string public constant VL_HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD = "10";

VL_COLLATERAL_CANNOT_COVER_NEW_BORROW

string public constant VL_COLLATERAL_CANNOT_COVER_NEW_BORROW = "11";

VL_STABLE_BORROWING_NOT_ENABLED

string public constant VL_STABLE_BORROWING_NOT_ENABLED = "12";

VL_COLLATERAL_SAME_AS_BORROWING_CURRENCY

string public constant VL_COLLATERAL_SAME_AS_BORROWING_CURRENCY = "13";

VL_AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE

string public constant VL_AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE = "14";

VL_NO_DEBT_OF_SELECTED_TYPE

string public constant VL_NO_DEBT_OF_SELECTED_TYPE = "15";

VL_NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF

string public constant VL_NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF = "16";

VL_NO_STABLE_RATE_LOAN_IN_RESERVE

string public constant VL_NO_STABLE_RATE_LOAN_IN_RESERVE = "17";

VL_NO_VARIABLE_RATE_LOAN_IN_RESERVE

string public constant VL_NO_VARIABLE_RATE_LOAN_IN_RESERVE = "18";

VL_UNDERLYING_BALANCE_NOT_GREATER_THAN_0

string public constant VL_UNDERLYING_BALANCE_NOT_GREATER_THAN_0 = "19";

VL_DEPOSIT_ALREADY_IN_USE

string public constant VL_DEPOSIT_ALREADY_IN_USE = "20";

LP_NOT_ENOUGH_STABLE_BORROW_BALANCE

string public constant LP_NOT_ENOUGH_STABLE_BORROW_BALANCE = "21";

LP_INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET

string public constant LP_INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET = "22";

LP_LIQUIDATION_CALL_FAILED

string public constant LP_LIQUIDATION_CALL_FAILED = "23";

LP_NOT_ENOUGH_LIQUIDITY_TO_BORROW

string public constant LP_NOT_ENOUGH_LIQUIDITY_TO_BORROW = "24";

LP_REQUESTED_AMOUNT_TOO_SMALL

string public constant LP_REQUESTED_AMOUNT_TOO_SMALL = "25";

LP_INCONSISTENT_PROTOCOL_ACTUAL_BALANCE

string public constant LP_INCONSISTENT_PROTOCOL_ACTUAL_BALANCE = "26";

LP_CALLER_NOT_LENDING_POOL_CONFIGURATOR

string public constant LP_CALLER_NOT_LENDING_POOL_CONFIGURATOR = "27";

LP_INCONSISTENT_FLASHLOAN_PARAMS

string public constant LP_INCONSISTENT_FLASHLOAN_PARAMS = "28";

CT_CALLER_MUST_BE_LENDING_POOL

string public constant CT_CALLER_MUST_BE_LENDING_POOL = "29";

CT_CANNOT_GIVE_ALLOWANCE_TO_HIMSELF

string public constant CT_CANNOT_GIVE_ALLOWANCE_TO_HIMSELF = "30";

CT_TRANSFER_AMOUNT_NOT_GT_0

string public constant CT_TRANSFER_AMOUNT_NOT_GT_0 = "31";

RL_RESERVE_ALREADY_INITIALIZED

string public constant RL_RESERVE_ALREADY_INITIALIZED = "32";

LPC_RESERVE_LIQUIDITY_NOT_0

string public constant LPC_RESERVE_LIQUIDITY_NOT_0 = "34";

LPC_INVALID_ATOKEN_POOL_ADDRESS

string public constant LPC_INVALID_ATOKEN_POOL_ADDRESS = "35";

LPC_INVALID_STABLE_DEBT_TOKEN_POOL_ADDRESS

string public constant LPC_INVALID_STABLE_DEBT_TOKEN_POOL_ADDRESS = "36";

LPC_INVALID_VARIABLE_DEBT_TOKEN_POOL_ADDRESS

string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_POOL_ADDRESS = "37";

LPC_INVALID_STABLE_DEBT_TOKEN_UNDERLYING_ADDRESS

string public constant LPC_INVALID_STABLE_DEBT_TOKEN_UNDERLYING_ADDRESS = "38";

LPC_INVALID_VARIABLE_DEBT_TOKEN_UNDERLYING_ADDRESS

string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_UNDERLYING_ADDRESS = "39";

LPC_INVALID_ADDRESSES_PROVIDER_ID

string public constant LPC_INVALID_ADDRESSES_PROVIDER_ID = "40";

LPC_INVALID_CONFIGURATION

string public constant LPC_INVALID_CONFIGURATION = "75";

LPC_CALLER_NOT_EMERGENCY_ADMIN

string public constant LPC_CALLER_NOT_EMERGENCY_ADMIN = "76";

LPAPR_PROVIDER_NOT_REGISTERED

string public constant LPAPR_PROVIDER_NOT_REGISTERED = "41";

LPCM_HEALTH_FACTOR_NOT_BELOW_THRESHOLD

string public constant LPCM_HEALTH_FACTOR_NOT_BELOW_THRESHOLD = "42";

LPCM_COLLATERAL_CANNOT_BE_LIQUIDATED

string public constant LPCM_COLLATERAL_CANNOT_BE_LIQUIDATED = "43";

LPCM_SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER

string public constant LPCM_SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER = "44";

LPCM_NOT_ENOUGH_LIQUIDITY_TO_LIQUIDATE

string public constant LPCM_NOT_ENOUGH_LIQUIDITY_TO_LIQUIDATE = "45";

LPCM_NO_ERRORS

string public constant LPCM_NO_ERRORS = "46";

LP_INVALID_FLASHLOAN_MODE

string public constant LP_INVALID_FLASHLOAN_MODE = "47";

MATH_MULTIPLICATION_OVERFLOW

string public constant MATH_MULTIPLICATION_OVERFLOW = "48";

MATH_ADDITION_OVERFLOW

string public constant MATH_ADDITION_OVERFLOW = "49";

MATH_DIVISION_BY_ZERO

string public constant MATH_DIVISION_BY_ZERO = "50";

RL_LIQUIDITY_INDEX_OVERFLOW

string public constant RL_LIQUIDITY_INDEX_OVERFLOW = "51";

RL_VARIABLE_BORROW_INDEX_OVERFLOW

string public constant RL_VARIABLE_BORROW_INDEX_OVERFLOW = "52";

RL_LIQUIDITY_RATE_OVERFLOW

string public constant RL_LIQUIDITY_RATE_OVERFLOW = "53";

RL_VARIABLE_BORROW_RATE_OVERFLOW

string public constant RL_VARIABLE_BORROW_RATE_OVERFLOW = "54";

RL_STABLE_BORROW_RATE_OVERFLOW

string public constant RL_STABLE_BORROW_RATE_OVERFLOW = "55";

CT_INVALID_MINT_AMOUNT

string public constant CT_INVALID_MINT_AMOUNT = "56";

LP_FAILED_REPAY_WITH_COLLATERAL

string public constant LP_FAILED_REPAY_WITH_COLLATERAL = "57";

CT_INVALID_BURN_AMOUNT

string public constant CT_INVALID_BURN_AMOUNT = "58";

LP_FAILED_COLLATERAL_SWAP

string public constant LP_FAILED_COLLATERAL_SWAP = "60";

LP_INVALID_EQUAL_ASSETS_TO_SWAP

string public constant LP_INVALID_EQUAL_ASSETS_TO_SWAP = "61";

LP_REENTRANCY_NOT_ALLOWED

string public constant LP_REENTRANCY_NOT_ALLOWED = "62";

LP_CALLER_MUST_BE_AN_ATOKEN

string public constant LP_CALLER_MUST_BE_AN_ATOKEN = "63";

LP_IS_PAUSED

string public constant LP_IS_PAUSED = "64";

LP_NO_MORE_RESERVES_ALLOWED

string public constant LP_NO_MORE_RESERVES_ALLOWED = "65";

LP_INVALID_FLASH_LOAN_EXECUTOR_RETURN

string public constant LP_INVALID_FLASH_LOAN_EXECUTOR_RETURN = "66";

RC_INVALID_LTV

string public constant RC_INVALID_LTV = "67";

RC_INVALID_LIQ_THRESHOLD

string public constant RC_INVALID_LIQ_THRESHOLD = "68";

RC_INVALID_LIQ_BONUS

string public constant RC_INVALID_LIQ_BONUS = "69";

RC_INVALID_DECIMALS

string public constant RC_INVALID_DECIMALS = "70";

RC_INVALID_RESERVE_FACTOR

string public constant RC_INVALID_RESERVE_FACTOR = "71";

LPAPR_INVALID_ADDRESSES_PROVIDER_ID

string public constant LPAPR_INVALID_ADDRESSES_PROVIDER_ID = "72";

VL_INCONSISTENT_FLASHLOAN_PARAMS

string public constant VL_INCONSISTENT_FLASHLOAN_PARAMS = "73";

LP_INCONSISTENT_PARAMS_LENGTH

string public constant LP_INCONSISTENT_PARAMS_LENGTH = "74";

UL_INVALID_INDEX

string public constant UL_INVALID_INDEX = "77";

LP_NOT_CONTRACT

string public constant LP_NOT_CONTRACT = "78";

SDT_STABLE_DEBT_OVERFLOW

string public constant SDT_STABLE_DEBT_OVERFLOW = "79";

SDT_BURN_EXCEEDS_BALANCE

string public constant SDT_BURN_EXCEEDS_BALANCE = "80";

Enums

CollateralManagerErrors

enum CollateralManagerErrors {
    NO_ERROR,
    NO_COLLATERAL_AVAILABLE,
    COLLATERAL_CANNOT_BE_LIQUIDATED,
    CURRRENCY_NOT_BORROWED,
    HEALTH_FACTOR_ABOVE_THRESHOLD,
    NOT_ENOUGH_LIQUIDITY,
    NO_ACTIVE_RESERVE,
    HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD,
    INVALID_EQUAL_ASSETS_TO_SWAP,
    FROZEN_RESERVE
}

ReserveConfiguration

Git Source

Author: Aave

Implements the bitmap logic to handle the reserve configuration

State Variables

LTV_MASK

uint256 constant LTV_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000;

LIQUIDATION_THRESHOLD_MASK

uint256 constant LIQUIDATION_THRESHOLD_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000FFFF;

LIQUIDATION_BONUS_MASK

uint256 constant LIQUIDATION_BONUS_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000FFFFFFFF;

DECIMALS_MASK

uint256 constant DECIMALS_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00FFFFFFFFFFFF;

ACTIVE_MASK

uint256 constant ACTIVE_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFF;

FROZEN_MASK

uint256 constant FROZEN_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDFFFFFFFFFFFFFF;

BORROWING_MASK

uint256 constant BORROWING_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBFFFFFFFFFFFFFF;

STABLE_BORROWING_MASK

uint256 constant STABLE_BORROWING_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFFFFF;

RESERVE_FACTOR_MASK

uint256 constant RESERVE_FACTOR_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000FFFFFFFFFFFFFFFF;

LIQUIDATION_THRESHOLD_START_BIT_POSITION

For the LTV, the start bit is 0 (up to 15), hence no bitshifting is needed

uint256 constant LIQUIDATION_THRESHOLD_START_BIT_POSITION = 16;

LIQUIDATION_BONUS_START_BIT_POSITION

uint256 constant LIQUIDATION_BONUS_START_BIT_POSITION = 32;

RESERVE_DECIMALS_START_BIT_POSITION

uint256 constant RESERVE_DECIMALS_START_BIT_POSITION = 48;

IS_ACTIVE_START_BIT_POSITION

uint256 constant IS_ACTIVE_START_BIT_POSITION = 56;

IS_FROZEN_START_BIT_POSITION

uint256 constant IS_FROZEN_START_BIT_POSITION = 57;

BORROWING_ENABLED_START_BIT_POSITION

uint256 constant BORROWING_ENABLED_START_BIT_POSITION = 58;

STABLE_BORROWING_ENABLED_START_BIT_POSITION

uint256 constant STABLE_BORROWING_ENABLED_START_BIT_POSITION = 59;

RESERVE_FACTOR_START_BIT_POSITION

uint256 constant RESERVE_FACTOR_START_BIT_POSITION = 64;

MAX_VALID_LTV

uint256 constant MAX_VALID_LTV = 65535;

MAX_VALID_LIQUIDATION_THRESHOLD

uint256 constant MAX_VALID_LIQUIDATION_THRESHOLD = 65535;

MAX_VALID_LIQUIDATION_BONUS

uint256 constant MAX_VALID_LIQUIDATION_BONUS = 65535;

MAX_VALID_DECIMALS

uint256 constant MAX_VALID_DECIMALS = 255;

MAX_VALID_RESERVE_FACTOR

uint256 constant MAX_VALID_RESERVE_FACTOR = 65535;

Functions

setLtv

Sets the Loan to Value of the reserve

function setLtv(DataTypes.ReserveConfigurationMap memory self, uint256 ltv) internal pure;

Parameters

getLtv

Gets the Loan to Value of the reserve

function getLtv(DataTypes.ReserveConfigurationMap storage self) internal view returns (uint256);

Parameters

Returns

setLiquidationThreshold

Sets the liquidation threshold of the reserve

function setLiquidationThreshold(DataTypes.ReserveConfigurationMap memory self, uint256 threshold) internal pure;

Parameters

getLiquidationThreshold

Gets the liquidation threshold of the reserve

function getLiquidationThreshold(DataTypes.ReserveConfigurationMap storage self) internal view returns (uint256);

Parameters

Returns

setLiquidationBonus

Sets the liquidation bonus of the reserve

function setLiquidationBonus(DataTypes.ReserveConfigurationMap memory self, uint256 bonus) internal pure;

Parameters

getLiquidationBonus

Gets the liquidation bonus of the reserve

function getLiquidationBonus(DataTypes.ReserveConfigurationMap storage self) internal view returns (uint256);

Parameters

Returns

setDecimals

Sets the decimals of the underlying asset of the reserve

function setDecimals(DataTypes.ReserveConfigurationMap memory self, uint256 decimals) internal pure;

Parameters

getDecimals

Gets the decimals of the underlying asset of the reserve

function getDecimals(DataTypes.ReserveConfigurationMap storage self) internal view returns (uint256);

Parameters

Returns

setActive

Sets the active state of the reserve

function setActive(DataTypes.ReserveConfigurationMap memory self, bool active) internal pure;

Parameters

getActive

Gets the active state of the reserve

function getActive(DataTypes.ReserveConfigurationMap memory self) internal pure returns (bool);

Parameters

Returns

setFrozen

Sets the frozen state of the reserve

function setFrozen(DataTypes.ReserveConfigurationMap memory self, bool frozen) internal pure;

Parameters

getFrozen

Gets the frozen state of the reserve

function getFrozen(DataTypes.ReserveConfigurationMap storage self) internal view returns (bool);

Parameters

Returns

setBorrowingEnabled

Enables or disables borrowing on the reserve

function setBorrowingEnabled(DataTypes.ReserveConfigurationMap memory self, bool enabled) internal pure;

Parameters

getBorrowingEnabled

Gets the borrowing state of the reserve

function getBorrowingEnabled(DataTypes.ReserveConfigurationMap memory self) internal pure returns (bool);

Parameters

Returns

setStableRateBorrowingEnabled

Enables or disables stable rate borrowing on the reserve

function setStableRateBorrowingEnabled(DataTypes.ReserveConfigurationMap memory self, bool enabled) internal pure;

Parameters

getStableRateBorrowingEnabled

Gets the stable rate borrowing state of the reserve

function getStableRateBorrowingEnabled(DataTypes.ReserveConfigurationMap storage self) internal view returns (bool);

Parameters

Returns

setReserveFactor

Sets the reserve factor of the reserve

function setReserveFactor(DataTypes.ReserveConfigurationMap memory self, uint256 reserveFactor) internal pure;

Parameters

getReserveFactor

Gets the reserve factor of the reserve

function getReserveFactor(DataTypes.ReserveConfigurationMap storage self) internal view returns (uint256);

Parameters

Returns

getFlags

Gets the configuration flags of the reserve

function getFlags(DataTypes.ReserveConfigurationMap storage self) internal view returns (bool, bool, bool, bool);

Parameters

Returns

getParams

Gets the configuration paramters of the reserve

function getParams(DataTypes.ReserveConfigurationMap storage self)
    internal
    view
    returns (uint256, uint256, uint256, uint256, uint256);

Parameters

Returns

getParamsMemory

Gets the configuration paramters of the reserve from a memory object

function getParamsMemory(DataTypes.ReserveConfigurationMap memory self)
    internal
    pure
    returns (uint256, uint256, uint256, uint256, uint256);

Parameters

Returns

getFlagsMemory

Gets the configuration flags of the reserve from a memory object

function getFlagsMemory(DataTypes.ReserveConfigurationMap memory self) internal pure returns (bool, bool, bool, bool);

Parameters

Returns

UserConfiguration

Git Source

Functions

isUsingAsCollateral

function isUsingAsCollateral(DataTypes.UserConfigurationMap memory self, uint256 reserveIndex)
    internal
    pure
    returns (bool);

InterestRatesModel

Git Source

Functions

computeGrowthFactors

Computes and returns the new supply/borrow growth factors associated to the given market's pool & peer-to-peer indexes.

function computeGrowthFactors(
    uint256 _newPoolSupplyIndex,
    uint256 _newPoolBorrowIndex,
    Types.PoolIndexes memory _lastPoolIndexes,
    uint256 _p2pIndexCursor,
    uint256 _reserveFactor
) internal pure returns (GrowthFactors memory growthFactors);

Parameters

Returns

computeP2PIndex

Computes and returns the new peer-to-peer supply/borrow index of a market given its parameters.

function computeP2PIndex(P2PIndexComputeParams memory _params) internal pure returns (uint256 newP2PIndex);

Parameters

Returns

computeP2PSupplyRatePerYear

Computes and returns the peer-to-peer supply rate per year of a market given its parameters.

function computeP2PSupplyRatePerYear(P2PRateComputeParams memory _params)
    internal
    pure
    returns (uint256 p2pSupplyRate);

Parameters

Returns

computeP2PBorrowRatePerYear

Computes and returns the peer-to-peer borrow rate per year of a market given its parameters.

function computeP2PBorrowRatePerYear(P2PRateComputeParams memory _params)
    internal
    pure
    returns (uint256 p2pBorrowRate);

Parameters

Returns

Structs

GrowthFactors

STRUCTS ///

struct GrowthFactors {
    uint256 poolSupplyGrowthFactor;
    uint256 poolBorrowGrowthFactor;
    uint256 p2pSupplyGrowthFactor;
    uint256 p2pBorrowGrowthFactor;
}

P2PIndexComputeParams

struct P2PIndexComputeParams {
    uint256 poolGrowthFactor;
    uint256 p2pGrowthFactor;
    uint256 lastPoolIndex;
    uint256 lastP2PIndex;
    uint256 p2pDelta;
    uint256 p2pAmount;
}

P2PRateComputeParams

struct P2PRateComputeParams {
    uint256 poolSupplyRatePerYear;
    uint256 poolBorrowRatePerYear;
    uint256 poolIndex;
    uint256 p2pIndex;
    uint256 p2pDelta;
    uint256 p2pAmount;
    uint256 p2pIndexCursor;
    uint256 reserveFactor;
}

Types

Git Source

Author: Morpho Labs.

Common types and structs used in Morpho contracts.

Structs

SupplyBalance

STRUCTS ///

struct SupplyBalance {
    uint256 inP2P;
    uint256 onPool;
}

BorrowBalance

struct BorrowBalance {
    uint256 inP2P;
    uint256 onPool;
}

Indexes

struct Indexes {
    uint256 p2pSupplyIndex;
    uint256 p2pBorrowIndex;
    uint256 poolSupplyIndex;
    uint256 poolBorrowIndex;
}

MaxGasForMatching

struct MaxGasForMatching {
    uint64 supply;
    uint64 borrow;
    uint64 withdraw;
    uint64 repay;
}

Delta

struct Delta {
    uint256 p2pSupplyDelta;
    uint256 p2pBorrowDelta;
    uint256 p2pSupplyAmount;
    uint256 p2pBorrowAmount;
}

AssetLiquidityData

struct AssetLiquidityData {
    uint256 decimals;
    uint256 tokenUnit;
    uint256 liquidationThreshold;
    uint256 ltv;
    uint256 underlyingPrice;
    uint256 collateralEth;
    uint256 debtEth;
}

LiquidityData

struct LiquidityData {
    uint256 collateralEth;
    uint256 borrowableEth;
    uint256 maxDebtEth;
    uint256 debtEth;
}

PoolIndexes

struct PoolIndexes {
    uint32 lastUpdateTimestamp;
    uint112 poolSupplyIndex;
    uint112 poolBorrowIndex;
}

Market

struct Market {
    address underlyingToken;
    uint16 reserveFactor;
    uint16 p2pIndexCursor;
    bool isCreated;
    bool isPaused;
    bool isPartiallyPaused;
    bool isP2PDisabled;
}

MarketPauseStatus

struct MarketPauseStatus {
    bool isSupplyPaused;
    bool isBorrowPaused;
    bool isWithdrawPaused;
    bool isRepayPaused;
    bool isLiquidateCollateralPaused;
    bool isLiquidateBorrowPaused;
    bool isDeprecated;
}

Enums

PositionType

ENUMS ///

enum PositionType {
    SUPPLIERS_IN_P2P,
    SUPPLIERS_ON_POOL,
    BORROWERS_IN_P2P,
    BORROWERS_ON_POOL
}

EntryPositionsManager

Git Source

Inherits: IEntryPositionsManager, PositionsManagerUtils

Author: Morpho Labs.

Morpho's entry points: supply and borrow.

Functions

supplyLogic

LOGIC ///

Implements supply logic.

function supplyLogic(address _poolToken, address _from, address _onBehalf, uint256 _amount, uint256 _maxGasForMatching)
    external;

Parameters

borrowLogic

Peer-to-peer supply /// Pool supply ///

Implements borrow logic.

function borrowLogic(address _poolToken, uint256 _amount, uint256 _maxGasForMatching) external;

Parameters

_borrowAllowed

Peer-to-peer borrow /// Pool borrow ///

Checks whether the user can borrow or not.

function _borrowAllowed(address _user, address _poolToken, uint256 _borrowedAmount) internal returns (bool);

Parameters

Returns

Events

Supplied

EVENTS ///

Emitted when a supply happens.

event Supplied(
    address indexed _from,
    address indexed _onBehalf,
    address indexed _poolToken,
    uint256 _amount,
    uint256 _balanceOnPool,
    uint256 _balanceInP2P
);

Borrowed

Emitted when a borrow happens.

event Borrowed(
    address indexed _borrower,
    address indexed _poolToken,
    uint256 _amount,
    uint256 _balanceOnPool,
    uint256 _balanceInP2P
);

Errors

BorrowingNotEnabled

ERRORS ///

Thrown when borrowing is impossible, because it is not enabled on pool for this specific market.

error BorrowingNotEnabled();

UnauthorisedBorrow

Thrown when the user does not have enough collateral for the borrow.

error UnauthorisedBorrow();

SupplyIsPaused

Thrown when someone tries to supply but the supply is paused.

error SupplyIsPaused();

BorrowIsPaused

Thrown when someone tries to borrow but the borrow is paused.

error BorrowIsPaused();

Structs

SupplyVars

STRUCTS ///

struct SupplyVars {
    uint256 remainingToSupply;
    uint256 poolBorrowIndex;
    uint256 toRepay;
}

ExitPositionsManager

Git Source

Inherits: IExitPositionsManager, PositionsManagerUtils

Author: Morpho Labs.

Morpho's exit points: withdraw, repay and liquidate.

Functions

withdrawLogic

LOGIC ///

Implements withdraw logic with security checks.

function withdrawLogic(
    address _poolToken,
    uint256 _amount,
    address _supplier,
    address _receiver,
    uint256 _maxGasForMatching
) external;

Parameters

repayLogic

Implements repay logic with security checks.

function repayLogic(
    address _poolToken,
    address _repayer,
    address _onBehalf,
    uint256 _amount,
    uint256 _maxGasForMatching
) external;

Parameters

liquidateLogic

Liquidates a position.

function liquidateLogic(address _poolTokenBorrowed, address _poolTokenCollateral, address _borrower, uint256 _amount)
    external;

Parameters

increaseP2PDeltasLogic

Implements increaseP2PDeltas logic.

The current Morpho supply on the pool might not be enough to borrow _amount before resupplying it. In this case, consider calling this function multiple times.

function increaseP2PDeltasLogic(address _poolToken, uint256 _amount) external isMarketCreated(_poolToken);

Parameters

_unsafeWithdrawLogic

INTERNAL ///

Implements withdraw logic without security checks.

function _unsafeWithdrawLogic(
    address _poolToken,
    uint256 _amount,
    address _supplier,
    address _receiver,
    uint256 _maxGasForMatching
) internal;

Parameters

_unsafeRepayLogic

Pool withdraw /// Transfer withdraw /// Breaking withdraw ///

Implements repay logic without security checks.

function _unsafeRepayLogic(
    address _poolToken,
    address _repayer,
    address _onBehalf,
    uint256 _amount,
    uint256 _maxGasForMatching
) internal;

Parameters

_getUserHealthFactor

Pool repay /// Transfer repay /// Breaking repay ///

Returns the health factor of the user.

function _getUserHealthFactor(address _user, address _poolToken, uint256 _withdrawnAmount) internal returns (uint256);

Parameters

Returns

_withdrawAllowed

Checks whether the user can withdraw or not.

function _withdrawAllowed(address _user, address _poolToken, uint256 _withdrawnAmount) internal returns (bool);

Parameters

Returns

_liquidationAllowed

Returns whether a given user is liquidatable and the applicable close factor, given the deprecated status of the borrowed market.

function _liquidationAllowed(address _user, bool _isDeprecated)
    internal
    returns (bool liquidationAllowed, uint256 closeFactor);

Parameters

Returns

Events

Withdrawn

EVENTS ///

Emitted when a withdrawal happens.

event Withdrawn(
    address indexed _supplier,
    address indexed _receiver,
    address indexed _poolToken,
    uint256 _amount,
    uint256 _balanceOnPool,
    uint256 _balanceInP2P
);

Repaid

Emitted when a repayment happens.

event Repaid(
    address indexed _repayer,
    address indexed _onBehalf,
    address indexed _poolToken,
    uint256 _amount,
    uint256 _balanceOnPool,
    uint256 _balanceInP2P
);

Liquidated

Emitted when a liquidation happens.

event Liquidated(
    address _liquidator,
    address indexed _liquidated,
    address indexed _poolTokenBorrowed,
    uint256 _amountRepaid,
    address indexed _poolTokenCollateral,
    uint256 _amountSeized
);

P2PDeltasIncreased

Emitted when the peer-to-peer deltas are increased by the governance.

event P2PDeltasIncreased(address indexed _poolToken, uint256 _amount);

Errors

UserNotMemberOfMarket

ERRORS ///

Thrown when user is not a member of the market.

error UserNotMemberOfMarket();

UnauthorisedWithdraw

Thrown when the user does not have enough remaining collateral to withdraw.

error UnauthorisedWithdraw();

UnauthorisedLiquidate

Thrown when the positions of the user is not liquidatable.

error UnauthorisedLiquidate();

WithdrawIsPaused

Thrown when someone tries to withdraw but the withdraw is paused.

error WithdrawIsPaused();

RepayIsPaused

Thrown when someone tries to repay but the repay is paused.

error RepayIsPaused();

LiquidateCollateralIsPaused

Thrown when someone tries to liquidate but the liquidation with this asset as collateral is paused.

error LiquidateCollateralIsPaused();

LiquidateBorrowIsPaused

Thrown when someone tries to liquidate but the liquidation with this asset as debt is paused.

error LiquidateBorrowIsPaused();

Structs

WithdrawVars

STRUCTS ///

struct WithdrawVars {
    uint256 remainingGasForMatching;
    uint256 remainingToWithdraw;
    uint256 poolSupplyIndex;
    uint256 p2pSupplyIndex;
    uint256 onPoolSupply;
    uint256 toWithdraw;
}

RepayVars

struct RepayVars {
    uint256 remainingGasForMatching;
    uint256 remainingToRepay;
    uint256 poolSupplyIndex;
    uint256 poolBorrowIndex;
    uint256 p2pSupplyIndex;
    uint256 p2pBorrowIndex;
    uint256 borrowedOnPool;
    uint256 feeToRepay;
    uint256 toRepay;
}

LiquidateVars

struct LiquidateVars {
    uint256 liquidationBonus;
    uint256 collateralReserveDecimals;
    uint256 collateralTokenUnit;
    uint256 collateralBalance;
    uint256 collateralPrice;
    uint256 amountToSeize;
    uint256 borrowedReserveDecimals;
    uint256 borrowedTokenUnit;
    uint256 borrowedTokenPrice;
    uint256 amountToLiquidate;
    uint256 closeFactor;
    bool liquidationAllowed;
}

InterestRatesManager

Git Source

Inherits: IInterestRatesManager, MorphoStorage

Author: Morpho Labs.

Smart contract handling the computation of indexes used for peer-to-peer interactions.

This contract inherits from MorphoStorage so that Morpho can delegate calls to this contract.

Functions

updateIndexes

EXTERNAL ///

Updates the peer-to-peer indexes and pool indexes (only stored locally).

function updateIndexes(address _poolToken) external;

Parameters

_getPoolIndexes

INTERNAL ///

Returns the current pool indexes.

function _getPoolIndexes(address _underlyingToken)
    internal
    view
    returns (uint256 poolSupplyIndex, uint256 poolBorrowIndex);

Parameters

Returns

_computeP2PIndexes

Computes and returns new peer-to-peer indexes.

function _computeP2PIndexes(Params memory _params)
    internal
    pure
    returns (uint256 newP2PSupplyIndex, uint256 newP2PBorrowIndex);

Parameters