Smart contracts allow us to read and write data to the blockchain by executing deterministic programs. When coding a smart contract for use on Ethereum, we use a programming language called
Solidity. Solidity files end in the .sol extension.
You can delete any files that may be in your workspace when you first boot up Remix.
You will want to create several files:
- FlashLoan.sol
- FlashLoanReceiverBase.sol
- ILendingPoolAddressesProvider.sol
- IFlashLoanReceiver.sol
- ILendingPool.sol
- Withdrawable.sol
The following code snippet is the implementation of FlashLoan.sol.
This Flash Loan will be borrowing 1
DAI.
pragma solidity ^0.6.6;
import "./FlashLoanReceiverBase.sol";
import "./ILendingPoolAddressesProvider.sol";
import "./ILendingPool.sol";
contract FlashloanV1 is FlashLoanReceiverBaseV1 {
constructor(address _addressProvider) FlashLoanReceiverBaseV1(_addressProvider) public{}
/**
Flash loan 1000000000000000000 wei (1 ether) worth of `_asset`
*/
function flashloan(address _asset) public onlyOwner {
bytes memory data = "";
uint amount = 1 ether;
ILendingPoolV1 lendingPool = ILendingPoolV1(addressesProvider.getLendingPool());
lendingPool.flashLoan(address(this), _asset, amount, data);
}
/**
This function is called after your contract has received the flash loaned amount
*/
function executeOperation(
address _reserve,
uint256 _amount,
uint256 _fee,
bytes calldata _params
)
external
override
{
require(_amount <= getBalanceInternal(address(this), _reserve), "Invalid balance, was the flashLoan successful?");
//
// Your logic goes here.
// !! Ensure that *this contract* has enough of `_reserve` funds to payback the `_fee` !!
//
uint totalDebt = _amount.add(_fee);
transferFundsBackToPoolInternal(_reserve, totalDebt);
}
}
pragma solidity ^0.6.6;
import "./FlashLoanReceiverBase.sol";
import "./ILendingPoolAddressesProvider.sol";
import "./ILendingPool.sol";
contract FlashloanV1 is FlashLoanReceiverBaseV1 {
constructor(address _addressProvider) FlashLoanReceiverBaseV1(_addressProvider) public{}
/**
Flash loan 1000000000000000000 wei (1 ether) worth of `_asset`
*/
function flashloan(address _asset) public onlyOwner {
bytes memory data = "";
uint amount = 1 ether;
ILendingPoolV1 lendingPool = ILendingPoolV1(addressesProvider.getLendingPool());
lendingPool.flashLoan(address(this), _asset, amount, data);
}
/**
This function is called after your contract has received the flash loaned amount
*/
function executeOperation(
address _reserve,
uint256 _amount,
uint256 _fee,
bytes calldata _params
)
external
override
{
require(_amount <= getBalanceInternal(address(this), _reserve), "Invalid balance, was the flashLoan successful?");
//
// Your logic goes here.
// !! Ensure that *this contract* has enough of `_reserve` funds to payback the `_fee` !!
//
uint totalDebt = _amount.add(_fee);
transferFundsBackToPoolInternal(_reserve, totalDebt);
}
}
pragma solidity ^0.6.6;
import "./FlashLoanReceiverBase.sol";
import "./ILendingPoolAddressesProvider.sol";
import "./ILendingPool.sol";
contract FlashloanV1 is FlashLoanReceiverBaseV1 {
constructor(address _addressProvider) FlashLoanReceiverBaseV1(_addressProvider) public{}
/**
Flash loan 1000000000000000000 wei (1 ether) worth of `_asset`
*/
function flashloan(address _asset) public onlyOwner {
bytes memory data = "";
uint amount = 1 ether;
ILendingPoolV1 lendingPool = ILendingPoolV1(addressesProvider.getLendingPool());
lendingPool.flashLoan(address(this), _asset, amount, data);
}
/**
This function is called after your contract has received the flash loaned amount
*/
function executeOperation(
address _reserve,
uint256 _amount,
uint256 _fee,
bytes calldata _params
)
external
override
{
require(_amount <= getBalanceInternal(address(this), _reserve), "Invalid balance, was the flashLoan successful?");
//
// Your logic goes here.
// !! Ensure that *this contract* has enough of `_reserve` funds to payback the `_fee` !!
//
uint totalDebt = _amount.add(_fee);
transferFundsBackToPoolInternal(_reserve, totalDebt);
}
}
To summarize, we start by importing the dependencies required to execute our Flash Loan. Some of these dependencies are called
abstract contracts. An abstract contract has at
least one function that isn’t implemented. You can think of it as a blueprint of a house. A builder uses this blueprint to make a house. However, in our analogy the blueprint is an abstract contract, you are the builder, and the house is the derived contract.
In our case the Flash Loan contract is using an abstract contract called
FlashLoanReceiverBaseV1. It provides necessary implementation details such as repayment of the Flash Loan.
Now to break down the code line by line.
- First, we have to define the solidity compiler version. In this case, it's 0.6.6.
2-4. Importing dependencies for the smart contract
6. The FlashLoanV1 contract is inheriting from the FlashLoanReceiverBaseV1 contract.
8. We passed the address of one of the Lending Pool Providers of Aave. In this case, we are providing the address of DAI Lending Pool.
13. We have defined a function called flashLoan. It takes the address of the asset we want to flash loan. In this case the asset is DAI.
14. We don't have any need of data for the flash loan, so we are passing an empty string.
15. We are defining the number of DAI(in terms of wei which is 10^18) we want to loan.
16. We initialize the LendingPool interface which is ILendingPoolV1 provided by Aave so that we can call the flashLoan function.
17. Finally, we call our flashLoan function. The function takes 4 main parameters. First we pass the address which will receive the loan. In our case, it's our own contract. Second, we pass the address of the asset. In our case, it's the address of DAI in the Kovan network. Third, we pass the amount of assets, and in our case it's 1 “ether” amount of units(or 10^18 in “wei” units). Last but not least, we pass the data value which in our case is an empty string.
24-31. Next, we define the second function which is executeOperation. It’s where we utilize the flash loan. It’s called internally after the flashLoan function is successfully executed. It takes 4 main parameter which are:
1. The address of reserve to which we will have to pay back the loan.
2. The amount of asset
3. The fee that is charged by the protocol
4. Additional parameter which is used internally by the function.
33. It checks if we received the appropriate amount of loan or else it will throw an error message.
34. At this point, this is where you would implement logic for any arbitrary use case.
40. We add the fee along with the loan amount by using add function provided by SafeMaths library.
41. At last we pay back the total debt or loan amount back to the lending pool.
