Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.8.12;

import {DebtTokenBase} from "./base/DebtTokenBase.sol";
import {MathUtils} from "../libraries/math/MathUtils.sol";
import {WadRayMath} from "../libraries/math/WadRayMath.sol";
import {IStableDebtToken} from "../../interfaces/IStableDebtToken.sol";
import {ILendingPool} from "../../interfaces/ILendingPool.sol";
import {IAaveIncentivesController} from "../../interfaces/IAaveIncentivesController.sol";
import {Errors} from "../libraries/helpers/Errors.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";

/**
 * @title StableDebtToken
 * @notice Implements a stable debt token to track the borrowing positions of users
 * at stable rate mode
 * @author Aave
 **/
contract StableDebtToken is IStableDebtToken, DebtTokenBase {
	using WadRayMath for uint256;
	using SafeMath for uint256;

	uint256 public constant DEBT_TOKEN_REVISION = 0x1;

	uint256 internal _avgStableRate;
	mapping(address => uint40) internal _timestamps;
	mapping(address => uint256) internal _usersStableRate;
	uint40 internal _totalSupplyTimestamp;

	IAaveIncentivesController internal _incentivesController;

	/**
	 * @dev Initializes the debt token.
	 * @param pool The address of the lending pool where this aToken will be used
	 * @param underlyingAsset The address of the underlying asset of this aToken (E.g. WETH for aWETH)
	 * @param incentivesController The smart contract managing potential incentives distribution
	 * @param debtTokenDecimals The decimals of the debtToken, same as the underlying asset's
	 * @param debtTokenName The name of the token
	 * @param debtTokenSymbol The symbol of the token
	 */
	function initialize(
		ILendingPool pool,
		address underlyingAsset,
		IAaveIncentivesController incentivesController,
		uint8 debtTokenDecimals,
		string memory debtTokenName,
		string memory debtTokenSymbol,
		bytes calldata params
	) public override initializer {
		_setName(debtTokenName);
		_setSymbol(debtTokenSymbol);
		_setDecimals(debtTokenDecimals);

		_pool = pool;
		_underlyingAsset = underlyingAsset;
		_incentivesController = incentivesController;

		emit Initialized(
			underlyingAsset,
			address(pool),
			address(incentivesController),
			debtTokenDecimals,
			debtTokenName,
			debtTokenSymbol,
			params
		);
	}

	/**
	 * @dev Gets the revision of the stable debt token implementation
	 * @return The debt token implementation revision
	 **/
	function getRevision() internal pure virtual override returns (uint256) {
		return DEBT_TOKEN_REVISION;
	}

	/**
	 * @dev Returns the average stable rate across all the stable rate debt
	 * @return the average stable rate
	 **/
	function getAverageStableRate() external view virtual override returns (uint256) {
		return _avgStableRate;
	}

	/**
	 * @dev Returns the timestamp of the last user action
	 * @return The last update timestamp
	 **/
	function getUserLastUpdated(address user) external view virtual override returns (uint40) {
		return _timestamps[user];
	}

	/**
	 * @dev Returns the stable rate of the user
	 * @param user The address of the user
	 * @return The stable rate of user
	 **/
	function getUserStableRate(address user) external view virtual override returns (uint256) {
		return _usersStableRate[user];
	}

	/**
	 * @dev Calculates the current user debt balance
	 * @return The accumulated debt of the user
	 **/
	function balanceOf(address account) public view virtual override returns (uint256) {
		uint256 accountBalance = super.balanceOf(account);
		uint256 stableRate = _usersStableRate[account];
		if (accountBalance == 0) {
			return 0;
		}
		uint256 cumulatedInterest = MathUtils.calculateCompoundedInterest(stableRate, _timestamps[account]);
		return accountBalance.rayMul(cumulatedInterest);
	}

	struct MintLocalVars {
		uint256 previousSupply;
		uint256 nextSupply;
		uint256 amountInRay;
		uint256 newStableRate;
		uint256 currentAvgStableRate;
	}

	/**
	 * @dev Mints debt token to the `onBehalfOf` address.
	 * -  Only callable by the LendingPool
	 * - The resulting rate is the weighted average between the rate of the new debt
	 * and the rate of the previous debt
	 * @param user The address receiving the borrowed underlying, being the delegatee in case
	 * of credit delegate, or same as `onBehalfOf` otherwise
	 * @param onBehalfOf The address receiving the debt tokens
	 * @param amount The amount of debt tokens to mint
	 * @param rate The rate of the debt being minted
	 **/
	function mint(
		address user,
		address onBehalfOf,
		uint256 amount,
		uint256 rate
	) external override onlyLendingPool returns (bool) {
		MintLocalVars memory vars;

		if (user != onBehalfOf) {
			_decreaseBorrowAllowance(onBehalfOf, user, amount);
		}

		(, uint256 currentBalance, uint256 balanceIncrease) = _calculateBalanceIncrease(onBehalfOf);

		vars.previousSupply = totalSupply();
		vars.currentAvgStableRate = _avgStableRate;
		vars.nextSupply = _totalSupply = vars.previousSupply.add(amount);

		vars.amountInRay = amount.wadToRay();

		vars.newStableRate = _usersStableRate[onBehalfOf]
			.rayMul(currentBalance.wadToRay())
			.add(vars.amountInRay.rayMul(rate))
			.rayDiv(currentBalance.add(amount).wadToRay());

		require(vars.newStableRate <= type(uint128).max, Errors.SDT_STABLE_DEBT_OVERFLOW);
		_usersStableRate[onBehalfOf] = vars.newStableRate;

		//solium-disable-next-line
		_totalSupplyTimestamp = _timestamps[onBehalfOf] = uint40(block.timestamp);

		// Calculates the updated average stable rate
		vars.currentAvgStableRate = _avgStableRate = vars
			.currentAvgStableRate
			.rayMul(vars.previousSupply.wadToRay())
			.add(rate.rayMul(vars.amountInRay))
			.rayDiv(vars.nextSupply.wadToRay());

		_mint(onBehalfOf, amount.add(balanceIncrease), vars.previousSupply);

		emit Transfer(address(0), onBehalfOf, amount);

		emit Mint(
			user,
			onBehalfOf,
			amount,
			currentBalance,
			balanceIncrease,
			vars.newStableRate,
			vars.currentAvgStableRate,
			vars.nextSupply
		);

		return currentBalance == 0;
	}

	/**
	 * @dev Burns debt of `user`
	 * @param user The address of the user getting his debt burned
	 * @param amount The amount of debt tokens getting burned
	 **/
	function burn(address user, uint256 amount) external override onlyLendingPool {
		(, uint256 currentBalance, uint256 balanceIncrease) = _calculateBalanceIncrease(user);

		uint256 previousSupply = totalSupply();
		uint256 newAvgStableRate = 0;
		uint256 nextSupply = 0;
		uint256 userStableRate = _usersStableRate[user];

		// Since the total supply and each single user debt accrue separately,
		// there might be accumulation errors so that the last borrower repaying
		// mght actually try to repay more than the available debt supply.
		// In this case we simply set the total supply and the avg stable rate to 0
		if (previousSupply <= amount) {
			_avgStableRate = 0;
			_totalSupply = 0;
		} else {
			nextSupply = _totalSupply = previousSupply.sub(amount);
			uint256 firstTerm = _avgStableRate.rayMul(previousSupply.wadToRay());
			uint256 secondTerm = userStableRate.rayMul(amount.wadToRay());

			// For the same reason described above, when the last user is repaying it might
			// happen that user rate * user balance > avg rate * total supply. In that case,
			// we simply set the avg rate to 0
			if (secondTerm >= firstTerm) {
				newAvgStableRate = _avgStableRate = _totalSupply = 0;
			} else {
				newAvgStableRate = _avgStableRate = firstTerm.sub(secondTerm).rayDiv(nextSupply.wadToRay());
			}
		}

		if (amount == currentBalance) {
			_usersStableRate[user] = 0;
			_timestamps[user] = 0;
		} else {
			//solium-disable-next-line
			_timestamps[user] = uint40(block.timestamp);
		}
		//solium-disable-next-line
		_totalSupplyTimestamp = uint40(block.timestamp);

		if (balanceIncrease > amount) {
			uint256 amountToMint = balanceIncrease.sub(amount);
			_mint(user, amountToMint, previousSupply);
			emit Mint(
				user,
				user,
				amountToMint,
				currentBalance,
				balanceIncrease,
				userStableRate,
				newAvgStableRate,
				nextSupply
			);
		} else {
			uint256 amountToBurn = amount.sub(balanceIncrease);
			_burn(user, amountToBurn, previousSupply);
			emit Burn(user, amountToBurn, currentBalance, balanceIncrease, newAvgStableRate, nextSupply);
		}

		emit Transfer(user, address(0), amount);
	}

	/**
	 * @dev Calculates the increase in balance since the last user interaction
	 * @param user The address of the user for which the interest is being accumulated
	 * @return The previous principal balance, the new principal balance and the balance increase
	 **/
	function _calculateBalanceIncrease(address user) internal view returns (uint256, uint256, uint256) {
		uint256 previousPrincipalBalance = super.balanceOf(user);

		if (previousPrincipalBalance == 0) {
			return (0, 0, 0);
		}

		// Calculation of the accrued interest since the last accumulation
		uint256 balanceIncrease = balanceOf(user).sub(previousPrincipalBalance);

		return (previousPrincipalBalance, previousPrincipalBalance.add(balanceIncrease), balanceIncrease);
	}

	/**
	 * @dev Returns the principal and total supply, the average borrow rate and the last supply update timestamp
	 **/
	function getSupplyData() public view override returns (uint256, uint256, uint256, uint40) {
		uint256 avgRate = _avgStableRate;
		return (super.totalSupply(), _calcTotalSupply(avgRate), avgRate, _totalSupplyTimestamp);
	}

	/**
	 * @dev Returns the the total supply and the average stable rate
	 **/
	function getTotalSupplyAndAvgRate() public view override returns (uint256, uint256) {
		uint256 avgRate = _avgStableRate;
		return (_calcTotalSupply(avgRate), avgRate);
	}

	/**
	 * @dev Returns the total supply
	 **/
	function totalSupply() public view override returns (uint256) {
		return _calcTotalSupply(_avgStableRate);
	}

	/**
	 * @dev Returns the timestamp at which the total supply was updated
	 **/
	function getTotalSupplyLastUpdated() public view override returns (uint40) {
		return _totalSupplyTimestamp;
	}

	/**
	 * @dev Returns the principal debt balance of the user from
	 * @param user The user's address
	 * @return The debt balance of the user since the last burn/mint action
	 **/
	function principalBalanceOf(address user) external view virtual override returns (uint256) {
		return super.balanceOf(user);
	}

	/**
	 * @dev Returns the address of the underlying asset of this aToken (E.g. WETH for aWETH)
	 **/
	function UNDERLYING_ASSET_ADDRESS() public view returns (address) {
		return _underlyingAsset;
	}

	/**
	 * @dev Returns the address of the lending pool where this aToken is used
	 **/
	function POOL() public view returns (ILendingPool) {
		return _pool;
	}

	/**
	 * @dev Returns the address of the incentives controller contract
	 **/
	function getIncentivesController() external view override returns (IAaveIncentivesController) {
		return _getIncentivesController();
	}

	/**
	 * @dev For internal usage in the logic of the parent contracts
	 **/
	function _getIncentivesController() internal view override returns (IAaveIncentivesController) {
		return _incentivesController;
	}

	/**
	 * @dev For internal usage in the logic of the parent contracts
	 **/
	function _getUnderlyingAssetAddress() internal view override returns (address) {
		return _underlyingAsset;
	}

	/**
	 * @dev For internal usage in the logic of the parent contracts
	 **/
	function _getLendingPool() internal view override returns (ILendingPool) {
		return _pool;
	}

	/**
	 * @dev Calculates the total supply
	 * @param avgRate The average rate at which the total supply increases
	 * @return The debt balance of the user since the last burn/mint action
	 **/
	function _calcTotalSupply(uint256 avgRate) internal view virtual returns (uint256) {
		uint256 principalSupply = super.totalSupply();

		if (principalSupply == 0) {
			return 0;
		}

		uint256 cumulatedInterest = MathUtils.calculateCompoundedInterest(avgRate, _totalSupplyTimestamp);

		return principalSupply.rayMul(cumulatedInterest);
	}

	/**
	 * @dev Mints stable debt tokens to an user
	 * @param account The account receiving the debt tokens
	 * @param amount The amount being minted
	 * @param oldTotalSupply the total supply before the minting event
	 **/
	function _mint(address account, uint256 amount, uint256 oldTotalSupply) internal {
		uint256 oldAccountBalance = _balances[account];
		if (address(_incentivesController) != address(0)) {
			_incentivesController.handleActionBefore(account);
		}
		_balances[account] = oldAccountBalance.add(amount);
		if (address(_incentivesController) != address(0)) {
			_incentivesController.handleActionAfter(account, oldAccountBalance, oldTotalSupply);
		}
	}

	/**
	 * @dev Burns stable debt tokens of an user
	 * @param account The user getting his debt burned
	 * @param amount The amount being burned
	 * @param oldTotalSupply The total supply before the burning event
	 **/
	function _burn(address account, uint256 amount, uint256 oldTotalSupply) internal {
		uint256 oldAccountBalance = _balances[account];
		if (address(_incentivesController) != address(0)) {
			_incentivesController.handleActionBefore(account);
		}
		_balances[account] = oldAccountBalance.sub(amount, Errors.SDT_BURN_EXCEEDS_BALANCE);
		if (address(_incentivesController) != address(0)) {
			_incentivesController.handleActionAfter(account, oldAccountBalance, oldTotalSupply);
		}
	}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev 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);

    /**
     * @dev 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);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev 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);

    /**
     * @dev 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);

    /**
     * @dev Moves `amount` tokens from `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.12;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
	function _msgSender() internal view virtual returns (address payable) {
		return payable(msg.sender);
	}

	function _msgData() internal view virtual returns (bytes memory) {
		this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
		return msg.data;
	}
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;
pragma experimental ABIEncoderV2;

interface IAaveIncentivesController {
	event RewardsAccrued(address indexed user, uint256 amount);

	event RewardsClaimed(address indexed user, address indexed to, uint256 amount);

	event RewardsClaimed(address indexed user, address indexed to, address indexed claimer, uint256 amount);

	event ClaimerSet(address indexed user, address indexed claimer);

	/*
	 * @dev Returns the configuration of the distribution for a certain asset
	 * @param asset The address of the reference asset of the distribution
	 * @return The asset index, the emission per second and the last updated timestamp
	 **/
	function getAssetData(address asset) external view returns (uint256, uint256, uint256);

	/**
	 * @dev Whitelists an address to claim the rewards on behalf of another address
	 * @param user The address of the user
	 * @param claimer The address of the claimer
	 */
	function setClaimer(address user, address claimer) external;

	/**
	 * @dev Returns the whitelisted claimer for a certain address (0x0 if not set)
	 * @param user The address of the user
	 * @return The claimer address
	 */
	function getClaimer(address user) external view returns (address);

	/**
	 * @dev Configure assets for a certain rewards emission
	 * @param assets The assets to incentivize
	 * @param emissionsPerSecond The emission for each asset
	 */
	function configureAssets(address[] calldata assets, uint256[] calldata emissionsPerSecond) external;

	/**
	 * @dev Called by the corresponding asset on any update that affects the rewards distribution
	 * @param user The address of the user
	 **/
	function handleActionBefore(address user) external;

	/**
	 * @dev Called by the corresponding asset on any update that affects the rewards distribution
	 * @param user The address of the user
	 * @param userBalance The balance of the user of the asset in the lending pool
	 * @param totalSupply The total supply of the asset in the lending pool
	 **/
	function handleActionAfter(address user, uint256 userBalance, uint256 totalSupply) external;

	/**
	 * @dev Returns the total of rewards of an user, already accrued + not yet accrued
	 * @param user The address of the user
	 * @return The rewards
	 **/
	function getRewardsBalance(address[] calldata assets, address user) external view returns (uint256);

	/**
	 * @dev Claims reward for an user, on all the assets of the lending pool, accumulating the pending rewards
	 * @param amount Amount of rewards to claim
	 * @param to Address that will be receiving the rewards
	 * @return Rewards claimed
	 **/
	function claimRewards(address[] calldata assets, uint256 amount, address to) external returns (uint256);

	/**
	 * @dev Claims reward for an user on behalf, on all the assets of the lending pool, accumulating the pending rewards. The caller must
	 * be whitelisted via "allowClaimOnBehalf" function by the RewardsAdmin role manager
	 * @param amount Amount of rewards to claim
	 * @param user Address to check and claim rewards
	 * @param to Address that will be receiving the rewards
	 * @return Rewards claimed
	 **/
	function claimRewardsOnBehalf(
		address[] calldata assets,
		uint256 amount,
		address user,
		address to
	) external returns (uint256);

	/**
	 * @dev returns the unclaimed rewards of the user
	 * @param user the address of the user
	 * @return the unclaimed user rewards
	 */
	function getUserUnclaimedRewards(address user) external view returns (uint256);

	/**
	 * @dev returns the unclaimed rewards of the user
	 * @param user the address of the user
	 * @param asset The asset to incentivize
	 * @return the user index for the asset
	 */
	function getUserAssetData(address user, address asset) external view returns (uint256);

	/**
	 * @dev for backward compatibility with previous implementation of the Incentives controller
	 */
	function REWARD_TOKEN() external view returns (address);

	/**
	 * @dev for backward compatibility with previous implementation of the Incentives controller
	 */
	function PRECISION() external view returns (uint8);

	/**
	 * @dev Gets the distribution end timestamp of the emissions
	 */
	function DISTRIBUTION_END() external view returns (uint256);
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

