文件 1 的 1：AaveV3Lender.sol
pragma solidity 0.8.18;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
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 _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
interface IERC4626 is IERC20, IERC20Metadata {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
function asset() external view returns (address assetTokenAddress);
function totalAssets() external view returns (uint256 totalManagedAssets);
function convertToShares(uint256 assets) external view returns (uint256 shares);
function convertToAssets(uint256 shares) external view returns (uint256 assets);
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
function previewDeposit(uint256 assets) external view returns (uint256 shares);
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
function maxMint(address receiver) external view returns (uint256 maxShares);
function previewMint(uint256 shares) external view returns (uint256 assets);
function mint(uint256 shares, address receiver) external returns (uint256 assets);
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
function withdraw(
uint256 assets,
address receiver,
address owner
) external returns (uint256 shares);
function maxRedeem(address owner) external view returns (uint256 maxShares);
function previewRedeem(uint256 shares) external view returns (uint256 assets);
function redeem(
uint256 shares,
address receiver,
address owner
) external returns (uint256 assets);
}
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
interface ITokenizedStrategy is IERC4626, IERC20Permit {
event UpdatePendingManagement(address indexed newPendingManagement);
event UpdateManagement(address indexed newManagement);
event UpdateKeeper(address indexed newKeeper);
event UpdateEmergencyAdmin(address indexed newEmergencyAdmin);
event UpdatePerformanceFee(uint16 newPerformanceFee);
event UpdatePerformanceFeeRecipient(
address indexed newPerformanceFeeRecipient
);
event UpdateProfitMaxUnlockTime(uint256 newProfitMaxUnlockTime);
event StrategyShutdown();
event Reported(
uint256 profit,
uint256 loss,
uint256 protocolFees,
uint256 performanceFees
);
function init(
address _asset,
string memory _name,
address _management,
address _performanceFeeRecipient,
address _keeper
) external;
function withdraw(
uint256 assets,
address receiver,
address owner,
uint256 maxLoss
) external returns (uint256);
function redeem(
uint256 shares,
address receiver,
address owner,
uint256 maxLoss
) external returns (uint256);
function isManagement(address _sender) external view returns (bool);
function isKeeperOrManagement(address _sender) external view returns (bool);
function isEmergencyAuthorized(
address _sender
) external view returns (bool);
function tend() external;
function report() external returns (uint256 _profit, uint256 _loss);
function MIN_FEE() external view returns (uint16);
function MAX_FEE() external view returns (uint16);
function FACTORY() external view returns (address);
function apiVersion() external view returns (string memory);
function pricePerShare() external view returns (uint256);
function totalIdle() external view returns (uint256);
function totalDebt() external view returns (uint256);
function management() external view returns (address);
function pendingManagement() external view returns (address);
function keeper() external view returns (address);
function emergencyAdmin() external view returns (address);
function performanceFee() external view returns (uint16);
function performanceFeeRecipient() external view returns (address);
function fullProfitUnlockDate() external view returns (uint256);
function profitUnlockingRate() external view returns (uint256);
function profitMaxUnlockTime() external view returns (uint256);
function lastReport() external view returns (uint256);
function isShutdown() external view returns (bool);
function unlockedShares() external view returns (uint256);
function setPendingManagement(address) external;
function acceptManagement() external;
function setKeeper(address _keeper) external;
function setEmergencyAdmin(address _emergencyAdmin) external;
function setPerformanceFee(uint16 _performanceFee) external;
function setPerformanceFeeRecipient(
address _performanceFeeRecipient
) external;
function setProfitMaxUnlockTime(uint256 _profitMaxUnlockTime) external;
function shutdownStrategy() external;
function emergencyWithdraw(uint256 _amount) external;
function decreaseAllowance(
address spender,
uint256 subtractedValue
) external returns (bool);
function increaseAllowance(
address spender,
uint256 addedValue
) external returns (bool);
}
abstract contract BaseStrategy {
modifier onlySelf() {
_onlySelf();
_;
}
modifier onlyManagement() {
TokenizedStrategy.isManagement(msg.sender);
_;
}
modifier onlyKeepers() {
TokenizedStrategy.isKeeperOrManagement(msg.sender);
_;
}
modifier onlyEmergencyAuthorized() {
TokenizedStrategy.isEmergencyAuthorized(msg.sender);
_;
}
function _onlySelf() internal view {
require(msg.sender == address(this), "!self");
}
address public constant tokenizedStrategyAddress =
0xDFC8cD9F2f2d306b7C0d109F005DF661E14f4ff2;
ITokenizedStrategy internal immutable TokenizedStrategy;
ERC20 internal immutable asset;
constructor(address _asset, string memory _name) {
asset = ERC20(_asset);
TokenizedStrategy = ITokenizedStrategy(address(this));
_delegateCall(
abi.encodeCall(
ITokenizedStrategy.init,
(_asset, _name, msg.sender, msg.sender, msg.sender)
)
);
assembly {
sstore(
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc,
tokenizedStrategyAddress
)
}
}
function _deployFunds(uint256 _amount) internal virtual;
function _freeFunds(uint256 _amount) internal virtual;
function _harvestAndReport()
internal
virtual
returns (uint256 _totalAssets);
function _tend(uint256 _totalIdle) internal virtual {}
function _tendTrigger() internal view virtual returns (bool) {
return false;
}
function tendTrigger() external view virtual returns (bool, bytes memory) {
return (
_tendTrigger(),
abi.encodeWithSelector(ITokenizedStrategy.tend.selector)
);
}
function availableDepositLimit(
address
) public view virtual returns (uint256) {
return type(uint256).max;
}
function availableWithdrawLimit(
address
) public view virtual returns (uint256) {
return type(uint256).max;
}
function _emergencyWithdraw(uint256 _amount) internal virtual {}
function deployFunds(uint256 _amount) external virtual onlySelf {
_deployFunds(_amount);
}
function freeFunds(uint256 _amount) external virtual onlySelf {
_freeFunds(_amount);
}
function harvestAndReport() external virtual onlySelf returns (uint256) {
return _harvestAndReport();
}
function tendThis(uint256 _totalIdle) external virtual onlySelf {
_tend(_totalIdle);
}
function shutdownWithdraw(uint256 _amount) external virtual onlySelf {
_emergencyWithdraw(_amount);
}
function _delegateCall(
bytes memory _calldata
) internal returns (bytes memory) {
(bool success, bytes memory result) = tokenizedStrategyAddress
.delegatecall(_calldata);
if (!success) {
assembly {
let ptr := mload(0x40)
let size := returndatasize()
returndatacopy(ptr, 0, size)
revert(ptr, size)
}
}
return result;
}
fallback() external {
address _tokenizedStrategyAddress = tokenizedStrategyAddress;
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(
gas(),
_tokenizedStrategyAddress,
0,
calldatasize(),
0,
0
)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
}
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1);
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10**64) {
value /= 10**64;
result += 64;
}
if (value >= 10**32) {
value /= 10**32;
result += 32;
}
if (value >= 10**16) {
value /= 10**16;
result += 16;
}
if (value >= 10**8) {
value /= 10**8;
result += 8;
}
if (value >= 10**4) {
value /= 10**4;
result += 4;
}
if (value >= 10**2) {
value /= 10**2;
result += 2;
}
if (value >= 10**1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IScaledBalanceToken {
event Mint(
address indexed caller,
address indexed onBehalfOf,
uint256 value,
uint256 balanceIncrease,
uint256 index
);
event Burn(
address indexed from,
address indexed target,
uint256 value,
uint256 balanceIncrease,
uint256 index
);
function scaledBalanceOf(address user) external view returns (uint256);
function getScaledUserBalanceAndSupply(
address user
) external view returns (uint256, uint256);
function scaledTotalSupply() external view returns (uint256);
function getPreviousIndex(address user) external view returns (uint256);
}
interface IRewardsDistributor {
event AssetConfigUpdated(
address indexed asset,
address indexed reward,
uint256 oldEmission,
uint256 newEmission,
uint256 oldDistributionEnd,
uint256 newDistributionEnd,
uint256 assetIndex
);
event Accrued(
address indexed asset,
address indexed reward,
address indexed user,
uint256 assetIndex,
uint256 userIndex,
uint256 rewardsAccrued
);
event EmissionManagerUpdated(
address indexed oldEmissionManager,
address indexed newEmissionManager
);
function setDistributionEnd(
address asset,
address reward,
uint32 newDistributionEnd
) external;
function setEmissionPerSecond(
address asset,
address[] calldata rewards,
uint88[] calldata newEmissionsPerSecond
) external;
function getDistributionEnd(
address asset,
address reward
) external view returns (uint256);
function getUserAssetIndex(
address user,
address asset,
address reward
) external view returns (uint256);
function getRewardsData(
address asset,
address reward
) external view returns (uint256, uint256, uint256, uint256);
function getRewardsByAsset(
address asset
) external view returns (address[] memory);
function getRewardsList() external view returns (address[] memory);
function getUserAccruedRewards(
address user,
address reward
) external view returns (uint256);
function getUserRewards(
address[] calldata assets,
address user,
address reward
) external view returns (uint256);
function getAllUserRewards(
address[] calldata assets,
address user
) external view returns (address[] memory, uint256[] memory);
function getAssetDecimals(address asset) external view returns (uint8);
function getEmissionManager() external view returns (address);
function setEmissionManager(address emissionManager) external;
}
interface IRewardsController is IRewardsDistributor {
event ClaimerSet(address indexed user, address indexed claimer);
event RewardsClaimed(
address indexed user,
address indexed reward,
address indexed to,
address claimer,
uint256 amount
);
event TransferStrategyInstalled(
address indexed reward,
address indexed transferStrategy
);
event RewardOracleUpdated(
address indexed reward,
address indexed rewardOracle
);
function setClaimer(address user, address claimer) external;
function getRewardOracle(address reward) external view returns (address);
function getClaimer(address user) external view returns (address);
function getTransferStrategy(
address reward
) external view returns (address);
function handleAction(
address user,
uint256 userBalance,
uint256 totalSupply
) external;
function claimRewards(
address[] calldata assets,
uint256 amount,
address to,
address reward
) external returns (uint256);
function claimRewardsOnBehalf(
address[] calldata assets,
uint256 amount,
address user,
address to,
address reward
) external returns (uint256);
function claimRewardsToSelf(
address[] calldata assets,
uint256 amount,
address reward
) external returns (uint256);
function claimAllRewards(
address[] calldata assets,
address to
)
external
returns (address[] memory rewardsList, uint256[] memory claimedAmounts);
function claimAllRewardsOnBehalf(
address[] calldata assets,
address user,
address to
)
external
returns (address[] memory rewardsList, uint256[] memory claimedAmounts);
function claimAllRewardsToSelf(
address[] calldata assets
)
external
returns (address[] memory rewardsList, uint256[] memory claimedAmounts);
}
interface IPoolAddressesProvider {
event MarketIdSet(string indexed oldMarketId, string indexed newMarketId);
event PoolUpdated(address indexed oldAddress, address indexed newAddress);
event PoolConfiguratorUpdated(
address indexed oldAddress,
address indexed newAddress
);
event PriceOracleUpdated(
address indexed oldAddress,
address indexed newAddress
);
event ACLManagerUpdated(
address indexed oldAddress,
address indexed newAddress
);
event ACLAdminUpdated(
address indexed oldAddress,
address indexed newAddress
);
event PriceOracleSentinelUpdated(
address indexed oldAddress,
address indexed newAddress
);
event PoolDataProviderUpdated(
address indexed oldAddress,
address indexed newAddress
);
event ProxyCreated(
bytes32 indexed id,
address indexed proxyAddress,
address indexed implementationAddress
);
event AddressSet(
bytes32 indexed id,
address indexed oldAddress,
address indexed newAddress
);
event AddressSetAsProxy(
bytes32 indexed id,
address indexed proxyAddress,
address oldImplementationAddress,
address indexed newImplementationAddress
);
function getMarketId() external view returns (string memory);
function setMarketId(string calldata newMarketId) external;
function getAddress(bytes32 id) external view returns (address);
function setAddressAsProxy(
bytes32 id,
address newImplementationAddress
) external;
function setAddress(bytes32 id, address newAddress) external;
function getPool() external view returns (address);
function setPoolImpl(address newPoolImpl) external;
function getPoolConfigurator() external view returns (address);
function setPoolConfiguratorImpl(address newPoolConfiguratorImpl) external;
function getPriceOracle() external view returns (address);
function setPriceOracle(address newPriceOracle) external;
function getACLManager() external view returns (address);
function setACLManager(address newAclManager) external;
function getACLAdmin() external view returns (address);
function setACLAdmin(address newAclAdmin) external;
function getPriceOracleSentinel() external view returns (address);
function setPriceOracleSentinel(address newPriceOracleSentinel) external;
function getPoolDataProvider() external view returns (address);
function setPoolDataProvider(address newDataProvider) external;
}
library DataTypesV3 {
struct ReserveData {
ReserveConfigurationMap configuration;
uint128 liquidityIndex;
uint128 currentLiquidityRate;
uint128 variableBorrowIndex;
uint128 currentVariableBorrowRate;
uint128 currentStableBorrowRate;
uint40 lastUpdateTimestamp;
uint16 id;
address aTokenAddress;
address stableDebtTokenAddress;
address variableDebtTokenAddress;
address interestRateStrategyAddress;
uint128 accruedToTreasury;
uint128 unbacked;
uint128 isolationModeTotalDebt;
}
struct ReserveConfigurationMap {
uint256 data;
}
struct UserConfigurationMap {
uint256 data;
}
struct EModeCategory {
uint16 ltv;
uint16 liquidationThreshold;
uint16 liquidationBonus;
address priceSource;
string label;
}
enum InterestRateMode {
NONE,
STABLE,
VARIABLE
}
struct ReserveCache {
uint256 currScaledVariableDebt;
uint256 nextScaledVariableDebt;
uint256 currPrincipalStableDebt;
uint256 currAvgStableBorrowRate;
uint256 currTotalStableDebt;
uint256 nextAvgStableBorrowRate;
uint256 nextTotalStableDebt;
uint256 currLiquidityIndex;
uint256 nextLiquidityIndex;
uint256 currVariableBorrowIndex;
uint256 nextVariableBorrowIndex;
uint256 currLiquidityRate;
uint256 currVariableBorrowRate;
uint256 reserveFactor;
ReserveConfigurationMap reserveConfiguration;
address aTokenAddress;
address stableDebtTokenAddress;
address variableDebtTokenAddress;
uint40 reserveLastUpdateTimestamp;
uint40 stableDebtLastUpdateTimestamp;
}
struct ExecuteLiquidationCallParams {
uint256 reservesCount;
uint256 debtToCover;
address collateralAsset;
address debtAsset;
address user;
bool receiveAToken;
address priceOracle;
uint8 userEModeCategory;
address priceOracleSentinel;
}
struct ExecuteSupplyParams {
address asset;
uint256 amount;
address onBehalfOf;
uint16 referralCode;
}
struct ExecuteBorrowParams {
address asset;
address user;
address onBehalfOf;
uint256 amount;
InterestRateMode interestRateMode;
uint16 referralCode;
bool releaseUnderlying;
uint256 maxStableRateBorrowSizePercent;
uint256 reservesCount;
address oracle;
uint8 userEModeCategory;
address priceOracleSentinel;
}
struct ExecuteRepayParams {
address asset;
uint256 amount;
InterestRateMode interestRateMode;
address onBehalfOf;
bool useATokens;
}
struct ExecuteWithdrawParams {
address asset;
uint256 amount;
address to;
uint256 reservesCount;
address oracle;
uint8 userEModeCategory;
}
struct ExecuteSetUserEModeParams {
uint256 reservesCount;
address oracle;
uint8 categoryId;
}
struct FinalizeTransferParams {
address asset;
address from;
address to;
uint256 amount;
uint256 balanceFromBefore;
uint256 balanceToBefore;
uint256 reservesCount;
address oracle;
uint8 fromEModeCategory;
}
struct FlashloanParams {
address receiverAddress;
address[] assets;
uint256[] amounts;
uint256[] interestRateModes;
address onBehalfOf;
bytes params;
uint16 referralCode;
uint256 flashLoanPremiumToProtocol;
uint256 flashLoanPremiumTotal;
uint256 maxStableRateBorrowSizePercent;
uint256 reservesCount;
address addressesProvider;
uint8 userEModeCategory;
bool isAuthorizedFlashBorrower;
}
struct FlashloanSimpleParams {
address receiverAddress;
address asset;
uint256 amount;
bytes params;
uint16 referralCode;
uint256 flashLoanPremiumToProtocol;
uint256 flashLoanPremiumTotal;
}
struct FlashLoanRepaymentParams {
uint256 amount;
uint256 totalPremium;
uint256 flashLoanPremiumToProtocol;
address asset;
address receiverAddress;
uint16 referralCode;
}
struct CalculateUserAccountDataParams {
UserConfigurationMap userConfig;
uint256 reservesCount;
address user;
address oracle;
uint8 userEModeCategory;
}
struct ValidateBorrowParams {
ReserveCache reserveCache;
UserConfigurationMap userConfig;
address asset;
address userAddress;
uint256 amount;
InterestRateMode interestRateMode;
uint256 maxStableLoanPercent;
uint256 reservesCount;
address oracle;
uint8 userEModeCategory;
address priceOracleSentinel;
bool isolationModeActive;
address isolationModeCollateralAddress;
uint256 isolationModeDebtCeiling;
}
struct ValidateLiquidationCallParams {
ReserveCache debtReserveCache;
uint256 totalDebt;
uint256 healthFactor;
address priceOracleSentinel;
}
struct CalculateInterestRatesParams {
uint256 unbacked;
uint256 liquidityAdded;
uint256 liquidityTaken;
uint256 totalStableDebt;
uint256 totalVariableDebt;
uint256 averageStableBorrowRate;
uint256 reserveFactor;
address reserve;
address aToken;
}
struct InitReserveParams {
address asset;
address aTokenAddress;
address stableDebtAddress;
address variableDebtAddress;
address interestRateStrategyAddress;
uint16 reservesCount;
uint16 maxNumberReserves;
}
}
interface IPool {
event MintUnbacked(
address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
uint16 indexed referralCode
);
event BackUnbacked(
address indexed reserve,
address indexed backer,
uint256 amount,
uint256 fee
);
event Supply(
address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
uint16 indexed referralCode
);
event Withdraw(
address indexed reserve,
address indexed user,
address indexed to,
uint256 amount
);
event Borrow(
address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
DataTypesV3.InterestRateMode interestRateMode,
uint256 borrowRate,
uint16 indexed referralCode
);
event Repay(
address indexed reserve,
address indexed user,
address indexed repayer,
uint256 amount,
bool useATokens
);
event SwapBorrowRateMode(
address indexed reserve,
address indexed user,
DataTypesV3.InterestRateMode interestRateMode
);
event IsolationModeTotalDebtUpdated(
address indexed asset,
uint256 totalDebt
);
event UserEModeSet(address indexed user, uint8 categoryId);
event ReserveUsedAsCollateralEnabled(
address indexed reserve,
address indexed user
);
event ReserveUsedAsCollateralDisabled(
address indexed reserve,
address indexed user
);
event RebalanceStableBorrowRate(
address indexed reserve,
address indexed user
);
event FlashLoan(
address indexed target,
address initiator,
address indexed asset,
uint256 amount,
DataTypesV3.InterestRateMode interestRateMode,
uint256 premium,
uint16 indexed referralCode
);
event LiquidationCall(
address indexed collateralAsset,
address indexed debtAsset,
address indexed user,
uint256 debtToCover,
uint256 liquidatedCollateralAmount,
address liquidator,
bool receiveAToken
);
event ReserveDataUpdated(
address indexed reserve,
uint256 liquidityRate,
uint256 stableBorrowRate,
uint256 variableBorrowRate,
uint256 liquidityIndex,
uint256 variableBorrowIndex
);
event MintedToTreasury(address indexed reserve, uint256 amountMinted);
function mintUnbacked(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
) external;
function backUnbacked(address asset, uint256 amount, uint256 fee) external;
function supply(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
) external;
function supplyWithPermit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode,
uint256 deadline,
uint8 permitV,
bytes32 permitR,
bytes32 permitS
) external;
function withdraw(
address asset,
uint256 amount,
address to
) external returns (uint256);
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
) external;
function repay(
address asset,
uint256 amount,
uint256 interestRateMode,
address onBehalfOf
) external returns (uint256);
function repayWithPermit(
address asset,
uint256 amount,
uint256 interestRateMode,
address onBehalfOf,
uint256 deadline,
uint8 permitV,
bytes32 permitR,
bytes32 permitS
) external returns (uint256);
function repayWithATokens(
address asset,
uint256 amount,
uint256 interestRateMode
) external returns (uint256);
function swapBorrowRateMode(
address asset,
uint256 interestRateMode
) external;
function rebalanceStableBorrowRate(address asset, address user) external;
function setUserUseReserveAsCollateral(
address asset,
bool useAsCollateral
) external;
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
) external;
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata interestRateModes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) external;
function flashLoanSimple(
address receiverAddress,
address asset,
uint256 amount,
bytes calldata params,
uint16 referralCode
) external;
function getUserAccountData(
address user
)
external
view
returns (
uint256 totalCollateralBase,
uint256 totalDebtBase,
uint256 availableBorrowsBase,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor
);
function initReserve(
address asset,
address aTokenAddress,
address stableDebtAddress,
address variableDebtAddress,
address interestRateStrategyAddress
) external;
function dropReserve(address asset) external;
function setReserveInterestRateStrategyAddress(
address asset,
address rateStrategyAddress
) external;
function setConfiguration(
address asset,
DataTypesV3.ReserveConfigurationMap calldata configuration
) external;
function getConfiguration(
address asset
) external view returns (DataTypesV3.ReserveConfigurationMap memory);
function getUserConfiguration(
address user
) external view returns (DataTypesV3.UserConfigurationMap memory);
function getReserveNormalizedIncome(
address asset
) external view returns (uint256);
function getReserveNormalizedVariableDebt(
address asset
) external view returns (uint256);
function getReserveData(
address asset
) external view returns (DataTypesV3.ReserveData memory);
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) external;
function getReservesList() external view returns (address[] memory);
function getReserveAddressById(uint16 id) external view returns (address);
function ADDRESSES_PROVIDER()
external
view
returns (IPoolAddressesProvider);
function updateBridgeProtocolFee(uint256 bridgeProtocolFee) external;
function updateFlashloanPremiums(
uint128 flashLoanPremiumTotal,
uint128 flashLoanPremiumToProtocol
) external;
function configureEModeCategory(
uint8 id,
DataTypesV3.EModeCategory memory config
) external;
function getEModeCategoryData(
uint8 id
) external view returns (DataTypesV3.EModeCategory memory);
function setUserEMode(uint8 categoryId) external;
function getUserEMode(address user) external view returns (uint256);
function resetIsolationModeTotalDebt(address asset) external;
function MAX_STABLE_RATE_BORROW_SIZE_PERCENT()
external
view
returns (uint256);
function FLASHLOAN_PREMIUM_TOTAL() external view returns (uint128);
function BRIDGE_PROTOCOL_FEE() external view returns (uint256);
function FLASHLOAN_PREMIUM_TO_PROTOCOL() external view returns (uint128);
function MAX_NUMBER_RESERVES() external view returns (uint16);
function mintToTreasury(address[] calldata assets) external;
function rescueTokens(address token, address to, uint256 amount) external;
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
) external;
}
interface IInitializableAToken {
event Initialized(
address indexed underlyingAsset,
address indexed pool,
address treasury,
address incentivesController,
uint8 aTokenDecimals,
string aTokenName,
string aTokenSymbol,
bytes params
);
function initialize(
IPool pool,
address treasury,
address underlyingAsset,
IRewardsController incentivesController,
uint8 aTokenDecimals,
string calldata aTokenName,
string calldata aTokenSymbol,
bytes calldata params
) external;
}
interface IAToken is IERC20, IScaledBalanceToken, IInitializableAToken {
event BalanceTransfer(
address indexed from,
address indexed to,
uint256 value,
uint256 index
);
function mint(
address caller,
address onBehalfOf,
uint256 amount,
uint256 index
) external returns (bool);
function burn(
address from,
address receiverOfUnderlying,
uint256 amount,
uint256 index
) external;
function mintToTreasury(uint256 amount, uint256 index) external;
function transferOnLiquidation(
address from,
address to,
uint256 value
) external;
function transferUnderlyingTo(address user, uint256 amount) external;
function handleRepayment(address user, uint256 amount) external;
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function getIncentivesController()
external
view
returns (IRewardsController);
function UNDERLYING_ASSET_ADDRESS() external view returns (address);
function RESERVE_TREASURY_ADDRESS() external view returns (address);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function nonces(address owner) external view returns (uint256);
function rescueTokens(address token, address to, uint256 amount) external;
}
interface IUniswapV3SwapCallback {
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external;
}
interface ISwapRouter is IUniswapV3SwapCallback {
struct ExactInputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
uint160 sqrtPriceLimitX96;
}
function exactInputSingle(
ExactInputSingleParams calldata params
) external payable returns (uint256 amountOut);
struct ExactInputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
}
function exactInput(
ExactInputParams calldata params
) external payable returns (uint256 amountOut);
struct ExactOutputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
uint160 sqrtPriceLimitX96;
}
function exactOutputSingle(
ExactOutputSingleParams calldata params
) external payable returns (uint256 amountIn);
struct ExactOutputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
}
function exactOutput(
ExactOutputParams calldata params
) external payable returns (uint256 amountIn);
function refundETH() external payable;
}
contract UniswapV3Swapper {
uint256 public minAmountToSell;
address public base = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address public router = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
mapping(address => mapping(address => uint24)) public uniFees;
function _setUniFees(
address _token0,
address _token1,
uint24 _fee
) internal virtual {
uniFees[_token0][_token1] = _fee;
uniFees[_token1][_token0] = _fee;
}
function _swapFrom(
address _from,
address _to,
uint256 _amountIn,
uint256 _minAmountOut
) internal virtual returns (uint256 _amountOut) {
if (_amountIn > minAmountToSell) {
_checkAllowance(router, _from, _amountIn);
if (_from == base || _to == base) {
ISwapRouter.ExactInputSingleParams memory params = ISwapRouter
.ExactInputSingleParams(
_from,
_to,
uniFees[_from][_to],
address(this),
block.timestamp,
_amountIn,
_minAmountOut,
0
);
_amountOut = ISwapRouter(router).exactInputSingle(params);
} else {
bytes memory path = abi.encodePacked(
_from,
uniFees[_from][base],
base,
uniFees[base][_to],
_to
);
_amountOut = ISwapRouter(router).exactInput(
ISwapRouter.ExactInputParams(
path,
address(this),
block.timestamp,
_amountIn,
_minAmountOut
)
);
}
}
}
function _swapTo(
address _from,
address _to,
uint256 _amountTo,
uint256 _maxAmountFrom
) internal virtual returns (uint256 _amountIn) {
if (_maxAmountFrom > minAmountToSell) {
_checkAllowance(router, _from, _maxAmountFrom);
if (_from == base || _to == base) {
ISwapRouter.ExactOutputSingleParams memory params = ISwapRouter
.ExactOutputSingleParams(
_from,
_to,
uniFees[_from][_to],
address(this),
block.timestamp,
_amountTo,
_maxAmountFrom,
0
);
_amountIn = ISwapRouter(router).exactOutputSingle(params);
} else {
bytes memory path = abi.encodePacked(
_to,
uniFees[base][_to],
base,
uniFees[_from][base],
_from
);
_amountIn = ISwapRouter(router).exactOutput(
ISwapRouter.ExactOutputParams(
path,
address(this),
block.timestamp,
_amountTo,
_maxAmountFrom
)
);
}
}
}
function _checkAllowance(
address _contract,
address _token,
uint256 _amount
) internal virtual {
if (ERC20(_token).allowance(address(this), _contract) < _amount) {
ERC20(_token).approve(_contract, 0);
ERC20(_token).approve(_contract, _amount);
}
}
}
contract AaveV3Lender is BaseStrategy, UniswapV3Swapper {
using SafeERC20 for ERC20;
IPool public constant lendingPool =
IPool(0x794a61358D6845594F94dc1DB02A252b5b4814aD);
uint256 internal constant SUPPLY_CAP_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFF000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
uint256 internal constant SUPPLY_CAP_START_BIT_POSITION = 116;
uint256 internal immutable decimals;
IRewardsController public immutable rewardsController;
IAToken public immutable aToken;
bool public claimRewards = true;
mapping(address => uint256) public minAmountToSellMapping;
constructor(
address _asset,
string memory _name
) BaseStrategy(_asset, _name) {
aToken = IAToken(lendingPool.getReserveData(_asset).aTokenAddress);
require(address(aToken) != address(0), "!aToken");
decimals = ERC20(address(aToken)).decimals();
rewardsController = aToken.getIncentivesController();
asset.safeApprove(address(lendingPool), type(uint256).max);
base = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
router = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
}
function setUniFees(
address _token0,
address _token1,
uint24 _fee
) external onlyManagement {
_setUniFees(_token0, _token1, _fee);
}
function setMinAmountToSell(
uint256 _minAmountToSell
) external onlyManagement {
minAmountToSell = _minAmountToSell;
}
function _deployFunds(uint256 _amount) internal override {
lendingPool.supply(address(asset), _amount, address(this), 0);
}
function _freeFunds(uint256 _amount) internal override {
lendingPool.withdraw(
address(asset),
Math.min(aToken.balanceOf(address(this)), _amount),
address(this)
);
}
function _harvestAndReport()
internal
override
returns (uint256 _totalAssets)
{
if (claimRewards) {
_claimAndSellRewards();
}
if (!TokenizedStrategy.isShutdown()) {
uint256 looseAsset = asset.balanceOf(address(this));
if (looseAsset > 0) {
lendingPool.supply(
address(asset),
Math.min(looseAsset, availableDepositLimit(address(this))),
address(this),
0
);
}
}
_totalAssets =
aToken.balanceOf(address(this)) +
asset.balanceOf(address(this));
}
function _claimAndSellRewards() internal {
address[] memory assets = new address[](1);
assets[0] = address(aToken);
(address[] memory rewardsList, ) = rewardsController
.claimAllRewardsToSelf(assets);
address token;
for (uint256 i = 0; i < rewardsList.length; ++i) {
token = rewardsList[i];
if (token == address(asset)) {
continue;
} else {
uint256 balance = ERC20(token).balanceOf(address(this));
if (balance > minAmountToSellMapping[token]) {
_swapFrom(token, address(asset), balance, 0);
}
}
}
}
function availableDepositLimit(
address
) public view override returns (uint256) {
uint256 supplyCap = getSupplyCap();
if (supplyCap == 0) return type(uint256).max;
uint256 supply = aToken.totalSupply();
if (supplyCap <= supply) return 0;
return supplyCap - supply;
}
function getSupplyCap() public view returns (uint256) {
uint256 data = lendingPool
.getReserveData(address(asset))
.configuration
.data;
uint256 cap = (data & ~SUPPLY_CAP_MASK) >>
SUPPLY_CAP_START_BIT_POSITION;
return cap * (10 ** decimals);
}
function availableWithdrawLimit(
address
) public view override returns (uint256) {
return TokenizedStrategy.totalIdle() + asset.balanceOf(address(aToken));
}
function sellRewardManually(
address _token,
uint256 _amount,
uint256 _minAmountOut
) external onlyManagement {
_swapFrom(
_token,
address(asset),
Math.min(_amount, ERC20(_token).balanceOf(address(this))),
_minAmountOut
);
}
function setMinAmountToSellMapping(
address _token,
uint256 _amount
) external onlyManagement {
minAmountToSellMapping[_token] = _amount;
}
function setClaimRewards(bool _bool) external onlyManagement {
claimRewards = _bool;
}
function _emergencyWithdraw(uint256 _amount) internal override {
lendingPool.withdraw(
address(asset),
Math.min(_amount, aToken.balanceOf(address(this))),
address(this)
);
}
}
