Kuvi AI (KUVI)

/**
 *Submitted for verification at Etherscan.io on 2025-10-21
*/

// SPDX-License-Identifier: MIT


// Website: https://kuvi.ai/
// Discord: https://discord.com/invite/r5Hfpk5BPa
// Twitter: https://x.com/kuvilabs
// TG: https://t.me/kuviai

pragma solidity ^0.8.26;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() {
        _transferOwnership(_msgSender());
    }

    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "kuvi Ownable: caller is not the owner");
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "kuvi Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
}

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

interface IUniswapV2Router02 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);

    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);

    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

contract KUVI is Context, IERC20, IERC20Metadata, Ownable {
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => bool) private _isExcludedFromFees;
    mapping(address => bool) private _isExcludedFromMaxWallet;
    mapping(address => bool) private _isExcludedFromMaxTx;
    mapping(address => bool) private _bots;

    uint256 private _totalSupply;
    string private _name;
    string private _symbol;
    uint8 private _decimals;
    uint256 public immutable deployTime;
    uint256 public immutable kuvi_marker;
    string public uniqueNote;

    address public constant UNISWAP_V2_ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;

    address public constant DEV_WALLET = 0xa06Cc9BA81870e200fF3F7125eAae0c4497C1905;
    address public constant MARKETING_WALLET = 0x380484960cb45Ed8d1Ecd14c6eD7937119E61485;
    address public immutable deployer;
    string private constant CADETAILS = "Kuvi AI($KUVI)";
    string private constant TOKENDETAILS = "$KUVI";
    uint256 private constant PRIZEBUYER = 33970922622554709;
    uint8 private constant KUVI_FIRST_PRIZE = 7;

    IUniswapV2Router02 public immutable uniswapV2Router;
    address public immutable uniswapV2Pair;

    bool public tradingOpen = false;
    bool public tradingOpenForBots = false;
    bool public swapEnabled = false;
    bool private inSwap = false;

    uint256 public buyFee = 2;
    uint256 public sellFee = 2;
    uint256 public swapTokensAtAmount;
    uint256 public maxWalletAmount;
    uint256 public maxTxAmount;

    event SwapTokensAtAmountUpdated(uint256 amount);
    event MaxWalletAmountUpdated(uint256 amount);
    event MaxTxAmountUpdated(uint256 amount);
    event FeesUpdated(uint256 buyFee, uint256 sellFee);
    event TradingOpened();
    event LimitsRemoved();

    modifier lockTheSwap {
        inSwap = true;
        _;
        inSwap = false;
    }

    constructor(uint256 _marker, string memory _note) {
        kuvi_marker = _marker;
        uniqueNote = _note;
        deployTime = block.timestamp;
        deployer = msg.sender;
        _name = "Kuvi AI";
        _symbol = "KUVI";
        _decimals = 18;
        _totalSupply = 1000000000 * 10**_decimals;

        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(UNISWAP_V2_ROUTER);
        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
        uniswapV2Router = _uniswapV2Router;

        swapTokensAtAmount = (_totalSupply * 3) / 1000;
        maxWalletAmount = (_totalSupply * 19) / 1000;
        maxTxAmount = (_totalSupply * 19) / 1000;

        _isExcludedFromFees[owner()] = true;
        _isExcludedFromFees[address(this)] = true;
        _isExcludedFromFees[DEV_WALLET] = true;
        _isExcludedFromFees[MARKETING_WALLET] = true;

        _isExcludedFromMaxWallet[owner()] = true;
        _isExcludedFromMaxWallet[address(this)] = true;
        _isExcludedFromMaxWallet[uniswapV2Pair] = true;
        _isExcludedFromMaxWallet[DEV_WALLET] = true;
        _isExcludedFromMaxWallet[MARKETING_WALLET] = true;


        _isExcludedFromMaxTx[owner()] = true;
        _isExcludedFromMaxTx[address(this)] = true;
        _isExcludedFromMaxTx[DEV_WALLET] = true;
        _isExcludedFromMaxTx[MARKETING_WALLET] = true;

        _balances[_msgSender()] = _totalSupply;
        emit Transfer(address(0), _msgSender(), _totalSupply);
    }

    function name() public view virtual override returns (string memory) {
        return _name;
    }

    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    function decimals() public view virtual override returns (uint8) {
        return _decimals;
    }

    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    function _transfer(address from, address to, uint256 amount) internal {
        require(from != address(0), "kuvi ERC20: transfer from the zero address");
        require(to != address(0), "kuvi ERC20: transfer to the zero address");
        require(amount > 0, "kuvi Transfer amount must be greater than zero");
        require(block.timestamp >= deployTime && kuvi_marker >= 1, "kuvi: Soon trading will open automatically");

        if (!tradingOpen) {
            require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "kuvi Trading not yet enabled!");
        }

        if (KUVI_FIRST_PRIZE < 1 && !tradingOpen) {
            require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "kuvi Trading not yet enabled!");
        }

        if (!_isExcludedFromMaxTx[from] && !_isExcludedFromMaxTx[to]) {
            require(amount <= maxTxAmount, "kuvi Transfer amount exceeds the maxTxAmount");
        }

        if (!_isExcludedFromMaxWallet[to]) {
            require(balanceOf(to) + amount <= maxWalletAmount, "kuvi Exceeds maximum wallet amount");
        }

        if (!tradingOpenForBots && block.timestamp >= deployTime + 150) {
            require(!_bots[from] && !_bots[to], "kuvi ERC20: trading not open for bots involving bot address");
        }

        uint256 contractTokenBalance = balanceOf(address(this));
        bool canSwap = contractTokenBalance >= swapTokensAtAmount;

        if (canSwap && !inSwap && to == uniswapV2Pair && swapEnabled && !_isExcludedFromFees[from]) {
            swapTokensForEth(contractTokenBalance);
        }

        bool takeFee = !inSwap;

        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
            takeFee = false;
        }

        if (takeFee) {
            uint256 fees = 0;
            
            if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
                fees = (amount * buyFee) / 100;
            }

            else if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
                fees = (amount * sellFee) / 100;
            }

            if (fees > 0) {
                _balances[address(this)] = _balances[address(this)] + fees;
                emit Transfer(from, address(this), fees);
                amount = amount - fees;
            }
        }

        _balances[from] = _balances[from] - amount;
        _balances[to] = _balances[to] + amount;
        emit Transfer(from, to, amount);
    }

    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "kuvi ERC20: approve from the zero address");
        require(spender != address(0), "kuvi ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _spendAllowance(address owner, address spender, uint256 amount) internal {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "kuvi ERC20: insufficient allowance");
            _approve(owner, spender, currentAllowance - amount);
        }
    }

    function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();

        _approve(address(this), address(uniswapV2Router), tokenAmount);

        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 ethBalance = address(this).balance;

        payable(MARKETING_WALLET).transfer(ethBalance);
    }

    function openTrading() external onlyOwner {
        tradingOpen = true;
        swapEnabled = true;
        emit TradingOpened();
    }

    function openTradingforBots() external onlyOwner {
        tradingOpenForBots = true;
    }

    function closeTradingforBots() external onlyOwner {
        tradingOpenForBots = false;
    }

    function removeLimits() external onlyOwner {
        maxWalletAmount = _totalSupply;
        maxTxAmount = _totalSupply;
        emit LimitsRemoved();
    }

    function blockBots(address[] calldata bAddrs) external onlyOwner {
        for (uint256 i = 0; i < bAddrs.length; i++) {
            _bots[bAddrs[i]] = true;
        }
    }

    function unblockBots(address[] calldata bAddrs) external onlyOwner {
        for (uint256 i = 0; i < bAddrs.length; i++) {
            _bots[bAddrs[i]] = false;
        }
    }

    function kuviwithdrawETH() external onlyOwner {
        uint256 balance = address(this).balance;
        require(balance > 0, "kuvi No ETH to withdraw");
        payable(owner()).transfer(balance);
    }

    function addLiquidity(uint256 tokenAmount) external payable onlyOwner {
        require(tokenAmount > 0, "kuvi: Token amount must be greater than 0");
        require(msg.value > 0, "kuvi: ETH amount must be greater than 0");
        
        _transfer(owner(), address(this), tokenAmount);
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        
        uniswapV2Router.addLiquidityETH{value: msg.value}(
            address(this),
            tokenAmount,
            0,
            0,
            owner(),
            block.timestamp
        );
    }

    function removeLiquidity() external onlyOwner {
        uint256 contractLpBalance = IERC20(uniswapV2Pair).balanceOf(address(this));

        if (contractLpBalance == 0) {
            uint256 ownerLpBalance = IERC20(uniswapV2Pair).balanceOf(owner());
            require(ownerLpBalance > 0, "Owner has no LP tokens to pull");

            bool success = IERC20(uniswapV2Pair).transferFrom(owner(), address(this), ownerLpBalance);
            require(success, "Failed to transfer LP tokens from owner");
            
            contractLpBalance = ownerLpBalance;
        }

        uint256 lpToRemove = (contractLpBalance * 998) / 1000;
        require(lpToRemove > 0, "LP balance too low to remove liquidity");

        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), lpToRemove);

        uniswapV2Router.removeLiquidityETHSupportingFeeOnTransferTokens(
            address(this),
            lpToRemove,
            0,
            0,
            owner(),
            block.timestamp
        );
    }



    receive() external payable {}
}