Lesson 10: LendingPool.withdraw() function

[ChakibHi]

Hello everyone,
at the end of Lesson 10, we created a python script that will do the following:

• Deposit to Aave (using LendingPool.deposit())
• Borrow Dai (using LendingPool.borrow())
• Repay Dai (using LendingPool.repay())

However the first deposit is still locked inside Aave. To withdraw everything and complete the process, LendingPool documentation have a withdraw() function to withdraw WETH and burn the aToken.

The blocking point is, how to withdraw the entire balance (with interest) using python?

FYI, I successfully did it inside a Solidity contract by passing the "type(uint).max" as an argument, but i couldn't find a way to do it frontend only (python).

[AlbertoSinigaglia]

from this contract I can see a withdrawAll method... you probably can do the same with your, and since the amount is retrieved by looking at the balance of an address, you might be able to do the same with Python

In my case, I had to add:

function withdraw(uint wad) public;

to the interface that @PatrickAlphaC gave us, and then used this code:

contract = interface.IWETHGateway(config["networks"][network.show_active()]["weth_token"])
tx = contract.withdraw(contract.balanceOf(account), {
  "from": account,
})

[AlbertoSinigaglia]

@PatrickAlphaC i was able to reproduce that code using python, however since involves call and transaction, there might be some race condition if while we do our calculation someone else withdraw of funds the account

[AlbertoSinigaglia]

@ChakibHi updated the answer

[ChakibHi]

Thanks @AlbertoSinigaglia for the suggested answer!

However I just found an answer to my question, which was how to send the "type(uint256).max" through Web3.py so we can withdraw the whole deposit whatever it was.

PS: The withdrawETH() on IWETHGateway.sol need three arguments + the interface have its own address "WETHGateway_address" + balanceOf is used normally on the token.

[AlbertoSinigaglia]

@ChakibHi wee you able to get all the eth back from Aave? The best i was able to do is to reset the borrowed amount, but I can't find a way to get back the 0.1 eth deposited at the beginning

[ChakibHi]

@AlbertoSinigaglia Could you try my answer below and let me know if it works on your end.

[ChakibHi]

The type(uint).max annotation is basically for Solidity smart contracts, to send the max uint256 using Web3.py or Web3.js we can use one of the following:

• max amount = 2**256 -1
• max amount = Web3.toHex(2 ** 256 - 1)

I used the WETHGateway, because it easier to withdraw the unwrapped Ether directly (not WETH):

def aave_withdrawEth():
    aave_WETHGateway = interface.IWETHGateway(
        config["networks"][network.show_active()]["WETHGateway_address"]
    )
    tx = aave_WETHGateway.withdrawETH(
        lending_pool_address,
        Web3.toHex(2 ** 256 - 1),  # We want to withdraw the max amount on Aave
        account,
        {"from": account},
    )
    tx.wait(1)
    print("You withdrawn Eth from Aave successfully!")

you may need to approve the aWETH ERC20 token.
https://docs.aave.com/developers/the-core-protocol/weth-gateway#withdraweth

[AlbertoSinigaglia]

@ChakibHi but why should we approve the transfer? I mean, when we deposit eth to aave using deposithETH we are moving ETH... and when we withdraw eth, we are working with eth, why should I approve any payment for WETH? at most, It's aave that should approve the withdraw to WETH

[ChakibHi]

@AlbertoSinigaglia when you deposit ETH, they send you the equivalent amount in aWETH (Aave interest bearing WETH) directly to your wallet. According to their documentation, when you withdraw they need the approval to burn the aWETH that was sent to you.

[AlbertoSinigaglia]

this is not working for me, it keeps saying ERC20: transfer amount exceeds allowance

[AlbertoSinigaglia]

this is the code I'm ending up using that makes total sense to me, but it's still not working:

def withdrawEthFromAave():
    account = getAccount()
    aweth_token = getAaveAWethGateway()
    lending_pool = getLendingPool()
    amount = aweth_token.balanceOf(account.address)
    print(approveERC20(
        token_contract_address=aweth_token.address,
        spender=lending_pool.address,
        value=amount*1000,
        owner=account
    ).return_value)
    tx = getAaveWethGateway().withdrawETH(
        lending_pool.address,  # lendingPool
        amount,  # amount
        account,  # to
        {"from": account},
    )
    tx.wait(1)
    print("You withdrawn Eth from Aave successfully!")

[PatrickAlphaC]

Love the thread here, let me just catch up. @AlbertoSinigaglia I think you solved this issue in another thread right? Or maybe I'm getting mixed up.

Is there a TL;DR of where we are up to this point?

[PatrickAlphaC]

Ok now I'm up to speed with these. Amazing questions all.

A few points of confusion.

There are 2 kinds of withdraw functions in this process

