Need to implement this

Add cream finance route (route 8)
Checkout the docs here.

Chains to add the route to:-

• Polygon
• Avalanche
• Arbitrum

Add Euler route on Mainnet

Need to add uniswap v3 flash support to the FLA. Chains to add on:-

• Polygon
• Arbitrum
• Optimism (Need to make a new folder for this)

Checkout the docs here.
In order to take flashloan using a uniswap v3 pool, we need the call the flash function of the pool. So, we will be needing the pool address. We kept this extra param for future use, which we will be using for this integration. We will be encoding the pool key in this param while calling the uniswap route from the frontend. On the contracts side, we need the decode and get the pool key. Pool key is a struct which contains token0 address, token1 address and fee tier of the pool.

In the route handler we will check that the length of the _tokens param should be 1 or 2.

• If its 1, _tokens[0] should be either equal to token0 or token1 from the pool key.
• If its 2, _tokens[0] and _tokens[1] should be equal to token0 and token1 respectively

Now, we have to calculate the pool address from the pool key in the route handler (using the uniswap v3 lib, or we can simply define our own function for it) and call the flash function of the pool, by passing the respective amounts.

In the callback, we will get the amounts, send the to the user, expect them to be returned with fee, and return it to the pool.

Start with polygon. We will add it to other chains too.

Contains all the minor updates that we need to implement with the next major update.

• Change instaFeeBps from 4 decimals to 6 decimals.

How can we flash borrow Compound and Aave in other ways? We can deposit collateral into these protocols and borrow against them.

MakerDAO provides free flashloan access of 500M DAI. So what we do in our flashloan aggregator is:

• Flashborrow 500M DAI.
• Deposit all of them into Compound or Aave.
• Borrow the flash tokens from Compound or Aave.
• Send them to the user.
• User will return.
• Payback the flash tokens on Compound or Aave.
• Withdraw 500M DAI.
• Flashpayback 500M DAI.

We can name Compound as route 3 and Aave as route 4.

A fee variable. Just like Aave flashloan. 1 = 1 BPS = 0.01% fee. 9 = 9 BPS = 0.09% fee.

The fee will be net. Eg:-
Let's say we set the fee at 5 BPS. If the flashloan fee is 2 BPS then we will only charge 3 BPS so net equals 5 BPS.
If the flashloan fee is already >=5 BPS. Eg:- Aave has 9 BPS then we won't charge anything in that case.

Before calling flashloan, hash the entire data in keccak bytes32 and store it in storage variable and when it calls back at the time verify the data back again and make it bytes(0)

This will allow us to add any flashloan provider without any security concerns.

Currently we get the funds first in the FLA, then transfer them to the user. If we add the recipient as the caller, then the funds will directly go to the caller. This will save some gas.

Always keep the first letter of function smaller. Eg:- change CompoundBorrow to compoundBorrow. This is the format that the whole coding industry follows.

Add function to transfer fees to Treasury. It'll accept addresses[] tokens & uint[] amounts as params. If amounts is type(uint).max then transfer max balanceOf.

Networks to add-in:

• Mainnet
• Polygon
• Arbitrum

Helpful links:
https://docs.balancer.fi/concepts/features/flash-loans
https://dev.balancer.fi/references/contracts/contract-addresses [Vaults has the flashloan function]
https://etherscan.io/address/0xBA12222222228d8Ba445958a75a0704d566BF2C8#writeContract

We're going to have flashloan aggregators on each chain and they will differ according to the flashloan source. Eg:- Aave in on 3 chains but maker is only on 1 chain so separate out things according to different chains.
Chains to start with:

• Mainnet
• Polygon
• Avalanche

There wont be any extra fee taken by FLA for whitelisted contracts.

How flashloan works technically?

