Flash Loan Code Examples: Solidity

Introduction

Flash loans let you borrow millions in crypto with zero collateral — as long as you repay within the same transaction. If your contract cannot repay, the entire transaction reverts and you only lose the gas already spent — cents to a few dollars at September 2026 base fees (0.154 gwei on 27 September), tens of dollars during congestion.

This guide provides working Solidity code for the three most common flash loan use cases: arbitrage, collateral swaps, and liquidations.

All examples use Aave V3, which charges 0.05% (5 basis points) per flash loan — a governance-set parameter, down from the 0.09% Aave V2 charged. For a $1M USDC flash loan, the fee is $500. Your strategy must generate more than $500 plus gas costs to be profitable.

Aave V3 is deployed on more than twenty networks, including Ethereum, Polygon, Arbitrum, Optimism and Base — any of the L2 deployments will settle a flash loan for a fraction of Ethereum mainnet gas, so check current gas on the chains you are considering rather than assuming one is always cheapest.

Honest assessment of flash loan profitability: simple DEX arbitrage opportunities are almost entirely captured by MEV bots running on Flashbots.

If you are a solo developer without MEV infrastructure, focus on less competitive strategies like collateral swaps, self-liquidation prevention, and position restructuring. These use flash loans for utility rather than profit extraction and face less competition.

Flash loans are unique to DeFi — no equivalent exists in traditional finance. They work because blockchain transactions are atomic: every operation in a transaction either succeeds completely or reverts entirely.

A flash loan provider lends you funds at the start of a transaction and checks repayment at the end.

If you have not repaid the principal plus fee by the final step, the entire transaction (including the original loan) is rolled back as if it never happened.

This atomicity is enforced by the EVM itself, which means the lender faces zero default risk and therefore requires zero collateral.

Understanding this mechanism is essential before writing flash loan contracts.

The code examples in this guide progress from simple to complex. The first contract demonstrates a basic flash loan lifecycle in under 50 lines of Solidity.

From there, each example adds real-world logic: multi-DEX arbitrage routing, collateral swaps across lending protocols, and automated liquidation bots. All contracts include inline comments explaining the key decisions and potential failure modes.

Prerequisites: Solidity ^0.8.10, Hardhat or Foundry, working knowledge of ERC-20 tokens and DEX mechanics. Every contract in this guide is intended as an educational starting point — always run a professional security audit before deploying anything to mainnet with real funds.

Development Setup

Prerequisites

• Node.js 16+ and npm
• Hardhat or Foundry
• Basic Solidity knowledge
• Understanding of how flash loans work

Install Dependencies

npm install --save-dev hardhat @aave/core-v3 @openzeppelin/contracts
npm install --save-dev @uniswap/v2-periphery @uniswap/v3-periphery

Network Configuration

Aave V3 is deployed on multiple networks. Use these addresses:

• Ethereum: 0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e
• Polygon: 0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb
• Arbitrum: 0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb

Simple Flash Loan Contract

This basic contract demonstrates the minimum code needed to take out a flash loan and repay it:

pragma solidity ^0.8.10;

import "@aave/core-v3/contracts/flashloan/base/FlashLoanSimpleReceiverBase.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract SimpleFlashLoan is FlashLoanSimpleReceiverBase {
    address payable owner;

    constructor(address _addressProvider)
        FlashLoanSimpleReceiverBase(IPoolAddressesProvider(_addressProvider))
    {
        owner = payable(msg.sender);
    }

    // This function is called after your contract receives the flash loan
    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        
        // Your custom logic goes here
        // Example: arbitrage, collateral swap, etc.
        
        // Approve the Pool contract to pull the owed amount
        uint256 amountOwed = amount + premium;
        IERC20(asset).approve(address(POOL), amountOwed);
        
        return true;
    }

    function requestFlashLoan(address _token, uint256 _amount) public {
        address receiverAddress = address(this);
        address asset = _token;
        uint256 amount = _amount;
        bytes memory params = "";
        uint16 referralCode = 0;

        POOL.flashLoanSimple(
            receiverAddress,
            asset,
            amount,
            params,
            referralCode
        );
    }

    receive() external payable {}
}

How It Works

• Constructor: Initialises with Aave Pool address provider
• requestFlashLoan: Starts the flash loan by calling the Aave Pool
• executeOperation: Called by Aave with borrowed funds
• Approval: Must approve Aave to pull back loan + fee

Usage Example

// Deploy contract
const flashLoan = await SimpleFlashLoan.deploy(POOL_ADDRESS_PROVIDER);

// Request 1000 USDC flash loan
const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
await flashLoan.requestFlashLoan(USDC, ethers.utils.parseUnits("1000", 6));

Arbitrage Contract

This contract executes arbitrage between Uniswap and Sushiswap:

pragma solidity ^0.8.10;

import "@aave/core-v3/contracts/flashloan/base/FlashLoanSimpleReceiverBase.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";

contract FlashLoanArbitrage is FlashLoanSimpleReceiverBase {
    IUniswapV2Router02 public immutable uniswapRouter;
    IUniswapV2Router02 public immutable sushiswapRouter;
    
    constructor(
        address _addressProvider,
        address _uniswapRouter,
        address _sushiswapRouter
    ) FlashLoanSimpleReceiverBase(IPoolAddressesProvider(_addressProvider)) {
        uniswapRouter = IUniswapV2Router02(_uniswapRouter);
        sushiswapRouter = IUniswapV2Router02(_sushiswapRouter);
    }

    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        // Decode parameters
        (address tokenOut, uint256 minProfit) = abi.decode(params, (address, uint256));
        
        // Step 1: Sell on Uniswap
        address[] memory path = new address[](2);
        path[0] = asset;
        path[1] = tokenOut;
        
        IERC20(asset).approve(address(uniswapRouter), amount);
        uint256[] memory amountsOut = uniswapRouter.swapExactTokensForTokens(
            amount,
            0,
            path,
            address(this),
            block.timestamp
        );
        
        // Step 2: Buy back on Sushiswap
        path[0] = tokenOut;
        path[1] = asset;
        
        IERC20(tokenOut).approve(address(sushiswapRouter), amountsOut[1]);
        uint256[] memory amountsBack = sushiswapRouter.swapExactTokensForTokens(
            amountsOut[1],
            amount + premium + minProfit,
            path,
            address(this),
            block.timestamp
        );
        
        // Verify profit
        require(amountsBack[1] >= amount + premium + minProfit, "Insufficient profit");
        
        // Approve repayment
        IERC20(asset).approve(address(POOL), amount + premium);
        
        return true;
    }

    function executeArbitrage(
        address _asset,
        uint256 _amount,
        address _tokenOut,
        uint256 _minProfit
    ) external {
        bytes memory params = abi.encode(_tokenOut, _minProfit);
        POOL.flashLoanSimple(address(this), _asset, _amount, params, 0);
    }
}

Key Features