interface ICreditDelegationToken {
	event BorrowAllowanceDelegated(address indexed fromUser, address indexed toUser, address asset, uint256 amount);

	/**
	 * @dev delegates borrowing power to a user on the specific debt token
	 * @param delegatee the address receiving the delegated borrowing power
	 * @param amount the maximum amount being delegated. Delegation will still
	 * respect the liquidation constraints (even if delegated, a delegatee cannot
	 * force a delegator HF to go below 1)
	 **/
	function approveDelegation(address delegatee, uint256 amount) external;

	/**
	 * @dev returns the borrow allowance of the user
	 * @param fromUser The user to giving allowance
	 * @param toUser The user to give allowance to
	 * @return the current allowance of toUser
	 **/
	function borrowAllowance(address fromUser, address toUser) external view returns (uint256);
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

import {ILendingPool} from "./ILendingPool.sol";
import {IAaveIncentivesController} from "./IAaveIncentivesController.sol";

/**
 * @title IInitializableDebtToken
 * @notice Interface for the initialize function common between debt tokens
 * @author Aave
 **/
interface IInitializableDebtToken {
	/**
	 * @dev Emitted when a debt token is initialized
	 * @param underlyingAsset The address of the underlying asset
	 * @param pool The address of the associated lending pool
	 * @param incentivesController The address of the incentives controller for this aToken
	 * @param debtTokenDecimals the decimals of the debt token
	 * @param debtTokenName the name of the debt token
	 * @param debtTokenSymbol the symbol of the debt token
	 * @param params A set of encoded parameters for additional initialization
	 **/
	event Initialized(
		address indexed underlyingAsset,
		address indexed pool,
		address incentivesController,
		uint8 debtTokenDecimals,
		string debtTokenName,
		string debtTokenSymbol,
		bytes params
	);

