Gecko

/*

The first chapter of the GECKO jungle is here, fren.
Don’t blink, because the next big move could drop at any moment. 
This is just the beginning.

Telegram: https://t.me/gecko_portal
Follow us on X: https://x.com/geckooneth
Website: https://geckoeth.com
                
Note: this is not the final contract. Join tg for eca.
                                                                        
                                                                                                    
                                               ↑↑↑↑↑↑↑                                              
                                   ↑↑↑  ↑↑↑    ↑↑   ↑↑↑↑↑↑↑   ↑↑                                    
                               ↑         ↑↑↑↑↑↑      ↑↑↑↑         ↑↑                                
                             ↑  ↑↑↑↑↑     ↑↑↑↑↑              ↑↑↑↑↑   ↑                              
                            ↑↑↑      ↑↑                   ↑↑↑       ↑ ↑                             
                           ↑           ↑↑    ↑↑↑ ↑↑      ↑            ↑↑                            
                                ↑↑↑↑↑↑↑↑ ↑              ↑  ↑↑↑↑↑↑↑↑    ↑                            
                          ↑    ↑↑↑↑↑↑↑                     ↑↑↑↑↑↑↑↑↑    ↑                           
                              ↑↑↑↑↑↑↑↑                      ↑↑↑↑↑↑↑↑↑   ↑                           
                              ↑↑↑↑↑↑↑↑↑↑↑↑               ↑↑↑↑↑↑↑↑↑↑↑↑   ↑                           
                          ↑   ↑↑↑↑↑↑↑↑↑↑↑                ↑↑↑↑↑↑↑↑↑↑↑↑   ↑                           
                          ↑    ↑↑↑↑↑↑↑↑↑↑                 ↑↑↑↑↑↑↑↑↑↑   ↑↑                           
                          ↑↑    ↑↑↑↑↑↑↑                    ↑↑↑↑↑↑↑↑     ↑                           
                           ↑ ↑                ↑    ↑                   ↑                            
                            ↑↑            ↑             ↑             ↑                             
                              ↑↑             ↑↑      ↑↑            ↑↑                               
                                 ↑↑                             ↑↑                                  
                                    ↑↑↑                      ↑↑                                     
                                         ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑                                         
                                               ↑↑↑↑↑↑↑                                              
                                              ↑↑                                                    
                                             ↑↑↑     ↑↑                                             
                                            ↑↑↑↑↑↑↑↑↑↑↑↑                                            
                                            ↑↑↑↑↑↑↑↑↑↑↑↑↑                                           
                                          ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑                                          
                                          ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑                                         
                                         ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ ↑                                        
                                        ↑  ↑↑↑↑↑↑↑↑↑↑↑↑↑↑  ↑                                        
                                        ↑ ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑  ↑                                       
                                       ↑  ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑                                          
                                       ↑ ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑                                          
                                       ↑ ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑                                         
                                          ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑                                          
                                          ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑                                          
                                          ↑↑↑↑↑↑↑  ↑↑↑↑↑↑↑                ↑↑                        
                                          ↑↑    ↑   ↑    ↑↑                ↑                        
                                           ↑   ↑    ↑    ↑↑  ↑          ↑ ↑                         
                                           ↑   ↑    ↑↑   ↑↑↑↑    ↑↑↑↑↑  ↑↑                          
                         ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑    ↑↑↑↑↑↑↑     ↑↑↑↑↑↑↑↑↑↑↑↑                             
                    ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ ↑↑↑↑        ↑↑↑       ↑↑↑  ↑↑                                  
                       ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑                                    
                                                                                                    
*/
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.27;

interface IUniswapV2Router02 {
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);

    function factory() external pure returns (address);
}

interface IUniswapV2Factory {
    function getPair(address tokenA, address tokenB) external view returns (address pair);
}

