AllTokensToLPFactoryFixed

{{
  "language": "Solidity",
  "sources": {
    "contracts/EthereumTokenFactoryFixed.sol": {
      "content": "// SPDX-License-Identifier: MIT\r
pragma solidity ^0.8.30;\r
\r
interface IUniswapV3Factory {\r
    function createPool(address tokenA, address tokenB, uint24 fee) external returns (address pool);\r
    function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address pool);\r
}\r
\r
interface INonfungiblePositionManager {\r
    struct MintParams {\r
        address token0;\r
        address token1;\r
        uint24 fee;\r
        int24 tickLower;\r
        int24 tickUpper;\r
        uint256 amount0Desired;\r
        uint256 amount1Desired;\r
        uint256 amount0Min;\r
        uint256 amount1Min;\r
        address recipient;\r
        uint256 deadline;\r
    }\r
\r
    struct CollectParams {\r
        uint256 tokenId;\r
        address recipient;\r
        uint128 amount0Max;\r
        uint128 amount1Max;\r
    }\r
\r
    function mint(MintParams calldata params) external payable returns (\r
        uint256 tokenId,\r
        uint128 liquidity,\r
        uint256 amount0,\r
        uint256 amount1\r
    );\r
\r
    function collect(CollectParams calldata params) external payable returns (uint256 amount0, uint256 amount1);\r
    function ownerOf(uint256 tokenId) external view returns (address owner);\r
    function safeTransferFrom(address from, address to, uint256 tokenId) external;\r
}\r
\r
interface ISwapRouter {\r
    struct ExactInputSingleParams {\r
        address tokenIn;\r
        address tokenOut;\r
        uint24 fee;\r
        address recipient;\r
        uint256 deadline;\r
        uint256 amountIn;\r
        uint256 amountOutMinimum;\r
        uint160 sqrtPriceLimitX96;\r
    }\r
\r
    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);\r
}\r
\r
interface IERC20 {\r
    function transfer(address to, uint256 amount) external returns (bool);\r
    function transferFrom(address from, address to, uint256 amount) external returns (bool);\r
    function balanceOf(address account) external view returns (uint256);\r
    function approve(address spender, uint256 amount) external returns (bool);\r
    function totalSupply() external view returns (uint256);\r
}\r
\r
interface IWETH {\r
    function deposit() external payable;\r
    function balanceOf(address) external view returns (uint256);\r
}\r
\r
contract AutoAntiSniperERC20 {\r
    mapping(address => uint256) private _balances;\r
    mapping(address => mapping(address => uint256)) private _allowances;\r
\r
    uint256 private _totalSupply;\r
    string private _name;\r
    string private _symbol;\r
    address private _owner;\r
    uint256 private _deployBlock;\r
    bool private _antiSniperEnabled = true;\r
\r
    constructor(string memory name_, string memory symbol_, uint256 totalSupply_, address owner_) {\r
        _name = name_;\r
        _symbol = symbol_;\r
        _totalSupply = totalSupply_;\r
        _owner = owner_;\r
        _deployBlock = block.number;\r
        _balances[owner_] = totalSupply_;\r
    }\r
\r
    function name() public view returns (string memory) {\r
        return _name;\r
    }\r
\r
    function symbol() public view returns (string memory) {\r
        return _symbol;\r
    }\r
\r
    function decimals() public pure returns (uint8) {\r
        return 18;\r
    }\r
\r
    function totalSupply() public view returns (uint256) {\r
        return _totalSupply;\r
    }\r
\r
    function balanceOf(address account) public view returns (uint256) {\r
        return _balances[account];\r
    }\r
\r
    function transfer(address to, uint256 amount) public returns (bool) {\r
        address owner = msg.sender;\r
        _transfer(owner, to, amount);\r
        return true;\r
    }\r
\r
    function allowance(address owner, address spender) public view returns (uint256) {\r
        return _allowances[owner][spender];\r
    }\r
\r
    function approve(address spender, uint256 amount) public returns (bool) {\r
        address owner = msg.sender;\r
        _approve(owner, spender, amount);\r
        return true;\r
    }\r
\r
    function transferFrom(address from, address to, uint256 amount) public returns (bool) {\r
        address spender = msg.sender;\r
        _spendAllowance(from, spender, amount);\r
        _transfer(from, to, amount);\r
        return true;\r
    }\r
\r
    function _transfer(address from, address to, uint256 amount) internal {\r
        require(from != address(0), "ERC20: transfer from the zero address");\r
        require(to != address(0), "ERC20: transfer to the zero address");\r
\r
        // Anti-sniper protection\r
        if (_antiSniperEnabled && block.number <= _deployBlock + 3) {\r
            require(from == _owner || to == _owner, "Anti-sniper: transfers blocked for first 3 blocks");\r
        }\r
\r
        uint256 fromBalance = _balances[from];\r
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");\r
        unchecked {\r
            _balances[from] = fromBalance - amount;\r
            _balances[to] += amount;\r
        }\r
    }\r
\r
    function _approve(address owner, address spender, uint256 amount) internal {\r
        require(owner != address(0), "ERC20: approve from the zero address");\r
        require(spender != address(0), "ERC20: approve to the zero address");\r
\r
        _allowances[owner][spender] = amount;\r
    }\r
\r
    function _spendAllowance(address owner, address spender, uint256 amount) internal {\r
        uint256 currentAllowance = allowance(owner, spender);\r
        if (currentAllowance != type(uint256).max) {\r
            require(currentAllowance >= amount, "ERC20: insufficient allowance");\r
            unchecked {\r
                _approve(owner, spender, currentAllowance - amount);\r
            }\r
        }\r
    }\r
\r
    function disableAntiSniper() external {\r
        require(msg.sender == _owner, "Only owner can disable anti-sniper");\r
        _antiSniperEnabled = false;\r
    }\r
}\r
\r
contract AllTokensToLPFactoryFixed {\r
    address public owner;\r
    \r
    mapping(uint256 => address) public tokenCreators;\r
    mapping(address => uint256) public creatorFees;\r
    mapping(address => uint256) public userTokenCount;\r
    mapping(address => mapping(uint256 => address)) public createdTokens;\r
    mapping(address => uint256) public totalCreatorFees;\r
    uint256 public totalFees;\r
    uint256 public tokenCounter;\r
    \r
    // Ethereum mainnet addresses\r
    address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\r
    address constant UNISWAP_V3_FACTORY = 0x1F98431c8aD98523631AE4a59f267346ea31F984;\r
    address constant POSITION_MANAGER = 0xC36442b4a4522E871399CD717aBDD847Ab11FE88;\r
    address constant SWAP_ROUTER = 0xE592427A0AEce92De3Edee1F18E0157C05861564;\r
    \r
    // Price range ticks for full range liquidity\r
    int24 constant TICK_LOWER = -887200;\r
    int24 constant TICK_UPPER = 887200;\r
    \r
    uint256 constant MIN_SWAP_AMOUNT = 1000 * 10**18;\r
    uint256 constant CREATOR_SHARE = 50;\r
    uint256 constant PLATFORM_SHARE = 50;\r
    uint256 constant REQUIRED_ETH = 0.00005 ether;\r
    \r
    event TokenCreated(address indexed creator, address indexed tokenAddress, string name, string symbol, uint256 tokenId, address pool, int24 tickLower, int24 tickUpper);\r
    event ExcessFundsSent(address indexed creator, uint256 amount, address indexed recipient);\r
    event FeesCollected(uint256 indexed tokenId, uint256 ethAmount, uint256 tokenAmount, uint256 swappedETH);\r
    event TokensDirectToCreator(address indexed creator, address indexed tokenAddress, uint256 amount);\r
    event CreatorWithdraw(address indexed creator, uint256 ethAmount);\r
    event PlatformWithdraw(uint256 ethAmount);\r
    event AllTokensDeposited(address indexed tokenAddress, uint256 totalTokens, uint256 finalBalance);\r
    event TokenFeesWithdrawn(address indexed creator, address indexed tokenAddress, uint256 amount);\r
    \r
    modifier onlyCreatorOrAdmin(uint256 tokenId) {\r
        address creator = tokenCreators[tokenId];\r
        require(creator == msg.sender || owner == msg.sender, "Not authorized");\r
        _;\r
    }\r
    \r
    modifier onlyOwner() {\r
        require(msg.sender == owner, "Not owner");\r
        _;\r
    }\r
    \r
    constructor() {\r
        owner = msg.sender;\r
    }\r
\r
    function createToken(string memory name, string memory symbol) external payable returns (address tokenAddress, uint256 tokenId) {\r
        require(msg.value >= REQUIRED_ETH);\r
        require(bytes(name).length > 0 && bytes(name).length <= 32);\r
        require(bytes(symbol).length > 0 && bytes(symbol).length <= 32);\r
        \r
        tokenAddress = _deployToken(name, symbol, msg.sender);\r
        tokenId = tokenCounter++;\r
        tokenCreators[tokenId] = msg.sender;\r
        createdTokens[msg.sender][userTokenCount[msg.sender]] = tokenAddress;\r
        userTokenCount[msg.sender]++;\r
        \r
        _createLiquidityPosition(tokenAddress, tokenId);\r
        \r
        return (tokenAddress, tokenId);\r
    }\r
\r
    function _deployToken(string memory name, string memory symbol, address creator) private returns (address tokenAddress) {\r
        uint256 totalSupply = 1000000000 * 10**18;\r
        bytes32 salt;\r
        address predictedAddress;\r
        uint256 attempts = 0;\r
        \r
        do {\r
            salt = keccak256(abi.encodePacked(creator, name, symbol, block.timestamp, attempts, block.prevrandao));\r
            predictedAddress = _computeCreate2Address(salt, name, symbol, creator);\r
            attempts++;\r
        } while (predictedAddress <= WETH && attempts < 5000);\r
        \r
        require(predictedAddress > WETH, "Unable to generate token address > WETH");\r
        \r
        bytes memory bytecode = abi.encodePacked(\r
            type(AutoAntiSniperERC20).creationCode,\r
            abi.encode(name, symbol, totalSupply, creator)\r
        );\r
        \r
        assembly {\r
            tokenAddress := create2(0, add(bytecode, 0x20), mload(bytecode), salt)\r
        }\r
        require(tokenAddress != address(0), "Token deployment failed");\r
    }\r
\r
    function _createLiquidityPosition(address tokenAddress, uint256 tokenId) private {\r
        uint256 totalSupply = 1000000000 * 10**18;\r
        \r
        // Create pool and approve tokens\r
        address pool = IUniswapV3Factory(UNISWAP_V3_FACTORY).createPool(tokenAddress, WETH, 3000);\r
        IERC20(tokenAddress).approve(POSITION_MANAGER, totalSupply);\r
        \r
        // Deposit WETH\r
        (bool success, ) = WETH.call{value: msg.value}(abi.encodeWithSignature("deposit()"));\r
        require(success, "WETH deposit failed");\r
        IERC20(WETH).approve(POSITION_MANAGER, msg.value);\r
        \r
        // Mint LP position\r
        (address token0, address token1) = tokenAddress < WETH ? (tokenAddress, WETH) : (WETH, tokenAddress);\r
        (uint256 amount0, uint256 amount1) = tokenAddress < WETH ? (totalSupply, msg.value) : (msg.value, totalSupply);\r
        \r
        (uint256 nftTokenId, , ,) = INonfungiblePositionManager(POSITION_MANAGER).mint(\r
            INonfungiblePositionManager.MintParams({\r
                token0: token0,\r
                token1: token1,\r
                fee: 3000,\r
                tickLower: -887200,\r
                tickUpper: 887200,\r
                amount0Desired: amount0,\r
                amount1Desired: amount1,\r
                amount0Min: 0,\r
                amount1Min: 0,\r
                recipient: address(this),\r
                deadline: block.timestamp + 300\r
            })\r
        );\r
        \r
        INonfungiblePositionManager(POSITION_MANAGER).safeTransferFrom(address(this), msg.sender, nftTokenId);\r
        emit TokenCreated(msg.sender, tokenAddress, "", "", tokenId, pool, -887200, 887200);\r
    }\r
\r
    function _computeCreate2Address(bytes32 salt, string memory name, string memory symbol, address creator) internal view returns (address) {\r
        bytes memory bytecode = abi.encodePacked(\r
            type(AutoAntiSniperERC20).creationCode,\r
            abi.encode(name, symbol, 1000000000 * 10**18, creator)\r
        );\r
        bytes32 bytecodeHash = keccak256(bytecode);\r
        return address(uint160(uint256(keccak256(abi.encodePacked(\r
            bytes1(0xff),\r
            address(this),\r
            salt,\r
            bytecodeHash\r
        )))));\r
    }\r
\r
    // Same functions as Base contract...\r
    function collectFees(uint256 tokenId) external onlyCreatorOrAdmin(tokenId) {\r
        INonfungiblePositionManager.CollectParams memory params = INonfungiblePositionManager.CollectParams({\r
            tokenId: tokenId,\r
            recipient: address(this),\r
            amount0Max: type(uint128).max,\r
            amount1Max: type(uint128).max\r
        });\r
        \r
        INonfungiblePositionManager(POSITION_MANAGER).collect(params);\r
    }\r
    \r
    function withdrawCreatorFees() external {\r
        uint256 amount = creatorFees[msg.sender];\r
        require(amount > 0, "No fees to withdraw");\r
        \r
        creatorFees[msg.sender] = 0;\r
        payable(msg.sender).transfer(amount);\r
        \r
        emit CreatorWithdraw(msg.sender, amount);\r
    }\r
    \r
    function withdrawPlatformFees() external onlyOwner {\r
        uint256 amount = totalFees;\r
        require(amount > 0, "No fees to withdraw");\r
        \r
        totalFees = 0;\r
        payable(owner).transfer(amount);\r
        \r
        emit PlatformWithdraw(amount);\r
    }\r
\r
    function getPlatformFees() external pure returns (uint256) {\r
        return REQUIRED_ETH;\r
    }\r
    \r
    function getTokenCount() external view returns (uint256) {\r
        return tokenCounter;\r
    }\r
    \r
    function getCreatorTokenBalance(address creator) external view returns (uint256) {\r
        return creatorFees[creator];\r
    }\r
\r
    function batchSwapTokenFees(address creator, address tokenAddress) external view returns (uint256) {\r
        // Placeholder for Base compatibility\r
        return 0;\r
    }\r
\r
    function rescueAndSellStuckTokens(address[] calldata tokens) external {\r
        // Placeholder for Base compatibility\r
        require(msg.sender == owner, "Not owner");\r
    }\r
\r
    // Receive ETH\r
    receive() external payable {}\r
\r
    // Safe transfer fallback\r
    function onERC721Received(address, address, uint256, bytes calldata) external pure returns (bytes4) {\r
        return this.onERC721Received.selector;\r
    }\r
}"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "evmVersion": "paris",
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    }
  }
}}