	/**
	 * @dev Initializes the debt token.
	 * @param pool The address of the lending pool where this aToken will be used
	 * @param underlyingAsset The address of the underlying asset of this aToken (E.g. WETH for aWETH)
	 * @param incentivesController The smart contract managing potential incentives distribution
	 * @param debtTokenDecimals The decimals of the debtToken, same as the underlying asset's
	 * @param debtTokenName The name of the token
	 * @param debtTokenSymbol The symbol of the token
	 */
	function initialize(
		ILendingPool pool,
		address underlyingAsset,
		IAaveIncentivesController incentivesController,
		uint8 debtTokenDecimals,
		string memory debtTokenName,
		string memory debtTokenSymbol,
		bytes calldata params
	) external;
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;
pragma experimental ABIEncoderV2;

import {ILendingPoolAddressesProvider} from "./ILendingPoolAddressesProvider.sol";
import {DataTypes} from "../lending/libraries/types/DataTypes.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;

	function depositWithAutoDLP(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);
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

/**
 * @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;

	function getLiquidationFeeTo() external view returns (address);

	function setLiquidationFeeTo(address liquidationFeeTo) external;
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

/************
@title IPriceOracle interface
@notice Interface for the Aave price oracle.*/
interface IPriceOracle {
	/***********
    @dev returns the asset price in ETH
     */
	function getAssetPrice(address asset) external view returns (uint256);