• Swaps on two DEXes in one transaction
• Profit verification before completion
• Reverts if arbitrage unprofitable
• Configurable minimum profit threshold

Collateral Swap Contract

Swap collateral on Aave without closing your position:

pragma solidity ^0.8.10;

import "@aave/core-v3/contracts/flashloan/base/FlashLoanSimpleReceiverBase.sol";
import "@aave/core-v3/contracts/interfaces/IPool.sol";

contract CollateralSwap is FlashLoanSimpleReceiverBase {
    IUniswapV2Router02 public immutable swapRouter;
    
    constructor(address _addressProvider, address _swapRouter)
        FlashLoanSimpleReceiverBase(IPoolAddressesProvider(_addressProvider))
    {
        swapRouter = IUniswapV2Router02(_swapRouter);
    }

    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        (address oldCollateral, address newCollateral, uint256 debtAmount) = 
            abi.decode(params, (address, address, uint256));
        
        // Step 1: Repay debt with flash loan
        IERC20(asset).approve(address(POOL), debtAmount);
        POOL.repay(asset, debtAmount, 2, initiator);
        
        // Step 2: Withdraw old collateral
        POOL.withdraw(oldCollateral, type(uint256).max, address(this));
        
        // Step 3: Swap old collateral to new collateral
        uint256 oldCollateralBalance = IERC20(oldCollateral).balanceOf(address(this));
        IERC20(oldCollateral).approve(address(swapRouter), oldCollateralBalance);
        
        address[] memory path = new address[](2);
        path[0] = oldCollateral;
        path[1] = newCollateral;
        
        swapRouter.swapExactTokensForTokens(
            oldCollateralBalance,
            0,
            path,
            address(this),
            block.timestamp
        );
        
        // Step 4: Supply new collateral
        uint256 newCollateralBalance = IERC20(newCollateral).balanceOf(address(this));
        IERC20(newCollateral).approve(address(POOL), newCollateralBalance);
        POOL.supply(newCollateral, newCollateralBalance, initiator, 0);
        
        // Step 5: Borrow to repay flash loan
        POOL.borrow(asset, amount + premium, 2, 0, initiator);
        
        // Approve repayment
        IERC20(asset).approve(address(POOL), amount + premium);
        
        return true;
    }
}

Use Case

Switch from ETH collateral to WBTC without closing your loan position. All happens in one transaction.

Liquidation Bot Contract

Simplified liquidation contract (production version needs more checks):

pragma solidity ^0.8.10;

contract FlashLoanLiquidator is FlashLoanSimpleReceiverBase {
    function executeOperation(
        address asset,
        uint256 amount,
        uint256 premium,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        (address user, address collateralAsset) = abi.decode(params, (address, address));
        
        // Liquidate user position
        IERC20(asset).approve(address(POOL), amount);
        POOL.liquidationCall(collateralAsset, asset, user, amount, false);
        
        // Sell received collateral
        uint256 collateralReceived = IERC20(collateralAsset).balanceOf(address(this));
        // ... swap collateral to debt asset ...
        
        // Repay flash loan
        IERC20(asset).approve(address(POOL), amount + premium);
        return true;
    }
}

Important Notes

• Monitor health factors off-chain
• Calculate profitability before execution
• Account for gas costs and slippage
• Competition is fierce - use MEV protection

Testing & Deployment

Hardhat Test Example

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("FlashLoan", function () {
  it("Should execute flash loan successfully", async function () {
    const FlashLoan = await ethers.getContractFactory("SimpleFlashLoan");
    const flashLoan = await FlashLoan.deploy(POOL_ADDRESS_PROVIDER);
    
    const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
    const amount = ethers.utils.parseUnits("1000", 6);
    
    await expect(flashLoan.requestFlashLoan(USDC, amount))
      .to.emit(flashLoan, "FlashLoanExecuted");
  });
});

Mainnet Forking

// hardhat.config.js
module.exports = {
  networks: {
    hardhat: {
      forking: {
        url: `https://eth-mainnet.alchemyapi.io/v2/${ALCHEMY_KEY}`,
        blockNumber: 18000000
      }
    }
  }
};

Deployment Checklist

• Test on mainnet fork first
• Deploy to testnet (Sepolia/Hoodi)
• Verify contracts on Etherscan
• Start with small amounts on mainnet
• Monitor gas prices and MEV

Security Considerations

Critical Security Checks

• Access Control: Only authorised addresses should be able to trigger a flash loan from your contract
• Reentrancy: Use OpenZeppelin's ReentrancyGuard
• Price Manipulation: Use TWAP oracles, not spot prices
• Slippage Protection: Set minimum output amounts
• Gas Limits: Ensure sufficient gas for complex operations

Common Vulnerabilities

• Not checking msg.sender in executeOperation
• Insufficient approval amounts
• Missing profit verification
• Hardcoded addresses (use constructor params)
• No emergency withdrawal function

Best Practices

• Get professional security audit before mainnet
• Use established libraries (OpenZeppelin, Aave)
• Implement circuit breakers for large losses
• Monitor transactions and set alerts
• Keep private keys in hardware wallets

Advanced Flash Loan Patterns

Multi-Protocol Arbitrage

Advanced arbitrage strategies involve multiple DeFi protocols to maximise profit opportunities. This pattern takes one flash loan and routes the borrowed funds through several DEXes, yield farming protocols, and lending platforms to capture complex arbitrage opportunities.

These sophisticated strategies go beyond simple two-pool arbitrage and can achieve higher returns by leveraging protocol-specific inefficiencies and cross-platform opportunities.

// Multi-protocol arbitrage example
contract MultiProtocolArbitrage is FlashLoanReceiverBase {
    using SafeERC20 for IERC20;
    
    struct ArbitrageParams {
        address[] dexes;
        address[] tokens;
        uint256[] amounts;
        bytes[] swapData;
    }
    
    function executeMultiArbitrage(
        address asset,
        uint256 amount,
        ArbitrageParams memory params
    ) external onlyOwner {
        bytes memory data = abi.encode(params);
        
        IPoolAddressesProvider provider = IPoolAddressesProvider(
            0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e
        );
        IPool pool = IPool(provider.getPool());
        
        address[] memory assets = new address[](1);
        assets[0] = asset;
        uint256[] memory amounts = new uint256[](1);
        amounts[0] = amount;
        uint256[] memory modes = new uint256[](1);
        modes[0] = 0;
        
        pool.flashLoan(address(this), assets, amounts, modes, address(this), data, 0);
    }
    
    function executeOperation(
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata premiums,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        ArbitrageParams memory arbParams = abi.decode(params, (ArbitrageParams));
        
        // Execute complex multi-step arbitrage
        uint256 profit = _executeMultiStepArbitrage(
            assets[0],
            amounts[0],
            arbParams
        );
        
        // Ensure profitability
        uint256 totalDebt = amounts[0] + premiums[0];
        require(profit > totalDebt, "Arbitrage not profitable");
        
        // Approve repayment
        IERC20(assets[0]).safeApprove(address(POOL), totalDebt);
        
        return true;
    }
    
    function _executeMultiStepArbitrage(
        address asset,
        uint256 amount,
        ArbitrageParams memory params
    ) internal returns (uint256) {
        uint256 currentAmount = amount;
        
        // Step 1: Swap on DEX 1
        currentAmount = _swapOnDEX(
            params.dexes[0],
            params.tokens[0],
            params.tokens[1],
            currentAmount,
            params.swapData[0]
        );
        
        // Step 2: Provide liquidity and harvest rewards
        currentAmount = _provideLiquidityAndHarvest(
            params.tokens[1],
            currentAmount
        );
        
        // Step 3: Swap back on DEX 2
        currentAmount = _swapOnDEX(
            params.dexes[1],
            params.tokens[1],
            params.tokens[0],
            currentAmount,
            params.swapData[1]
        );
        
        return currentAmount;
    }
}

