How do I borrow a flash loan? A deep dive

Search…
Mainnet smart contract addresses are listed in the Smart Contracts guide
1 Overview
To borrow a flash loan, you need to create and deploy a Flash Borrower smart contract that borrows a flash loan, performs a business operation, and returns the loan with the borrowing fee. This guide demonstrates how to write and deploy a simple flash borrower smart contract that borrows and returns a flash loan. Smart contracts are written in Solidity and can be deployed and tested using Remix IDE.
In the diagram below, we present a high-level interaction flow between the smart contracts
​
A high-level interaction diagram
Flash loans are borrowed and used as follows
1.Alice invokes the flash lending process by calling the FlashLoan method on the Equalizer flash loan provider smart contract
2.The flash loan provider smart contract triggers the flash loan transfer from the vault to the flash borrower smart contract built and deployed by Alice
3.The assets are transferred to the flash borrower smart contract
4.The flash loan provider smart contract triggers the business logic operation on the flash borrower smart contract
5.The flash borrower smart contract uses the loan to perform business operations on a decentralized exchange
6.Flash loan provider smart contract triggers the transfer of assets from the flash borrower back to the vault
All operations are performed within a single blockchain transaction, hence the name Flash Loan.
If the principal and the fee are not returned, the transaction will revert and all funds will be restored to the vault.
2 Simple flash borrowing smart contract
Below, we present a simple flash borrower method that borrows a flash loan, emits an event and returns the flash loan:
1
/*
2
*  FlashBorrowerExample is a simple method that
3
*  borrows and returns a flash loan.
4
*/
5
contract FlashBorrowerExample is IERC3156FlashBorrower {
6
    uint256 MAX_INT = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
7
​
8
    // @dev ERC-3156 Flash loan callback
9
    function onFlashLoan(
10
        address initiator,
11
        address token,
12
        uint256 amount,
13
        uint256 fee,
14
        bytes calldata data
15
    ) external override returns (bytes32) {
16
        
17
        // Set the allowance to payback the flash loan
18
        IERC20(token).approve(msg.sender, MAX_INT);
19
        
20
        // Build your trading business logic here
21
        // e.g., sell on uniswapv2
22
        // e.g., buy on uniswapv3
23
​
24
        // Return success to the lender, he will transfer get the funds back if allowance is set accordingly
25
        return keccak256('ERC3156FlashBorrower.onFlashLoan');
26
    }
27
}
Copied!
The full smart contract example is presented in Appendix A.1 of this document.
Examples in this document are for demonstration purposes only. Use them only on test networks.
3 Deploy the smart contract
For testing purposes, we strongly suggest deploying the test smart contract on one of the supported blockchain test nets.
This section summarizes how to deploy and interact with a smart contract using Remix IDE. 
Visit the Remix - Ethereum IDE website
Remix is an online tool for writing and interacting with smart contracts.
Create smart contract
Click on New File and name it FlashBorrowerExample. Copy the smart contract from Appendix A.1 or the one we deployed on the Rinkeby Testnet.
Create a new smart contract
Compile the smart contract
Solidity is a compiled language meaning smart contracts must be compiled before we deploy them on a blockchain. In the sidebar select SOLIDITY COMPILER and compile the smart contract by clicking on the Compile button.
Compile the example smart contract
Deploy the smart contract to the Rinkeby test network
After we In the sidebar select DEPLOY & RUN TRANSACTIONS as presented below. For the demo purpose, we deployed a simple Flash Borrower Example smart contract on the Rinkeby Testnet. If you just want to interact with the smart contract, skip this step. 
Flash Borrower example smart contract address on Rinkeby Testnet is 0x5b4b021d2abcf6116d782884bc5cd414027aeff2​
DEPLOY & RUN TRANSACTIONS
Next, select Environment: Injected Web3 as presented below. This will open your Metamask plugin and ask you to connect your wallet. Click on Deploy to deploy the smart contract. You will be prompted to sign a transaction.
Make sure you are connected to the Rinkeby testnet.
4 Interact with a smart contract via Etherscan
In the How do I borrow a flash loan? guide you can learn how to interact with the smart contract. To call your smart contract, replace the receiver address with the address of the contract you deployed.