• User's contract calls the flashloan contract with tokens, amounts and the encoded data in bytes to execute.
• Flashloan contract sends the tokens to user's contract and calls a function (in Aave's case that function is executeOperation() with data and fees in the params.
• User contracts decodes the data and use it in however manner they desire condition by the end of it user needs to return all the assets to the flashloan contract.

Aave flashloan docs.

Look at the readme here

This is our current flashloan. Not very much standardised at the moment.

Build an upgradable Flashloan aggregator contract.
It'll have a function like:

function initiateFlashLoan(	
        address[] memory tokens_,	
        uint256[] memory amounts_,
        uint256 route_,
        bytes calldata data	
    ) external isDSA isWhitelisted(data) {	
        // code
    }

route will help to decide from which flashloan provider do we need to flash borrow.

Dont harcode the fees for pools on contract level, rather take them as params

also getting error here 👍 can you help fix?

$ npm run test:runner

[email protected] test:runner
hardhat run scripts/run-tests.ts

No need to generate any newer typings.
? What chain do you want to run tests on? mainnet
? Which file's tests do you want to run? all
No need to generate any newer typings.

FlashLoan
Single token

1. "before each" hook for "Should be able to take flashLoan of a single token from AAVE"

Resolver
1,2,3,4,5,6,7,9,5,5,5,5,5,5
✓ Should be able to return routes info (15391ms)
3,4,5,6,7,5
2,3,4,5,6,7,5
✓ Should be able to return the best route for flashloan (31816ms)
1,2,3,4,5,6,7,9,5,5,5,5,5,5,3,4,5,6,7,5
✓ Should be able to return all the data for flashloan (800ms)

3 passing (56s)
1 failing

FlashLoan
"before each" hook for "Should be able to take flashLoan of a single token from AAVE":
Error: VM Exception while processing transaction: reverted with reason string 'Address: low-level delegate call failed'

Thanks for any help:

Add a route in FLA which will give flashloan from the funds stored in itself. This route will offer the lowest gas fee.

We need to update the flashloan aggregator from scratch. Current code has a lot of redundant code that has caused the contract size to increase a lot and it's hard to add new routes to it.

We need to merge all the common code together and try to make logics as modular and reusable as possible. All the core logics and storage variable updates should remain on the core contract. Rest everything can be moved to helpers or separate implementation.

• Set up a new proxy
• The main flashloan aggregator will have 11 routes.
• Currently we have 8 and we need to add 2 new routes:
  • Route 8 for Uniswap V3. We have this route on other chains, just need to add on mainnet. Eg for polygon.
  • Route 11 for Maker PSM. Maker PSM allows DAI to USDC swaps at 1:1 ratio. The flow for this will be, if the flashloan token is USDC, take flashloan of DAI from Maker. Swap this DAI from Maker PSM for 1:1 USDC. The user will payback USDC + flashloan fee. Swap this amount from PSM and payback on Maker.

Add FLA support on Fantom with the following routes -

1. Aave V3
2. Self Route

Add the addNewRoute and fallback functions so that we can add a new route directly via calling addNewRoute on the main contract instead of re-deploying the main contract.

Additional function to add -
addNewRoutesAndEnable , updateRouteImplementations, changeRouteStatus, getEnabledRoutes

Chains-

• Arbitrum
• Avalanche
• Fantom
• Mainnet
• Optimism

Lenders will lend there tokens (USDC for now) to our contract, which we will supply to aave.
We will use the collateral to borrow, give flashloan and payback (aave flashloan at 0% fee).
Lenders will get the aave's apy, along with some cut in the fee whenever this route is used.

On mainnet:-

• Flashborrow ETH from Balancer.
• Deposit in Aave/Compound.
• ... existing MakerDAO thing we are doing.

On Polygon:-

• Replicate the same thing.

Add a special function cast(). If the caller address is a DSA account then call the cast function rather than executeOperation.

#27 (comment)

Currently we get the funds first in the FLA, then transfer them to the user. If we add the receiverAddress as the caller, then the funds will directly go to the caller. This will save some gas.