Flash Loan Aggregation

Flash loan aggregation lets a contract source liquidity from several providers (Aave, dYdX, Balancer), so it can get the best rate and the maximum available liquidity.

This pattern is essential for large arbitrage operations that exceed single protocol limits and need to optimise for both cost and liquidity availability.

contract FlashLoanAggregator {
    enum Provider { AAVE, BALANCER, DYDX }
    
    struct LoanRequest {
        address asset;
        uint256 amount;
        Provider preferredProvider;
        bytes data;
    }
    
    function getBestProvider(
        address asset,
        uint256 amount
    ) public view returns (Provider, uint256) {
        uint256 aaveFee = _getAaveFee(asset, amount);
        uint256 balancerFee = _getBalancerFee(asset, amount);
        uint256 dydxFee = _getDydxFee(asset, amount);
        
        if (aaveFee <= balancerFee && aaveFee <= dydxFee) {
            return (Provider.AAVE, aaveFee);
        } else if (balancerFee <= dydxFee) {
            return (Provider.BALANCER, balancerFee);
        } else {
            return (Provider.DYDX, dydxFee);
        }
    }
    
    function executeOptimalFlashLoan(LoanRequest memory request) external {
        (Provider bestProvider, uint256 fee) = getBestProvider(
            request.asset,
            request.amount
        );
        
        if (bestProvider == Provider.AAVE) {
            _executeAaveFlashLoan(request);
        } else if (bestProvider == Provider.BALANCER) {
            _executeBalancerFlashLoan(request);
        } else {
            _executeDydxFlashLoan(request);
        }
    }
}

Recursive Flash Loans

A recursive flash loan opens a second flash loan from inside the first one's executeOperation, before the first has been repaid.

This advanced pattern enables complex strategies like leveraged yield farming, where you borrow assets, use them as collateral to borrow more, and repeat the process to amplify returns.

contract RecursiveFlashLoan is FlashLoanReceiverBase {
    uint256 public constant MAX_RECURSION = 5;
    uint256 private recursionCount;
    
    struct RecursiveParams {
        uint256 targetLeverage;
        address collateralAsset;
        address borrowAsset;
        uint256 currentLevel;
    }
    
    function executeLeveragedPosition(
        address asset,
        uint256 initialAmount,
        uint256 targetLeverage
    ) external onlyOwner {
        recursionCount = 0;
        
        RecursiveParams memory params = RecursiveParams({
            targetLeverage: targetLeverage,
            collateralAsset: asset,
            borrowAsset: asset,
            currentLevel: 1
        });
        
        bytes memory data = abi.encode(params);
        _initiateFlashLoan(asset, initialAmount, data);
    }
    
    function executeOperation(
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata premiums,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        RecursiveParams memory recParams = abi.decode(params, (RecursiveParams));
        
        // Deposit as collateral
        _depositCollateral(assets[0], amounts[0]);
        
        // Check if we need more leverage
        if (recParams.currentLevel < recParams.targetLeverage && 
            recursionCount < MAX_RECURSION) {
            
            // Calculate next borrow amount (70% of deposited for safety)
            uint256 nextBorrowAmount = (amounts[0] * 70) / 100;
            
            // Prepare for recursive call
            recParams.currentLevel++;
            recursionCount++;
            
            bytes memory nextData = abi.encode(recParams);
            _initiateFlashLoan(assets[0], nextBorrowAmount, nextData);
        }
        
        // Repay current flash loan
        uint256 totalDebt = amounts[0] + premiums[0];
        IERC20(assets[0]).safeApprove(address(POOL), totalDebt);
        
        return true;
    }
}

Production Deployment Guide

Pre-Deployment Checklist

Before deploying flash loan contracts to mainnet, complete this comprehensive checklist to ensure security, efficiency, and regulatory compliance.

Each item addresses critical aspects that could result in significant financial losses if overlooked during the deployment process.

• Security Audit: Engage professional auditors (ConsenSys Diligence, Trail of Bits, OpenZeppelin) for comprehensive smart contract review
• Gas optimisation: optimise contract bytecode size and execution gas costs through compiler optimisation and code refactoring
• Slippage Protection: Implement dynamic slippage calculations based on market volatility and liquidity depth
• Circuit Breakers: Add emergency pause functionality and maximum loss limits per transaction
• Access Controls: Implement role-based access control with multi-signature wallet requirements for critical functions
• Monitoring Integration: Set up real-time monitoring for contract interactions, profit/loss tracking, and anomaly detection
• Legal Compliance: Ensure compliance with local regulations regarding automated trading and DeFi activities

Deployment Strategy

A phased deployment approach minimises risks and allows for iterative improvements based on real-world performance data.

Start with limited functionality and gradually expand capabilities as confidence grows through systematic testing and validation.

Phase 1: Limited Testnet Deployment

// Deployment script for testnet
const { ethers, upgrades } = require("hardhat");

async function deployTestnet() {
    const [deployer] = await ethers.getSigners();
    
    console.log("Deploying with account:", deployer.address);
    console.log("Account balance:", (await deployer.getBalance()).toString());
    
    // Deploy with proxy for upgradeability
    const FlashLoanArbitrage = await ethers.getContractFactory("FlashLoanArbitrage");
    const flashLoanArbitrage = await upgrades.deployProxy(
        FlashLoanArbitrage,
        [
            "0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e", // Aave Pool Provider
            deployer.address, // Owner
            ethers.utils.parseEther("0.1") // Max loss per transaction
        ],
        { initializer: 'initialize' }
    );
    
    await flashLoanArbitrage.deployed();
    console.log("FlashLoanArbitrage deployed to:", flashLoanArbitrage.address);
    
    // Verify contract
    await hre.run("verify:verify", {
        address: flashLoanArbitrage.address,
        constructorArguments: []
    });
}

deployTestnet()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error(error);
        process.exit(1);
    });

Phase 2: Mainnet Soft Launch

Deploy to mainnet with conservative parameters: low maximum transaction amounts, limited to well-established token pairs, and manual approval required for each arbitrage opportunity.

