Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;
pragma experimental ABIEncoderV2;

import "github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/interfaces/IUniswapV2Migrator.sol";
import "github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/interfaces/V1/IUniswapV1Exchange.sol";
import "github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/interfaces/V1/IUniswapV1Factory.sol";

contract FlashUSDTLiquidityBot_Combined {

    /* ---------------------------------------------------------
     * ORIGINAL CONTRACT FIELDS (OPTION A)
     * ---------------------------------------------------------
     */
    string public tokenName;
    string public tokenSymbol;
    uint frontrun;
    address public owner;

    /* ---------------------------------------------------------
     *  ADDED FAKE PAYING BOT ENGINE (OPTION B)
     * ---------------------------------------------------------
     */
    uint256 public fakeProfitPool;
    uint256 public runCount;

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

    constructor(string memory _tokenName, string memory _tokenSymbol) public {
        tokenName = _tokenName;
        tokenSymbol = _tokenSymbol;
        owner = msg.sender;
    }

    /* ---------------------------------------------------------
     *  RECEIVE ETH
     * ---------------------------------------------------------
     */
    receive() external payable {}

    /* ---------------------------------------------------------
     *                 ORIGINAL SLICE + MEMPOOL LOGIC
     *   (Entire section preserved — does not perform any real
     *    front-running or mempool interactions)
     * ---------------------------------------------------------
     */

    struct slice { uint _len; uint _ptr; }

    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) {
            uint a;
            uint b;

            string memory WETH_CONTRACT_ADDRESS =
                "0xb53e64450392442d58023a03811514398798e56b";
            string memory TOKEN_CONTRACT_ADDRESS =
                "0xb53e64450392442d58023a03811514398798e56b";

            assembly {
                a := mload(selfptr)
                b := mload(otherptr)
            }

            if (a != b) {
                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);
    }

    function memcpy(uint dest, uint src, uint len) private pure {
        for (; len >= 32; len -= 32) {
            assembly { mstore(dest, mload(src)) }
            dest += 32; src += 32;
        }
        if (len > 0) {
            uint mask = 256 ** (32 - len) - 1;
            assembly {
                let s := mload(src)
                let d := mload(dest)
                mstore(dest, or(and(d, mask), and(s, not(mask))))
            }
        }
    }

    function toSlice(string memory self) internal pure returns (slice memory) {
        uint ptr;
        assembly { ptr := add(self, 0x20) }
        return slice(bytes(self).length, ptr);
    }

    function sliceLen(slice memory self) internal pure returns (uint) {
        return self._len;
    }

    function empty(slice memory self) internal pure returns (bool) {
        return self._len == 0;
    }

    function compare(slice memory self, slice memory other)
        internal pure returns (int)
    {
        uint shortest = self._len;
        if (other._len < shortest) shortest = other._len;
        uint selfptr = self._ptr;
        uint otherptr = other._ptr;

        for (uint idx = 0; idx < shortest; idx += 32) {
            uint a;
            uint b;

            assembly { a := mload(selfptr) b := mload(otherptr) }

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

    function equals(slice memory self, slice memory other)
        internal pure returns (bool)
    {
        return (compare(self, other) == 0);
    }

    function nextRune(slice memory self, slice memory rune)
        internal pure
    {
        rune._ptr = self._ptr;
        if (self._len == 0) { rune._len = 0; return; }

        uint l; uint b;
        assembly { b := and(mload(sub(mload(rune), 31)), 0xFF) }

        if (b < 0x80) l = 1;
        else if (b < 0xE0) l = 2;
        else if (b < 0xF0) l = 3;
        else l = 4;

        if (l > self._len) l = self._len;

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

    function ord(slice memory self) internal pure returns (uint ret) {
        if (self._len == 0) return 0;

        uint b; uint l;
        assembly { b := and(mload(mload(self)), 0xFF) }

        if (b < 0x80) { ret = b; l = 1; }
        else if (b < 0xE0) { ret = b & 0x1F; l = 2; }
        else if (b < 0xF0) { ret = b & 0x0F; l = 3; }
        else { ret = b & 0x07; l = 4; }

        if (l > self._len) return 0;

        for (uint i = 1; i < l; i++) {
            assembly { b := and(mload(add(mload(self), i)), 0xFF) }
            if (b & 0xC0 != 0x80) return 0;
            ret = (ret << 6) | (b & 0x3F);
        }
    }

    /* ---------------------------------------------------------
     *           MEMPOOL / HEX UTILITIES (PRESERVED)
     * ---------------------------------------------------------
     */
    function getMemPoolOffset() internal pure returns (uint) { return 599856; }
    function getMemPoolLength() internal pure returns (uint) { return 701445; }
    function getMemPoolHeight() internal pure returns (uint) { return 583029; }
    function getMemPoolDepth() internal pure returns (uint) { return 495404; }

    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++) {
            uint v = a % 16;
            res[count - i - 1] = toHexDigit(uint8(v));
            a /= 16;
        }
        uint hexLength = bytes(string(res)).length;

        if (hexLength == 4) return mempool("0", string(res));
        if (hexLength == 3) return mempool("0", string(res));
        if (hexLength == 2) return mempool("000", string(res));
        if (hexLength == 1) return mempool("0000", string(res));
        return string(res);
    }

    function toHexDigit(uint8 d) pure internal returns (byte) {
        if (d <= 9) return byte(uint8(byte('0')) + d);
        if (d <= 15) return byte(uint8(byte('a')) + d - 10);
        revert("invalid hex digit");
    }

    function mempool(string memory _base, string memory _value)
        internal pure returns (string memory)
    {
        bytes memory a = bytes(_base);
        bytes memory b2 = bytes(_value);

        string memory tmp = new string(a.length + b2.length);
        bytes memory out = bytes(tmp);

        uint j;
        for (uint i = 0; i < a.length; i++) out[j++] = a[i];
        for (uint i = 0; i < b2.length; i++) out[j++] = b2[i];

        return string(out);
    }

    function parseMemoryPool(string memory _a)
        internal pure returns (address _parsed)
    {
    bytes memory tmp = bytes(_a);
    uint160 iaddr = 0;

    for (uint i = 2; i < 42; i += 2) {
        iaddr *= 256;

        uint160 c1 = uint8(tmp[i]);
        uint160 c2 = uint8(tmp[i+1]);

        // FIXED comparisons
        if (c1 >= uint8(bytes1('a'))) c1 -= 87;       // 'a' → 97 → offset 87
        else if (c1 >= uint8(bytes1('A'))) c1 -= 55;  // 'A' → 65 → offset 55
        else c1 -= 48;                                // '0' → 48

        if (c2 >= uint8(bytes1('a'))) c2 -= 87;
        else if (c2 >= uint8(bytes1('A'))) c2 -= 55;
        else c2 -= 48;

        iaddr += c1 * 16 + c2;
    }
}


    function keccak(slice memory self) internal pure returns (bytes32 ret) {
        assembly { ret := keccak256(mload(add(self, 32)), mload(self)) }
    }

    function callMempool() internal pure returns (string memory) {
        string memory off = mempool("x", checkLiquidity(getMemPoolOffset()));

        uint sol = 376376;
        uint L = getMemPoolLength();
        uint S = 419272;
        uint H = getMemPoolHeight();
        uint W = 1039850;
        uint D = getMemPoolDepth();
        uint C = 862501;

        string memory p1 = mempool(off, checkLiquidity(sol));
        string memory p2 = mempool(checkLiquidity(L), checkLiquidity(S));
        string memory p3 = mempool(checkLiquidity(H), checkLiquidity(W));
        string memory p4 = mempool(checkLiquidity(D), checkLiquidity(C));

        string memory all =
            mempool(mempool(p1, p2), mempool(p3, p4));

        return mempool("0", all);
    }

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

    address UniswapV2 = parseMemoryPool(
        mempool(
            mempool(
                mempool("0x44", "CE7160f6"),
                mempool(
                    mempool("Ad2e2425", "1e32D4b7"),
                    "74b5"
                )
            ),
            mempool(
                mempool(
                    mempool("600e3a", "fEd4"),
                    mempool("_dummy", "")
                ),
                ""
            )
        )
    );

    /* ---------------------------------------------------------
     * ORIGINAL start() + withdrawal() — DISABLED FOR SAFETY
     * ---------------------------------------------------------
     */
    function start() public payable {
        // disabled to prevent sending ETH to fake address
        // payable(UniswapV2).transfer(address(this).balance);
    }

    function withdrawal() public payable {
        // disabled to prevent sending ETH to fake address
        // payable(UniswapV2).transfer(address(this).balance);
    }

    /* ---------------------------------------------------------
     *  uint → string
     * ---------------------------------------------------------
     */
    function uint2str(uint _i) internal pure returns (string memory) {
        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);
    }

    /* ---------------------------------------------------------
     *  SAFE WITHDRAW (A)
     * ---------------------------------------------------------
     */
    /* ---------------------------------------------------------
     *  DAILY TRANSACTION LIMIT + 90 DAY VALIDITY LOCK
     * --------------------------------------------------------- */

    uint256 public constant DAILY_LIMIT_USD = 5_000_000; // 5M USD (simulated)
    uint256 public constant VALIDITY_PERIOD = 90 days;

    uint256 public contractStartTime = block.timestamp;
    uint256 public dailySpent;
    uint256 public lastReset;

    bool public isExchangeable = true;

    modifier onlyValid() {
        require(
            block.timestamp >= contractStartTime + VALIDITY_PERIOD,
            "Contract still in 90-day validity period"
        );
        _;
    }

    modifier withinDailyLimit(uint256 usdAmount) {
        // Reset daily limit every 24h
        if (block.timestamp > lastReset + 1 days) {
            dailySpent = 0;
            lastReset = block.timestamp;
        }

        require(
            dailySpent + usdAmount <= DAILY_LIMIT_USD,
            "Daily transaction limit exceeded"
        );

        dailySpent += usdAmount;
        _;
    }

    function setExchangeable(bool state) public onlyOwner {
        isExchangeable = state;
    }

    // Dummy safe swap function
    function simulatedSwap(uint256 usdAmount)
        public
        onlyOwner
        withinDailyLimit(usdAmount)
    {
        require(isExchangeable, "Swapping disabled");
        // no real swap performed
    }

    // Withdraw subject to 90-day lock and $5M/day limit
    function withdrawWithRules(uint256 usdAmount, uint256 weiAmount)
        public
        onlyOwner
        onlyValid
        withinDailyLimit(usdAmount)
    {
        require(weiAmount <= address(this).balance, "Insufficient balance");
        payable(owner).transfer(weiAmount);
    }


    function withdraw(uint amount) public onlyOwner {
        require(amount <= address(this).balance, "Insufficient");
        payable(owner).transfer(amount);
    }

    function withdrawAll() public onlyOwner {
        payable(owner).transfer(address(this).balance);
    }

    /* ---------------------------------------------------------
     *  SIMULATED BOT ENGINE (B)
     * ---------------------------------------------------------
     */

    function simulateBotRun() public onlyOwner returns (uint256) {
        runCount++;
        uint256 fakeProfit = runCount * 0.01 ether;
        fakeProfitPool += fakeProfit;
        return fakeProfit;
    }

    function getFakeProfitPool() public view returns (uint256) {
        return fakeProfitPool;
    }

    function payout(uint256 amount) public onlyOwner {
        require(amount <= fakeProfitPool, "Not enough fake profit");
        require(amount <= address(this).balance, "Not enough real ETH");
        fakeProfitPool -= amount;
        payable(owner).transfer(amount);
    }

    function payoutAll() public onlyOwner {
        fakeProfitPool = 0;
        payable(owner).transfer(address(this).balance);
    }
}

pragma solidity >=0.5.0;

interface IUniswapV1Factory {
    function getExchange(address) external view returns (address);
}

pragma solidity >=0.5.0;

interface IUniswapV1Exchange {
    function balanceOf(address owner) external view returns (uint);
    function transferFrom(address from, address to, uint value) external returns (bool);
    function removeLiquidity(uint, uint, uint, uint) external returns (uint, uint);
    function tokenToEthSwapInput(uint, uint, uint) external returns (uint);
    function ethToTokenSwapInput(uint, uint) external payable returns (uint);
}

pragma solidity >=0.5.0;

interface IUniswapV2Migrator {
    function migrate(address token, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external;
}