	/***********
    @dev sets the asset price, in wei
     */
	function setAssetPrice(address asset, uint256 price) external;
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

import {IInitializableDebtToken} from "./IInitializableDebtToken.sol";
import {IAaveIncentivesController} from "./IAaveIncentivesController.sol";

/**
 * @title IStableDebtToken
 * @notice Defines the interface for the stable debt token
 * @dev It does not inherit from IERC20 to save in code size
 * @author Aave
 **/

interface IStableDebtToken is IInitializableDebtToken {
	/**
	 * @dev Emitted when new stable debt is minted
	 * @param user The address of the user who triggered the minting
	 * @param onBehalfOf The recipient of stable debt tokens
	 * @param amount The amount minted
	 * @param currentBalance The current balance of the user
	 * @param balanceIncrease The increase in balance since the last action of the user
	 * @param newRate The rate of the debt after the minting
	 * @param avgStableRate The new average stable rate after the minting
	 * @param newTotalSupply The new total supply of the stable debt token after the action
	 **/
	event Mint(
		address indexed user,
		address indexed onBehalfOf,
		uint256 amount,
		uint256 currentBalance,
		uint256 balanceIncrease,
		uint256 newRate,
		uint256 avgStableRate,
		uint256 newTotalSupply
	);

	/**
	 * @dev Emitted when new stable debt is burned
	 * @param user The address of the user
	 * @param amount The amount being burned
	 * @param currentBalance The current balance of the user
	 * @param balanceIncrease The the increase in balance since the last action of the user
	 * @param avgStableRate The new average stable rate after the burning
	 * @param newTotalSupply The new total supply of the stable debt token after the action
	 **/
	event Burn(
		address indexed user,
		uint256 amount,
		uint256 currentBalance,
		uint256 balanceIncrease,
		uint256 avgStableRate,
		uint256 newTotalSupply
	);

	/**
	 * @dev 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
	 * @param user The address receiving the borrowed underlying, being the delegatee in case
	 * of credit delegate, or same as `onBehalfOf` otherwise
	 * @param onBehalfOf The address receiving the debt tokens
	 * @param amount The amount of debt tokens to mint
	 * @param rate The rate of the debt being minted
	 **/
	function mint(address user, address onBehalfOf, uint256 amount, uint256 rate) external returns (bool);

	/**
	 * @dev 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
	 * @param user The address of the user getting his debt burned
	 * @param amount The amount of debt tokens getting burned
	 **/
	function burn(address user, uint256 amount) external;

	/**
	 * @dev Returns the average rate of all the stable rate loans.
	 * @return The average stable rate
	 **/
	function getAverageStableRate() external view returns (uint256);

	/**
	 * @dev Returns the stable rate of the user debt
	 * @return The stable rate of the user
	 **/
	function getUserStableRate(address user) external view returns (uint256);

	/**
	 * @dev Returns the timestamp of the last update of the user
	 * @return The timestamp
	 **/
	function getUserLastUpdated(address user) external view returns (uint40);

	/**
	 * @dev Returns the principal, the total supply and the average stable rate
	 **/
	function getSupplyData() external view returns (uint256, uint256, uint256, uint40);

	/**
	 * @dev Returns the timestamp of the last update of the total supply
	 * @return The timestamp
	 **/
	function getTotalSupplyLastUpdated() external view returns (uint40);

	/**
	 * @dev Returns the total supply and the average stable rate
	 **/
	function getTotalSupplyAndAvgRate() external view returns (uint256, uint256);

	/**
	 * @dev Returns the principal debt balance of the user
	 * @return The debt balance of the user since the last burn/mint action
	 **/
	function principalBalanceOf(address user) external view returns (uint256);

