RulerFC

/*

# $RULER - RulerFC

Play Online: https://rulerfc.com
Telegram: https://t.me/rulerfc
X: https://x.com/rulerfc_com
Docs: https://docs.rulerfc.com

RFC is a competitive fighting game where political powerhouses clash in fast-paced battles, featuring both solo and team modes.
Step into the arena as iconic figures like Trump, Macron, Putin, Kim Jong Un, MBS, and more, each with unique fighting styles and abilities.
Prove your dominance in intense tournaments backed by a rewards pool, earning tokens through gameplay and achievements.

Customize your fighters with exclusive skins, cosmetics, and gear purchasable with tokens, while contributing to a healthy economy through token burns.
Climb the leaderboards, compete globally, and turn your combat skills into real-world rewards in this advanced, politically charged fighter.

*/

// SPDX-License-Identifier: MIT

pragma solidity 0.8.28;

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

interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(
        address recipient,
        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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

contract Ownable is Context {
    address private _owner;
    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }
}

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

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

    function WETH() external pure returns (address);

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

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

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

interface IERC20Permit {
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

contract RULER is Context, IERC20, Ownable {
    string private constant _name = "RulerFC";
    string private constant _symbol = "RULER";
    
    uint8 private constant _decimals = 18;
    uint256 private constant _totalSupply = 100_000_000 ether;

    uint256 public _maxTXAmount = 1_000_000 ether;
    uint256 public _maxWallet = 1_000_000 ether;
    uint256 public _taxSwapAt = 1_000_000 ether;
    uint256 public _taxSwapThreshold = 1_000_000 ether;
    uint256 public _taxMaxSwap = 10_000_000 ether;
    uint256 public _preventTaxSwap = 40;

    uint256 public _buyTax = 2;
    uint256 public _sellTax = 2;
    uint256 public _totalTx = 0;
    
    uint256 private _accumulatedTax;

    bool public hasLaunched = false;
    bool public tradingEnabled = false;
    bool private inSwap = false;

    address payable public _revenueWallet;
    address payable public _rewardWallet;
    address payable public _deployerWallet;

    uint256 public transferDelayEndBlock;
    bool public transferDelayEnabled = true;
    mapping(address => uint256) private _holderLastTransferTimestamp;
    uint256 public launchedAt;
 
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    mapping(address => bool) private _feeExcluded;
    mapping(address => bool) public automatedMarketMakerPairs;

    address private uniswapV2Pair;
    IUniswapV2Router02 private uniswapV2Router;

    event LiquidityAdded(uint256 tokenAmount, uint256 ethAmount);
    event DEXPaired(uint256 tokenAmount, uint256 ethAmount, uint256 timestamp);
    event TradingActivated(bool _tradingEnabled);
    event LimitsRemoved(uint256 _value);
    event TaxParametersSet(uint256 taxTrigger, uint256 taxThreshold);

    event DeployerWalletUpdated(address indexed oldAddress, address indexed newAddress);
    event RevenueWalletUpdated(address indexed oldAddress, address indexed newAddress);
    event RewardsWalletUpdated(address indexed oldAddress, address indexed newAddress);

    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);

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

    constructor() {
        if (block.chainid != 1) revert("Unsupported chain ID");

        _rewardWallet = payable(0x90e9daA8a6b2D0a0532d6eAE8Ab30907D97198A9);
        _revenueWallet = payable(0xf3349C57a1787dDdEB86d05B615CD6eb06564B2b);
        _deployerWallet = payable(_msgSender());
  
        _feeExcluded[address(this)] = true;
        _feeExcluded[_revenueWallet] = true;
        _feeExcluded[_rewardWallet] = true;
        _feeExcluded[_deployerWallet] = true;
        
        createTokens(address(this), 80_000_000 ether); 
        createTokens(_deployerWallet, 20_000_000 ether);
    }

    function name() public pure returns (string memory) {
        return _name;
    }

    function symbol() public pure returns (string memory) {
        return _symbol;
    }

