What is a Flash Loan?

Detailed Instructions

Before initiating the flash loan, the borrower must identify a clear profit opportunity that exceeds the cost of the loan fee. This is typically a price discrepancy, or arbitrage, between different decentralized exchanges (DEXs) like Uniswap and SushiSwap. The borrower writes a smart contract that will execute the entire sequence. The contract logic must calculate the expected profit by factoring in all gas fees, protocol fees (e.g., Aave's 0.09% fee), and slippage. The opportunity must be validated off-chain first to ensure it's viable.

• Sub-step 1: Market Analysis: Use price oracles and on-chain data to find an asset (e.g., DAI) trading at $0.99 on Uniswap V3 and $1.01 on Curve.
• Sub-step 2: Profit Calculation: Determine the loan size needed. For a $1M loan, a 0.1% profit is $1,000. Subtract the $900 Aave fee and estimated $150 gas cost.
• Sub-step 3: Contract Drafting: Begin writing the smart contract that will request the loan from a provider like the Aave V3 Pool at address 0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2.

Detailed Instructions

The borrower's smart contract initiates the transaction by calling the flashLoan function on the lending protocol's pool contract. This is the core uncollateralized borrowing mechanism. The function call specifies the loan parameters, including the asset addresses, amounts, and the address of the borrower's contract that will receive the funds and execute the logic. Crucially, the contract must also implement a specific callback function, often named executeOperation, which the lending pool will call after sending the assets. This callback is where the profitable trade must occur.

• Sub-step 1: Function Call: The contract calls pool.flashLoan(recipient, assets, amounts, modes, onBehalfOf, params, referralCode).
• Sub-step 2: Specify Assets: For example, request 1,000,000 DAI (address: 0x6B175474E89094C44Da98b954EedeAC495271d0F).
• Sub-step 3: Set Mode: Set the debt mode to 0 for a simple flash loan (no debt to open). The recipient and onBehalfOf are set to the contract's own address.

Detailed Instructions

Upon receiving the funds, the lending pool immediately calls the executeOperation function in the borrower's contract. This function contains the entire business logic for the trade. The contract must swap the borrowed assets on one DEX to buy the undervalued asset, then sell it on another DEX for a profit, all within this single function execution. It uses decentralized exchange routers to perform the swaps. The contract must hold the profit in a form that allows it to repay the original loan amount plus fees.

• Sub-step 1: Swap on DEX A: Call uniswapRouter.swapExactTokensForTokens(amountIn, amountOutMin, path, address(this), deadline) to trade 1M DAI for WETH.
• Sub-step 2: Swap on DEX B: Call sushiswapRouter.swapExactTokensForTokens(wethAmount, minDAIOut, reversePath, address(this), deadline) to trade the WETH back for more DAI.
• Sub-step 3: Balance Check: Verify the contract now holds more than the original 1,000,000 DAI plus the 900 DAI (0.09%) fee. For example, a final balance of 1,001,500 DAI confirms a 600 DAI net profit.

Detailed Instructions

This is the critical repayment phase. Before the executeOperation function finishes, the contract must transfer the full borrowed amount plus the protocol fee back to the lending pool. This is done by approving the pool to pull the funds or by transferring them directly. If the repayment is successful, the entire transaction is committed to the blockchain. If the contract fails to repay (e.g., due to insufficient funds from a failed trade), the entire transaction is reverted as if it never happened, protecting the lender from loss. Any surplus profit is then transferred to the borrower's designated wallet address.

• Sub-step 1: Approve Repayment: Call dai.approve(poolAddress, repaymentAmount) to allow the pool to withdraw 1,000,900 DAI.
• Sub-step 2: Finalize Transaction: The executeOperation function returns true. The lending pool completes the transfer, settling the debt.
• Sub-step 3: Withdraw Profit: Transfer the remaining 600 DAI profit to the borrower's EOA (Externally Owned Account) using dai.transfer(msg.sender, profitAmount).

Tip: Always include a slippage tolerance (e.g., amountOutMin) in your swap functions to protect against price movements during the transaction, which could cause a repayment failure.

Detailed Instructions

A flash loan is a DeFi primitive that allows users to borrow assets without upfront collateral, provided the borrowed amount plus a fee is repaid within the same blockchain transaction. The entire loan lifecycle—borrow, execute logic, repay—is atomic, meaning it either completes fully or reverts entirely, leaving no debt. The primary technical risk resides in the borrower's custom logic executed between the borrow and repay calls. This logic is implemented in a smart contract, which must be meticulously audited. Common vulnerabilities include:

• Reentrancy Attacks: Ensure all state changes (e.g., updating internal balances) occur before making external calls to untrusted contracts. Use the Checks-Effects-Interactions pattern.
• Price Oracle Manipulation: Your strategy should not rely on a single, easily manipulated DEX price feed during the loan's execution.
• Gas Limit and Block Congestion: Complex operations may exceed the block gas limit, causing the entire transaction to fail and incurring costs.

Tip: Always test your flash loan contract extensively on a testnet (e.g., Sepolia, Goerli) using forked mainnet state to simulate real conditions.

Detailed Instructions

Flash loans are infamous for enabling large-scale market manipulation because they provide attackers with immense, temporary capital. The key risk is that they can be used to distort protocol pricing mechanisms or governance votes. You must analyze your protocol's exposure to these economic attacks. A primary vector is oracle price manipulation, where an attacker uses a flash loan to create massive, imbalanced swaps on a decentralized exchange (DEX) like Uniswap V3, artificially inflating or deflating an asset's price that other protocols use for valuations.

• Liquidation Attacks: An attacker could manipulate the price of a collateral asset downward to trigger unfair liquidations of positions on lending platforms like Aave.
• Governance Attacks: Borrowed tokens might be used to temporarily gain voting power to pass malicious proposals in DAOs.
• Arbitrage Slippage: Your own arbitrage strategy must account for the price impact of your large trade; calculate expected profit after fees and slippage.

Tip: Protocols should implement time-weighted average price (TWAP) oracles from sources like Chainlink, which are resistant to single-block price spikes caused by flash loans.

Detailed Instructions

Implementing security controls is non-negotiable. For borrowers, this means building fail-safes into your smart contract. For protocols that may interact with flash-loaned funds, it means adding defensive checks. A critical control is verifying transaction atomicity and loan repayment. You can implement a health check at the end of your flash loan logic. Furthermore, use access controls like OpenZeppelin's Ownable or AccessControl to restrict sensitive functions.

• Repayment Verification: At the end of your contract's executeOperation function (the standard callback for Aave flash loans), assert that the contract's balance of the borrowed asset is zero or that the protocol's debt has been cleared.
• Rate Limiting: Protocols can implement borrowing limits per block or transaction to cap potential damage, though this may limit functionality.
• Event Monitoring: Emit detailed events for borrowing and repayment to facilitate off-chain monitoring and alerting using tools like Tenderly or OpenZeppelin Defender.

solidityCopy
// Example Health Check in an Aave Flash Loan Receiver
function executeOperation(
    address[] calldata assets,
    uint256[] calldata amounts,
    uint256[] calldata premiums,
    address initiator,
    bytes calldata params
) external override returns (bool) {
    // ... your complex logic ...

    // Health Check: Ensure full repayment + fee
    for (uint i = 0; i < assets.length; i++) {
        uint256 amountOwed = amounts[i] + premiums[i];
        require(IERC20(assets[i]).balanceOf(address(this)) >= amountOwed, "Insufficient funds to repay");
        IERC20(assets[i]).approve(address(POOL), amountOwed);
    }
    return true;
}

Tip: Consider using audited, battle-tested flash loan infrastructure like Aave's IFlashLoanReceiver interface instead of building your own from scratch.

Detailed Instructions

Even with perfect code, external market conditions can cause a flash loan transaction to fail, resulting in lost gas fees. Your risk assessment must include liquidity risk and contingency planning. The borrowed assets must be available in the lending pool (e.g., Aave's pool at 0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4CE on Ethereum Mainnet) at the exact moment of execution. During periods of high volatility or network congestion, liquidity can be drained or gas prices can become prohibitive.

• Slippage Tolerance: Always define a maximum acceptable slippage for any DEX trade within your transaction. For example, on a Uniswap V3 swap, set sqrtPriceLimitX96 to bound the execution price.
• Gas Price Management: Use tools like Flashbots to submit bundles and avoid front-running or failure due to gas auction wars. Estimate gas accurately and set an appropriate maxFeePerGas and maxPriorityFeePerGas.
• Fallback Execution Paths: Design your logic to have alternative, less profitable exit strategies if the primary arbitrage or swap fails, potentially allowing partial repayment from other holdings.
• Protocol Insolvency Risk: Understand that if the flash loan provider itself (e.g., the Aave pool) becomes insolvent due to an exploit, it could affect the atomicity guarantee.

Tip: Simulate your transaction using eth_call RPC methods or Tenderly simulations before broadcasting it with real gas. Monitor pool liquidity via the protocol's public data endpoints or subgraphs.