This phase focuses on validating real-world performance without significant capital risk through careful monitoring and gradual scaling.

Phase 3: Automated Operations

After successful soft launch validation, gradually increase automation levels and transaction limits.

Implement sophisticated monitoring and alerting systems to detect and respond to market anomalies or technical issues quickly.

Infrastructure Requirements

Running flash loan strategies in production requires robust infrastructure to handle high-frequency transactions, real-time market data processing, and rapid response to arbitrage opportunities.

Consider these infrastructure components essential for professional-grade flash loan operations and competitive market participation.

• RPC Providers: Multiple redundant RPC endpoints (Alchemy, Infura, QuickNode) with automatic failover
• Mempool Monitoring: Real-time mempool analysis to detect competing transactions and adjust gas prices dynamically
• Private Transaction Pools: Integration with Flashbots or similar services to avoid MEV competition
• Database Systems: High-performance databases for storing transaction history, profit/loss data, and market analytics
• Monitoring Stack: Comprehensive monitoring using tools like Grafana, Prometheus, and custom alerting systems
• Backup Systems: Automated backup and disaster recovery procedures for critical data and private keys

Risk Management Framework

Implement a comprehensive risk management framework that addresses technical, market, and operational risks.

This framework should include position sizing rules, maximum drawdown limits, and automated circuit breakers that halt operations during extreme market conditions.

contract RiskManager {
    struct RiskParameters {
        uint256 maxPositionSize;
        uint256 maxDailyLoss;
        uint256 maxSlippage;
        uint256 minProfitThreshold;
        bool emergencyPause;
    }
    
    RiskParameters public riskParams;
    uint256 public dailyLoss;
    uint256 public lastResetTimestamp;
    
    modifier riskCheck(uint256 amount, uint256 expectedProfit) {
        require(!riskParams.emergencyPause, "Emergency pause active");
        require(amount <= riskParams.maxPositionSize, "Position too large");
        require(expectedProfit >= riskParams.minProfitThreshold, "Profit too low");
        
        _updateDailyLoss();
        require(dailyLoss <= riskParams.maxDailyLoss, "Daily loss limit exceeded");
        _;
    }
    
    function _updateDailyLoss() internal {
        if (block.timestamp >= lastResetTimestamp + 1 days) {
            dailyLoss = 0;
            lastResetTimestamp = block.timestamp;
        }
    }
}

Monitoring and Analytics

Real-Time Performance Tracking

Effective monitoring is crucial to the success of flash loan operations.

Implement comprehensive tracking systems that monitor contract performance, market conditions, and profitability metrics in real-time.

This enables quick response to changing market conditions and identification of optimisation opportunities.

Key Performance Indicators (KPIs)

• Success Rate: Percentage of profitable flash loan transactions over a given period
• Average Profit per Transaction: Mean profit excluding gas costs and fees
• Gas Efficiency: Gas used per dollar of profit generated
• Market Impact: Price impact of arbitrage transactions on target markets
• Execution Speed: Time from opportunity detection to transaction confirmation
• Slippage Analysis: Actual vs. expected slippage across different market conditions

Event Logging and Analytics

Implement comprehensive event logging in your smart contracts to enable detailed post-transaction analysis and performance optimisation.

Proper logging helps identify patterns, optimise strategies, and debug issues quickly in production environments.

contract FlashLoanAnalytics {
    event FlashLoanExecuted(
        address asset,
        uint256 amount,
        uint256 premium,
        uint256 profit,
        uint256 gasUsed,
        address initiator,
        uint256 timestamp
    );
    
    event ArbitrageOpportunity(
        address tokenA,
        address indexed tokenB,
        address indexed dexA,
        address dexB,
        uint256 priceA,
        uint256 priceB,
        uint256 expectedProfit,
        uint256 timestamp
    );
    
    event RiskEvent(
        string eventType,
        uint256 amount,
        uint256 threshold,
        address indexed contract,
        uint256 timestamp
    );
    
    struct TransactionMetrics {
        uint256 totalTransactions;
        uint256 successfulTransactions;
        uint256 totalProfit;
        uint256 totalGasUsed;
        uint256 averageProfit;
        uint256 successRate;
    }
    
    mapping(address => TransactionMetrics) public userMetrics;
    
    function updateMetrics(
        address user,
        bool success,
        uint256 profit,
        uint256 gasUsed
    ) internal {
        TransactionMetrics storage metrics = userMetrics[user];
        
        metrics.totalTransactions++;
        metrics.totalGasUsed += gasUsed;
        
        if (success) {
            metrics.successfulTransactions++;
            metrics.totalProfit += profit;
        }
        
        metrics.successRate = (metrics.successfulTransactions * 100) / metrics.totalTransactions;
        metrics.averageProfit = metrics.totalProfit / metrics.successfulTransactions;
    }
}

Market Data Integration

Integrate with multiple market data providers to ensure accurate price feeds and opportunity detection.

Reliable market data is essential for identifying profitable arbitrage opportunities and calculating optimal transaction parameters.

Price Feed Aggregation

contract PriceFeedAggregator {
    using AggregatorV3Interface for AggregatorV3Interface;
    
    struct PriceFeed {
        AggregatorV3Interface feed;
        uint256 heartbeat;
        uint256 deviation;
        bool isActive;
    }
    
    mapping(address => PriceFeed[]) public priceFeeds;
    
    function getAggregatedPrice(address token) external view returns (uint256, uint256) {
        PriceFeed[] memory feeds = priceFeeds[token];
        require(feeds.length > 0, "No price feeds available");
        
        uint256[] memory prices = new uint256[](feeds.length);
        uint256 validPrices = 0;
        
        for (uint256 i = 0; i < feeds.length; i++) {
            if (feeds[i].isActive) {
                (, int256 price, , uint256 updatedAt, ) = feeds[i].feed.latestRoundData();
                
                // Check if price is fresh
                if (block.timestamp - updatedAt <= feeds[i].heartbeat && price > 0) {
                    prices[validPrices] = uint256(price);
                    validPrices++;
                }
            }
        }
        
        require(validPrices > 0, "No valid prices available");
        
        // Calculate median price for robustness
        uint256 medianPrice = _calculateMedian(prices, validPrices);
        uint256 confidence = _calculateConfidence(prices, validPrices, medianPrice);
        
        return (medianPrice, confidence);
    }
    
    function _calculateMedian(uint256[] memory prices, uint256 length) 
        internal pure returns (uint256) {
        // Sort prices array
        for (uint256 i = 0; i < length - 1; i++) {
            for (uint256 j = 0; j < length - i - 1; j++) {
                if (prices[j] > prices[j + 1]) {
                    uint256 temp = prices[j];
                    prices[j] = prices[j + 1];
                    prices[j + 1] = temp;
                }
            }
        }
        
        if (length % 2 == 0) {
            return (prices[length / 2 - 1] + prices[length / 2]) / 2;
        } else {
            return prices[length / 2];
        }
    }
}

Alerting and Notification Systems