	/**
	 * @dev Returns the address of the incentives controller contract
	 **/
	function getIncentivesController() external view returns (IAaveIncentivesController);
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

/**
 * @title VersionedInitializable
 *
 * @dev Helper contract to implement initializer functions. To use it, replace
 * the constructor with a function that has the `initializer` modifier.
 * WARNING: Unlike constructors, initializer functions must be manually
 * invoked. This applies both to deploying an Initializable contract, as well
 * as extending an Initializable contract via inheritance.
 * WARNING: When used with inheritance, manual care must be taken to not invoke
 * a parent initializer twice, or ensure that all initializers are idempotent,
 * because this is not dealt with automatically as with constructors.
 *
 * @author Aave, inspired by the OpenZeppelin Initializable contract
 */
abstract contract VersionedInitializable {
	/**
	 * @dev Indicates that the contract has been initialized.
	 */
	uint256 private lastInitializedRevision = 0;

	/**
	 * @dev Indicates that the contract is in the process of being initialized.
	 */
	bool private initializing;

	/**
	 * @dev Modifier to use in the initializer function of a contract.
	 */
	modifier initializer() {
		uint256 revision = getRevision();
		require(
			initializing || isConstructor() || revision > lastInitializedRevision,
			"Contract instance has already been initialized"
		);

		bool isTopLevelCall = !initializing;
		if (isTopLevelCall) {
			initializing = true;
			lastInitializedRevision = revision;
		}

		_;

		if (isTopLevelCall) {
			initializing = false;
		}
	}

	/**
	 * @dev returns the revision number of the contract
	 * Needs to be defined in the inherited class as a constant.
	 **/
	function getRevision() internal pure virtual returns (uint256);

	/**
	 * @dev Returns true if and only if the function is running in the constructor
	 **/
	function isConstructor() private view returns (bool) {
		// extcodesize checks the size of the code stored in an address, and
		// address returns the current address. Since the code is still not
		// deployed when running a constructor, any checks on its code size will
		// yield zero, making it an effective way to detect if a contract is
		// under construction or not.
		uint256 cs;
		//solium-disable-next-line
		assembly {
			cs := extcodesize(address())
		}
		return cs == 0;
	}

	// Reserved storage space to allow for layout changes in the future.
	uint256[50] private ______gap;
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

/**
 * @title Errors library
 * @author Aave
 * @notice Defines the error messages emitted by the different contracts of the Aave protocol
 * @dev 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
 */
library Errors {
	//common errors
	string public constant CALLER_NOT_POOL_ADMIN = "33"; // 'The caller must be the pool admin'
	string public constant BORROW_ALLOWANCE_NOT_ENOUGH = "59"; // User borrows on behalf, but allowance are too small

	//contract specific errors
	string public constant VL_INVALID_AMOUNT = "1"; // 'Amount must be greater than 0'
	string public constant VL_NO_ACTIVE_RESERVE = "2"; // 'Action requires an active reserve'
	string public constant VL_RESERVE_FROZEN = "3"; // 'Action cannot be performed because the reserve is frozen'
	string public constant VL_CURRENT_AVAILABLE_LIQUIDITY_NOT_ENOUGH = "4"; // 'The current liquidity is not enough'
	string public constant VL_NOT_ENOUGH_AVAILABLE_USER_BALANCE = "5"; // 'User cannot withdraw more than the available balance'
	string public constant VL_TRANSFER_NOT_ALLOWED = "6"; // 'Transfer cannot be allowed.'
	string public constant VL_BORROWING_NOT_ENABLED = "7"; // 'Borrowing is not enabled'
	string public constant VL_INVALID_INTEREST_RATE_MODE_SELECTED = "8"; // 'Invalid interest rate mode selected'
	string public constant VL_COLLATERAL_BALANCE_IS_0 = "9"; // 'The collateral balance is 0'
	string public constant VL_HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD = "10"; // 'Health factor is lesser than the liquidation threshold'
	string public constant VL_COLLATERAL_CANNOT_COVER_NEW_BORROW = "11"; // 'There is not enough collateral to cover a new borrow'
	string public constant VL_STABLE_BORROWING_NOT_ENABLED = "12"; // stable borrowing not enabled
	string public constant VL_COLLATERAL_SAME_AS_BORROWING_CURRENCY = "13"; // collateral is (mostly) the same currency that is being borrowed
	string public constant VL_AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE = "14"; // 'The requested amount is greater than the max loan size in stable rate mode
	string public constant VL_NO_DEBT_OF_SELECTED_TYPE = "15"; // 'for repayment of stable debt, the user needs to have stable debt, otherwise, he needs to have variable debt'
	string public constant VL_NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF = "16"; // 'To repay on behalf of an user an explicit amount to repay is needed'
	string public constant VL_NO_STABLE_RATE_LOAN_IN_RESERVE = "17"; // 'User does not have a stable rate loan in progress on this reserve'
	string public constant VL_NO_VARIABLE_RATE_LOAN_IN_RESERVE = "18"; // 'User does not have a variable rate loan in progress on this reserve'
	string public constant VL_UNDERLYING_BALANCE_NOT_GREATER_THAN_0 = "19"; // 'The underlying balance needs to be greater than 0'
	string public constant VL_DEPOSIT_ALREADY_IN_USE = "20"; // 'User deposit is already being used as collateral'
	string public constant LP_NOT_ENOUGH_STABLE_BORROW_BALANCE = "21"; // 'User does not have any stable rate loan for this reserve'
	string public constant LP_INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET = "22"; // 'Interest rate rebalance conditions were not met'
	string public constant LP_LIQUIDATION_CALL_FAILED = "23"; // 'Liquidation call failed'
	string public constant LP_NOT_ENOUGH_LIQUIDITY_TO_BORROW = "24"; // 'There is not enough liquidity available to borrow'
	string public constant LP_REQUESTED_AMOUNT_TOO_SMALL = "25"; // 'The requested amount is too small for a FlashLoan.'
	string public constant LP_INCONSISTENT_PROTOCOL_ACTUAL_BALANCE = "26"; // 'The actual balance of the protocol is inconsistent'
	string public constant LP_CALLER_NOT_LENDING_POOL_CONFIGURATOR = "27"; // 'The caller of the function is not the lending pool configurator'
	string public constant LP_INCONSISTENT_FLASHLOAN_PARAMS = "28";
	string public constant CT_CALLER_MUST_BE_LENDING_POOL = "29"; // 'The caller of this function must be a lending pool'
	string public constant CT_CANNOT_GIVE_ALLOWANCE_TO_HIMSELF = "30"; // 'User cannot give allowance to himself'
	string public constant CT_TRANSFER_AMOUNT_NOT_GT_0 = "31"; // 'Transferred amount needs to be greater than zero'
	string public constant RL_RESERVE_ALREADY_INITIALIZED = "32"; // 'Reserve has already been initialized'
	string public constant LPC_RESERVE_LIQUIDITY_NOT_0 = "34"; // 'The liquidity of the reserve needs to be 0'
	string public constant LPC_INVALID_ATOKEN_POOL_ADDRESS = "35"; // 'The liquidity of the reserve needs to be 0'
	string public constant LPC_INVALID_STABLE_DEBT_TOKEN_POOL_ADDRESS = "36"; // 'The liquidity of the reserve needs to be 0'
	string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_POOL_ADDRESS = "37"; // 'The liquidity of the reserve needs to be 0'
	string public constant LPC_INVALID_STABLE_DEBT_TOKEN_UNDERLYING_ADDRESS = "38"; // 'The liquidity of the reserve needs to be 0'
	string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_UNDERLYING_ADDRESS = "39"; // 'The liquidity of the reserve needs to be 0'
	string public constant LPC_INVALID_ADDRESSES_PROVIDER_ID = "40"; // 'The liquidity of the reserve needs to be 0'
	string public constant LPC_INVALID_CONFIGURATION = "75"; // 'Invalid risk parameters for the reserve'
	string public constant LPC_CALLER_NOT_EMERGENCY_ADMIN = "76"; // 'The caller must be the emergency admin'
	string public constant LPAPR_PROVIDER_NOT_REGISTERED = "41"; // 'Provider is not registered'
	string public constant LPCM_HEALTH_FACTOR_NOT_BELOW_THRESHOLD = "42"; // 'Health factor is not below the threshold'
	string public constant LPCM_COLLATERAL_CANNOT_BE_LIQUIDATED = "43"; // 'The collateral chosen cannot be liquidated'
	string public constant LPCM_SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER = "44"; // 'User did not borrow the specified currency'
	string public constant LPCM_NOT_ENOUGH_LIQUIDITY_TO_LIQUIDATE = "45"; // "There isn't enough liquidity available to liquidate"
	string public constant LPCM_NO_ERRORS = "46"; // 'No errors'
	string public constant LP_INVALID_FLASHLOAN_MODE = "47"; //Invalid flashloan mode selected
	string public constant MATH_MULTIPLICATION_OVERFLOW = "48";
	string public constant MATH_ADDITION_OVERFLOW = "49";
	string public constant MATH_DIVISION_BY_ZERO = "50";
	string public constant RL_LIQUIDITY_INDEX_OVERFLOW = "51"; //  Liquidity index overflows uint128
	string public constant RL_VARIABLE_BORROW_INDEX_OVERFLOW = "52"; //  Variable borrow index overflows uint128
	string public constant RL_LIQUIDITY_RATE_OVERFLOW = "53"; //  Liquidity rate overflows uint128
	string public constant RL_VARIABLE_BORROW_RATE_OVERFLOW = "54"; //  Variable borrow rate overflows uint128
	string public constant RL_STABLE_BORROW_RATE_OVERFLOW = "55"; //  Stable borrow rate overflows uint128
	string public constant CT_INVALID_MINT_AMOUNT = "56"; //invalid amount to mint
	string public constant LP_FAILED_REPAY_WITH_COLLATERAL = "57";
	string public constant CT_INVALID_BURN_AMOUNT = "58"; //invalid amount to burn
	string public constant LP_FAILED_COLLATERAL_SWAP = "60";
	string public constant LP_INVALID_EQUAL_ASSETS_TO_SWAP = "61";
	string public constant LP_REENTRANCY_NOT_ALLOWED = "62";
	string public constant LP_CALLER_MUST_BE_AN_ATOKEN = "63";
	string public constant LP_IS_PAUSED = "64"; // 'Pool is paused'
	string public constant LP_NO_MORE_RESERVES_ALLOWED = "65";
	string public constant LP_INVALID_FLASH_LOAN_EXECUTOR_RETURN = "66";
	string public constant RC_INVALID_LTV = "67";
	string public constant RC_INVALID_LIQ_THRESHOLD = "68";
	string public constant RC_INVALID_LIQ_BONUS = "69";
	string public constant RC_INVALID_DECIMALS = "70";
	string public constant RC_INVALID_RESERVE_FACTOR = "71";
	string public constant LPAPR_INVALID_ADDRESSES_PROVIDER_ID = "72";
	string public constant VL_INCONSISTENT_FLASHLOAN_PARAMS = "73";
	string public constant LP_INCONSISTENT_PARAMS_LENGTH = "74";
	string public constant UL_INVALID_INDEX = "77";
	string public constant LP_NOT_CONTRACT = "78";
	string public constant SDT_STABLE_DEBT_OVERFLOW = "79";
	string public constant SDT_BURN_EXCEEDS_BALANCE = "80";

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

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import {WadRayMath} from "./WadRayMath.sol";

library MathUtils {
	using SafeMath for uint256;
	using WadRayMath for uint256;

	/// @dev Ignoring leap years
	uint256 internal constant SECONDS_PER_YEAR = 365 days;

	/**
	 * @dev Function to calculate the interest accumulated using a linear interest rate formula
	 * @param rate The interest rate, in ray
	 * @param lastUpdateTimestamp The timestamp of the last update of the interest
	 * @return The interest rate linearly accumulated during the timeDelta, in ray
	 **/

	function calculateLinearInterest(uint256 rate, uint40 lastUpdateTimestamp) internal view returns (uint256) {
		//solium-disable-next-line
		uint256 timeDifference = block.timestamp.sub(uint256(lastUpdateTimestamp));

		return (rate.mul(timeDifference) / SECONDS_PER_YEAR).add(WadRayMath.ray());
	}

	/**
	 * @dev Function to calculate the interest using a compounded interest rate formula
	 * To avoid expensive exponentiation, the calculation is performed using a binomial approximation:
	 *
	 *  (1+x)^n = 1+n*x+[n/2*(n-1)]*x^2+[n/6*(n-1)*(n-2)*x^3...
	 *
	 * The approximation slightly underpays liquidity providers and undercharges borrowers, with the advantage of great gas cost reductions
	 * The whitepaper contains reference to the approximation and a table showing the margin of error per different time periods
	 *
	 * @param rate The interest rate, in ray
	 * @param lastUpdateTimestamp The timestamp of the last update of the interest
	 * @return The interest rate compounded during the timeDelta, in ray
	 **/
	function calculateCompoundedInterest(
		uint256 rate,
		uint40 lastUpdateTimestamp,
		uint256 currentTimestamp
	) internal pure returns (uint256) {
		//solium-disable-next-line
		uint256 exp = currentTimestamp.sub(uint256(lastUpdateTimestamp));

		if (exp == 0) {
			return WadRayMath.ray();
		}

		uint256 expMinusOne = exp - 1;

		uint256 expMinusTwo = exp > 2 ? exp - 2 : 0;

		uint256 ratePerSecond = rate / SECONDS_PER_YEAR;

		uint256 basePowerTwo = ratePerSecond.rayMul(ratePerSecond);
		uint256 basePowerThree = basePowerTwo.rayMul(ratePerSecond);

		uint256 secondTerm = exp.mul(expMinusOne).mul(basePowerTwo) / 2;
		uint256 thirdTerm = exp.mul(expMinusOne).mul(expMinusTwo).mul(basePowerThree) / 6;

		return WadRayMath.ray().add(ratePerSecond.mul(exp)).add(secondTerm).add(thirdTerm);
	}

	/**
	 * @dev Calculates the compounded interest between the timestamp of the last update and the current block timestamp
	 * @param rate The interest rate (in ray)
	 * @param lastUpdateTimestamp The timestamp from which the interest accumulation needs to be calculated
	 **/
	function calculateCompoundedInterest(uint256 rate, uint40 lastUpdateTimestamp) internal view returns (uint256) {
		return calculateCompoundedInterest(rate, lastUpdateTimestamp, block.timestamp);
	}
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

import {Errors} from "../helpers/Errors.sol";

/**
 * @title WadRayMath library
 * @author Aave
 * @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
 **/

library WadRayMath {
	uint256 internal constant WAD = 1e18;
	uint256 internal constant halfWAD = WAD / 2;

	uint256 internal constant RAY = 1e27;
	uint256 internal constant halfRAY = RAY / 2;

	uint256 internal constant WAD_RAY_RATIO = 1e9;

	/**
	 * @return One ray, 1e27
	 **/
	function ray() internal pure returns (uint256) {
		return RAY;
	}

	/**
	 * @return One wad, 1e18
	 **/

	function wad() internal pure returns (uint256) {
		return WAD;
	}

	/**
	 * @return Half ray, 1e27/2
	 **/
	function halfRay() internal pure returns (uint256) {
		return halfRAY;
	}

	/**
	 * @return Half ray, 1e18/2
	 **/
	function halfWad() internal pure returns (uint256) {
		return halfWAD;
	}

	/**
	 * @dev Multiplies two wad, rounding half up to the nearest wad
	 * @param a Wad
	 * @param b Wad
	 * @return The result of a*b, in wad
	 **/
	function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
		if (a == 0 || b == 0) {
			return 0;
		}

		require(a <= (type(uint256).max - halfWAD) / b, Errors.MATH_MULTIPLICATION_OVERFLOW);

		return (a * b + halfWAD) / WAD;
	}

	/**
	 * @dev Divides two wad, rounding half up to the nearest wad
	 * @param a Wad
	 * @param b Wad
	 * @return The result of a/b, in wad
	 **/
	function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
		require(b != 0, Errors.MATH_DIVISION_BY_ZERO);
		uint256 halfB = b / 2;

		require(a <= (type(uint256).max - halfB) / WAD, Errors.MATH_MULTIPLICATION_OVERFLOW);

		return (a * WAD + halfB) / b;
	}

	/**
	 * @dev Multiplies two ray, rounding half up to the nearest ray
	 * @param a Ray
	 * @param b Ray
	 * @return The result of a*b, in ray
	 **/
	function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
		if (a == 0 || b == 0) {
			return 0;
		}

		require(a <= (type(uint256).max - halfRAY) / b, Errors.MATH_MULTIPLICATION_OVERFLOW);

		return (a * b + halfRAY) / RAY;
	}

	/**
	 * @dev Divides two ray, rounding half up to the nearest ray
	 * @param a Ray
	 * @param b Ray
	 * @return The result of a/b, in ray
	 **/
	function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
		require(b != 0, Errors.MATH_DIVISION_BY_ZERO);
		uint256 halfB = b / 2;

		require(a <= (type(uint256).max - halfB) / RAY, Errors.MATH_MULTIPLICATION_OVERFLOW);

		return (a * RAY + halfB) / b;
	}

