AllTokensToLPFactoryFixed

{{
  "language": "Solidity",
  "sources": {
    "contracts/FixedFactory.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
}\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
    function mint(MintParams calldata params) external payable returns (\r
        uint256 tokenId,\r
        uint128 liquidity,\r
        uint256 amount0,\r
        uint256 amount1\r
    );\r
\r
    function createAndInitializePoolIfNecessary(\r
        address token0,\r
        address token1,\r
        uint24 fee,\r
        uint160 sqrtPriceX96\r
    ) external payable returns (address pool);\r
    \r
    struct CollectParams {\r
        uint256 tokenId;\r
        address recipient;\r
        uint128 amount0Max;\r
        uint128 amount1Max;\r
    }\r
    \r
    function collect(CollectParams calldata params) external payable returns (uint256 amount0, uint256 amount1);\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
    function transfer(address, uint256) external returns (bool);\r
    function approve(address spender, uint256 amount) external returns (bool);\r
    function withdraw(uint256) external;\r
}\r
\r
// Enhanced anti-sniper ERC20 with Universal Router support\r
contract AutoAntiSniperERC20 {\r
    string public name;\r
    string public symbol;\r
    uint8 public decimals = 18;\r
    uint256 public totalSupply = 1000000000 * 10**18; // 1 billion tokens\r
    \r
    mapping(address => uint256) public balanceOf;\r
    mapping(address => mapping(address => uint256)) public allowance;\r
    \r
    // Anti-sniper variables\r
    address public factory;\r
    address public creator;\r
    uint256 public launchTime; // When token was created\r
    uint256 public devBuyWindow = 300; // 5 minutes for dev exclusive access\r
    \r
    // Ethereum Uniswap addresses that should always be allowed\r
    address constant POSITION_MANAGER = 0xC36442b4a4522E871399CD717aBDD847Ab11FE88;\r
    address constant SWAP_ROUTER = 0xE592427A0AEce92De3Edee1F18E0157C05861564;\r
    address constant UNIVERSAL_ROUTER = 0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD;  // FIX: Added Universal Router\r
    address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\r
    \r
    event Transfer(address indexed from, address indexed to, uint256 value);\r
    event Approval(address indexed owner, address indexed spender, uint256 value);\r
    \r
    modifier tradingAllowed() {\r
        // Always allow factory, creator, and core Uniswap contracts\r
        if (msg.sender == creator || \r
            msg.sender == factory || \r
            msg.sender == POSITION_MANAGER ||\r
            msg.sender == SWAP_ROUTER ||\r
            msg.sender == UNIVERSAL_ROUTER ||  // FIX: Added Universal Router to whitelist\r
            tx.origin == creator) {\r
            _;\r
            return;\r
        }\r
        \r
        // For everyone else, check dev buy window\r
        if (block.timestamp < launchTime + devBuyWindow) {\r
            revert();\r
        }\r
        _;\r
    }\r
    \r
    constructor(string memory _name, string memory _symbol, address _creator) {\r
        name = _name;\r
        symbol = _symbol;\r
        creator = _creator;\r
        factory = msg.sender;\r
        launchTime = block.timestamp; // Record launch time automatically\r
        balanceOf[factory] = totalSupply; // All tokens start in factory\r
        emit Transfer(address(0), factory, totalSupply);\r
    }\r
    \r
\r
    \r
    function transfer(address to, uint256 amount) external tradingAllowed returns (bool) {\r
        require(to != address(0));\r
        require(balanceOf[msg.sender] >= amount);\r
        \r
        balanceOf[msg.sender] -= amount;\r
        balanceOf[to] += amount;\r
        emit Transfer(msg.sender, to, amount);\r
        return true;\r
    }\r
    \r
    function approve(address spender, uint256 amount) external returns (bool) {\r
        require(spender != address(0));\r
        allowance[msg.sender][spender] = amount;\r
        emit Approval(msg.sender, spender, amount);\r
        return true;\r
    }\r
    \r
    function transferFrom(address from, address to, uint256 amount) external tradingAllowed returns (bool) {\r
        require(from != address(0));\r
        require(to != address(0));\r
        require(balanceOf[from] >= amount);\r
        require(allowance[from][msg.sender] >= amount);\r
        \r
        balanceOf[from] -= amount;\r
        balanceOf[to] += amount;\r
        allowance[from][msg.sender] -= amount;\r
        emit Transfer(from, to, amount);\r
        return true;\r
    }\r
}\r
\r
// Enhanced factory with NO AUTO-SWAP (tokens go directly to creator)\r
contract AllTokensToLPFactoryFixed {\r
    \r
    struct TokenInfo {\r
        address tokenAddress;\r
        address creator;\r
        string name;\r
        string symbol;\r
        uint256 tokenId;\r
        uint256 createdAt;\r
        address pool;\r
        int24 tickLower;\r
        int24 tickUpper;\r
        uint256 totalFeesETH;\r
    }\r
    \r
    TokenInfo[] public allTokens;\r
    mapping(address => TokenInfo[]) public createdTokens;\r
    mapping(uint256 => address) public tokenCreators;\r
    mapping(address => uint256) public creatorFeesETH;\r
\r
    address public platformAdmin;\r
    uint256 public platformFeesETH;\r
    \r
    // ETHEREUM MAINNET V3 addresses\r
    address constant POSITION_MANAGER = 0xC36442b4a4522E871399CD717aBDD847Ab11FE88;\r
    address constant SWAP_ROUTER = 0xE592427A0AEce92De3Edee1F18E0157C05861564;\r
    address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\r
    uint24 constant POOL_FEE = 10000;\r
    \r
    // Price range ticks\r
    int24 constant TICK_LOWER = -887200;\r
    int24 constant TICK_UPPER = 207200;\r
    \r
    // ORIGINAL FEE STRUCTURE (unchanged)\r
    uint256 constant CREATOR_SHARE = 50;\r
    uint256 constant PLATFORM_SHARE = 50;\r
    uint256 constant REQUIRED_ETH = 0.001 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
    \r
    modifier onlyCreatorOrAdmin(uint256 tokenId) {\r
        address creator = tokenCreators[tokenId];\r
        require(creator != address(0));\r
        require(msg.sender == creator || msg.sender == platformAdmin);\r
        _;\r
    }\r
    \r
    constructor() {\r
        platformAdmin = 0x9360c80CA79409b5e315A9791bB0208C02D6ae32;\r
    }\r
    \r
    // Calculate sqrt price\r
    function calculateSqrtPriceX96(address token) internal pure returns (uint160) {\r
        bool tokenIsToken0 = token < WETH;\r
        \r
        if (tokenIsToken0) {\r
            // token0 = TOKEN, token1 = WETH\r
            return 2505414483750479500000000;\r
        } else {\r
            // token0 = WETH, token1 = TOKEN\r
            return 2505414483750479200000000000000000;\r
        }\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 <= 10);\r
        \r
        uint256 liquidityAmount = REQUIRED_ETH;\r
        uint256 excessAmount = msg.value - liquidityAmount;\r
        \r
        // Deploy the automatic anti-sniper ERC20 token with salt iteration\r
        tokenAddress = _deployTokenWithValidAddress(name, symbol, msg.sender);\r
        \r
        // Create pool and deposit ALL tokens using full range\r
        address pool;\r
        (tokenId, pool) = _createFullRangeLP(tokenAddress, liquidityAmount);\r
        \r
        tokenCreators[tokenId] = msg.sender;\r
        \r
        // Send excess funds to platform admin\r
        if (excessAmount > 0) {\r
            (bool success, ) = platformAdmin.call{value: excessAmount}("");\r
            require(success);\r
            emit ExcessFundsSent(msg.sender, excessAmount, platformAdmin);\r
        }\r
        \r
        // Store token info\r
        TokenInfo memory tokenInfo = TokenInfo({\r
            tokenAddress: tokenAddress,\r
            creator: msg.sender,\r
            name: name,\r
            symbol: symbol,\r
            tokenId: tokenId,\r
            createdAt: block.timestamp,\r
            pool: pool,\r
            tickLower: TICK_LOWER,\r
            tickUpper: TICK_UPPER,\r
            totalFeesETH: 0\r
        });\r
        \r
        createdTokens[msg.sender].push(tokenInfo);\r
        allTokens.push(tokenInfo);\r
        \r
        emit TokenCreated(msg.sender, tokenAddress, name, symbol, tokenId, pool, TICK_LOWER, TICK_UPPER);\r
        \r
        return (tokenAddress, tokenId);\r
    }\r
    \r
    // Deploy token with salt iteration to ensure address > WETH\r
    function _deployTokenWithValidAddress(string memory name, string memory symbol, address creator) internal returns (address) {\r
        uint256 saltNonce = 0;\r
        address predictedAddress;\r
        \r
        // Keep trying until we get an address > WETH\r
        do {\r
            bytes32 salt = keccak256(abi.encodePacked(name, symbol, creator, block.timestamp, saltNonce));\r
            predictedAddress = _computeCreate2Address(salt, name, symbol, creator);\r
            saltNonce++;\r
            \r
            // Prevent infinite loop (should never happen based on our testing)\r
            require(saltNonce < 100, "Could not find valid address");\r
        } while (predictedAddress <= WETH);\r
        \r
        // Deploy with the valid salt\r
        bytes32 finalSalt = keccak256(abi.encodePacked(name, symbol, creator, block.timestamp, saltNonce - 1));\r
        return _deployTokenWithSalt(finalSalt, name, symbol, creator);\r
    }\r
    \r
    // Compute CREATE2 address without deploying\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, creator)\r
        );\r
        \r
        bytes32 hash = keccak256(\r
            abi.encodePacked(\r
                bytes1(0xff),\r
                address(this),\r
                salt,\r
                keccak256(bytecode)\r
            )\r
        );\r
        \r
        return address(uint160(uint256(hash)));\r
    }\r
    \r
    // Deploy token using CREATE2 with specific salt\r
    function _deployTokenWithSalt(bytes32 salt, string memory name, string memory symbol, address creator) internal returns (address) {\r
        bytes memory bytecode = abi.encodePacked(\r
            type(AutoAntiSniperERC20).creationCode,\r
            abi.encode(name, symbol, creator)\r
        );\r
        \r
        address tokenAddress;\r
        assembly {\r
            tokenAddress := create2(0, add(bytecode, 0x20), mload(bytecode), salt)\r
        }\r
        \r
        require(tokenAddress != address(0), "Token deployment failed");\r
        require(tokenAddress > WETH, "Invalid token address generated");\r
        \r
        return tokenAddress;\r
    }\r