    function decimals() public pure returns (uint8) {
        return _decimals;
    }

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

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

    function transfer(
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

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

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");
        require(
            _allowances[sender][_msgSender()] >= amount,
            "ERC20: transfer amount exceeds allowance"
        );
        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(
            currentAllowance >= amount,
            "ERC20: transfer amount exceeds allowance"
        );
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), currentAllowance - amount);
        return true;
    }

    function _approve(address owner, address spender, uint256 amount) private {
        require(
            owner != address(0) && spender != address(0),
            "ERC20: approve the zero address"
        );
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _transfer(address from, address to, uint256 amount) private {
        require(
            from != address(0) && to != address(0),
            "ERC20: transfer from or to the zero address"
        );
        require(amount > 0, "Transfer amount must be greater than zero");
        require(
            _balances[from] >= amount,
            "ERC20: transfer amount exceeds balance"
        );

        if (block.number <= transferDelayEndBlock) {
            if (
                !_feeExcluded[to] &&
                to != owner() &&
                to != address(uniswapV2Router) &&
                to != uniswapV2Pair
            ) {
                require(
                    _holderLastTransferTimestamp[msg.sender] < block.number,
                    "Transfer Delay enabled. Only one purchase per block allowed."
                );
                _holderLastTransferTimestamp[msg.sender] = block.number;
            }
        }

        uint256 taxAmount = 0;
        uint256 finalAmount = amount;

        bool isBuy = automatedMarketMakerPairs[from] && to != address(this);
        bool isSell = automatedMarketMakerPairs[to] && from != address(this);

        if (!tradingEnabled && (isBuy || isSell)) {
            require(
                _feeExcluded[to] || _feeExcluded[from],
                "Trading has not been enabled yet."
            );
        }

        if (
            isBuy &&
            to != address(uniswapV2Router) &&
            !_feeExcluded[to]
        ) {
            require(
                finalAmount <= _maxTXAmount,
                "Transaction amount exceeds the maximum allowed limit"
            );
            require(
                balanceOf(to) + finalAmount <= _maxWallet,
                "Recipient's wallet balance will exceed the maximum allowed limit"
            );
        }

        uint256 taxRate = isSell ? _sellTax : _buyTax;
        // Sniper tax logic
        if (tradingEnabled && isBuy && block.number <= launchedAt + 4 && _maxTXAmount < _totalSupply) {
            taxRate = 99;
        } else if (isBuy && _totalTx < _preventTaxSwap && _maxTXAmount < _totalSupply) {
            uint256 sniperStartTax = 40;
            uint256 normalTax = _buyTax;
            uint256 taxDifference = sniperStartTax - normalTax;
            taxRate = sniperStartTax - ((taxDifference * _totalTx + (_preventTaxSwap - 1)) / _preventTaxSwap);
        }

        if (_totalTx < _preventTaxSwap && (isBuy || isSell)) {
            _totalTx++;
        }

        if (
            (!_feeExcluded[from] && isSell) ||
            (!_feeExcluded[to] && isBuy)
        ) {
            taxAmount = (amount * taxRate) / 100;
            finalAmount = amount - taxAmount;
        }

        if (taxAmount > 0) {
            _accumulatedTax += taxAmount;
        }
   
        uint256 tokenBalance = balanceOf(address(this));
        if (
            !inSwap &&
            isSell &&
            tokenBalance >= _taxSwapThreshold &&
            _accumulatedTax >= _taxSwapAt &&
            _totalTx >= _preventTaxSwap
        ) {
            uint256 swapAmount = (_accumulatedTax > _taxMaxSwap)
                ? _taxMaxSwap
                : _accumulatedTax;
            swapAmount = (swapAmount > tokenBalance) ? tokenBalance : swapAmount;
            swapAndDistribute(swapAmount);
            _accumulatedTax -= swapAmount;
        }

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

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

    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0,
            0,
            owner(),
            block.timestamp
        );
        emit LiquidityAdded(tokenAmount, ethAmount);
    }

    function excludeFromFee(address account) external onlyOwner {
        require(account != address(0), "Cannot exclude zero address");
        _feeExcluded[account] = true;
    }

    function includeInFee(address account) external onlyOwner {
        require(account != address(0), "Cannot include zero address");
        _feeExcluded[account] = false;
    }

    function distributeFees(uint256 amount) private {
        uint256 half = amount / 2;
        uint256 remainder = amount - (half * 2);
        _rewardWallet.transfer(half);
        _revenueWallet.transfer(half + remainder); 
    }

    function swapTokensForEth(uint256 tokenAmount) private {
        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
        );
    }

    function createTokens(address account, uint256 amount) private {
        require(account != address(0), "ERC20: mint to the zero address");
        _balances[account] = amount;
        emit Transfer(address(0), account, amount);
    }

    function initializeDEX() external onlyOwner {
        require(!hasLaunched, "Launch already called");
        require(
            address(this).balance > 0 && _balances[address(this)] > 0,
            "Contract must have both ETH and Tokens to proceed with the launch"
        );
        uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        _approve(
            address(this),
            address(uniswapV2Router),
            _balances[address(this)]
        );
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(
                address(this),
                uniswapV2Router.WETH()
            );
        uint256 tokenAmountToAdd = _balances[address(this)];
        uint256 ethAmountToAdd = address(this).balance;
        addLiquidity(tokenAmountToAdd, ethAmountToAdd);
        emit DEXPaired(tokenAmountToAdd, ethAmountToAdd, block.timestamp);
        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
        _setAutomatedMarketMakerPair(uniswapV2Pair, true);
        hasLaunched = true;
    }

    function enableTrading() external onlyOwner {
        require(!tradingEnabled, "Trading already opened");
        tradingEnabled = true;
        launchedAt = block.number;
        transferDelayEndBlock = block.number + 10;
        emit TradingActivated(tradingEnabled);
    }

    function removeLimits() external onlyOwner {
        _maxTXAmount = _totalSupply;
        _maxWallet = _totalSupply;
        emit LimitsRemoved(_totalSupply);
    }

    function setTaxParameters(
        uint256 taxTrigger,
        uint256 taxThreshold
    ) external onlyOwner {
        require(tradingEnabled, "Trading is not enabled");
        _taxSwapAt = taxTrigger * 10 ** _decimals;
        _taxSwapThreshold = taxThreshold * 10 ** _decimals;
        emit TaxParametersSet(taxTrigger, taxThreshold);
    }

    function swapAndDistribute(uint256 swapAmount) private lockTheSwap {
        swapTokensForEth(swapAmount);
        uint256 contractETHBalance = address(this).balance;
        if (contractETHBalance > 0) {
            uint256 amountToDistribute = contractETHBalance;
            distributeFees(amountToDistribute);
        }
    }

    function withdrawStuckEther(uint256 amount) external onlyOwner {
        require(tradingEnabled, "Trading must be enabled");
        require(hasLaunched, "Liquidity must be added");
        require(amount <= address(this).balance, "Insufficient balance");
         _deployerWallet.transfer(amount);
    }

    function withdrawStuckTokens(
        address tokenAddress,
        uint256 amount
    ) external onlyOwner {
        require(tradingEnabled, "Trading must be enabled");
        require(hasLaunched, "Liquidity must be added");
        IERC20 tokenContract = IERC20(tokenAddress);
        uint256 contractBalance = tokenContract.balanceOf(address(this));
        require(amount <= contractBalance, "Insufficient balance");
        tokenContract.transfer(_deployerWallet, amount);
    }

    function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
        require(
            pair != uniswapV2Pair || value == true,
            "The uniswap pair cannot be removed"
        );
        _setAutomatedMarketMakerPair(pair, value);
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {
        automatedMarketMakerPairs[pair] = value;
        emit SetAutomatedMarketMakerPair(pair, value);
    }

    receive() external payable {}
}

{
  "compilationTarget": {
    "contracts/RULER.sol": "RULER"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}