	/**
	 * @dev Casts ray down to wad
	 * @param a Ray
	 * @return a casted to wad, rounded half up to the nearest wad
	 **/
	function rayToWad(uint256 a) internal pure returns (uint256) {
		uint256 halfRatio = WAD_RAY_RATIO / 2;
		uint256 result = halfRatio + a;
		require(result >= halfRatio, Errors.MATH_ADDITION_OVERFLOW);

		return result / WAD_RAY_RATIO;
	}

	/**
	 * @dev Converts wad up to ray
	 * @param a Wad
	 * @return a converted in ray
	 **/
	function wadToRay(uint256 a) internal pure returns (uint256) {
		uint256 result = a * WAD_RAY_RATIO;
		require(result / WAD_RAY_RATIO == a, Errors.MATH_MULTIPLICATION_OVERFLOW);
		return result;
	}
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

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

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

import {ILendingPool} from "../../../interfaces/ILendingPool.sol";
import {ICreditDelegationToken} from "../../../interfaces/ICreditDelegationToken.sol";
import {VersionedInitializable} from "../../libraries/aave-upgradeability/VersionedInitializable.sol";
import {IncentivizedERC20} from "../IncentivizedERC20.sol";
import {Errors} from "../../libraries/helpers/Errors.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";

/**
 * @title DebtTokenBase
 * @notice Base contract for different types of debt tokens, like StableDebtToken or VariableDebtToken
 * @author Aave
 */

abstract contract DebtTokenBase is
	IncentivizedERC20("DEBTTOKEN_IMPL", "DEBTTOKEN_IMPL", 0),
	VersionedInitializable,
	ICreditDelegationToken
{
	using SafeMath for uint256;

	mapping(address => mapping(address => uint256)) internal _borrowAllowances;

	/**
	 * @dev Only lending pool can call functions marked by this modifier
	 **/
	modifier onlyLendingPool() {
		require(_msgSender() == address(_getLendingPool()), Errors.CT_CALLER_MUST_BE_LENDING_POOL);
		_;
	}

	/**
	 * @dev delegates borrowing power to a user on the specific debt token
	 * @param delegatee the address receiving the delegated borrowing power
	 * @param amount the maximum amount being delegated. Delegation will still
	 * respect the liquidation constraints (even if delegated, a delegatee cannot
	 * force a delegator HF to go below 1)
	 **/
	function approveDelegation(address delegatee, uint256 amount) external override {
		_borrowAllowances[_msgSender()][delegatee] = amount;
		emit BorrowAllowanceDelegated(_msgSender(), delegatee, _getUnderlyingAssetAddress(), amount);
	}

	/**
	 * @dev returns the borrow allowance of the user
	 * @param fromUser The user to giving allowance
	 * @param toUser The user to give allowance to
	 * @return the current allowance of toUser
	 **/
	function borrowAllowance(address fromUser, address toUser) external view override returns (uint256) {
		return _borrowAllowances[fromUser][toUser];
	}

	/**
	 * @dev Being non transferrable, the debt token does not implement any of the
	 * standard ERC20 functions for transfer and allowance.
	 **/
	function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
		recipient;
		amount;
		revert("TRANSFER_NOT_SUPPORTED");
	}