contract GeckoToken {
    string public name = "Gecko";
    string public symbol = "GECKO";
    uint8 public decimals = 18;
    uint256 public totalSupply = 1000000000 * 10**18; // 1 billion tokens
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    
    address public owner;
    bool public tradingEnabled;
    address public uniswapV2Pair;
    address public constant uniswapV2Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    IUniswapV2Router02 public uniswapRouter;
    address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; // Mainnet WETH address

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event TradingEnabled(bool status);
    event LiquidityAdded(uint256 tokensAdded, uint256 ethAdded, address lpTokenRecipient);

    constructor() {
        owner = msg.sender;
        balanceOf[address(this)] = totalSupply; // Contract holds all tokens initially
        tradingEnabled = false;
        uniswapRouter = IUniswapV2Router02(uniswapV2Router);
        emit Transfer(address(0), address(this), totalSupply);
    }

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

    modifier tradingAllowed() {
        require(tradingEnabled || msg.sender == owner || msg.sender == uniswapV2Pair || msg.sender == uniswapV2Router, "Trading is not enabled yet");
        _;
    }

    function enableTrading() public onlyOwner {
        tradingEnabled = true;
        emit TradingEnabled(true);
    }

    function addLiquidity(uint256 tokenAmount, address lpTokenRecipient) external payable onlyOwner {
        require(tokenAmount > 0 && msg.value > 0, "Insufficient liquidity amounts");
        require(balanceOf[address(this)] >= tokenAmount, "Insufficient token balance in contract");

        // If no LP token recipient is specified, default to the contract owner
        if (lpTokenRecipient == address(0)) {
            lpTokenRecipient = owner;
        }

        // Approve token transfer to cover all possible scenarios
        _approve(address(this), address(uniswapRouter), tokenAmount);

        // Add the liquidity
        (uint256 amountToken, uint256 amountETH, ) = uniswapRouter.addLiquidityETH{value: msg.value}(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            lpTokenRecipient,
            block.timestamp + 15 minutes
        );

        // Set the uniswapV2Pair address if it hasn't been set yet
        if (uniswapV2Pair == address(0)) {
            address factory = uniswapRouter.factory();
            uniswapV2Pair = IUniswapV2Factory(factory).getPair(address(this), WETH);
        }

        emit LiquidityAdded(amountToken, amountETH, lpTokenRecipient);
    }

    function transfer(address to, uint256 value) public tradingAllowed returns (bool success) {
        require(balanceOf[msg.sender] >= value, "Insufficient balance");
        balanceOf[msg.sender] -= value;
        balanceOf[to] += value;
        emit Transfer(msg.sender, to, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value) public tradingAllowed returns (bool success) {
        require(balanceOf[from] >= value, "Insufficient balance");
        require(allowance[from][msg.sender] >= value, "Insufficient allowance");
        balanceOf[from] -= value;
        balanceOf[to] += value;
        allowance[from][msg.sender] -= value;
        emit Transfer(from, to, value);
        return true;
    }
    
    function approve(address spender, uint256 value) public returns (bool success) {
        return _approve(msg.sender, spender, value);
    }

    function _approve(address owner, address spender, uint256 value) internal returns (bool success) {
        allowance[owner][spender] = value;
        emit Approval(owner, spender, value);
        return true;
    }

    // Function to allow the contract to receive ETH
    receive() external payable {}

    // Function for the owner to withdraw tokens from the contract
    function withdrawTokens(address to, uint256 amount) external onlyOwner {
        require(balanceOf[address(this)] >= amount, "Insufficient balance in contract");
        balanceOf[address(this)] -= amount;
        balanceOf[to] += amount;
        emit Transfer(address(this), to, amount);
    }

    // Function for the owner to withdraw ETH from the contract
    function withdrawETH(address payable to, uint256 amount) external onlyOwner {
        require(address(this).balance >= amount, "Insufficient ETH balance in contract");
        to.transfer(amount);
    }
}

{
  "compilationTarget": {
    "GeckoToken.sol": "GeckoToken"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}