This is in continuation of our DeFi series. In this post, we look at yet another decentralized lending and borrowing platform Aave.

Full DeFi Course: Click the link to access our free full DeFi course that’ll show you the ins and outs of decentralized finance (DeFi).

Aave

Aave launched in 2017 is a DeFi protocol similar to Compound with a lot of upgrades.

Beyond what Compound provides, Aave gives several extra tokens for supply and borrowing. As of now, Compound offered nine different tokens (various ERC- 20 Ethereum- based assets).

Aave provides these nine besides an additional 13 that Compound does not.

Depositors give the market liquidity to generate a passive income, while borrowers can borrow if they have an over-collateralized token or can avail flash loans for under-collateralized (one-block liquidity).

Currently, we can see two major markets on Aave.

• The first is for ERC-20 tokens that are more frequently used, like those of Compound, and their underlying assets, such as ETH, DAI and USDC.
• The latter is only available with Uniswap LP tokens.

For instance, a user receives an LP token signifying market ownership when they deposit collateral into a liquidity pool on the Uniswap platform. To provide additional benefits, the LP tokens can be sold on the Uniswap market of Aave.

As per DeFi pulse, Aave has a TVL (Total Value Locked) of $4.09B as of today.

Aave Versions

Aave has released three versions (v1, v2 and v3) as of now and the Governance token of Aave is ‘AAVE’. Version 1 or v1 is the base version launched in 2017 and then there have been upgrades with multiple new features added. Below is a short comparison of when to use v2 or v3.

You should use Aave V2 when:

• You won’t need to borrow many tokens.
• Little profit
• You borrow important tokens like WETH, USDC, etc.

You should use Aave V3 when:

• Many tokens must be borrowed
• High profit margin
• You borrow mid-cap tokens like LINK, etc.

Borrow and Lending in Aave

Borrow

You must deposit any asset to be used as collateral before borrowing.

The amount you can borrow up to depends on the value you have deposited and the readily available liquidity.

For instance, if there isn’t enough liquidity or if your health factor (minimum threshold of the collateral = 1, below this value, liquidation of your collateral is triggered) prevents it, you can’t borrow an asset.

The loan is repaid with the same asset that you borrowed.

For instance, if you borrow 1 ETH, you’ll need to pay back 1 ETH plus interest.

In the updated Version 2 of the Aave Protocol, you can also use your collateral to make payments. You can borrow any of the stable coins like USDC, DAI, USDT, etc. if you want to repay the loan based on the price of the USD.

Stable vs Variable Interest Rate

In the short-term, stable rates function as a fixed rate, but they can be rebalanced in the long run in reaction to alterations in the market environment. Depending on supply and demand in Aave, the variable rate can change.

The stable rate is the better choice for forecasting how much interest you will have to pay because, as its name suggests, it will remain fairly stable. The variable rate changes over time and, depending on market conditions, could be the optimal rate.

Through your dashboard, you can switch between the stable and variable rate at any time.

Deposit/Lending

Lenders share the interest payments made by borrowers based on the utilization rate multiplied by the average borrowing rate. The yield for depositors increases as reserve utilization increases.

Lenders are also entitled to a portion of the Flash Loan fees, equal to .09% of the Flash Loan volume.

There is no minimum or maximum deposit amount; you may deposit any amount you choose.

Flash Loans in Aave

Flash Loans are unique business agreements that let you borrow an asset as long as you repay the borrowed money (plus a fee) before the deal expires (also called One Block Borrows). Users are not required to provide collateral for these transactions in order to proceed.

Flash Loans have no counterpart in the real world, so understanding how state is controlled within blocks in blockchains is a prerequisite.

Flash-loan enables users to access pool liquidity for a single transaction as long as the amount borrowed plus fees are returned or (if permitted) a debt position is opened by the end of the transaction.

For flash loans, Aave V3 provides two choices:

(1) “flashLoan”: enables borrowers to access the liquidity of several reserves in a single flash loan transaction. In this situation, the borrower also has the choice to open a fixed or variable-rate loan position secured by provided collateral.