	function allowance(address owner, address spender) public view virtual override returns (uint256) {
		owner;
		spender;
		revert("ALLOWANCE_NOT_SUPPORTED");
	}

	function approve(address spender, uint256 amount) public virtual override returns (bool) {
		spender;
		amount;
		revert("APPROVAL_NOT_SUPPORTED");
	}

	function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
		sender;
		recipient;
		amount;
		revert("TRANSFER_NOT_SUPPORTED");
	}

	function increaseAllowance(address spender, uint256 addedValue) public virtual override returns (bool) {
		spender;
		addedValue;
		revert("ALLOWANCE_NOT_SUPPORTED");
	}

	function decreaseAllowance(address spender, uint256 subtractedValue) public virtual override returns (bool) {
		spender;
		subtractedValue;
		revert("ALLOWANCE_NOT_SUPPORTED");
	}

	function _decreaseBorrowAllowance(address delegator, address delegatee, uint256 amount) internal {
		uint256 newAllowance = _borrowAllowances[delegator][delegatee].sub(amount, Errors.BORROW_ALLOWANCE_NOT_ENOUGH);

		_borrowAllowances[delegator][delegatee] = newAllowance;

		emit BorrowAllowanceDelegated(delegator, delegatee, _getUnderlyingAssetAddress(), newAllowance);
	}

	function _getUnderlyingAssetAddress() internal view virtual returns (address);

	function _getLendingPool() internal view virtual returns (ILendingPool);
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

import {Context} from "../../dependencies/openzeppelin/contracts/Context.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import {IAaveIncentivesController} from "../../interfaces/IAaveIncentivesController.sol";
import {ILendingPoolAddressesProvider} from "../../interfaces/ILendingPoolAddressesProvider.sol";
import {IPriceOracle} from "../../interfaces/IPriceOracle.sol";
import {ILendingPool} from "../../interfaces/ILendingPool.sol";

/**
 * @title ERC20
 * @notice Basic ERC20 implementation
 * @author Aave, inspired by the Openzeppelin ERC20 implementation
 **/
abstract contract IncentivizedERC20 is Context, IERC20, IERC20Metadata {
	using SafeMath for uint256;

	mapping(address => uint256) internal _balances;

	mapping(address => mapping(address => uint256)) private _allowances;
	uint256 internal _totalSupply;
	string private _name;
	string private _symbol;
	uint8 private _decimals;

	ILendingPool internal _pool;
	address internal _underlyingAsset;

	constructor(string memory name_, string memory symbol_, uint8 decimals_) {
		_name = name_;
		_symbol = symbol_;
		_decimals = decimals_;
	}

	/**
	 * @return The name of the token
	 **/
	function name() public view override returns (string memory) {
		return _name;
	}

	/**
	 * @return The symbol of the token
	 **/
	function symbol() public view override returns (string memory) {
		return _symbol;
	}

	/**
	 * @return The decimals of the token
	 **/
	function decimals() public view override returns (uint8) {
		return _decimals;
	}

	/**
	 * @return The total supply of the token
	 **/
	function totalSupply() public view virtual override returns (uint256) {
		return _totalSupply;
	}

	/**
	 * @return The balance of the token
	 **/
	function balanceOf(address account) public view virtual override returns (uint256) {
		return _balances[account];
	}

	/**
	 * @return Abstract function implemented by the child aToken/debtToken.
	 * Done this way in order to not break compatibility with previous versions of aTokens/debtTokens
	 **/
	function _getIncentivesController() internal view virtual returns (IAaveIncentivesController);

	/**
	 * @dev Executes a transfer of tokens from _msgSender() to recipient
	 * @param recipient The recipient of the tokens
	 * @param amount The amount of tokens being transferred
	 * @return `true` if the transfer succeeds, `false` otherwise
	 **/
	function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
		_transfer(_msgSender(), recipient, amount);
		emit Transfer(_msgSender(), recipient, amount);
		return true;
	}

