# Understanding Flash Loan Smart Contract

**SETTING UP FLASHLOAN**

{% hint style="info" %}
Please note that executing a flash loan is a complex transaction and the user should have a sound understanding of Solidity to fully comprehend the structure and models used within the smart contracts.
{% endhint %}

{% content-ref url="/pages/-Mb-wBzWPwYgbkN2Sr2t" %}
[UnilendFlashLoan](/unilend-finance/unilend-v1/for-developers/unilendflashloan.md)
{% endcontent-ref %}

**Overview of cycle to execute flash loan:**

* Your contract `_receiver` calls the Unilend smart contract, requesting loan of certain `_amount` from the `_reserve`.
* Unilend smart contract runs some sanity check and then transfer the `_amount`

   from the `_reserve`  to your contract `_receiver`.
* Your contract `_receiver` holding the `_amount` execute implementation of your code.
* Once your code is executed you transfer the flash loan `_amount` to `_reserve` along with `_fee`.

| Parameters  | Type    | Defination of parameters                                        |
| ----------- | ------- | --------------------------------------------------------------- |
| `_receiver` | address | address of the contract receiving the funds.                    |
| `_reserve`  | address | addresses of the reserves to flash loan                         |
| `_amount`   | uint256 | amounts of `_asset` to flashloan.                               |
| `_fee`      | uint256 | premium incured over the loan `_amount`                         |
| `_params`   | bytes   | bytes-encoded parameters to be used by the `_receiver` contract |

#### 1. Create your flash loan contract

To develop your own flash loan contract, start building contract interface over Unilend library `UnilendFlashLoanReceiverBase`

**2. Executing flash loan**

Create a `executeOperation()` function within the contract for implementing your arbitary logic and requesting fund with local function `transferInternal()`

**3. Calling flash loan**

Define a `flashloanCall()` function inside your smart contract taking relevant parameters as  `_asset` and `_amount` that would be passed to local function `flashLoan()` of `UnilendFlashLoanRecieverBase`

**4. Completing flash loan transaction**

Once you have performed your logic with the flash loaned assets (in your `executeOperation()` function), you will need to pay back the flash loaned amounts**.** In the payback cycle ensure that \*your contract\* has enough of funds to pay the `_fee`

```
pragma solidity 0.8.0;
// SPDX-License-Identifier: MIT

import "https://raw.githubusercontent.com/UniLend/flashloan_interface/main/contracts/UnilendFlashLoanReceiverBase.sol";


contract Flashloan is UnilendFlashLoanReceiverBase {
    using SafeMath for uint256;
    
    constructor() {}
    
    function executeOperation(
        address _reserve,
        uint256 _amount,
        uint256 _fee,
        bytes calldata _params
    )
        external
    {
        require(_amount <= getBalanceInternal(address(this), _reserve), "Invalid balance, was the flashLoan successful?");
        _params;
        
        //
        // Your logic goes here.
        // !! Ensure that *this contract* has enough of `_reserve` funds to payback the `_fee` !!
        //
        
        
        uint totalDebt = _amount.add(_fee);
        transferInternal(getUnilendCoreAddress(), _reserve, totalDebt);
    }
    
    function flashloanCall(address _asset, uint _amount) payable external {
        bytes memory data;
        
        flashLoan(address(this), _asset, _amount, data);
    }
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://unilend.gitbook.io/unilend-finance/unilend-v1/the-protocol/flash-loan/performing-flashloan.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.