Implement comprehensive alerting systems that notify operators of critical events, performance anomalies, and market opportunities.

Effective alerting enables rapid response to both problems and opportunities in the fast-moving DeFi environment.

Alert Categories

• Critical Alerts: Contract failures, security breaches, or significant losses requiring immediate attention
• Performance Alerts: Declining success rates, increased gas costs, or reduced profitability trends
• Opportunity Alerts: Large arbitrage opportunities or favourable market conditions
• Maintenance Alerts: Routine maintenance needs, contract upgrades, or configuration changes

Profitability Analysis

Regular profitability analysis helps optimise strategies and identify the most effective approaches.

Track profitability across different market conditions, token pairs, and time periods so that you can keep refining your flash loan strategies.

contract ProfitabilityTracker {
    struct ProfitMetrics {
        uint256 totalRevenue;
        uint256 totalCosts;
        uint256 netProfit;
        uint256 transactionCount;
        uint256 averageProfit;
        uint256 profitMargin;
    }
    
    mapping(bytes32 => ProfitMetrics) public strategyMetrics;
    
    function updateProfitMetrics(
        string memory strategy,
        uint256 revenue,
        uint256 costs
    ) external {
        bytes32 strategyHash = keccak256(abi.encodePacked(strategy));
        ProfitMetrics storage metrics = strategyMetrics[strategyHash];
        
        metrics.totalRevenue += revenue;
        metrics.totalCosts += costs;
        metrics.netProfit = metrics.totalRevenue - metrics.totalCosts;
        metrics.transactionCount++;
        
        if (metrics.transactionCount > 0) {
            metrics.averageProfit = metrics.netProfit / metrics.transactionCount;
            metrics.profitMargin = (metrics.netProfit * 100) / metrics.totalRevenue;
        }
    }
    
    function getROI(string memory strategy, uint256 timeframe) 
        external view returns (uint256) {
        bytes32 strategyHash = keccak256(abi.encodePacked(strategy));
        ProfitMetrics memory metrics = strategyMetrics[strategyHash];
        
        if (metrics.totalCosts == 0) return 0;
        
        return (metrics.netProfit * 100) / metrics.totalCosts;
    }
}

Advanced Flash Loan Implementation Strategies

Gas Optimisation Techniques

Gas optimisation is crucial for flash loan profitability. Here are specific techniques that reduce transaction costs by 20-40%:

// Gas-optimised flash loan contract
contract optimisedFlashLoan is FlashLoanReceiverBase {
    using SafeERC20 for IERC20;
    
    // Pack struct to save storage slots
    struct ArbitrageData {
        address tokenA;      // 20 bytes
        address tokenB;      // 20 bytes
        uint96 minProfit;    // 12 bytes - fits in one slot
        address dexA;        // 20 bytes
        address dexB;        // 20 bytes
        uint96 slippage;     // 12 bytes - fits in one slot
    }
    
    // Use immutable for frequently accessed addresses
    address private immutable WETH;
    address private immutable USDC;
    IUniswapV2Router02 private immutable uniRouter;
    IUniswapV2Router02 private immutable sushiRouter;
    
    constructor(
        address _weth,
        address _usdc,
        address _uniRouter,
        address _sushiRouter
    ) {
        WETH = _weth;
        USDC = _usdc;
        uniRouter = IUniswapV2Router02(_uniRouter);
        sushiRouter = IUniswapV2Router02(_sushiRouter);
    }
    
    // Use assembly for efficient token transfers
    function _safeTransfer(address token, address to, uint256 amount) internal {
        assembly {
            let freeMemoryPointer := mload(0x40)
            mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
            mstore(add(freeMemoryPointer, 4), to)
            mstore(add(freeMemoryPointer, 36), amount)
            
            let success := call(gas(), token, 0, freeMemoryPointer, 68, 0, 0)
            
            if iszero(success) {
                revert(0, 0)
            }
        }
    }
    
    // Batch multiple operations in single call
    function executeBatchArbitrage(
        address[] calldata assets,
        uint256[] calldata amounts,
        ArbitrageData[] calldata arbData
    ) external onlyOwner {
        require(assets.length == amounts.length, "Length mismatch");
        require(assets.length == arbData.length, "Data mismatch");
        
        for (uint256 i = 0; i < assets.length;) {
            _executeArbitrage(assets[i], amounts[i], arbData[i]);
            unchecked { ++i; }
        }
    }
}

Advanced Arbitrage Algorithms

Professional arbitrage requires sophisticated price discovery and execution algorithms:

contract AdvancedArbitrageEngine {
    struct PriceData {
        uint256 price;
        uint256 liquidity;
        uint256 timestamp;
        uint8 confidence;
    }
    
    mapping(address => mapping(address => PriceData[])) public priceHistory;
    
    // Calculate optimal arbitrage amount using quadratic formula
    function calculateOptimalAmount(
        uint256 reserveA0,
        uint256 reserveA1,
        uint256 reserveB0,
        uint256 reserveB1,
        uint256 feeA,
        uint256 feeB
    ) public pure returns (uint256 optimalAmount) {
        // Quadratic formula: ax^2 + bx + c = 0
        // Where profit = (output - input - fees)
        
        uint256 a = (feeA * feeB) / 1e6;
        uint256 b = (reserveA1 * feeB + reserveB0 * feeA) / 1e3;
        uint256 c = reserveA1 * reserveB0;
        
        // Calculate discriminant
        uint256 discriminant = b * b + 4 * a * c;
        uint256 sqrtDiscriminant = _sqrt(discriminant);
        
        // Return optimal amount
        optimalAmount = (sqrtDiscriminant - b) / (2 * a);
    }
    
    // Implement Newton-Raphson square root for gas efficiency
    function _sqrt(uint256 x) internal pure returns (uint256) {
        if (x == 0) return 0;
        
        uint256 z = (x + 1) / 2;
        uint256 y = x;
        
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
        
        return y;
    }
    
    // Multi-hop arbitrage path finding
    function findOptimalPath(
        address tokenIn,
        address tokenOut,
        uint256 amountIn
    ) external view returns (
        address[] memory path,
        address[] memory exchanges,
        uint256 expectedProfit
    ) {
        // Implement Dijkstra's algorithm for optimal path
        // This is a simplified version - production needs full graph search
        
        path = new address[](3);
        exchanges = new address[](2);
        
        // Direct path
        (uint256 directProfit,) = _calculateDirectProfit(tokenIn, tokenOut, amountIn);
        
        // Multi-hop paths through WETH
        address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
        (uint256 hopProfit,) = _calculateHopProfit(tokenIn, WETH, tokenOut, amountIn);
        
        if (hopProfit > directProfit) {
            path[0] = tokenIn;
            path[1] = WETH;
            path[2] = tokenOut;
            expectedProfit = hopProfit;
        } else {
            path = new address[](2);
            path[0] = tokenIn;
            path[1] = tokenOut;
            expectedProfit = directProfit;
        }
    }
}

