... in your project

Reference Implementation
If you're familiar with Solidity, the best place to start is to copy the contracts in our Flash Loan Truffle box. The contract you call is Flashloan.sol with function flashloan().
If you want to follow a step by step procedure, see below.
Step by step
To interact with the Flash Loan functionality of the Aave protocol, a basic understanding of Solidity and its inheritance techniques are needed. 
Your contract should inherit from the FlashLoanReceiverBase contract, which can be found here (Solidity ^0.5.0) or here (Solidity ^0.6.6).
Your contract should call the flashLoan() function of the LendingPool. For more information on the flashLoan() function, see the documentation here.
An example of your contract calling the LendingPool:
1
/**
2
* Flash Loan of 1000 DAI
3
*/
4
address receiver = address(this) // Can also be a separate contract
5
address asset = "0x6b175474e89094c44da98b954eedeac495271d0f"; // Dai
6
uint256 amount = 1000 * 1e18;
7
​
8
// If no params are needed, use an empty params:
9
bytes memory params = "";
10
// Else encode the params like below (bytes encoded param of type `address` and `uint`)
11
// bytes memory params = abi.encode(address(this), 1234);
12
​
13
ILendingPool lendingPool = ILendingPool(addressesProvider.getLendingPool());
14
lendingPool.flashLoan(address(this), asset, amount, params);
Copied!
If you need to pass in arbitrary parameters for the executeOperation() to use, then you can pass in any bytes encoded data via the params_ input. Otherwise, you can pass in an empty bytes encoded value as shown above.
When your contract calls lendingPool.flashLoan(), our LendingPool contract completes some sanity checks,  transfers the requested _amount of _reserve asset to the receiver you specified, then calls executeOperation() on the receiver contract your specified.
Your receiver contract must have a function with the exact function signature as the following:
1
function executeOperation(address _reserve, uint256 _amount, uint256 _fee, bytes memory _params) external
Copied!
Before the end of your executeOperation() function, you must payback the Flash Loan amount and the fee . If this action is not performed, the transaction will be reverted. 
In our example below, we have inherited from the FlashLoanReceiverBase contract so can simply call transferFundsBackToPoolInternal() to repay the loan and fee amount. 
An example implementation of your receiver contract that receives the Flash Loan:
solidity ^0.6.6
Solidity ^0.5.0
1
pragma solidity ^0.6.6;
2
​
3
import "./FlashLoanReceiverBase.sol";
4
import "./ILendingPoolAddressesProvider.sol";
5
import "./ILendingPool.sol";
6
​
7
contract Flashloan is FlashLoanReceiverBase {
8
​
9
    constructor(address _addressProvider) FlashLoanReceiverBase(_addressProvider) public {}
10
​
11
    /**
12
        This function is called after your contract has received the flash loaned amount
13
     */
14
    function executeOperation(
15
        address _reserve,
16
        uint256 _amount,
17
        uint256 _fee,
18
        bytes calldata _params
19
    )
20
        external
21
        override
22
    {
23
        require(_amount <= getBalanceInternal(address(this), _reserve), "Invalid balance, was the flashLoan successful?");
24
​
25
        //
26
        // Your logic goes here.
27
        // !! Ensure that *this contract* has enough of `_reserve` funds to payback the `_fee` !!
28
        //
29
​
30
        uint totalDebt = _amount.add(_fee);
31
        transferFundsBackToPoolInternal(_reserve, totalDebt);
32
    }
33
​
34
    function flashloan() public onlyOwner {
35
        /**
36
        * Flash Loan of 1000 DAI
37
        */
38
        address receiver = address(this) // Can also be a separate contract
39
        address asset = "0x6b175474e89094c44da98b954eedeac495271d0f"; // Dai
40
        uint256 amount = 1000 * 1e18;
41
        
42
        // If no params are needed, use an empty params:
43
        bytes memory params = "";
44
        // Else encode the params like below (bytes encoded param of type `address` and `uint`)
45
        // bytes memory params = abi.encode(address(this), 1234);
46
        
47
        ILendingPool lendingPool = ILendingPool(addressesProvider.getLendingPool());
48
        lendingPool.flashLoan(address(this), asset, amount, params);
49
    }
50
}
Copied!
1
pragma solidity ^0.5.0;
2
​
3
import "@openzeppelin/contracts/math/SafeMath.sol";
4
​
5
import "../tokens/MintableERC20.sol";
6
import "../../flashloan/base/FlashLoanReceiverBase.sol";
7
import "../../configuration/LendingPoolAddressesProvider.sol";
8
import "../../configuration/NetworkMetadataProvider.sol";
9
​
10
contract FlashLoanReceiverExample is FlashLoanReceiverBase {
11
    using SafeMath for uint256;
12
​
13
    constructor(LendingPoolAddressesProvider _provider)
14
        FlashLoanReceiverBase(_provider)
15
        public {}
16
​
17
    function executeOperation(
18
        address _reserve,
19
        uint256 _amount,
20
        uint256 _fee,
21
        bytes memory _params) external {
22
​
23
        //check the contract has the specified balance
24
        require(_amount <= getBalanceInternal(address(this), _reserve), 
25
            "Invalid balance for the contract");
26
​
27
        /**
28
            CUSTOM ACTION TO PERFORM WITH THE BORROWED LIQUIDITY
29
            
30
            Example of decoding bytes param of type `address` and `uint`
31
            (address sampleAddress, uint sampleAmount) = abi.decode(_params, (address, uint));
32
        */
33
​
34
        transferFundsBackToPoolInternal(_reserve, _amount.add(_fee));
35
    }
36
}
Copied!
​

V1 Guides & Tutorials - Previous

Performing a Flash Loan

... with Truffle

Last modified 1yr ago

Copy link

Contents

Reference Implementation

Step by step