5 Interact with a smart contract using Ethers
For testing purposes, we strongly suggest deploying the test smart contract on one of the supported blockchain test nets.
Below we present a JavaScript snippet you can use to interact with the Flash Borrower smart contract.
1
// Load the ethers librariy
2
const {
3
  ethers
4
} = require("ethers");
5
// Load the ABI. The flashloan Provider interface can be found on
6
// https://github.com/Equalizer-Finance/equalizer-smart-contracts-v1/blob/master/contracts/interfaces/IERC3156FlashLender.sol
7
const providerAbi = require("./abi.json");
8
// JSON-RPC endpoint
9
const jsonRpcURL = 'https://rinkeby.infura.io/v3/<API-KEY>';
10
​
11
// Private key of the account that will borrow a flash loan
12
// Important! Never share your private key with anyone!
13
const privateKey = '<YOUR-PRIVATE-KEY-GOES-HERE>';
14
​
15
// the address of the FlashLoan Receiver that implements the interface 
16
// https://github.com/Equalizer-Finance/equalizer-smart-contracts-v1/blob/master/contracts/interfaces/IERC3156FlashBorrower.sol
17
​
18
// example receiver here: https://rinkeby.etherscan.io/address/0x9B38b85e22C94F4a57b4507216B7E444b667B872#code
19
const flashLoanReceiverAddress = '0x41EC9B0C0f0a354e3d7d9f1982643eEd0a8C2EB1';
20
​
21
// the address of the flashloan provider - rinkeby example
22
const flashLoanProviderAddress = '0x3649380F6ce217Ae1d76FCc4092d3c84EB45f7d1';
23
​
24
// the address of the borrowed token - rinkeby USDT example below
25
const tokenAddress = '0xbE6C02195A28d163A1DF2e05B0596416d326b190';
26
​
27
// can be extracted from vaultFactory with tokenAddress
28
const vaultOfToken = '0xCfB9243003EAB8676634e891162a6f7c74855E8f';
29
​
30
(async () => {
31
  // init the provider
32
  const provider = new ethers.providers.JsonRpcProvider(jsonRpcURL);
33
  // init the wallet
34
  const wallet = new ethers.Wallet(privateKey, provider);
35
​
36
  // init the contract of flashloan provider with wallet connected to it
37
  const flashLoanProviderContract = new ethers.Contract(flashLoanProviderAddress, providerAbi, wallet);
38
  // const receiverContract = new ethers.Contract (flashLoanReceiverAddress, )
39
  try {
40
​
41
    // check max loan amount for the token
42
    const maxAmount = await flashLoanProviderContract.maxFlashLoan(tokenAddress);
43
    console.log(maxAmount);
44
    // make sure u set allowance for the provider for the vault
45
    // get a loan
46
​
47
    console.log(await (await flashLoanProviderContract.flashLoan(flashLoanReceiverAddress, tokenAddress, 100, "0x", {
48
      gasLimit: 1000000,
49
      gasPrice: 1000000000
50
    })).wait());
51
​
52
  } catch (e) {
53
    console.log(e);
54
    // Error handling
55
  }
56
})();
Copied!
Appendix
A.1 Flash Borrower smart contract example
1
// SPDX-License-Identifier: MIT
2
pragma solidity 0.8.4;
3
​
4
interface IERC20 {
5
    function approve(address spender, uint256 amount) external returns (bool);
6
}
7
​
8
interface IERC3156FlashBorrower {
9
    /**
10
     * @dev Receive a flash loan.
11
     * @param initiator The initiator of the loan.
12
     * @param token The loan currency.
13
     * @param amount The amount of tokens lent.
14
     * @param fee The additional amount of tokens to repay.
15
     * @param data Arbitrary data structure, intended to contain user-defined parameters.
16
     * @return The keccak256 hash of "ERC3156FlashBorrower.onFlashLoan"
17
     */
18
    function onFlashLoan(
19
        address initiator,
20
        address token,
21
        uint256 amount,
22
        uint256 fee,
23
        bytes calldata data
24
    ) external returns (bytes32);
25
}
26
​
27
/*
28
*  FlashBorrowerExample is a simple smart contract that enables
29
*  to borrow and returns a flash loan.
30
*/
31
contract FlashBorrowerExample is IERC3156FlashBorrower {
32
    uint256 MAX_INT = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
33
​
34
    // @dev ERC-3156 Flash loan callback
35
    function onFlashLoan(
36
        address initiator,
37
        address token,
38
        uint256 amount,
39
        uint256 fee,
40
        bytes calldata data
41
    ) external override returns (bytes32) {
42
        
43
        // Set the allowance to payback the flash loan
44
        IERC20(token).approve(msg.sender, MAX_INT);
45
        
46
        // Build your trading business logic here
47
        // e.g., sell on uniswapv2
48
        // e.g., buy on uniswapv3
49
​
50
        // Return success to the lender, he will transfer get the funds back if allowance is set accordingly
51
        return keccak256('ERC3156FlashBorrower.onFlashLoan');
52
    }
53
}
Copied!
A.2 Flash Loan Provider ABI
1
[
2
  {
3
    "inputs": [
4
      {
5
        "internalType": "contract VaultFactory",
6
        "name": "_vaultFactory",
7
        "type": "address"
8
      }
9
    ],
10
    "stateMutability": "nonpayable",
11
    "type": "constructor"
12
  },
13
  {
14
    "anonymous": false,
15
    "inputs": [
16
      {
17
        "indexed": true,
18
        "internalType": "address",
19
        "name": "receiver",
20
        "type": "address"
21
      },
22
      {
23
        "indexed": false,
24
        "internalType": "address",
25
        "name": "token",
26
        "type": "address"
27
      },
28
      {
29
        "indexed": false,
30
        "internalType": "uint256",
31
        "name": "amount",
32
        "type": "uint256"
33
      },
34
      {
35
        "indexed": false,
36
        "internalType": "uint256",
37
        "name": "fee",
38
        "type": "uint256"
39
      },
40
      {
41
        "indexed": false,
42
        "internalType": "uint256",
43
        "name": "treasuryFee",
44
        "type": "uint256"
45
      }
46
    ],
47
    "name": "FlashLoan",
48
    "type": "event"
49
  },
50
  {
51
    "inputs": [],
52
    "name": "CALLBACK_SUCCESS",
53
    "outputs": [
54
      {
55
        "internalType": "bytes32",
56
        "name": "",
57
        "type": "bytes32"
58
      }
59
    ],
60
    "stateMutability": "view",
61
    "type": "function"
62
  },
63
  {
64
    "inputs": [
65
      {
66
        "internalType": "address",
67
        "name": "token",
68
        "type": "address"
69
      },
70
      {
71
        "internalType": "uint256",
72
        "name": "amount",
73
        "type": "uint256"
74
      }
75
    ],
76
    "name": "flashFee",
77
    "outputs": [
78
      {
79
        "internalType": "uint256",
80
        "name": "",
81
        "type": "uint256"
82
      }
83
    ],
84
    "stateMutability": "view",
85
    "type": "function"
86
  },
87
  {
88
    "inputs": [
89
      {
90
        "internalType": "contract IERC3156FlashBorrower",
91
        "name": "receiver",
92
        "type": "address"
93
      },
94
      {
95
        "internalType": "address",
96
        "name": "token",
97
        "type": "address"
98
      },
99
      {
100
        "internalType": "uint256",
101
        "name": "amount",
102
        "type": "uint256"
103
      },
104
      {
105
        "internalType": "bytes",
106
        "name": "data",
107
        "type": "bytes"
108
      }
109
    ],
110
    "name": "flashLoan",
111
    "outputs": [
112
      {
113
        "internalType": "bool",
114
        "name": "",
115
        "type": "bool"
116
      }
117
    ],
118
    "stateMutability": "nonpayable",
119
    "type": "function"
120
  },
121
  {
122
    "inputs": [
123
      {
124
        "internalType": "address",
125
        "name": "token",
126
        "type": "address"
127
      }
128
    ],
129
    "name": "maxFlashLoan",
130
    "outputs": [
131
      {
132
        "internalType": "uint256",
133
        "name": "",
134
        "type": "uint256"
135
      }
136
    ],
137
    "stateMutability": "view",
138
    "type": "function"
139
  },
140
  {
141
    "inputs": [],
142
    "name": "vaultFactory",
143
    "outputs": [
144
      {
145
        "internalType": "contract VaultFactory",
146
        "name": "",
147
        "type": "address"
148
      }
149
    ],
150
    "stateMutability": "view",
151
    "type": "function"
152
  }
153
]
Copied!