\r
    function _createFullRangeLP(address tokenAddress, uint256 ethAmount) internal returns (uint256 tokenId, address pool) {\r
        // Convert ETH to WETH\r
        IWETH(WETH).deposit{value: ethAmount}();\r
        \r
        uint256 totalTokens = IERC20(tokenAddress).balanceOf(address(this));\r
        require(totalTokens == 1000000000 * 10**18);\r
        \r
        // Determine token order\r
        bool tokenIsToken0 = tokenAddress < WETH;\r
        address token0 = tokenIsToken0 ? tokenAddress : WETH;\r
        address token1 = tokenIsToken0 ? WETH : tokenAddress;\r
        \r
        uint160 sqrtPriceX96 = calculateSqrtPriceX96(tokenAddress);\r
        \r
        pool = INonfungiblePositionManager(POSITION_MANAGER).createAndInitializePoolIfNecessary(\r
            token0, token1, POOL_FEE, sqrtPriceX96\r
        );\r
        \r
        IERC20(tokenAddress).approve(POSITION_MANAGER, totalTokens);\r
        IWETH(WETH).approve(POSITION_MANAGER, ethAmount);\r
        \r
        (tokenId, , ,) = INonfungiblePositionManager(POSITION_MANAGER).mint(\r
            INonfungiblePositionManager.MintParams({\r
                token0: token0,\r
                token1: token1,\r
                fee: POOL_FEE,\r
                tickLower: TICK_LOWER,\r
                tickUpper: TICK_UPPER,\r
                amount0Desired: tokenIsToken0 ? totalTokens : ethAmount,\r
                amount1Desired: tokenIsToken0 ? ethAmount : totalTokens,\r
                amount0Min: 0, \r
                amount1Min: 0,\r
                recipient: address(this),\r
                deadline: block.timestamp + 300\r
            })\r
        );\r
        \r
        uint256 finalBalance = IERC20(tokenAddress).balanceOf(address(this));\r
        emit AllTokensDeposited(tokenAddress, totalTokens, finalBalance);\r
        \r
        return (tokenId, pool);\r
    }\r
    \r
    // FIX: NO AUTO-SWAP - Tokens go directly to creator\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
        (uint256 amount0, uint256 amount1) = INonfungiblePositionManager(POSITION_MANAGER).collect(params);\r
        \r
        if (amount0 == 0 && amount1 == 0) return;\r
        \r
        address creator = tokenCreators[tokenId];\r
        uint256 ethAmount = 0;\r
        uint256 tokenAmount = 0;\r
        address tokenAddress;\r
        \r
        for (uint i = 0; i < allTokens.length; i++) {\r
            if (allTokens[i].tokenId == tokenId) {\r
                tokenAddress = allTokens[i].tokenAddress;\r
                break;\r
            }\r
        }\r
        \r
        bool tokenIsToken0 = tokenAddress < WETH;\r
        if (tokenIsToken0) {\r
            tokenAmount = amount0;\r
            ethAmount = amount1;\r
        } else {\r
            tokenAmount = amount1;\r
            ethAmount = amount0;\r
        }\r
        \r
        if (ethAmount > 0) {\r
            IWETH(WETH).withdraw(ethAmount);\r
        }\r
        \r
        // FIX: SEND TOKENS DIRECTLY TO CREATOR (NO SWAPPING!)\r
        if (tokenAmount > 0) {\r
            IERC20(tokenAddress).transfer(creator, tokenAmount);\r
            emit TokensDirectToCreator(creator, tokenAddress, tokenAmount);\r
        }\r
        \r
        // Handle ETH fees with original 50/50 split\r
        if (ethAmount > 0) {\r
            uint256 platformETH = (ethAmount * PLATFORM_SHARE) / 100;\r
            uint256 creatorETH = ethAmount - platformETH;\r
            \r
            creatorFeesETH[creator] += creatorETH;\r
            platformFeesETH += platformETH;\r
            \r
            for (uint i = 0; i < allTokens.length; i++) {\r
                if (allTokens[i].tokenId == tokenId) {\r
                    allTokens[i].totalFeesETH += ethAmount;\r
                    break;\r
                }\r
            }\r
        }\r
        \r
        emit FeesCollected(tokenId, ethAmount, tokenAmount, 0); // 0 swapped ETH since no swapping\r
    }\r
    \r
    function collectTokenFees(address tokenAddress) external {\r
        // Find all tokens for this creator and collect fees from them\r
        for (uint i = 0; i < allTokens.length; i++) {\r
            if (allTokens[i].tokenAddress == tokenAddress && allTokens[i].creator == msg.sender) {\r
                try this.collectFees(allTokens[i].tokenId) {\r
                } catch {\r
                }\r
                break;\r
            }\r
        }\r
    }\r
    \r
\r
    \r
    function withdrawCreatorFees() external {\r
        uint256 amount = creatorFeesETH[msg.sender];\r
        require(amount > 0);\r
        \r
        creatorFeesETH[msg.sender] = 0;\r
        (bool success, ) = msg.sender.call{value: amount}("");\r
        require(success);\r
        \r
        emit CreatorWithdraw(msg.sender, amount);\r
    }\r
    \r
    function withdrawPlatformFees() external {\r
        require(msg.sender == platformAdmin);\r
        uint256 amount = platformFeesETH;\r
        require(amount > 0);\r
        \r
        platformFeesETH = 0;\r
        (bool success, ) = platformAdmin.call{value: amount}("");\r
        require(success);\r
        \r
        emit PlatformWithdraw(amount);\r
    }\r
    \r
    function getCreatorFees(address creator) external view returns (uint256) {\r
        return creatorFeesETH[creator];\r
    }\r
    \r
    function getPlatformFees() external view returns (uint256) {\r
        return platformFeesETH;\r
    }\r
    \r
    function getTokenCount() external view returns (uint256) {\r
        return allTokens.length;\r
    }\r
    \r
    receive() external payable {}\r
}"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "evmVersion": "paris",
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    }
  }
}}