This PR includes Aave v3 constants, event reading from blockchain and a Jupyter notebook for analyzing the data, and event documentation in eth_defi/aave_v3/README.md.

The Aave v3 ABI JSON files can be generated with make aavev3, which copies them from the @aave/core-v3 NPM package to the working directory (Node.js required).

• Github and other searches to find Python (and JavaScript) open source examples for getting data out from Uniswap v3
• Data structure how to store this data in the (SQL) database for historical queries

Question that needs to be answered:

• Given (chain id, Uniswap v3 deployment address)
• What is the historical price for buy/sell (timestamp, trading pair, token0 quantity in) -> token1 quantity out

Can be a single pool price at milestone 1, later expanded to cover auto routing and multi-hop trades.

Uniswap trade analyzer should be able to tell why the trade failed

• Too much slippage
• Some internal Uniswap error
• (There should be no other reasons if the tokens are not scam tokens)

As a bonus, trade analyzer should able to tell if the trade was reverted because of slippage. Though not sure how we can pick up this from the transaction receipt, I believe is going to be quite hard. The ”real” EVM nodes do not store the revert reason for very long time (few hundreds of blocks) and one might need to replay the transaction.

https://snakecharmers.ethereum.org/web3py-revert-reason-parsing/

This would be a research task of doing some little trades with Ganache and see what kind of data we can get out of JSON-RPC for the revert reason -if any. And then do the transaction replay trick.

Creaet a function that calculates amountIn and amountOut values for buy/sell with a specific slippage.

See this question for details:

https://ethereum.stackexchange.com/questions/99404/pancakeswap-anti-front-run

First for Uniswap v2, as its dog eats dog frontrun battle at BNB Chain.

Some tokens with ponzinomis have a token tax. This is especially popular on wild west blockchains like BNB Chain and PancakeSwap.

Token tax is used to

• Create deflanatory tokens
• Create malicious honey pots for trading bots ("buy only") - effectively a very high tokex tax like 90% on sell

An example trading pair and token with token tax is ELEPHANT-BUSD.

• Buy has 10% tax
• Sell has 10% tax

honeypot.is is an independent service to check the token tax. It does this by (likely) running Ganache mainnet fork and simulates the transactions. There is no API to ask this information.

Step 1: Read the token tax with Python

To figure out the amount of different token taxes (buy, sell, transfer) one needs to run a simulated transaction in Ganache.

Here is a pseudo-Python code to do it:

from eth_account.signers.local import LocalAccount
from eth_typing import HexAddress
from web3 import Web3

from eth_defi.uniswap_v2.deployment import UniswapV2Deployment
from tradeexecutor.utils import dataclass


@dataclass
class TokenTaxInfo:
    """Different token taxes we figured out."""

    #: Token in the question
    base_token: HexAddress

    #: Which token we traded against it
    quote_token: HexAddress

    #: How much % we lost of the token on buy
    buy_tax: float

    #: How much % we lose the token when we transfer between addresses
    transfer_tax:float

    #: How much % we lose the token when we sold it
    sell_tax: float


def estimate_token_taxes(
        uniswap: UniswapV2Deployment,
        base_token: HexAddress,
        quote_token: HexAddress,
        buy_account: LocalAccount,
        sell_account: LocalAccount
    ) -> TokenTaxInfo:
    """Estimates different token taxes for a token by running Ganache simulations for it.

    :param uniswap:
        Uniswap deployment on a Ganache mainnet fork.
        Set up prior calling this function.
        See `ganache.py` and `test_ganache.py` for more details.

    :param base_token:
        The token of which tax properties we are figuring out.

    :param quote_token:
        Address of the quote token used for the trading pair. E.g. `BUDS`, `WBNB`
        Based on this information we can derive Uniswap trading pair address.

    :param buy_account:
        The account that does initial buy to measure the buy tax.
        This account must be loaded with gas money (ETH/BNB) and `quote_token`
        for a purchase.

    :param sell_account:
        The account that receives the token transfer and does the sell to measure the sell tax.
        This account must be loaded with gas money for the sell.

    :return:
        ToxTaxInfo tells us what we figure out about taxes.
        This can be later recorded to a database.
    """

    web3: Web3 = uniswap.web3

    # Figure out base_token/quote_token trading pair
    # Buy base_token with buy_account
    # Measure the loss as "buy tax"
    # Transfer tokens to sell_account
    # Measure the loss as "transfer tax"
    # Sell tokens
    # Measure the loss as "sell tax"

The TokenTaxInfo info can be then stored in a database or similar, like SQL, JSON file repo and so on. It can be later retrieved when you want to trade tokens.

Step 2: Making taxed tokens easily tradeable with Python

Create a buy/sell_with_tax(token_tax_info: TokenTaxInfo, max_slippage) function that considers slippage and token tax and correctly handles trading these kinds of tokens.

• Normally buying ELELPHANT-BUSD would revert
• Normally selling a token tax token would fail with execution reverted: TransferHelper: TRANSFER_FROM_FAILED because there is a mismatch between allowance() and swap amount

Create four test based on BSC mainnet fork using the existing Ganache fixtures

• Naive buy of ELEPHANT fails
• Taxed buy of ELEPHANT success, we can calculate the taxed amount after the buy (update analyse_trade to return this value)
• Naive sell of ELEPHANT fails
• Taxed sell of ELEPHANT success, we can calculate the taxed amount after the sell
• Comment how this can be also considered in three-way trade (BUSD-BNB-ELEPHANT)

• Add a method to efficiently store block headers on disk to save a lot of time and API calls if we need to resume after a crash
• Parquet append method used
• The storage method is chain reorganisation safe

• Feature: generic price oracle implementation with configurable price function
• Feature: time weighted average price (TWAP) price function for price oracle
• Feature: price oracle implementation for Uniswap v2 pools
• Feature: fetch_pair_details to get info on Uniswap v2 pairs

Badge logo:

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/tradingstrategy-ai/web3-ethereum-defi/master?labpath=docs/source/tutorials
)

Current the event reader can't handle chain reorg situation, so it's likely to fail here: https://github.com/tradingstrategy-ai/web3-ethereum-defi/blob/df38b8a97176cc5b3dbc92783c0791c9603b0c5b/eth_defi/event_reader/reader.py#L148-L161

• [ ] Write a function that opens a loan position in Aave v3 by depositing any Aave v3 reserve token and receives aToken back
• [ ] The function can live in eth_defi.aave_v3.loan module - The module should be modelled similar as e.g. Uniswap v2 swap_with_slippage_protection and deploy_trading_pair - Function name: deposit_in_aave - Inputs: HotWallet instance (assumed loaded with USDC), aave_deposit_address, token_address, amount - Outputs: tx_hash
• [ ] The module must be sufficiently documented for autodoc according to the coding conventions
• [ ] The code must be formatted to according to the coding conventions - there is is black that complains on open PRs if this is not the case
• [ ] There must be integration test
  • Because there is no framework to set up Aave v3 smart contracts in Ethereum Tester environment, one must use Ganache mainnet fork for the test. Normally this is unpreferable, but creating Aave v3 test environment itself is large task.
  • There are some examples of using Ganache in tests in test_ganache and test_token_tax
  • The test can be called test_aave_deposit.py
  • A test case check that the 0) Hot wallet starts with USDC on Ethereum mainnet 1) deposit was correctly registered with the Aave reserves 2) you receive the corresponding Aave aUSDC token back in the wallet, with the correct amount
  • Because there is no automatic mechanism to fetch Aave reserves and addresses as a list, please use hardcoded and commented values as text fixtures for now for any Ethereum address, with links to their respective descriptions of what they are