Professional Trading Algorithm Implementation

Professional flash loan trading requires sophisticated algorithms that analyse market microstructure, liquidity patterns, and execution timing to maximise profitability.

Advanced implementations utilise statistical arbitrage models, mean reversion strategies, and momentum-based execution algorithms that identify optimal entry and exit points for flash loan operations.

contract ProfessionalTradingEngine {
    using FixedPointMathLib for uint256;
    
    struct MarketData {
        uint256 price;
        uint256 volume;
        uint256 volatility;
        uint256 timestamp;
        uint256 liquidity;
    }
    
    struct TradingSignal {
        int256 strength;      // -1000 to 1000 (basis points)
        uint256 confidence;   // 0 to 100
        uint256 timeHorizon;  // seconds
        bool isValid;
    }
    
    // Exponential moving average calculation for price trends
    function calculateEMA(
        uint256 currentPrice,
        uint256 previousEMA,
        uint256 smoothingFactor
    ) public pure returns (uint256) {
        // EMA = (Current Price * Smoothing Factor) + (Previous EMA * (1 - Smoothing Factor))
        uint256 weight = smoothingFactor.mulDivDown(currentPrice, 1e18);
        uint256 previousWeight = (1e18 - smoothingFactor).mulDivDown(previousEMA, 1e18);
        return weight + previousWeight;
    }
    
    // Bollinger Bands implementation for volatility analysis
    function calculateBollingerBands(
        uint256[] memory prices,
        uint256 period,
        uint256 standardDeviations
    ) public pure returns (uint256 upperBand, uint256 lowerBand, uint256 middleBand) {
        require(prices.length >= period, "Insufficient price data");
        
        // Calculate simple moving average
        uint256 sum = 0;
        for (uint256 i = prices.length - period; i < prices.length; i++) {
            sum += prices[i];
        }
        middleBand = sum / period;
        
        // Calculate standard deviation
        uint256 variance = 0;
        for (uint256 i = prices.length - period; i < prices.length; i++) {
            uint256 diff = prices[i] > middleBand ?
                          prices[i] - middleBand : 
                          middleBand - prices[i];
            variance += diff * diff;
        }
        uint256 stdDev = _sqrt(variance / period);
        
        upperBand = middleBand + (stdDev * standardDeviations / 1e18);
        lowerBand = middleBand - (stdDev * standardDeviations / 1e18);
    }
    
    // RSI calculation for momentum analysis
    function calculateRSI(
        uint256[] memory prices,
        uint256 period
    ) public pure returns (uint256 rsi) {
        require(prices.length > period, "Insufficient data for RSI");
        
        uint256 gains = 0;
        uint256 losses = 0;
        
        for (uint256 i = prices.length - period; i < prices.length - 1; i++) {
            if (prices[i + 1] > prices[i]) {
                gains += prices[i + 1] - prices[i];
            } else {
                losses += prices[i] - prices[i + 1];
            }
        }
        
        if (losses == 0) return 100;
        
        uint256 avgGain = gains / period;
        uint256 avgLoss = losses / period;
        uint256 rs = avgGain.mulDivDown(1e18, avgLoss);
        
        rsi = 100 - (100 * 1e18) / (1e18 + rs);
    }
    
    // Advanced signal generation combining multiple indicators
    function generateTradingSignal(
        MarketData[] memory marketHistory,
        uint256 currentPrice
    ) external pure returns (TradingSignal memory signal) {
        require(marketHistory.length >= 20, "Insufficient market data");
        
        // Extract prices for technical analysis
        uint256[] memory prices = new uint256[](marketHistory.length);
        for (uint256 i = 0; i < marketHistory.length; i++) {
            prices[i] = marketHistory[i].price;
        }
        
        // Calculate technical indicators
        uint256 rsi = calculateRSI(prices, 14);
        (uint256 upperBB, uint256 lowerBB, uint256 middleBB) = calculateBollingerBands(prices, 20, 2e18);
        
        // Generate composite signal
        int256 rsiSignal = 0;
        if (rsi < 30) rsiSignal = 500;      // Oversold - bullish
        else if (rsi > 70) rsiSignal = -500; // Overbought - bearish
        
        int256 bbSignal = 0;
        if (currentPrice < lowerBB) bbSignal = 300;      // Below lower band - bullish
        else if (currentPrice > upperBB) bbSignal = -300; // Above upper band - bearish
        
        // Combine signals with weights
        signal.strength = (rsiSignal * 60 + bbSignal * 40) / 100;
        signal.confidence = _calculateConfidence(rsi, currentPrice, middleBB);
        signal.timeHorizon = 300; // 5 minutes
        signal.isValid = signal.confidence > 60;
    }
    
    function _calculateConfidence(
        uint256 rsi,
        uint256 currentPrice,
        uint256 middleBB
    ) internal pure returns (uint256) {
        // Higher confidence when RSI is extreme and price is near middle band
        uint256 rsiConfidence = rsi < 20 || rsi > 80 ? 80 : 40;
        uint256 priceConfidence = currentPrice > middleBB * 95 / 100 &&
                                 currentPrice < middleBB * 105 / 100 ? 70 : 50;
        
        return (rsiConfidence + priceConfidence) / 2;
    }
}

Advanced Liquidity Analysis and Market Making

Professional flash loan strategies require deep understanding of liquidity dynamics, order book analysis, and market making principles. Advanced implementations analyse bid-ask spreads, market depth, and liquidity concentration to identify optimal execution strategies that minimise market impact while maximising profitability through sophisticated liquidity analysis techniques.

