flash-loan-usage

# Flash Loan Patterns ## Flash Loan Providers | Provider | Fee | Multi-Asset | Notes | |----------|-----|-------------|-------| | Aave V3 | 0.05% | Yes (`flashLoan`) | Most popular, widest asset support | | Uniswap V2/V3 | 0.3% / pool fee | Yes (flash swap) | Built into swap, repay with other token | | Uniswap V4 | 0% | Yes (flash accounting) | Enabled by PoolManager's delta-tracking which will always settle cleanly as long as the full delta is repaid within the unlock context. | | Balancer V2 | 0% | Yes | Free, limited to Balancer vault assets | | dYdX | 0% | Limited | Solo margin flash loans | ## Aave V3 Flash Loan Receiver ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {FlashLoanSimpleReceiverBase} from "@aave/v3-core/contracts/flashloan/base/FlashLoanSimpleReceiverBase.sol"; import {IPoolAddressesProvider} from "@aave/v3-core/contracts/interfaces/IPoolAddressesProvider.sol"; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; contract AaveFlashLoan is FlashLoanSimpleReceiverBase { address public immutable owner; constructor(IPoolAddressesProvider provider) FlashLoanSimpleReceiverBase(provider) { owner = msg.sender; } function executeOperation( address asset, uint256 amount, uint256 premium, address initiator, bytes calldata params ) external override returns (bool) { require(msg.sender == address(POOL), "caller must be pool"); require(initiator == address(this), "untrusted initiator"); (uint8 action) = abi.decode(params, (uint8)); if (action == 1) _arbitrage(asset, amount); else if (action == 2) _liquidate(asset, amount, params); else if (action == 3) _collateralSwap(asset, amount, params); uint256 repayment = amount + premium; IERC20(asset).approve(address(POOL), repayment); return true; } function execute(address asset, uint256 amount, bytes calldata params) external { require(msg.sender == owner, "only owner"); POOL.flashLoanSimple(address(this), asset, amount, params, 0); } function _arbitrage(address asset, uint256 amount) internal { // Buy low on DEX A, sell high on DEX B // Profit must exceed the 0.05% premium } function _liquidate(address asset, uint256 amount, bytes calldata params) internal { // Use borrowed funds to liquidate an underwater position // Receive collateral at a discount, swap back to repay } function _collateralSwap(address asset, uint256 amount, bytes calldata params) internal { // Repay existing debt, withdraw old collateral // Swap to new collateral, deposit, re-borrow } } ``` ## Aave V3 Multi-Asset Flash Loan ```solidity function executeMultiFlash( address[] calldata assets, uint256[] calldata amounts ) external { uint256[] memory modes = new uint256[](assets.length); // mode 0 = full repay, 1 = stable debt, 2 = variable debt POOL.flashLoan( address(this), assets, amounts, modes, address(this), // onBehalfOf "", // params 0 // referralCode ); } ``` ## Uniswap V3 Flash Swap ```solidity import {IUniswapV3FlashCallback} from "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol"; contract UniV3Flash is IUniswapV3FlashCallback { IUniswapV3Pool public immutable pool; function initFlash(uint256 amount0, uint256 amount1) external { pool.flash(address(this), amount0, amount1, abi.encode(msg.sender)); } function uniswapV3FlashCallback( uint256 fee0, uint256 fee1, bytes calldata data ) external override { require(msg.sender == address(pool), "unauthorized"); address caller = abi.decode(data, (address)); // Use amount0 + amount1 here // Repay: principal + fee if (fee0 > 0) IERC20(pool.token0()).transfer(address(pool), amount0 + fee0); if (fee1 > 0) IERC20(pool.token1()).transfer(address(pool), amount1 + fee1); } } ``` ## Balancer V2 Flash Loan (Zero Fee) ```solidity import {IFlashLoanRecipient} from "@balancer-labs/v2-interfaces/contracts/vault/IFlashLoanRecipient.sol"; import {IVault} from "@balancer-labs/v2-interfaces/contracts/vault/IVault.sol"; contract BalancerFlash is IFlashLoanRecipient { IVault public constant VAULT = IVault(0xBA12222222228d8Ba445958a75a0704d566BF2C8); function receiveFlashLoan( IERC20[] memory tokens, uint256[] memory amounts, uint256[] memory feeAmounts, bytes memory userData ) external override { require(msg.sender == address(VAULT), "unauthorized"); // feeAmounts are 0 for Balancer // Your logic here for (uint256 i = 0; i < tokens.length; i++) { tokens[i].transfer(address(VAULT), amounts[i] + feeAmounts[i]); } } function execute(IERC20[] calldata tokens, uint256[] calldata amounts) external { VAULT.flashLoan(this, tokens, amounts, ""); } } ``` ## Arbitrage Pattern ``` 1. Flash borrow X tokens of asset A from Aave 2. Swap A -> B on DEX₁ (where A is cheap) 3. Swap B -> A on DEX₂ (where A is expensive) 4. Repay X + premium to Aave 5. Keep profit (A_out - X - premium) ``` Profit condition: `output - input - premium - gas > 0` ## Liquidation Bot Pattern ``` 1. Monitor health factors via events or polling 2. Flash borrow the debt asset 3. Call liquidationCall() on Aave / absorb() on Compound 4. Receive discounted collateral 5. Swap collateral back to debt asset 6. Repay flash loan + premium 7. Keep liquidation bonus minus fees ``` ## Checklist - [ ] Always validate `msg.sender` is the lending pool in callbacks - [ ] Validate `initiator` is your own contract (prevents griefing) - [ ] Calculate profit after all fees (flash loan premium + swap fees + gas) - [ ] Use Balancer for zero-fee flash loans when assets are available - [ ] Approve exact repayment amount (principal + premium) before return - [ ] Test with forked mainnet to verify real liquidity and pricing - [ ] Add access control — only owner/keeper can trigger flash loans - [ ] Handle the case where arbitrage is unprofitable (revert early)