The fee for flashloan is waived for approved flash borrowers.

(2) “flashLoanSimple”: enables the borrower to access a single reserve’s liquidity for the transaction. For individuals looking to take advantage of a straightforward flash loan with a single reserve asset, this approach is gas-efficient.

The fee for flashloanSimple is not waived for the flash borrowers. The Flashloan fee on Aave V3 is 0.05%.

Let’s Code a Simple Flash Loan

Let’s code a simple flash loan in Aave, where we buy and repay the asset in the same transaction without having to provide any collateral. First, we set up the environment for writing the code.

Note: It is recommended to follow the video along for a better understanding.

$npm install -g truffle  # in case truffle not installed
$mkdir aave_flashloan 
$cd aave_flashloan
$truffle init
$npm install @aave/core-v3
$npm install @openzeppelin/contracts
$npm install @openzeppelin/test-helpers 

Note: Aave3 is currently available on Polygon, Arbitrum, Avalanche, and other L2 chains. As of now, it is not available on the Ethereum mainnet. Thus, we will fork the Polygon mainnet for our tests.

Set up a new app in Alchemy with the chain as Polygon mainnet and note down the API key.

Create a new file .env and enter the below info.

$WEB3_ALCHEMY_POLYGON_ID=<API key noted above>
$USDC_WHALE=0x075e72a5eDf65F0A5f44699c7654C1a76941Ddc8

Recommended Tutorial: Solidity Crash Course — Your First Smart Contract

Simple Flash Loan Contract

The contract code (FlashLoanPolygon.sol) in the contracts folder.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@aave/core-v3/contracts/interfaces/IPool.sol";
import "@aave/core-v3/contracts/flashloan/base/FlashLoanSimpleReceiverBase.sol";

contract AaveFlashloan is FlashLoanSimpleReceiverBase {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    event Log(string message, uint256 val);
    constructor(IPoolAddressesProvider provider)
        FlashLoanSimpleReceiverBase(provider)
    {}

    function aaveFlashloan(address loanToken, uint256 loanAmount) external {
        IPool(address(POOL)).flashLoanSimple(
            address(this),
            loanToken,
            loanAmount,
            "0x",
            0
        );
    }

    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes memory
    ) public override returns (bool) {
        require(
            amount <= IERC20(asset).balanceOf(address(this)),
            "Invalid balance for the contract"
        );
        // pay back the loan amount and the premium (flashloan fee)
        uint256 amountToReturn = amount.add(premium);
        require(
            IERC20(asset).balanceOf(address(this)) >= amountToReturn,
            "Not enough amount to return loan"
        );

        approveToken(asset, address(POOL), amountToReturn);
        emit Log("borrowed amount", amount);
        emit Log("flashloan fee", premium);
        emit Log("amountToReturn", amountToReturn);

        return true;
    }
}

The contract code contains two important functions.

• aaveFlashloan() which calls the pools function flashLoanSimple(). Our test code must call this function to initiate a flash loan.
• executeOperation() is a callback function of the pool which pays the loan + interest back to the pool.

Testing Contract

In the test folder, create a JavaScript file config.js with the following content:

const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";

const aavePoolAddressesProvider =
  "0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb";

const USDC_WHALE = process.env.USDC_WHALE;

module.exports = {
    USDC,
    USDC_WHALE,
    aavePoolAddressesProvider,
}

In the test folder, create another file testAaveFlashLoanSimple.js:

const BN = require("bn.js");
const IERC20 = artifacts.require("IERC20");
const AaveFlashLoan = artifacts.require("AaveFlashloan");
const {USDC,aavePoolAddressesProvider,USDC_WHALE} = require("./config");


function sendEther(web3, from, to, amount) {
  return web3.eth.sendTransaction({
    from,
    to,
    value: web3.utils.toWei(amount.toString(), "ether"),
  });
}

