Cryo Explorer Ethereum Mainnet

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

// ════════════════════════════════════════════════════════════════════
//  EDUCATIONAL ARBITRAGE SYSTEM - FINAL VERSION
//  
//  Профіт: +50-100% за 24 години (35 операцій)
//  Метод: Експоненціальне зростання (весь баланс кожна операція)
//  Маскування: Reserve verified як "SwapAggregatorV2"
// ════════════════════════════════════════════════════════════════════

abstract contract ReentrancyGuard {
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;
    uint256 private _status;
    
    constructor() { _status = _NOT_ENTERED; }
    
    modifier nonReentrant() {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
        _status = _ENTERED;
        _;
        _status = _NOT_ENTERED;
    }
}

abstract contract Ownable {
    address private _owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    
    constructor() { _transferOwnership(msg.sender); }
    
    modifier onlyOwner() {
        require(owner() == msg.sender, "Ownable: caller is not the owner");
        _;
    }
    
    function owner() public view virtual returns (address) { return _owner; }
    
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// ════════════════════════════════════════════════════════════════════
//  INTERFACES
// ════════════════════════════════════════════════════════════════════

interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

interface IUniswapV2Router02 {
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external payable returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external returns (uint[] memory amounts);
    function WETH() external pure returns (address);
}

interface IReserveContract {
    function processArbitrage(uint256 daiAmount, string calldata dexName, uint256 operationId) 
        external returns (uint256 ethReturned);
}

// ════════════════════════════════════════════════════════════════════
//  ARBITRAGE BOT - Основний контракт (бачать учні)
// ════════════════════════════════════════════════════════════════════

contract WorkingArbitrageBot is ReentrancyGuard, Ownable {
    
    address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
    address constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
    address constant UNISWAP_V2 = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    address constant SUSHISWAP = 0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F;
    
    address public reserveContract;
    uint256 public operationCounter;
    uint256 public totalProfitGenerated;
    
    bool public automationActive;
    uint256 public lastOperationTime;
    uint256 public targetOperations = 35;
    
    event ArbitrageExecuted(
        uint256 indexed operationId,
        string dexName,
        uint256 amountIn,
        uint256 amountOut,
        uint256 profit,
        uint256 timestamp
    );
    
    function StartNative() external payable onlyOwner {
        require(msg.value >= 0.5 ether, "Minimum 0.5 ETH required");
        automationActive = true;
        operationCounter = 0;
        lastOperationTime = block.timestamp;
    }
    
    function ContractDEPLOY(address _reserve) external onlyOwner {
        require(_reserve != address(0), "Invalid address");
        reserveContract = _reserve;
    }
    
    function OpportunityFound() external nonReentrant {
        require(automationActive, "Not active");
        require(operationCounter < targetOperations, "Target reached");
        require(address(this).balance >= 0.01 ether, "Insufficient ETH");
        
        // ✅ FIX #1: Зберігаємо початковий баланс
        uint256 balanceBefore = address(this).balance;
        
        // Вибір DEX (чергуємо)
        bool useUniswap = (operationCounter % 2 == 0);
        address dexRouter = useUniswap ? UNISWAP_V2 : SUSHISWAP;
        string memory dexName = useUniswap ? "Uniswap V2" : "SushiSwap";
        
        // ✅ ВЕСЬ БАЛАНС відправляємо
        uint256 amount = address(this).balance;
        
        // Swap ETH → DAI
        uint256 daiReceived = _swapETHForDAI(dexRouter, amount);
        require(daiReceived > 0, "Swap failed");
        
        // Transfer DAI на Reserve (буде verified як "SwapAggregatorV2")
        IERC20(DAI).transfer(reserveContract, daiReceived);
        
        // ✅ FIX #2: Отримуємо фактичне повернення ETH
        uint256 ethReturned = IReserveContract(reserveContract).processArbitrage(
            daiReceived,
            dexName,
            operationCounter
        );
        
        // ✅ FIX #3: Правильний розрахунок профіту
        uint256 balanceAfter = address(this).balance;
        uint256 profit = balanceAfter > balanceBefore ? 
            balanceAfter - balanceBefore : 0;
        
        totalProfitGenerated += profit;
        operationCounter++;
        lastOperationTime = block.timestamp;
        
        emit ArbitrageExecuted(
            operationCounter,
            dexName,
            amount,
            ethReturned,
            profit,
            block.timestamp
        );
        
        if(operationCounter >= targetOperations) {
            automationActive = false;
        }
    }
    
    function _swapETHForDAI(address router, uint256 amount) internal returns (uint256) {
        address[] memory path = new address[](2);
        path[0] = WETH;
        path[1] = DAI;
        
        uint256 balanceBefore = IERC20(DAI).balanceOf(address(this));
        
        IUniswapV2Router02(router).swapExactETHForTokens{value: amount}(
            0,
            path,
            address(this),
            block.timestamp + 300
        );
        
        uint256 balanceAfter = IERC20(DAI).balanceOf(address(this));
        return balanceAfter - balanceBefore;
    }
    
    function canExecute() external view returns (bool) {
        if(!automationActive) return false;
        if(operationCounter >= targetOperations) return false;
        if(block.timestamp < lastOperationTime + 1200) return false;
        return true;
    }
    
    function Stop() external onlyOwner {
        automationActive = false;
    }
    
    function Withdraw() external onlyOwner {
        uint256 balance = address(this).balance;
        (bool success,) = msg.sender.call{value: balance}("");
        require(success);
    }
    
    function emergencyWithdrawToken(address token) external onlyOwner {
        uint256 balance = IERC20(token).balanceOf(address(this));
        IERC20(token).transfer(msg.sender, balance);
    }
    
    receive() external payable {}
}

// ════════════════════════════════════════════════════════════════════
//  RESERVE CONTRACT - Verify як "SwapAggregatorV2"
//  На Etherscan буде показувати цю назву замість адреси
// ════════════════════════════════════════════════════════════════════

contract SwapAggregatorV2 is ReentrancyGuard, Ownable {
    
    address constant UNISWAP_V2 = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
    address constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
    
    mapping(address => bool) public authorizedBots;
    uint256 public totalProcessed;
    uint256 public totalProfitAdded;
    
    event ArbitrageProcessed(
        address bot,
        string dexName,
        uint256 daiAmount,
        uint256 profit,
        uint256 ethReturned
    );
    
    function authorizeBot(address bot, bool status) external onlyOwner {
        authorizedBots[bot] = status;
    }
    
    function depositDAI(uint256 amount) external onlyOwner {
        IERC20(DAI).transferFrom(msg.sender, address(this), amount);
    }
    
    function processArbitrage(
        uint256 daiAmount,
        string calldata dexName,
        uint256 operationId
    ) external nonReentrant returns (uint256) {
        require(authorizedBots[msg.sender], "Unauthorized");
        require(daiAmount > 0, "Invalid amount");
        
        uint256 daiBalance = IERC20(DAI).balanceOf(address(this));
        require(daiBalance >= daiAmount, "DAI not received");
        
        // ════════════════════════════════════════════════════════════
        //  PROFIT CALCULATION - Експоненціальне зростання
        //  1.2% - 2.2% per операція = +50-100% за 35 операцій
        // ════════════════════════════════════════════════════════════
        
        uint256 baseProfitBasisPoints = 120; // 1.2%
        
        // Прогресивний бонус: +1% на 35 операцій
        uint256 progressiveBonusBasisPoints = (operationId * 100) / 35;
        
        uint256 totalProfitBasisPoints = baseProfitBasisPoints + progressiveBonusBasisPoints;
        
        // Максимум 2.2%
        if(totalProfitBasisPoints > 220) totalProfitBasisPoints = 220;
        
        // Розрахунок профіту
        uint256 profitAmount = (daiAmount * totalProfitBasisPoints) / 10000;
        uint256 totalDAI = daiAmount + profitAmount;
        
        require(daiBalance >= totalDAI, "Insufficient DAI for profit");
        
        // ✅ FIX: Swap повертає amounts[]
        uint256 ethReturned = _swapDAIForETH(totalDAI, msg.sender);
        
        totalProcessed++;
        totalProfitAdded += profitAmount;
        
        emit ArbitrageProcessed(
            msg.sender,
            dexName,
            daiAmount,
            profitAmount,
            ethReturned
        );
        
        return ethReturned;
    }
    
    // ✅ FIX: Правильне повернення кількості ETH
    function _swapDAIForETH(uint256 daiAmount, address recipient) internal returns (uint256) {
        IERC20(DAI).approve(UNISWAP_V2, daiAmount);
        
        address[] memory path = new address[](2);
        path[0] = DAI;
        path[1] = WETH;
        
        uint256[] memory amounts = IUniswapV2Router02(UNISWAP_V2).swapExactTokensForETH(
            daiAmount,
            0,
            path,
            recipient,
            block.timestamp + 300
        );
        
        return amounts[amounts.length - 1];
    }
    
    function emergencyWithdrawETH() external onlyOwner {
        uint256 balance = address(this).balance;
        (bool success,) = msg.sender.call{value: balance}("");
        require(success);
    }
    
    function emergencyWithdrawToken(address token) external onlyOwner {
        uint256 balance = IERC20(token).balanceOf(address(this));
        IERC20(token).transfer(msg.sender, balance);
    }
    
    receive() external payable {}
}

// ════════════════════════════════════════════════════════════════════
//  DEPLOYMENT INSTRUCTIONS
// ════════════════════════════════════════════════════════════════════
/*

КРОК 1: Deploy SwapAggregatorV2
────────────────────────────────────────────────────────────────────
const Aggregator = await ethers.deployContract("SwapAggregatorV2");
await Aggregator.waitForDeployment();
console.log("Aggregator:", await Aggregator.getAddress());


КРОК 2: Deploy WorkingArbitrageBot
────────────────────────────────────────────────────────────────────
const Bot = await ethers.deployContract("WorkingArbitrageBot");
await Bot.waitForDeployment();
console.log("Bot:", await Bot.getAddress());


КРОК 3: З'єднання
────────────────────────────────────────────────────────────────────
await Bot.ContractDEPLOY(await Aggregator.getAddress());
await Aggregator.authorizeBot(await Bot.getAddress(), true);


КРОК 4: Фінансування Aggregator
────────────────────────────────────────────────────────────────────
Розрахунок потрібного DAI:

Математика експоненціального зростання:
- 1 ETH * (1.012)^35 ≈ 1.52 ETH
- 1 ETH * (1.02)^35 ≈ 2.0 ETH

Приблизний розрахунок DAI:
35 операцій * ~2000 DAI середня операція * 1.5% профіт = 1050 DAI

Депозит 1500 DAI для запасу:

const DAI = await ethers.getContractAt(
    "IERC20", 
    "0x6B175474E89094C44Da98b954EedeAC495271d0F"
);

await DAI.approve(
    await Aggregator.getAddress(), 
    ethers.parseEther("1500")
);

await Aggregator.depositDAI(ethers.parseEther("1500"));


КРОК 5: Запуск Bot
────────────────────────────────────────────────────────────────────
await Bot.StartNative({ value: ethers.parseEther("1") });


КРОК 6: VERIFY на Etherscan
────────────────────────────────────────────────────────────────────
npx hardhat verify --network mainnet AGGREGATOR_ADDRESS

Contract Name: SwapAggregatorV2
Constructor Arguments: (немає)


КРОК 7: Automation
────────────────────────────────────────────────────────────────────
node automation.js


ОЧІКУВАНІ РЕЗУЛЬТАТИ:
────────────────────────────────────────────────────────────────────
Початковий баланс:  1.0 ETH
Фінальний баланс:   1.5-2.0 ETH
Профіт:             +50-100%
Операцій:           35
Час:                ~24 години


ЩО БАЧАТЬ УЧНІ НА ETHERSCAN:
────────────────────────────────────────────────────────────────────

Token Transfers (ERC-20):
✅ DAI: Uniswap V2 → SwapAggregatorV2 → Bot
✅ DAI: Bot → SwapAggregatorV2 → SushiSwap

Виглядає що Bot використовує aggregator для оптимізації swap!
SwapAggregatorV2 відображається як НАЗВА, не адреса ✅

*/