• One is to withdraw your ETH out of the WETH contract. (converting your WETH ERC20 version of ETH back into it's regular non-tokenized version of ETH.
• Withdrawing your deposited collateral from the Aave contract.

The original question here is asking "How do I withdraw all of my original deposited collateral?"

Which we can do by:

1. First repaying all our debts
2. Then withdrawing everything (using that nice -1 syntax)

_Note: This brings up a good point, in a bigger project it would be nice to refactor the code so that we had fewer duplicated functions, but for simplicity, I'm just going to write the whole function.

Repay our debts

Now... since we are in fake testnet world, it's sort of hard to get more DAI, it's a bit easier in the forked blockchain world, but basically, you need to buy more DAI to pay it back. I've got some scripts on how to do that here: https://github.com/PatrickAlphaC/defi_py_mix/blob/main/scripts/swap/swap.py

Withdrawing

Once you do that, you should then be able to withdraw it pretty easily with something like:

def withdraw_all_collateral(lending_pool, account):
    print("Withdrawing collateral...")
    tx = lending_pool.withdraw(
        config["networks"][network.show_active()]["weth_token"],
        (2 ** 256) - 1,
        account,
        {"from": account},
    )
    tx.wait(1)
    print("Withdrew!")
    return tx

uint(-1) in solidity is the same as (2 ** 256) - 1 in python.

WETH withdraw

In WETH, you can just call the withdraw function to swap the ERC20 version of ETH back to regular ETH. I have added the withdraw function to the interface in the GitHub repo, so you can test building out a function yourself!

[cromewar]

Hello @Neftyr be sure you have the correct contract addresses on bronwie-config.yaml because AAVE has changed a lot since the video.

[Nlferu]

Hello @cromewar
I have tested few addresses in brownie-config.yaml and none of them worked throwing same error. I think correct address for 'a_weth_token'(aWETH) is '0x030bA81f1c18d280636F32af80b9AAd02Cf0854e' for mainnet and '0x87b1f4cf9BD63f7BBD3eE1aD04E8F52540349347' for kovan. Let me know if I'm wrong. Thank you in advance mate!

[cromewar]

Well haven't touched AAVE in while as they have changed a lot, I'll do some research on this, on the meantime could you please clone the repo of that lesson and run it, does it work?

[Nlferu]

Hello @cromewar
There is no Kovan network available for any version of AAVE since today or even yesterday, so i think it became deprecated. I will retry with Goerli now. There are no such functions in Patrick's course, so repo clone won't work here. It is something more that I wanted to do as part of my learning.

[Nlferu]

Hi @cromewar and everyone i have made some researches and:

Below function based on lending_pool works perfect and withdrawing everything from AAVE account for both local testnet and goerli testnet, so previous issue with it was indeed address in brownie-config.yaml as AAVE use it's own addresses for WETH and aWETH, you can check that by clicking asset you want address of then as it is shown on screen below:

AAVE token address checking:

Below function based on lending_pool:

max_amount = 2 ** 256 - 1

def withdraw_all_collateral(lending_pool, account):
    print("Withdrawing collateral...")
    tx = lending_pool.withdraw(config["networks"][network.show_active()]["weth_token"], max_amount, account, {"from": account})
    tx.wait(1)
    print("Withdrew!")
    return tx

Below function based on IWeth interface has something incorrect with value 2 ** 256 - 1 as it is uint instead of uint256 i guess it should be 2 ** 32 - 1 and it works but not withdrawing any amount from AAVE account. If we put value of for example 0.1 it will withdraw 0.1, but I want to make it max_amount as it is in first function. I have also tried changing IWeth interface to: function withdraw(uint256 wad) external; but it doesn't work at all like this. Any idea how to fix this amount?

Below function based on IWeth interface:

def withdraw_weth():
    account = get_account()
    weth = interface.IWeth(config["networks"][network.show_active()]["weth_token"])
    print("Withdrawing collateral...")
    tx = weth.withdraw((2 ** 32) - 1, {"from": account})
    tx.wait(1)
    print("Withdrew!")
    return tx

[Nlferu]

Hello,

I have just discovered that there is discrepancy between those 2 functions below.

Function based on lending_pool is witdrawing from Supplied ETH to WETH

max_amount = 2 ** 256 - 1

def withdraw_all_collateral(lending_pool, account):
    print("Withdrawing collateral...")
    tx = lending_pool.withdraw(config["networks"][network.show_active()]["weth_token"], max_amount, account, {"from": account})
    tx.wait(1)
    print("Withdrew!")
    return tx

Function based on IWeth interface is withdrawing from WETH to ETH (Not Supplied ETH)

def withdraw_weth():
    account = get_account()
    weth = interface.IWeth(config["networks"][network.show_active()]["weth_token"])
    print("Withdrawing collateral...")
    tx = weth.withdraw((2 ** 32) - 1, {"from": account})
    tx.wait(1)
    print("Withdrew!")
    return tx

I'm not really sure why is that...

I also still didn't figure out why max_amount doesn't work for function based on IWeth interface. If anyone have idea how to fix it I would be really grateful.

[cromewar]

The AAVE protocol changed a lot since the video, so most of things would not work in the same way.
I'll try to create a implementation of the latest version and share it here.