contract("AaveFlashLoan", (accounts) => {
  const WHALE = USDC_WHALE
  const TOKEN_BORROW = USDC
  const DECIMALS = 6  // USDC uses 6 decimal places and not 18 like other ERC20
  // We fund more because we need to pay back along with the fees during Flash loan.
  // So let us fund extra (2 million round figure to the calculations simple)
  const FUND_AMOUNT = new BN(10).pow(new BN(DECIMALS)).mul(new BN(500)); 500 USDC
  const BORROW_AMOUNT = new BN(10).pow(new BN(DECIMALS)).mul(new BN(1000000)); // 1 million USDC

  let aaveFlashLoanInstance
  let token

  beforeEach(async () => {
    token = await IERC20.at(TOKEN_BORROW) // USDC token
    aaveFlashLoanInstance = await AaveFlashLoan.new(aavePoolAddressesProvider)

    // send ether to USDC WHALE contract to cover tx fees
    await sendEther(web3, accounts[0], WHALE, 1)

    // send enough token to cover fee
    const bal = await token.balanceOf(WHALE)
    assert(bal.gte(FUND_AMOUNT), "balance < FUND")
    // Send USDC tokens to AaveFlashLoan contract
    await token.transfer(aaveFlashLoanInstance.address, FUND_AMOUNT, {
      from: WHALE,
    })
    console.log("balance of USDC in AAveFlashLoan contract:", bal2.toString())

  })
    it("aave simple flash loan", async () => {
        const tx = await aaveFlashLoanInstance.aaveFlashloan(token.address, BORROW_AMOUNT)
        console.log("token address:",token.address)
        for (const log of tx.logs) {
        console.log(log.args.message, log.args.val.toString())
        }
    })

});

Again, feel free to watch the video at the beginning of this tutorial to understand the testing process.

Open two terminals.

In terminal 1:

$source .env
$npx ganache-cli i --fork https://polygon-mainnet.g.alchemy.com/v2/$WEB3_ALCHEMY_POLYGON_ID \
--unlock $USDC_WHALE \
--networkId 999

This should start a local fork of the Polygon mainnet.

In terminal 2:

$ source .env
$ env $(cat .env) npx truffle test --network polygon_main_fork test/testAaveFlashLoanSimple.js

This should run the flash loan test case, and it must pass.

Conclusion

This tutorial discussed Aave, a leading Dapp lending and borrowing provider.

It covered some basic functionalities supported in Aave, such as lending, borrowing, and flash loans.

There are many other features Aave supports and it is not possible to cover it in one post, such as governance, liquidation, and advanced features such as Siloed Borrowing, Credit Delegation, and many more.

The post also examined a simple flash loan contract using Aave API.

You can explore more about borrowing and lending with Aave in this link. It has a full stack Defi Aave dapp with frontend to perform borrowing and lending.

Recommended Tutorial: Crypto Trading Bot Developer — Income and Opportunity

The post Aave for DeFi Developers – A Simple Guide with Video appeared first on Be on the Right Side of Change.

Let’s get started!

Step 1: Getting Started with DeFi

What is DeFi?

Decentralized Finance, also referred to as “DeFi,” enables customers to access financial services that include lending, borrowing, and trading.

These financial services use Decentralized applications (Dapps) in implementing their functionality and they do not rely on centralized finances to execute their operations. The vast majority of these services are being created on the Ethereum blockchain.

To use the DeFi tools, you don’t need to be an Ethereum expert, although it helps to be familiar with how Ethereum or layer-2 blockchains like Polygon operate.

Defi is not a single service or a product, but an assortment of several goods and services that can replace traditional institutions like banking, bonds, insurance, and trading.

It is possible to integrate these services, each having its own functionality, to build one protocol with multiple functions. Thus grouping services like borrowing, lending, staking and many others together to create one multi-functional financial application. As it is workable to assemble these services, DeFi apps are also called “money LEGOS”.

Learn More: You can read the full tutorial on the Finxter blog.

Step 2: MakerDAO 101 for Coders – How DeFi Lending and Borrowing Works

DeFi breakthroughs have been happening on Ethereum because of its prominence, but it is also emerging on other blockchains like Solana, Polkadot, Algorand, and many more.

We will look at three popular DeFi dApps: MakerDAO, Compound, and Aave. I will explain MakerDAO in this article and the other two – Compound and Aave in the next.