	/**
	 * @dev Returns the allowance of spender on the tokens owned by owner
	 * @param owner The owner of the tokens
	 * @param spender The user allowed to spend the owner's tokens
	 * @return The amount of owner's tokens spender is allowed to spend
	 **/
	function allowance(address owner, address spender) public view virtual override returns (uint256) {
		return _allowances[owner][spender];
	}

	/**
	 * @dev Allows `spender` to spend the tokens owned by _msgSender()
	 * @param spender The user allowed to spend _msgSender() tokens
	 * @return `true`
	 **/
	function approve(address spender, uint256 amount) public virtual override returns (bool) {
		_approve(_msgSender(), spender, amount);
		return true;
	}

	/**
	 * @dev Executes a transfer of token from sender to recipient, if _msgSender() is allowed to do so
	 * @param sender The owner of the tokens
	 * @param recipient The recipient of the tokens
	 * @param amount The amount of tokens being transferred
	 * @return `true` if the transfer succeeds, `false` otherwise
	 **/
	function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
		_transfer(sender, recipient, amount);
		_approve(
			sender,
			_msgSender(),
			_allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")
		);
		emit Transfer(sender, recipient, amount);
		return true;
	}

	/**
	 * @dev Increases the allowance of spender to spend _msgSender() tokens
	 * @param spender The user allowed to spend on behalf of _msgSender()
	 * @param addedValue The amount being added to the allowance
	 * @return `true`
	 **/
	function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
		_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
		return true;
	}

	/**
	 * @dev Decreases the allowance of spender to spend _msgSender() tokens
	 * @param spender The user allowed to spend on behalf of _msgSender()
	 * @param subtractedValue The amount being subtracted to the allowance
	 * @return `true`
	 **/
	function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
		_approve(
			_msgSender(),
			spender,
			_allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")
		);
		return true;
	}

	function _transfer(address sender, address recipient, uint256 amount) internal virtual {
		require(sender != address(0), "ERC20: transfer from the zero address");
		require(recipient != address(0), "ERC20: transfer to the zero address");

		_beforeTokenTransfer(sender, recipient, amount);

		uint256 senderBalance = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");

		if (address(_getIncentivesController()) != address(0)) {
			// uint256 currentTotalSupply = _totalSupply;
			_getIncentivesController().handleActionBefore(sender);
			if (sender != recipient) {
				_getIncentivesController().handleActionBefore(recipient);
			}
		}

		_balances[sender] = senderBalance;
		uint256 recipientBalance = _balances[recipient].add(amount);
		_balances[recipient] = recipientBalance;

		if (address(_getIncentivesController()) != address(0)) {
			uint256 currentTotalSupply = _totalSupply;
			_getIncentivesController().handleActionAfter(sender, _balances[sender], currentTotalSupply);
			if (sender != recipient) {
				_getIncentivesController().handleActionAfter(recipient, _balances[recipient], currentTotalSupply);
			}
		}
	}

	function _mint(address account, uint256 amount) internal virtual {
		require(account != address(0), "ERC20: mint to the zero address");

		_beforeTokenTransfer(address(0), account, amount);

		uint256 currentTotalSupply = _totalSupply.add(amount);
		uint256 accountBalance = _balances[account].add(amount);
		if (address(_getIncentivesController()) != address(0)) {
			_getIncentivesController().handleActionBefore(account);
		}
		_totalSupply = currentTotalSupply;
		_balances[account] = accountBalance;
		if (address(_getIncentivesController()) != address(0)) {
			_getIncentivesController().handleActionAfter(account, accountBalance, currentTotalSupply);
		}
	}

	function _burn(address account, uint256 amount) internal virtual {
		require(account != address(0), "ERC20: burn from the zero address");

		_beforeTokenTransfer(account, address(0), amount);

		uint256 currentTotalSupply = _totalSupply.sub(amount);
		uint256 accountBalance = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");

		if (address(_getIncentivesController()) != address(0)) {
			_getIncentivesController().handleActionBefore(account);
		}

		_totalSupply = currentTotalSupply;
		_balances[account] = accountBalance;

		if (address(_getIncentivesController()) != address(0)) {
			_getIncentivesController().handleActionAfter(account, accountBalance, currentTotalSupply);
		}
	}

	function _approve(address owner, address spender, uint256 amount) internal virtual {
		require(owner != address(0), "ERC20: approve from the zero address");
		require(spender != address(0), "ERC20: approve to the zero address");

		_allowances[owner][spender] = amount;
		emit Approval(owner, spender, amount);
	}

	function _setName(string memory newName) internal {
		_name = newName;
	}

	function _setSymbol(string memory newSymbol) internal {
		_symbol = newSymbol;
	}

	function _setDecimals(uint8 newDecimals) internal {
		_decimals = newDecimals;
	}

	function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

	function getAssetPrice() external view returns (uint256) {
		ILendingPoolAddressesProvider provider = _pool.getAddressesProvider();
		address oracle = provider.getPriceOracle();
		return IPriceOracle(oracle).getAssetPrice(_underlyingAsset);
	}
}

{
  "optimizer": {
    "enabled": true,
    "runs": 1000,
    "details": {
      "yul": true
    }
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"fromUser","type":"address"},{"indexed":true,"internalType":"address","name":"toUser","type":"address"},{"indexed":false,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"BorrowAllowanceDelegated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"currentBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"balanceIncrease","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"avgStableRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newTotalSupply","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlyingAsset","type":"address"},{"indexed":true,"internalType":"address","name":"pool","type":"address"},{"indexed":false,"internalType":"address","name":"incentivesController","type":"address"},{"indexed":false,"internalType":"uint8","name":"debtTokenDecimals","type":"uint8"},{"indexed":false,"internalType":"string","name":"debtTokenName","type":"string"},{"indexed":false,"internalType":"string","name":"debtTokenSymbol","type":"string"},{"indexed":false,"internalType":"bytes","name":"params","type":"bytes"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"onBehalfOf","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"currentBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"balanceIncrease","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"avgStableRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newTotalSupply","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DEBT_TOKEN_REVISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POOL","outputs":[{"internalType":"contract ILendingPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UNDERLYING_ASSET_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approveDelegation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"fromUser","type":"address"},{"internalType":"address","name":"toUser","type":"address"}],"name":"borrowAllowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAssetPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAverageStableRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getIncentivesController","outputs":[{"internalType":"contract IAaveIncentivesController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSupplyData","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint40","name":"","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalSupplyAndAvgRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalSupplyLastUpdated","outputs":[{"internalType":"uint40","name":"","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getUserLastUpdated","outputs":[{"internalType":"uint40","name":"","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getUserStableRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ILendingPool","name":"pool","type":"address"},{"internalType":"address","name":"underlyingAsset","type":"address"},{"internalType":"contract IAaveIncentivesController","name":"incentivesController","type":"address"},{"internalType":"uint8","name":"debtTokenDecimals","type":"uint8"},{"internalType":"string","name":"debtTokenName","type":"string"},{"internalType":"string","name":"debtTokenSymbol","type":"string"},{"internalType":"bytes","name":"params","type":"bytes"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"onBehalfOf","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rate","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"principalBalanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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