contract LiquidityAnalyzer {
    struct LiquidityMetrics {
        uint256 totalLiquidity;
        uint256 bidLiquidity;
        uint256 askLiquidity;
        uint256 spread;
        uint256 marketDepth;
        uint256 impactCost;
    }
    
    // Calculate market impact for large trades
    function calculateMarketImpact(
        uint256 tradeSize,
        uint256 totalLiquidity,
        uint256 marketDepth
    ) public pure returns (uint256 impactBasisPoints) {
        // Market impact increases non-linearly with trade size
        uint256 liquidityRatio = tradeSize.mulDivDown(1e18, totalLiquidity);
        
        if (liquidityRatio < 1e16) { // < 1%
            impactBasisPoints = liquidityRatio.mulDivDown(10, 1e16); // 0.1% per 1% of liquidity
        } else if (liquidityRatio < 5e16) { // 1-5%
            impactBasisPoints = 10 + liquidityRatio.mulDivDown(20, 1e16); // Increasing impact
        } else {
            impactBasisPoints = 100 + liquidityRatio.mulDivDown(50, 1e16); // High impact
        }
    }
    
    // Optimal order splitting for large flash loan arbitrage
    function calculateOptimalSplitting(
        uint256 totalAmount,
        LiquidityMetrics memory metrics
    ) external pure returns (uint256[] memory orderSizes, uint256 totalCost) {
        uint256 maxSingleOrder = metrics.totalLiquidity / 20; // Max 5% of liquidity
        uint256 orderCount = (totalAmount + maxSingleOrder - 1) / maxSingleOrder;
        
        orderSizes = new uint256[](orderCount);
        
        for (uint256 i = 0; i < orderCount; i++) {
            if (i == orderCount - 1) {
                orderSizes[i] = totalAmount - (i * maxSingleOrder);
            } else {
                orderSizes[i] = maxSingleOrder;
            }
            
            // Calculate cumulative impact cost
            uint256 impact = calculateMarketImpact(orderSizes[i], metrics.totalLiquidity, metrics.marketDepth);
            totalCost += orderSizes[i].mulDivDown(impact, 10000);
        }
    }
    
    // Dynamic slippage calculation based on market conditions
    function calculateDynamicSlippage(
        uint256 tradeSize,
        uint256 volatility,
        uint256 liquidity,
        uint256 timeHorizon
    ) external pure returns (uint256 slippageBasisPoints) {
        // Base slippage from market impact
        uint256 baseSlippage = calculateMarketImpact(tradeSize, liquidity, liquidity / 10);
        
        // Volatility adjustment (higher volatility = higher slippage)
        uint256 volatilityAdjustment = volatility.mulDivDown(50, 1e18); // 0.5% per 1% volatility
        
        // Time horizon adjustment (longer time = higher slippage risk)
        uint256 timeAdjustment = timeHorizon > 60 ? (timeHorizon - 60) / 10 : 0; // 0.1% per 10 seconds
        
        slippageBasisPoints = baseSlippage + volatilityAdjustment + timeAdjustment;
        
        // Cap maximum slippage at 5%
        if (slippageBasisPoints > 500) {
            slippageBasisPoints = 500;
        }
    }
}

Risk-Adjusted Position Sizing and Portfolio Management

Professional flash loan operations require sophisticated risk management frameworks that dynamically adjust position sizes based on market volatility, correlation analysis, and portfolio-level risk metrics.

Advanced implementations utilise Value-at-Risk calculations, correlation matrices, and dynamic hedging strategies to optimise risk-adjusted returns while maintaining appropriate capital allocation across multiple strategies and market conditions.

contract RiskAdjustedPositioning {
    using FixedPointMathLib for uint256;
    
    struct RiskMetrics {
        uint256 volatility;        // Annualized volatility (18 decimals)
        uint256 sharpeRatio;       // Risk-adjusted return (18 decimals)
        uint256 maxDrawdown;       // Maximum historical loss (18 decimals)
        uint256 valueAtRisk;       // 95% VaR (18 decimals)
        uint256 correlation;       // Correlation with market (18 decimals)
    }
    
    struct PositionLimits {
        uint256 maxPositionSize;   // Maximum position in base currency
        uint256 maxPortfolioRisk;  // Maximum portfolio risk (18 decimals)
        uint256 maxConcentration;  // Maximum single position concentration
        uint256 stopLossLevel;     // Stop loss threshold (18 decimals)
    }
    
    mapping(address => RiskMetrics) public assetRiskMetrics;
    mapping(address => PositionLimits) public positionLimits;
    
    // Kelly Criterion for optimal position sizing
    function calculateKellyPosition(
        uint256 winProbability,    // Probability of profit (18 decimals)
        uint256 avgWin,           // Average winning amount (18 decimals)
        uint256 avgLoss,          // Average losing amount (18 decimals)
        uint256 totalCapital      // Total available capital
    ) public pure returns (uint256 optimalPosition) {
        require(winProbability <= 1e18, "Invalid probability");
        require(avgLoss > 0, "Average loss must be positive");
        
        // Kelly formula: f = (bp - q) / b
        // where b = avgWin/avgLoss, p = winProbability, q = 1-p
        uint256 b = avgWin.mulDivDown(1e18, avgLoss);
        uint256 q = 1e18 - winProbability;
        
        if (b.mulDivDown(winProbability, 1e18) <= q) {
            return 0; // Negative Kelly - don't trade
        }
        
        uint256 kellyFraction = (b.mulDivDown(winProbability, 1e18) - q).mulDivDown(1e18, b);
        
        // Apply Kelly fraction with safety margin (50% of Kelly)
        optimalPosition = totalCapital.mulDivDown(kellyFraction, 2e18);
    }
    
    // Portfolio-level risk calculation
    function calculatePortfolioRisk(
        address[] memory assets,
        uint256[] memory positions,
        uint256[][] memory correlationMatrix
    ) external view returns (uint256 portfolioVaR) {
        require(assets.length == positions.length, "Length mismatch");
        require(correlationMatrix.length == assets.length, "Correlation matrix size mismatch");
        
        uint256 portfolioVariance = 0;
        
        // Calculate portfolio variance using correlation matrix
        for (uint256 i = 0; i < assets.length; i++) {
            for (uint256 j = 0; j < assets.length; j++) {
                uint256 weight_i = positions[i];
                uint256 weight_j = positions[j];
                uint256 vol_i = assetRiskMetrics[assets[i]].volatility;
                uint256 vol_j = assetRiskMetrics[assets[j]].volatility;
                uint256 correlation = correlationMatrix[i][j];
                
                uint256 contribution = weight_i.mulDivDown(weight_j, 1e18)
                    .mulDivDown(vol_i, 1e18)
                    .mulDivDown(vol_j, 1e18)
                    .mulDivDown(correlation, 1e18);
                
                portfolioVariance += contribution;
            }
        }
        
        // Portfolio VaR = 1.65 * sqrt(variance) for 95% confidence
        uint256 portfolioVolatility = _sqrt(portfolioVariance);
        portfolioVaR = portfolioVolatility.mulDivDown(165e16, 1e18); // 1.65 * volatility
    }
    
    // Dynamic position sizing based on current market conditions
    function calculateDynamicPositionSize(
        address asset,
        uint256 basePosition,
        uint256 currentVolatility,
        uint256 marketStress
    ) external view returns (uint256 adjustedPosition) {
        RiskMetrics memory metrics = assetRiskMetrics[asset];
        PositionLimits memory limits = positionLimits[asset];
        
        // Volatility adjustment - reduce position when volatility increases
        uint256 volAdjustment = 1e18;
        if (currentVolatility > metrics.volatility) {
            uint256 volIncrease = currentVolatility - metrics.volatility;
            volAdjustment = 1e18 - volIncrease.mulDivDown(5e17, metrics.volatility); // Reduce by 50% per doubling of vol
        }
        
        // Market stress adjustment - reduce position during stress
        uint256 stressAdjustment = 1e18 - marketStress.mulDivDown(8e17, 1e18); // Reduce by 80% at max stress
        
        // Apply adjustments
        adjustedPosition = basePosition
            .mulDivDown(volAdjustment, 1e18)
            .mulDivDown(stressAdjustment, 1e18);
        
        // Ensure position doesn't exceed limits
        if (adjustedPosition > limits.maxPositionSize) {
            adjustedPosition = limits.maxPositionSize;
        }
    }
    
    // High-frequency execution optimisation
    function optimiseExecutionTiming(
        uint256 gasPrice,
        uint256 networkCongestion,
        uint256 opportunityDecay
    ) external pure returns (uint256 optimalDelay) {
        // Calculate optimal execution delay based on network conditions
        if (gasPrice > 50 gwei) {
            optimalDelay = 2; // Wait for gas price reduction
        } else if (networkCongestion > 80) {
            optimalDelay = 1; // Slight delay for congestion
        } else {
            optimalDelay = 0; // Execute immediately
        }
        
        // Adjust for opportunity decay rate
        if (opportunityDecay > 5e16) { // > 5% per second
            optimalDelay = 0; // Execute immediately if opportunity decaying fast
        }
    }
}