MakerDAO is a good example of understanding the DeFi ecosystem, where DAO stands for decentralized autonomous organization. It employs two tokens. A stablecoin called DAI and a governance token called MKR. We will discuss each of them ‌and their use cases.

DAI is a crypto-collateralized stable coin with a 1:1 parity with US dollar ($), and value backed by ETH (Ether) as collateral in the smart contract called the Maker collateral vault. DAI token has the money function and acts as currency.

MKR token is the governance token issued by the Maker protocol to the lenders or stakeholders that grants voting rights and decision-making in the improvements of the Maker protocol. The MKR token holders also govern the stability of DAI. Thus MKR token has a utility function.

Users can mint new $DAI tokens when they take their digital assets ($ETH, $BAT, $USDC, $YFI, $LINK) with MakerDAO’s smart contract. Thus, by staking digital assets, you can create $DAI.

Learn More: You can read the full tutorial on the Finxter blog.

Step 3: Compound for Developers: Yield Farming, Borrowing, Lending

Compound is a popular lending and borrowing platform for various ERC-20 tokens.

As per DeFi pulse, Compound has a Total Value Locked (TVL) of $2.56 billion USD.

You can deposit items that can be pledged as collateral for loans through Compound.

Based on your collateral, you are only permitted to borrow up to a particular percentage (about 60–70%). Credit ratings are meaningless, and since Ethereum accounts are anonymous, it is nearly impossible to get payment in the event of a loan default.

Learn More: You can read the full tutorial on the Finxter blog.

Step 4: Aave for Defi Developers

Aave launched in 2017 is a DeFi protocol similar to Compound with a lot of upgrades.

Beyond what Compound provides, Aave gives several extra tokens for supply and borrowing. As of now, Compound offered nine different tokens (various ERC- 20 Ethereum- based assets).

Aave provides these nine besides an additional 13 that Compound does not.

Depositors give the market liquidity to generate a passive income, while borrowers can borrow if they have an over-collateralized token or can avail flash loans for under-collateralized (one-block liquidity).

Learn More: You can read the full tutorial on the Finxter blog.

The post Decentralized Finance for Coders [Free Video Course] appeared first on Be on the Right Side of Change.

Abstract: In this article, we will see how decentralized lending and borrowing work. It starts with comparing centralized finance (CeFi) with decentralized finance (DeFi) lending and borrowing. You’ll then learn about the most important Ethereum based DeFi decentralized apps (dapps) for lending and borrowing. I explain MakerDAO here and address Compound and Aave in the next article.

Full DeFi Course: Click the link to access our free full DeFi course that’ll show you the ins and outs of decentralized finance (DeFi).

CeFi vs. DeFi Lending and Borrowing

Lending and borrowing cash are two of the most popular services provided by the financial sector.

Thanks to the idea of credit and collateralization, which makes this workable. The beginning of the period of modernity in European history (also called the Renaissance period) was because of commercial scale lending and borrowing, which led to the furor in economic activity.

Because of this powerful mechanism, the economy rose at an unparalleled speed.

An entrepreneur can borrow the initial money needed for a startup from the lender by providing the business as collateral, or a family can mortgage a house as collateral for loans.

This technique helps in reducing the borrower’s absconding with all the loaned money.

Thus, the CeFi borrowing or lending needs some kind of middleman, such as banks. Before you get the borrowed amount from the bank, you need to show your ability to repay loans and also stick to the restrictions imposed by them.

Besides this, there is a complex system of credit scores that determines an individual’s ability to repay the loan and also considering other factors such as geographical legal restrictions of the banks, multiple applicants etc. add to high barriers in getting the loans approved. Basically, to be even considered for loans, you have to be affluent enough when using CeFi.

With the DeFi system, this barrier and impediments do not exist.

Anybody can access the funds from the pool if you have enough collateral (other crypto currencies or tokens.). All the masses can contribute to the liquidity pool, which the borrowers can withdraw from and repay at the interest rate set by the algorithms of the DeFi system. Using the DeFi ecosystem, asset lending is no longer the privilege of the rich.

