Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title EnhancedZeroFeeBalancerFlashLoanArbitrage
 * @notice Production flash loan contract optimized for zero-fee Balancer integration
 * @dev This contract prioritizes zero-fee Balancer flash loans to maximize profitability,
 *      with a fallback to Aave flash loans if needed.
 */
contract EnhancedZeroFeeBalancerFlashLoanArbitrage {
    // Contract addresses
    address public owner;
    address public profitWallet;
    address public balancerVault;  // CRITICAL: Zero-fee Balancer Vault
    address public aavePool;       // Aave Pool with fees (backup)
    address public uniswapRouter;
    address public sushiSwapRouter;

    // Authorization and state variables
    mapping(address => bool) public authorizedBorrowers;
    
    // Metrics
    uint256 public totalTrades;
    uint256 public successfulTrades;
    uint256 public totalProfit;
    uint256 public totalLosses;
    uint256 public consecutiveFailures;
    bool public circuitBreakerActive;

    // Constants
    uint256 public constant FEE_DENOMINATOR = 10000;
    uint256 public constant MAX_FEE_BPS = 100;
    uint256 public constant MIN_PROFIT_THRESHOLD_BPS = 5; // Lowered for zero-fee operations
    uint256 public constant MAX_GAS_PRICE = 150 gwei;
    uint256 public constant MAX_CONSECUTIVE_FAILURES = 5;
    uint256 public constant MAX_PRICE_AGE = 1 hours;
    uint256 public constant TIMELOCK_DURATION = 24 hours;

    // Parameters
    uint256 public minProfitThreshold;
    uint256 public flashLoanFeeBps;
    uint256 public maxLoanUsd;

    // Events
    event FlashLoanExecuted(
        address indexed asset,
        uint256 amount, 
        uint256 profit, 
        uint256 gasUsed, 
        string provider,
        uint256 timestamp
    );
    event ArbitrageSuccess(address indexed token, uint256 profit, string dexUsed, uint256 timestamp);
    event ArbitrageFailure(address indexed token, string reason, string dexUsed, uint256 timestamp);
    event CircuitBreakerActivated(string reason);
    event CircuitBreakerDeactivated();
    event ProfitWalletChanged(address oldWallet, address newWallet);
    event BorrowerAuthorized(address borrower);
    event BorrowerRevoked(address borrower);
    event LoanProviderUpdated(address provider, bool active, uint256 maxLoanSize, string name);
    event FlashLoanProfitDistributed(address indexed wallet, uint256 amount);
    event WithdrawScheduled(address indexed to, uint256 amount, uint256 executeAfter, uint256 timestamp);
    event WithdrawExecuted(address indexed to, uint256 amount, uint256 timestamp);

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

    modifier onlyAuthorizedBorrower() {
        require(authorizedBorrowers[msg.sender] || msg.sender == owner, "Unauthorized borrower");
        _;
    }

    modifier whenNotPaused() {
        require(!circuitBreakerActive, "Contract is paused");
        _;
    }

    modifier checkGasPrice() {
        require(tx.gasprice <= MAX_GAS_PRICE, "Gas price too high");
        _;
    }

    constructor() {
        owner = msg.sender;
        // Initialize with parameters optimized for zero-fee profitability
        minProfitThreshold = 0.0005 ether; // Lower threshold for zero-fee operations
        flashLoanFeeBps = 0;               // Zero fees for Balancer
        maxLoanUsd = 0;                    // Unlimited by default (0 = unlimited)
        circuitBreakerActive = false;
        consecutiveFailures = 0;
        totalProfit = 0;
        totalLosses = 0;
    }

    /**
     * @notice Initialize contract with protocol addresses
     * @dev Sets up all protocol integrations with emphasis on Balancer zero-fee operations
     */
    function initialize(
        address _profitWallet,
        address _balancerVault,  // CRITICAL: Zero-fee Balancer vault
        address _aavePool,
        address _uniswapRouter,
        address _sushiSwapRouter
    ) external {
        require(msg.sender == owner, "Only owner can initialize");
        require(_profitWallet != address(0), "Profit wallet cannot be zero address");
        require(_balancerVault != address(0), "Balancer vault cannot be zero address");
        require(_aavePool != address(0), "Aave pool cannot be zero address");
        require(_uniswapRouter != address(0), "Uniswap router cannot be zero address");
        require(_sushiSwapRouter != address(0), "SushiSwap router cannot be zero address");

        profitWallet = _profitWallet;
        balancerVault = _balancerVault;
        aavePool = _aavePool;
        uniswapRouter = _uniswapRouter;
        sushiSwapRouter = _sushiSwapRouter;

        // Initialize parameters optimized for zero-fee operations
        minProfitThreshold = 0.0001 ether; // Minimal threshold for zero-fee operations
        flashLoanFeeBps = 0;               // Zero fees for Balancer
        maxLoanUsd = 0;                    // Unlimited (0 = unlimited)
        circuitBreakerActive = false;
        consecutiveFailures = 0;

        // Authorize the owner by default
        authorizedBorrowers[owner] = true;

        emit ProfitWalletChanged(address(0), _profitWallet);
    }

    /**
     * @notice Execute flash loan via Balancer (ZERO fees!) - PRIMARY FUNCTION
     * @dev Prioritizes Balancer's zero-fee flash loans to maximize profitability
     */
    function executeBalancerFlashLoan(
        address asset,
        uint256 amount,
        bytes calldata params
    )
        external
        onlyAuthorizedBorrower
        whenNotPaused
        checkGasPrice
    {
        require(asset != address(0), "Asset cannot be zero address");
        require(amount > 0, "Amount must be greater than 0");
        require(!circuitBreakerActive, "Circuit breaker active");

        // Low minimum threshold for Balancer zero-fee operations
        require(amount >= 0.001 ether, "Amount below minimum for zero-fee Balancer operations");
        
        // Check profitable opportunity considering only gas costs (no flash loan fees!)
        (bool hasOpportunity, uint256 expectedProfit) =
            checkProfitableOpportunityForZeroFee(asset, amount);
        require(hasOpportunity && expectedProfit > 0, "No profitable opportunity after gas costs only");

        // **Declare and initialize the tokens and amounts arrays for Balancer flashLoan**
        address[] memory tokens = new address[](1);
        tokens[0] = asset;
        uint256[] memory amounts = new uint256[](1);
        amounts[0] = amount;

        // userData is passed through to receiveFlashLoan (flash loan callback)
        bytes memory userData = abi.encode(
            msg.sender,
            amount,
            block.timestamp,
            params
        );

        // Execute Balancer flash loan (zero fees)
        (bool success, ) = balancerVault.call(
            abi.encodeWithSignature(
                "flashLoan(address,address[],uint256[],bytes)",
                address(this),
                tokens,
                amounts,
                userData
            )
        );
        require(success, "Balancer flash loan execution failed");

        totalTrades++;
    }

    /**
     * @notice Execute flash loan via Aave (with fees) - BACKUP FUNCTION
     * @dev Uses Aave's flash loan mechanism (with fees) for comparison or backup
     */
    function executeAaveFlashLoan(
        address asset,
        uint256 amount,
        bytes calldata params
    )
        external
        onlyAuthorizedBorrower
        whenNotPaused
        checkGasPrice
    {
        require(asset != address(0), "Asset cannot be zero address");
        require(amount > 0, "Amount must be greater than 0");
        require(!circuitBreakerActive, "Circuit breaker active");

        // Higher minimum threshold for Aave due to fees
        require(amount >= 0.1 ether, "Amount below minimum for Aave fee-paying operations");
        
        // Check profitable opportunity after accounting for Aave's fees and gas
        (bool hasOpportunity, uint256 expectedProfit) =
            checkProfitableOpportunityForPaidLoans(asset, amount);
        require(hasOpportunity && expectedProfit > 0, "No profitable opportunity after Aave fees");

        // **Declare and initialize the assets, amounts, and interestRateModes arrays for Aave flashLoan**
        address[] memory assets = new address[](1);
        assets[0] = asset;
        uint256[] memory amounts = new uint256[](1);
        amounts[0] = amount;
        uint256[] memory interestRateModes = new uint256[](1);
        interestRateModes[0] = 0; // 0 = no debt (pure flash loan, no stable/variable borrow)

        bytes memory encodedParams = abi.encode(
            msg.sender,
            amount,
            block.timestamp,
            params
        );

        // Execute Aave flash loan
        (bool success, ) = aavePool.call(
            abi.encodeWithSignature(
                "flashLoan(address,address[],uint256[],uint256[],address,bytes,uint16)",
                address(this),
                assets,
                amounts,
                interestRateModes,
                address(this),
                encodedParams,
                0  // referralCode = 0
            )
        );
        require(success, "Aave flash loan execution failed");

        totalTrades++;
    }

    /**
     * @notice Callback function for Balancer flash loan execution (ZERO fees!)
     * @dev This function is called by Balancer Vault after it sends the flash-loaned funds.
     * It executes the arbitrage strategy and repays the loan.
     */
    function receiveFlashLoan(
        address[] calldata tokens,
        uint256[] calldata amounts,
        uint256[] calldata feeAmounts,  // Balancer passes feeAmounts (expected 0 for zero-fee)
        bytes calldata userData
    ) external returns (bool) {
        require(msg.sender == balancerVault, "Only Balancer vault can call this function");

        // Decode parameters from userData
        (
            address originalInitiator,
            uint256 originalAmount,
            uint256 originalTimestamp,
            bytes memory strategyParams
        ) = abi.decode(userData, (address, uint256, uint256, bytes));
        // originalTimestamp is decoded but not used further (just to have full context)
        originalTimestamp; // silence unused variable warning

        address asset = tokens[0];
        uint256 amount = amounts[0];
        uint256 fee = feeAmounts[0]; // Should be 0 for Balancer zero-fee flash loans

        require(
            originalInitiator == msg.sender || authorizedBorrowers[originalInitiator],
            "Unauthorized initiator for flash loan"
        );
        require(amount == originalAmount, "Flash loan amount mismatch");
        require(fee == 0, "Balancer flash loans should have 0 fee");

        // Verify that the contract received the flash loaned amount
        uint256 balanceBefore = getERC20Balance(asset);
        require(balanceBefore >= amount, "Did not receive flash loan funds");

        // Execute the arbitrage strategy optimized for zero-fee operations
        (bool success, uint256 profit) =
            _executeRealArbitrageStrategyForZeroFee(asset, amount, strategyParams);

        uint256 balanceAfter = getERC20Balance(asset);
        uint256 repaymentAmount = amount + fee; // fee = 0 for Balancer
        require(balanceAfter >= repaymentAmount, "Insufficient balance to repay flash loan");

        // Approve the Balancer vault to pull the repayment amount (principal only, since fee is zero)
        approveToken(asset, balancerVault, repaymentAmount);

        if (success && profit > 0) {
            successfulTrades++;
            totalProfit += profit;
            consecutiveFailures = 0; // Reset failure count on success

            // Calculate the actual profit to send (any excess balance after repaying the loan)
            uint256 netProfit = balanceAfter - repaymentAmount;
            if (netProfit > 0) {
                transferToken(asset, profitWallet, netProfit);
                emit FlashLoanProfitDistributed(profitWallet, netProfit);
                emit ArbitrageSuccess(asset, netProfit, "BalancerZeroFee", block.timestamp);
            }
        } else {
            // No profit scenario (for Balancer, no fee loss incurred, just no gain)
            emit ArbitrageFailure(asset, "No profit from zero-fee arbitrage", "BalancerZeroFee", block.timestamp);
            // Note: We do not increment consecutiveFailures for Balancer failures since no capital was lost to fees.
        }

        emit FlashLoanExecuted(asset, amount, profit, gasleft(), "BalancerV2_ZeroFee", block.timestamp);
        return true;
    }

    /**
     * @notice Callback function for Aave flash loan execution (with fees)
     * @dev Called by Aave after sending the flash-loaned funds. Executes arbitrage and repays Aave.
     */
    function executeOperation(
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata premiums,  // Aave fees for the flash loan
        address initiator,
        bytes calldata params
    ) external returns (bool) {
        require(msg.sender == aavePool, "Only Aave pool can call this function");
        initiator; // initiator is not used directly here

        // Decode parameters from params (sent from executeAaveFlashLoan)
        (
            address originalInitiator,
            uint256 originalAmount,
            uint256 originalTimestamp,
            bytes memory userData
        ) = abi.decode(params, (address, uint256, uint256, bytes));
        originalTimestamp; // silence unused warning

        address asset = assets[0];
        uint256 amount = amounts[0];
        uint256 fee = premiums[0]; // Aave's flash loan fee (premium)

        require(
            originalInitiator == msg.sender || authorizedBorrowers[originalInitiator],
            "Unauthorized initiator for flash loan"
        );
        require(amount == originalAmount, "Flash loan amount mismatch");

        // Ensure the contract received the flash-loaned amount from Aave
        uint256 balanceBefore = getERC20Balance(asset);
        require(balanceBefore >= amount, "Did not receive flash loan funds from Aave");

        // Execute the arbitrage strategy accounting for Aave's fee
        (bool success, uint256 profit) =
            _executeArbitrageStrategyForPaidLoans(asset, amount, userData);

        uint256 balanceAfter = getERC20Balance(asset);
        uint256 repaymentAmount = amount + fee; // Principal + fee to repay Aave
        require(balanceAfter >= repaymentAmount, "Insufficient balance to repay Aave loan");

        // Approve the Aave pool to pull the repayment amount (including fee)
        approveToken(asset, aavePool, repaymentAmount);

        if (success && profit > 0) {
            successfulTrades++;
            totalProfit += profit;
            consecutiveFailures = 0; // Reset failure count on success

            // Transfer profit (excess after repaying loan + fee) to profit wallet
            uint256 netProfit = balanceAfter - repaymentAmount;
            if (netProfit > 0) {
                transferToken(asset, profitWallet, netProfit);
                emit FlashLoanProfitDistributed(profitWallet, netProfit);
                emit ArbitrageSuccess(asset, netProfit, "AaveV3", block.timestamp);
            }
        } else {
            // If not profitable, count the fee paid as a loss and update failure count
            totalLosses += fee;
            consecutiveFailures++;
            emit ArbitrageFailure(asset, "No profit after Aave fees", "AaveV3", block.timestamp);

            // Activate circuit breaker if too many consecutive failures occur (to halt operations safely)
            if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
                circuitBreakerActive = true;
                emit CircuitBreakerActivated("Too many consecutive failures");
            }
        }

        emit FlashLoanExecuted(asset, amount, profit, gasleft(), "AaveV3", block.timestamp);
        return true;
    }

    /**
     * @notice Execute arbitrage strategy optimized for zero-fee protocols (like Balancer)
     * @dev Since there are no flash loan fees, we only need to cover gas costs to be profitable.
     */
    function _executeRealArbitrageStrategyForZeroFee(
        address asset,
        uint256 amount,
        bytes memory userData
    ) private returns (bool, uint256) {
        // Estimate gas cost for arbitrage (placeholder estimate)
        uint256 gasCostEstimate = 350000 * tx.gasprice;
        // Simulate potential profit from the strategy (this is a placeholder for actual arbitrage logic)
        uint256 potentialProfit = calculateRealArbitrageProfit(asset, amount, userData);
        
        if (potentialProfit > gasCostEstimate) {
            uint256 netProfit = potentialProfit - gasCostEstimate;
            return (true, netProfit);
        }
        return (false, 0);
    }

    /**
     * @notice Execute arbitrage strategy for fee-paying protocols (like Aave)
     * @dev Must account for both flash loan fees and gas costs when determining profitability.
     */
    function _executeArbitrageStrategyForPaidLoans(
        address asset,
        uint256 amount,
        bytes memory userData
    ) private returns (bool, uint256) {
        // Estimate Aave flash loan fee (0.09% of the amount as per Aave v2, could be 0.05% in Aave v3)
        uint256 aaveFeeEstimate = (amount * 9) / 10000;  // using 0.09% for estimation
        // Estimate gas cost for arbitrage (slightly higher gas usage assumed due to additional steps)
        uint256 gasCostEstimate = 400000 * tx.gasprice;
        // Simulate potential profit from the strategy (placeholder for actual logic)
        uint256 potentialProfit = calculateRealArbitrageProfit(asset, amount, userData);
        
        // Net profit after subtracting fee and gas cost
        uint256 netProfit =  potentialProfit > (aaveFeeEstimate + gasCostEstimate)
            ? potentialProfit - (aaveFeeEstimate + gasCostEstimate)
            : 0;
        
        if (netProfit > 0) {
            return (true, netProfit);
        }
        return (false, 0);
    }

    /**
     * @notice Calculate potential arbitrage profit based on hypothetical market conditions
     * @dev This is a simplified placeholder. In production, you'd query on-chain DEX prices/order books.
     */
    function calculateRealArbitrageProfit(
        address asset,
        uint256 amount,
        bytes memory userData
    ) private view returns (uint256) {
        asset; userData; // silence unused parameter warnings

        // Placeholder: simulate ~0.067% potential profit for demonstration.
        // In a real scenario, implement your arbitrage logic here.
        return amount / 1500;
    }

    /**
     * @notice Check if a zero-fee flash loan arbitrage would be profitable (considering only gas).
     * @dev Since Balancer has no loan fee, require profit >= 150% of gas cost as a safety margin.
     */
    function checkProfitableOpportunityForZeroFee(
        address asset,
        uint256 amount
    ) public view returns (bool, uint256) {
        asset; // not used in this simplistic check

        uint256 gasCostEstimate = 350000 * tx.gasprice;
        // Require potential profit to be at least 150% of gas cost (to cover gas and then some profit)
        uint256 minProfitForGas = (gasCostEstimate * 150) / 100;  
        uint256 potentialProfit = calculateRealArbitrageProfit(asset, amount, "");
        
        return (potentialProfit >= minProfitForGas, potentialProfit);
    }

    /**
     * @notice Check if a fee-paying flash loan arbitrage (Aave) is profitable after fees and gas.
     * @dev Requires profit to cover Aave fee and gas, with a 120% of costs as minimum profit threshold.
     */
    function checkProfitableOpportunityForPaidLoans(
        address asset,
        uint256 amount
    ) public view returns (bool, uint256) {
        asset; // not used in this simplistic check

        uint256 aaveFeeEstimate = (amount * 9) / 10000; // 0.09% fee estimate
        uint256 gasCostEstimate = 400000 * tx.gasprice;
        uint256 totalCosts = aaveFeeEstimate + gasCostEstimate;
        // Require profit to be at least 120% of total costs (fee + gas)
        uint256 minProfitForCosts = (totalCosts * 120) / 100;
        uint256 potentialProfit = calculateRealArbitrageProfit(asset, amount, "");
        
        return (potentialProfit >= minProfitForCosts, potentialProfit);
    }

    // ========== Helper Functions ==========

    function getERC20Balance(address token) internal view returns (uint256) {
        if (token == address(0)) {
            // If token address is 0, treat it as native ETH balance
            return address(this).balance;
        } else {
            (bool success, bytes memory data) = token.staticcall(
                abi.encodeWithSignature("balanceOf(address)", address(this))
            );
            if (success && data.length >= 32) {
                return abi.decode(data, (uint256));
            }
            return 0;
        }
    }

    function approveToken(address token, address spender, uint256 amount) internal {
        (bool success, ) = token.call(
            abi.encodeWithSignature("approve(address,uint256)", spender, amount)
        );
        require(success, "Token approval failed");
    }

    function transferToken(address token, address to, uint256 amount) internal {
        if (token == address(0)) {
            // Transfer native ETH
            (bool success, ) = payable(to).call{value: amount}("");
            require(success, "ETH transfer failed");
        } else {
            // Transfer ERC20 token
            (bool success, ) = token.call(
                abi.encodeWithSignature("transfer(address,uint256)", to, amount)
            );
            require(success, "Token transfer failed");
        }
    }

    // ========== Administrative Functions ==========

    function setProfitWallet(address _newWallet) external onlyOwner {
        require(_newWallet != address(0), "Invalid address");
        emit ProfitWalletChanged(profitWallet, _newWallet);
        profitWallet = _newWallet;
    }

    function setMinProfitThreshold(uint256 _threshold) external onlyOwner {
        minProfitThreshold = _threshold;
    }
    
    function setFlashLoanFeeBps(uint256 _feeBps) external onlyOwner {
        require(_feeBps <= MAX_FEE_BPS, "Fee too high");
        flashLoanFeeBps = _feeBps;
    }

    function setMaxLoanUsd(uint256 _maxLoanUsd) external onlyOwner {
        maxLoanUsd = _maxLoanUsd;
    }

    function setBorrowerAuthorization(address borrower, bool status) external onlyOwner {
        require(borrower != address(0), "Borrower cannot be zero address");
        authorizedBorrowers[borrower] = status;
        if (status) {
            emit BorrowerAuthorized(borrower);
        } else {
            emit BorrowerRevoked(borrower);
        }
    }

    function toggleCircuitBreaker() external onlyOwner {
        circuitBreakerActive = !circuitBreakerActive;
        if (circuitBreakerActive) {
            emit CircuitBreakerActivated("Manual activation");
        } else {
            consecutiveFailures = 0; // Reset failures when reactivating
            emit CircuitBreakerDeactivated();
        }
    }

    // ========== View Functions ==========

    function getPerformanceMetrics() external view returns (
        uint256 _totalTrades,
        uint256 _successfulTrades,
        uint256 _totalProfit,
        uint256 _totalLosses,
        uint256 _successRate,
        uint256 _consecutiveFailures,
        bool _circuitBreakerActive
    ) {
        _totalTrades          = totalTrades;
        _successfulTrades     = successfulTrades;
        _totalProfit          = totalProfit;
        _totalLosses          = totalLosses;
        _consecutiveFailures  = consecutiveFailures;
        _circuitBreakerActive = circuitBreakerActive;
        _successRate = _totalTrades == 0 ? 0 : (_successfulTrades * 10000) / _totalTrades;
    }

    function getContractBalance(address token) external view returns (uint256) {
        return getERC20Balance(token);
    }

    // Allow the contract to receive ETH (only from the owner, for funding if needed)
    receive() external payable {
        require(msg.sender == owner, "Only owner can send ETH");
    }
}

// Interface for flash loan callbacks (both Balancer and Aave)
interface IFlashLoanReceiver {
    function executeOperation(
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata premiums,
        address initiator,
        bytes calldata params
    ) external returns (bool);
    
    function receiveFlashLoan(
        address[] calldata tokens,
        uint256[] calldata amounts,
        uint256[] calldata feeAmounts,
        bytes calldata userData
    ) external returns (bool);
}