High-Frequency Flash Loan Execution Patterns

High-frequency flash loan strategies require microsecond-level execution optimisation, sophisticated mempool monitoring, and advanced transaction ordering techniques. Professional implementations utilise custom RPC endpoints, private transaction pools, and specialised execution engines that minimise latency while maximising opportunity capture rates through systematic high-frequency execution optimisation.

contract HighFrequencyExecutor {
    // optimised storage layout for gas efficiency
    struct ExecutionParams {
        uint128 amount;          // Packed into single slot
        uint128 minProfit;       // Packed into single slot
        address asset;           // 20 bytes
        uint96 maxSlippage;      // 12 bytes - fits with address
    }
    
    // Pre-computed function selectors for gas optimisation
    bytes4 private constant SWAP_SELECTOR = 0x38ed1739;
    bytes4 private constant TRANSFER_SELECTOR = 0xa9059cbb;
    
    // Assembly-optimised token transfer
    function _fastTransfer(address token, address to, uint256 amount) internal {
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, TRANSFER_SELECTOR)
            mstore(add(ptr, 0x04), to)
            mstore(add(ptr, 0x24), amount)
            
            let success := call(gas(), token, 0, ptr, 0x44, 0, 0)
            if iszero(success) { revert(0, 0) }
        }
    }
    
    // Batch execution with minimal gas overhead
    function executeBatchArbitrage(
        ExecutionParams[] calldata params,
        bytes[] calldata swapData
    ) external {
        uint256 length = params.length;
        for (uint256 i; i < length;) {
            _executeoptimisedArbitrage(params[i], swapData[i]);
            unchecked { ++i; }
        }
    }
}

Gas-optimised contracts can save 20-40% compared to naive implementations, but the savings only matter at scale — if you execute fewer than 10 flash loans daily, optimisation effort is better spent on strategy quality than gas reduction.

Where Flash Loans Are Heading

Two developments worth tracking. Ethereum mainnet gas has fallen to the point where flash loans settle for cents, so the L2 deployments compete on liquidity rather than cost. Account abstraction (ERC-4337) may simplify flash loan UX by bundling operations into a single user transaction without a custom contract. What is not coming is a cross-chain flash loan: the loan must be repaid inside the transaction that opened it, and no bridge settles inside that transaction.

Conclusion

This guide covered the four core flash loan use cases with working Solidity code: simple flash loans (200-300k gas), DEX arbitrage (500k-1M gas), collateral swaps, and liquidations. All examples use Aave V3's 0.05% fee structure on Ethereum or any of its L2 deployments.

The honest reality: simple DEX arbitrage is almost entirely captured by MEV bots with dedicated infrastructure (Flashbots, private mempools, co-located servers). Solo developers should focus on flash loans for utility — collateral swaps, self-liquidation prevention, and position restructuring — rather than competitive profit extraction.

These utility use cases face less competition and provide genuine value to the user deploying them. Building a collateral swap contract that saves you from a costly liquidation penalty is a far more reliable return on your development time than competing with institutional MEV searchers — see our liquidation protection strategies guide for non-code defensive techniques that pair with these contracts.

Before deploying anything to mainnet: test on Hardhat mainnet fork, deploy to Sepolia testnet, get a professional audit for any contract handling significant value, start with small amounts, and implement circuit breakers.

Flash loan contracts that handle other people's funds should use multi-sig ownership and be audited by at least one reputable firm (Trail of Bits, OpenZeppelin, Certora). The cost of an audit ($5K-50K) is trivial compared to the funds at risk from a vulnerable contract.

For developers looking to build on these examples, the most productive next step is forking the Aave V3 contracts locally with Hardhat or Foundry and testing against a mainnet fork. This lets you simulate real liquidity conditions, accurate gas costs, and actual DEX pricing without risking real funds.

Once your contract passes comprehensive testing on a fork, deploy to Sepolia with test tokens before committing to mainnet.

The development cycle for flash loan contracts should be significantly longer than for standard DApps — the atomicity that protects lenders does not protect you from logic errors that waste gas or lose money on unprofitable trades.

Sources & References

• Etherscan Gas Tracker (read 27 September 2026)
• Aave. (2025). "Aave Developer Docs". Flash loan smart contract examples and tutorials.
• GitHub Aave. (2025). "Aave Protocol GitHub". Open-source flash loan implementations.
• Ethereum.org. (2025). "Ethereum Developer Resources". Smart contract development guides.
• Aave. (2025). "Aave Protocol Documentation". Official flash-loan mechanics, interfaces and risk parameters.

Frequently Asked Questions

What Solidity version do Aave V3 flash loan contracts need?

Contracts that take Aave V3 flash loans require Solidity ^0.8.10 or higher. The examples use 0.8.10 for compatibility with Aave's core contracts.

Can I use these code examples in production?

These examples are educational. Before production use, conduct thorough testing, security audits, and add proper error handling and access controls.

What are the gas costs for flash loans?

Gas costs vary by complexity. Simple flash loans: 200-300k gas, which was cents at the 0.154 gwei base fee read on 27 September 2026. Complex arbitrage: 500k-1M gas, still under a dollar at that fee and tens to hundreds of dollars in congestion. Always simulate first.

How do I test a flash loan contract locally?

Use Hardhat's mainnet forking feature to test against real Aave contracts without spending real ETH. See testing section above.

What's the flash loan fee on Aave V3?

Aave V3 charges a flash loan fee of 0.05% (5 basis points) on the amount borrowed. For 1000 USDC, fee is 0.5 USDC.

Can flash loans fail?

Yes. If your contract can't repay the loan + fee, the entire transaction reverts. You only lose gas fees, not the borrowed amount.

Do I need to deploy on mainnet to test?

No. Test on testnets (Sepolia) or use mainnet forking. Only deploy to mainnet after thorough testing.

How do I protect against MEV bots?

Use Flashbots RPC, private transactions, or MEV protection services. Competition for arbitrage is intense.

Financial Disclaimer

This content is not financial advice. All information provided is for educational purposes only. Cryptocurrency investments carry significant investment risk, and past performance does not guarantee future results. Always do your own research and consult a qualified financial advisor before making investment decisions.