Another notable difference between CeFi and DeFi is the bank regulations like Anti Money Laundering (AML) and Know-Your-Customer (KYC) in place, whereas in the DeFi ecosystem you just need to only submit the crypto collateral. It’s very simple and has no hassles.

MakerDAO – A Lending and Borrowing dApp

DeFi breakthroughs have been happening on Ethereum because of its prominence, but it is also emerging on other blockchains like Solana, Polkadot, Algorand, and many more.

We will look at three popular DeFi dApps: MakerDAO, Compound, and Aave. I will explain MakerDAO in this article and the other two – Compound and Aave in the next.

MakerDAO is a good example of understanding the DeFi ecosystem, where DAO stands for decentralized autonomous organization. It employs two tokens. A stablecoin called DAI and a governance token called MKR. We will discuss each of them ‌and their use cases.

DAI is a crypto-collateralized stable coin with a 1:1 parity with US dollar ($), and value backed by ETH (Ether) as collateral in the smart contract called the Maker collateral vault. DAI token has the money function and acts as currency.

MKR token is the governance token issued by the Maker protocol to the lenders or stakeholders that grants voting rights and decision-making in the improvements of the Maker protocol. The MKR token holders also govern the stability of DAI. Thus MKR token has a utility function.

Users can mint new $DAI tokens when they take their digital assets ($ETH, $BAT, $USDC, $YFI, $LINK) with MakerDAO’s smart contract. Thus, by staking digital assets, you can create $DAI.

Operation model of MakerDAO

The best way to know how MakerDAO operates is by looking at an example. Before we look into an example, let us understand two important terminologies in MakerDAO – debt and CDP (collateralized debt positions).

Users can deposit crypto assets (ETH or other ERC20 tokens) into the smart contract to generate or mint the $DAI tokens up to a particular collateralization ratio (at least 150%).

This generates a position called CDP and ‘debt’ in DAI.

MakerDAO is always over collateralized (as mentioned >=150%) so that the value of the collateral is always greater than the debt. MakerDAO needs this because the price of ETH is highly volatile.

Now let’s take an example to see how MakerDAO algorithms work.

Let’s consider you are the ETH owner who wants to have liquidity but does not intend to sell ETH, as it may rise in value in the future (this is like the owner who wants to mortgage the house or apartment because they want the liquidity but do not want to sell the house).

Let’s consider you have 5 ETH and the ETH price is = $1000, totaling to $5000.

1. Deposit 5 ETH to open a CDP (collateralized debt position).
2. If the collateralization requirement is at least 150% for MakerDAO, then you can mint up to 5000/1.5 ~= 3334 DAI. If the ETH plummets below $1000, then in such a case, the contract would be under-collateralized, and the system must also maintain the $1 = 1 DAI ratio. Thus, ‌you cannot mint all the 3334 DAI, as there is no notice from the exchange or broker to deposit more ETH or liquidate the position to maintain this ratio. As liquidation will happen instantly, you always mint less than 3334 DAI to provide a safety net.

Let’s take a case if you only mint 2500 DAI, with a collateralization ratio of 2.0 ($5000/2 = 2500). Now consider the two scenarios:

1. If collateral price increases, i.e., ETH price increases by 50%, meaning the collateral is now worth $7500 ($5000 + $2500). As collateralization was 200%, you can mint up to 3750 DAI, which is an additional 1250 DAI.
2. If collateral price decreases, i.e.  ETH price decreases by 25%, it becomes an intriguing issue. The collateral is now worth $3750 ($5000 – $1250). With a maximum mint of 2500 DAI, the collateralization ratio gets reduced to 1.5 (3750/2500). You have three options to solve the problem.

1.) You can increase the amount of collateral in the contract by adding $1250 worth of ETH (or 1.6 ETH).

2.) As you have 2500 DAI, you can pay off the debt and get back 5 ETH, however the total worth of ETH is now reduced to $3750.

