diff --git a/contracts/avalanche/connectors/aave/aave-rewards/events.sol b/contracts/avalanche/connectors/aave/aave-rewards/events.sol new file mode 100644 index 00000000..7fb14419 --- /dev/null +++ b/contracts/avalanche/connectors/aave/aave-rewards/events.sol @@ -0,0 +1,10 @@ +pragma solidity ^0.7.0; + +contract Events { + event LogClaimed( + address[] assets, + uint256 amt, + uint256 getId, + uint256 setId + ); +} diff --git a/contracts/avalanche/connectors/aave/aave-rewards/helpers.sol b/contracts/avalanche/connectors/aave/aave-rewards/helpers.sol new file mode 100644 index 00000000..f3ea8e66 --- /dev/null +++ b/contracts/avalanche/connectors/aave/aave-rewards/helpers.sol @@ -0,0 +1,12 @@ +pragma solidity ^0.7.0; + +import { DSMath } from "../../../common/math.sol"; +import { Basic } from "../../../common/basic.sol"; +import { AaveIncentivesInterface } from "./interface.sol"; + +abstract contract Helpers is DSMath, Basic { + /** + * @dev Aave Incentives + */ + AaveIncentivesInterface internal constant incentives = AaveIncentivesInterface(0x01D83Fe6A10D2f2B7AF17034343746188272cAc9); +} diff --git a/contracts/avalanche/connectors/aave/aave-rewards/interface.sol b/contracts/avalanche/connectors/aave/aave-rewards/interface.sol new file mode 100644 index 00000000..d50d1860 --- /dev/null +++ b/contracts/avalanche/connectors/aave/aave-rewards/interface.sol @@ -0,0 +1,9 @@ +pragma solidity ^0.7.0; + +interface AaveIncentivesInterface { + function claimRewards( + address[] calldata assets, + uint256 amount, + address to + ) external returns (uint256); +} \ No newline at end of file diff --git a/contracts/avalanche/connectors/aave/aave-rewards/main.sol b/contracts/avalanche/connectors/aave/aave-rewards/main.sol new file mode 100644 index 00000000..e982793e --- /dev/null +++ b/contracts/avalanche/connectors/aave/aave-rewards/main.sol @@ -0,0 +1,50 @@ +pragma solidity ^0.7.0; + + +/** + * @title Aave Rewards. + * @dev Claim Aave rewards. + */ + +import { TokenInterface } from "../../../common/interfaces.sol"; +import { Stores } from "../../../common/stores.sol"; +import { Helpers } from "./helpers.sol"; +import { Events } from "./events.sol"; + +abstract contract IncentivesResolver is Helpers, Events { + + /** + * @dev Claim Pending Rewards. + * @notice Claim Pending Rewards from Aave incentives contract. + * @param assets The list of assets supplied and borrowed. + * @param amt The amount of reward to claim. (uint(-1) for max) + * @param getId ID to retrieve amt. + * @param setId ID stores the amount of rewards claimed. + */ + function claim( + address[] calldata assets, + uint256 amt, + uint256 getId, + uint256 setId + ) external payable returns (string memory _eventName, bytes memory _eventParam) { + uint _amt = getUint(getId, amt); + + require(assets.length > 0, "invalid-assets"); + + _amt = incentives.claimRewards(assets, _amt, address(this)); + + + TokenInterface wavax = TokenInterface(wavaxAddr); + uint256 wavaxAmount = wavax.balanceOf(address(this)); + convertWavaxToAvax(wavaxAmount > 0, wavax, wavaxAmount); + + setUint(setId, _amt); + + _eventName = "LogClaimed(address[],uint256,uint256,uint256)"; + _eventParam = abi.encode(assets, _amt, getId, setId); + } +} + +contract ConnectV2AaveIncentivesAvalanche is IncentivesResolver { + string public constant name = "Aave-Incentives-v1"; +} diff --git a/contracts/avalanche/connectors/aave/v2/events.sol b/contracts/avalanche/connectors/aave/v2/events.sol new file mode 100644 index 00000000..805b2209 --- /dev/null +++ b/contracts/avalanche/connectors/aave/v2/events.sol @@ -0,0 +1,10 @@ +pragma solidity ^0.7.0; + +contract Events { + event LogDeposit(address indexed token, uint256 tokenAmt, uint256 getId, uint256 setId); + event LogWithdraw(address indexed token, uint256 tokenAmt, uint256 getId, uint256 setId); + event LogBorrow(address indexed token, uint256 tokenAmt, uint256 indexed rateMode, uint256 getId, uint256 setId); + event LogPayback(address indexed token, uint256 tokenAmt, uint256 indexed rateMode, uint256 getId, uint256 setId); + event LogEnableCollateral(address[] tokens); + event LogSwapRateMode(address indexed token, uint256 rateMode); +} diff --git a/contracts/avalanche/connectors/aave/v2/helpers.sol b/contracts/avalanche/connectors/aave/v2/helpers.sol new file mode 100644 index 00000000..cb1f13ef --- /dev/null +++ b/contracts/avalanche/connectors/aave/v2/helpers.sol @@ -0,0 +1,49 @@ +pragma solidity ^0.7.0; + +import { DSMath } from "../../../common/math.sol"; +import { Basic } from "../../../common/basic.sol"; +import { AaveLendingPoolProviderInterface, AaveDataProviderInterface } from "./interface.sol"; + +abstract contract Helpers is DSMath, Basic { + + /** + * @dev Aave Lending Pool Provider + */ + AaveLendingPoolProviderInterface constant internal aaveProvider = AaveLendingPoolProviderInterface(0xb6A86025F0FE1862B372cb0ca18CE3EDe02A318f); + + /** + * @dev Aave Protocol Data Provider + */ + AaveDataProviderInterface constant internal aaveData = AaveDataProviderInterface(0x65285E9dfab318f57051ab2b139ccCf232945451); + + /** + * @dev Aave Referral Code + */ + uint16 constant internal referralCode = 3228; + + /** + * @dev Checks if collateral is enabled for an asset + * @param token token address of the asset.(For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) + */ + function getIsColl(address token) internal view returns (bool isCol) { + (, , , , , , , , isCol) = aaveData.getUserReserveData(token, address(this)); + } + + /** + * @dev Get total debt balance & fee for an asset + * @param token token address of the debt.(For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) + * @param rateMode Borrow rate mode (Stable = 1, Variable = 2) + */ + function getPaybackBalance(address token, uint rateMode) internal view returns (uint) { + (, uint stableDebt, uint variableDebt, , , , , , ) = aaveData.getUserReserveData(token, address(this)); + return rateMode == 1 ? stableDebt : variableDebt; + } + + /** + * @dev Get total collateral balance for an asset + * @param token token address of the collateral.(For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) + */ + function getCollateralBalance(address token) internal view returns (uint bal) { + (bal, , , , , , , ,) = aaveData.getUserReserveData(token, address(this)); + } +} diff --git a/contracts/avalanche/connectors/aave/v2/interface.sol b/contracts/avalanche/connectors/aave/v2/interface.sol new file mode 100644 index 00000000..ab17fd22 --- /dev/null +++ b/contracts/avalanche/connectors/aave/v2/interface.sol @@ -0,0 +1,47 @@ +pragma solidity ^0.7.0; + +interface AaveInterface { + function deposit(address _asset, uint256 _amount, address _onBehalfOf, uint16 _referralCode) external; + function withdraw(address _asset, uint256 _amount, address _to) external; + function borrow( + address _asset, + uint256 _amount, + uint256 _interestRateMode, + uint16 _referralCode, + address _onBehalfOf + ) external; + function repay(address _asset, uint256 _amount, uint256 _rateMode, address _onBehalfOf) external; + function setUserUseReserveAsCollateral(address _asset, bool _useAsCollateral) external; + function swapBorrowRateMode(address _asset, uint256 _rateMode) external; +} + +interface AaveLendingPoolProviderInterface { + function getLendingPool() external view returns (address); +} + +interface AaveDataProviderInterface { + function getReserveTokensAddresses(address _asset) external view returns ( + address aTokenAddress, + address stableDebtTokenAddress, + address variableDebtTokenAddress + ); + function getUserReserveData(address _asset, address _user) external view returns ( + uint256 currentATokenBalance, + uint256 currentStableDebt, + uint256 currentVariableDebt, + uint256 principalStableDebt, + uint256 scaledVariableDebt, + uint256 stableBorrowRate, + uint256 liquidityRate, + uint40 stableRateLastUpdated, + bool usageAsCollateralEnabled + ); +} + +interface AaveAddressProviderRegistryInterface { + function getAddressesProvidersList() external view returns (address[] memory); +} + +interface ATokenInterface { + function balanceOf(address _user) external view returns(uint256); +} \ No newline at end of file diff --git a/contracts/avalanche/connectors/aave/v2/main.sol b/contracts/avalanche/connectors/aave/v2/main.sol new file mode 100644 index 00000000..3dd6239a --- /dev/null +++ b/contracts/avalanche/connectors/aave/v2/main.sol @@ -0,0 +1,216 @@ +pragma solidity ^0.7.0; + +/** + * @title Aave v2. + * @dev Lending & Borrowing. + */ + + +import { TokenInterface } from "../../../common/interfaces.sol"; +import { Stores } from "../../../common/stores.sol"; +import { Helpers } from "./helpers.sol"; +import { Events } from "./events.sol"; +import { AaveInterface } from "./interface.sol"; + +abstract contract AaveResolver is Events, Helpers { + /** + * @dev Deposit AVAX/ERC20_Token. + * @notice Deposit a token to Aave v2 for lending / collaterization. + * @param token The address of the token to deposit.(For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) + * @param amt The amount of the token to deposit. (For max: `uint256(-1)`) + * @param getId ID to retrieve amt. + * @param setId ID stores the amount of tokens deposited. + */ + function deposit( + address token, + uint256 amt, + uint256 getId, + uint256 setId + ) external payable returns (string memory _eventName, bytes memory _eventParam) { + uint _amt = getUint(getId, amt); + + AaveInterface aave = AaveInterface(aaveProvider.getLendingPool()); + + bool isAVAX = token == avaxAddr; + address _token = isAVAX ? wavaxAddr : token; + + TokenInterface tokenContract = TokenInterface(_token); + + if (isAVAX) { + _amt = _amt == uint(-1) ? address(this).balance : _amt; + convertAvaxToWavax(isAVAX, tokenContract, _amt); + } else { + _amt = _amt == uint(-1) ? tokenContract.balanceOf(address(this)) : _amt; + } + + approve(tokenContract, address(aave), _amt); + + aave.deposit(_token, _amt, address(this), referralCode); + + if (!getIsColl(_token)) { + aave.setUserUseReserveAsCollateral(_token, true); + } + + setUint(setId, _amt); + + _eventName = "LogDeposit(address,uint256,uint256,uint256)"; + _eventParam = abi.encode(token, _amt, getId, setId); + } + + /** + * @dev Withdraw AVAX/ERC20_Token. + * @notice Withdraw deposited token from Aave v2 + * @param token The address of the token to withdraw.(For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) + * @param amt The amount of the token to withdraw. (For max: `uint256(-1)`) + * @param getId ID to retrieve amt. + * @param setId ID stores the amount of tokens withdrawn. + */ + function withdraw( + address token, + uint256 amt, + uint256 getId, + uint256 setId + ) external payable returns (string memory _eventName, bytes memory _eventParam) { + uint _amt = getUint(getId, amt); + + AaveInterface aave = AaveInterface(aaveProvider.getLendingPool()); + bool isAVAX = token == avaxAddr; + address _token = isAVAX ? wavaxAddr : token; + + TokenInterface tokenContract = TokenInterface(_token); + + uint initialBal = tokenContract.balanceOf(address(this)); + aave.withdraw(_token, _amt, address(this)); + uint finalBal = tokenContract.balanceOf(address(this)); + + _amt = sub(finalBal, initialBal); + + convertWavaxToAvax(isAVAX, tokenContract, _amt); + + setUint(setId, _amt); + + _eventName = "LogWithdraw(address,uint256,uint256,uint256)"; + _eventParam = abi.encode(token, _amt, getId, setId); + } + + /** + * @dev Borrow AVAX/ERC20_Token. + * @notice Borrow a token using Aave v2 + * @param token The address of the token to borrow.(For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) + * @param amt The amount of the token to borrow. + * @param rateMode The type of borrow debt. (For Stable: 1, Variable: 2) + * @param getId ID to retrieve amt. + * @param setId ID stores the amount of tokens borrowed. + */ + function borrow( + address token, + uint256 amt, + uint256 rateMode, + uint256 getId, + uint256 setId + ) external payable returns (string memory _eventName, bytes memory _eventParam) { + uint _amt = getUint(getId, amt); + + AaveInterface aave = AaveInterface(aaveProvider.getLendingPool()); + + bool isAVAX = token == avaxAddr; + address _token = isAVAX ? wavaxAddr : token; + + aave.borrow(_token, _amt, rateMode, referralCode, address(this)); + convertWavaxToAvax(isAVAX, TokenInterface(_token), _amt); + + setUint(setId, _amt); + + _eventName = "LogBorrow(address,uint256,uint256,uint256,uint256)"; + _eventParam = abi.encode(token, _amt, rateMode, getId, setId); + } + + /** + * @dev Payback borrowed AVAX/ERC20_Token. + * @notice Payback debt owed. + * @param token The address of the token to payback.(For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) + * @param amt The amount of the token to payback. (For max: `uint256(-1)`) + * @param rateMode The type of debt paying back. (For Stable: 1, Variable: 2) + * @param getId ID to retrieve amt. + * @param setId ID stores the amount of tokens paid back. + */ + function payback( + address token, + uint256 amt, + uint256 rateMode, + uint256 getId, + uint256 setId + ) external payable returns (string memory _eventName, bytes memory _eventParam) { + uint _amt = getUint(getId, amt); + + AaveInterface aave = AaveInterface(aaveProvider.getLendingPool()); + + bool isAVAX = token == avaxAddr; + address _token = isAVAX ? wavaxAddr : token; + + TokenInterface tokenContract = TokenInterface(_token); + + _amt = _amt == uint(-1) ? getPaybackBalance(_token, rateMode) : _amt; + + if (isAVAX) convertAvaxToWavax(isAVAX, tokenContract, _amt); + + approve(tokenContract, address(aave), _amt); + + aave.repay(_token, _amt, rateMode, address(this)); + + setUint(setId, _amt); + + _eventName = "LogPayback(address,uint256,uint256,uint256,uint256)"; + _eventParam = abi.encode(token, _amt, rateMode, getId, setId); + } + + /** + * @dev Enable collateral + * @notice Enable an array of tokens as collateral + * @param tokens Array of tokens to enable collateral + */ + function enableCollateral( + address[] calldata tokens + ) external payable returns (string memory _eventName, bytes memory _eventParam) { + uint _length = tokens.length; + require(_length > 0, "0-tokens-not-allowed"); + + AaveInterface aave = AaveInterface(aaveProvider.getLendingPool()); + + for (uint i = 0; i < _length; i++) { + address token = tokens[i]; + if (getCollateralBalance(token) > 0 && !getIsColl(token)) { + aave.setUserUseReserveAsCollateral(token, true); + } + } + + _eventName = "LogEnableCollateral(address[])"; + _eventParam = abi.encode(tokens); + } + + /** + * @dev Swap borrow rate mode + * @notice Swaps user borrow rate mode between variable and stable + * @param token The address of the token to swap borrow rate.(For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) + * @param rateMode Desired borrow rate mode. (Stable = 1, Variable = 2) + */ + function swapBorrowRateMode( + address token, + uint rateMode + ) external payable returns (string memory _eventName, bytes memory _eventParam) { + AaveInterface aave = AaveInterface(aaveProvider.getLendingPool()); + + uint currentRateMode = rateMode == 1 ? 2 : 1; + + if (getPaybackBalance(token, currentRateMode) > 0) { + aave.swapBorrowRateMode(token, rateMode); + } + + _eventName = "LogSwapRateMode(address,uint256)"; + _eventParam = abi.encode(token, rateMode); + } +} + +contract ConnectV2AaveV2Avalanche is AaveResolver { + string constant public name = "AaveV2-v1"; +}