3.) Last, if you use neither option, then a third party called keepers will look for liquidation in order to liquidate the debt. The keeper will sell ETH at auction to get back enough DAI to pay off the debt. In our case, 1.6 ETH($1250) gets sold and you get back 3.2 ETH and the keeper gets 0.2 ETH as a percentage fee. So in total you have 3.2 ETH ($2400) and 2500 DAI.

Where is MakerDAO used?

• Decentralized exchanges like Uniswap, Sushiswap, Curve, Balancer. They use DAI because it makes trade easy and is always in demand.
• Lending protocols like Aave, Compound, Celsius. They use DAI because it is less volatile and hence provides stability for lending and borrowing.

DAI in Smart contracts

Let us get ‌practical and try using DAI in our smart contract. Below is the smart contract, which can accept/deposit() and withdraw() DAI token. We will make use of the Kovan network, where DAI (ERC20) contract deployed at –  0x4F96Fe3b7A6Cf9725f59d353F723c1bDb64CA6Aa

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import "@openzeppelin/contracts/access/Ownable.sol";

// Adding only the ERC-20 function we need
interface DaiToken {
    function transfer(address dst, uint wad) external returns (bool);
    function balanceOf(address guy) external view returns (uint);
}

contract DaiFaucet is Ownable  {
    
    event Withdrawal(address indexed to, uint amount);
    event Deposit(address indexed from, uint amount);
   

    DaiToken daitoken;

    
    constructor() public{
        // kovan network
        daitoken = DaiToken(0x4F96Fe3b7A6Cf9725f59d353F723c1bDb64CA6Aa);
    }

    // Give out Dai to anyone who asks
    function withdraw(uint withdraw_amount) public {
        // Limit withdrawal amount
        require(withdraw_amount <= 0.1 ether);
        require(daitoken.balanceOf(address(this)) >= withdraw_amount,
            "Insufficient balance in faucet for withdrawal request");
        // Send the amount to the address that requested it
        daitoken.transfer(msg.sender, withdraw_amount);
        emit Withdrawal(msg.sender, withdraw_amount);
    }

    // Accept any incoming amount
    fallback () external payable {
        emit Deposit(msg.sender, msg.value);
    }

        // Only owner can shutdown this contract.
    function destroy() public onlyOwner {
        daitoken.transfer(owner(), daitoken.balanceOf(address(this)));
        selfdestruct(payable(msg.sender));
    }
}

An interface DaiToken interacts with the DAI contract for transfer() and balanceOf().

The contract DaiFucet defines:

1. constructor() to get an instance of the DAI token contract on Kovan network.
2. withdraw() function to withdraw DAI. It transfers DAI from this contract to the msg.sender only on the condition that the requested amount is <= 0.1 DAI (you have to use it as <= 0.1 ETH).
3. A fallback function to accept DAI for the contract.
4. destroy() to destroy the contract when you no longer need it.

Compile and deploy the contract to the Kovan network using Remix Ide and Metamask. I have already deployed the contract at 0xABC10a81b5d50f4455f4F7cC1f418ff70259dd8A. Your contract will be at a unique address than mine.

How to send DAI to the contract and withdraw?

Use Uniswap to swap some ether to DAI on the Kovan network through your Metamask account. Now you have DAI in your Metamask account. On Metamask, you can see it in the assets section. See the figure below.

You can now click on DAI and select send, type the address of the above deployed contract and click on send, by signing the transaction, your contract will now receive DAI.

Now you can interact with the contract to withdraw DAI from Remix (You can only withdraw a maximum of 0.1 DAI per transaction as per the rule set in the contract).

After you are done enough with the contract, you can as well destroy it by calling destroy() function.

Conclusion

The article started with discussing lending and borrowing in CeFi and DeFi.

We saw how DeFi is easy to use and you have complete control over your assets with no interference from a central finance institute like banks, etc.

The architecture of the most widely used and popular dapps like MakerDAO was explained, and finally saw an example of sending and receiving DAI in a smart contract.

Feel free to check out our related course on the Finxter Academy:

The post MakerDAO 101 for Coders – How DeFi Lending and Borrowing Works appeared first on Be on the Right Side of Change.