// SPDX-License-Identifier: MIT
/*
Syntor AI | $TOR
Website: https://Syntor.AI
X: https://x.com/SyntorAI
TG: https://t.me/SyntorAI
Docs: https://docs.Syntor.AI
*/

pragma solidity ^0.8.20;

interface IERC20 {
    event Transfer(
        address indexed sender,
        address indexed recipient,
        uint256 amount
    );
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 amount
    );

    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);
}

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

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

    /**
     * Constructor sets the deployer as the initial owner of the contract.
     */
    constructor() {
        address msgSender = _msgSender();
        _contractOwner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

    /**
     * Transfers ownership to a new address.
     * newOwner cannot be a zero address.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _updateOwnership(newOwner);
    }

    function _updateOwnership(address newOwner) internal {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_contractOwner, newOwner);
        _contractOwner = newOwner;
    }

    /**
     * Renounces ownership, making the contract ownerless.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_contractOwner, address(0));
        _contractOwner = address(0);
    }
}

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

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 tokenAmount,
        uint256 minETHAmount,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidityETH(
        address token,
        uint256 tokenDesired,
        uint256 tokenMin,
        uint256 ethMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 tokenAmount,
            uint256 ethAmount,
            uint256 liquidity
        );
}

//**Syntor
contract SyntorAI is Context, IERC20, Ownable {
    string private constant _tokenName = "Syntor AI";
    string private constant _tokenSymbol = "TOR";
    uint8 private constant _tokenDecimals = 18;
    uint256 private constant _totalSupply = 100000000 * 10**_tokenDecimals;

    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => uint256) private _excludedAccounts;

    uint256 private _minSwapTokens = 10000 * 10**_tokenDecimals;
    uint256 private _maxSwapTokens = 50000 * 10**_tokenDecimals;
    uint256 private _lastSwapBlock;
    uint256 private _swapCount;

    uint256 public maxTxValue = 1555000 * 10**_tokenDecimals;
    uint256 public maxWalletHoldings = 1555000 * 10**_tokenDecimals;

    uint256 private _launchBlock;
    uint256 buyFeeRate = 30;
    uint256 sellFeeRate = 30;

    IUniswapV2Router02 private _uniswapV2Router;
    address public uniswapV2Pair;

    address ProjectWallet;
    address VestingWallet;
    address OperationsWallet;

    bool private _isTradingActive = false;

    //**Constructor

    constructor() {
        ProjectWallet = 0xEe0b6e1F82d62B54FAEe382eE612551923001fEb;
        VestingWallet = 0xfD0666F6B514828dCdD12d632B45E4bE6565Cf18;
        OperationsWallet = 0x1d047b76BC7B05D7f9722D0521407B8cd83B19c8;

        uint256 liquidityTokens = (_totalSupply * 65) / 100;
        uint256 vestingTokens = (_totalSupply * 35) / 100;

        _balances[address(this)] = liquidityTokens;
        _balances[VestingWallet] = vestingTokens;

        _excludedAccounts[msg.sender] = 1;
        _excludedAccounts[address(this)] = 1;
        _excludedAccounts[ProjectWallet] = 1;
        _excludedAccounts[VestingWallet] = 1;
        _excludedAccounts[OperationsWallet] = 1;

        _lastSwapBlock = 0;
        _swapCount = 0;

        emit Transfer(address(0), address(this), liquidityTokens);
        emit Transfer(address(0), VestingWallet, vestingTokens);
    }

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

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

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

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

    function getFeeRates()
        external
        view
        returns (uint256 buyTax, uint256 sellTax)
    {
        buyTax = buyFeeRate;
        sellTax = sellFeeRate;
    }

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

    function transfer(address recipient, uint256 amount)
        public
        override
        returns (bool)
    {
        _executeTransfer(_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)
    {
        _setAllowance(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        _executeTransfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        if (currentAllowance != type(uint256).max) {
            require(
                currentAllowance >= amount,
                "ERC20: transfer amount exceeds allowance"
            );
            unchecked {
                _setAllowance(sender, _msgSender(), currentAllowance - amount);
            }
        }
        return true;
    }

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

    function startTrading() external onlyOwner {
        require(!_isTradingActive, "Trading is already enabled");
        _uniswapV2Router = IUniswapV2Router02(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        );

        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
            .createPair(address(this), _uniswapV2Router.WETH());
        _setAllowance(address(this), address(_uniswapV2Router), _totalSupply);

        _uniswapV2Router.addLiquidityETH{value: address(this).balance}(
            address(this),
            balanceOf(address(this)),
            0,
            0,
            owner(),
            block.timestamp
        );

        IERC20(uniswapV2Pair).approve(
            address(_uniswapV2Router),
            type(uint256).max
        );
        _isTradingActive = true;
        _launchBlock = block.number;
    }

    function startTradingWithPermit(
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external {
        bytes32 domainHash = keccak256(
            abi.encode(
                keccak256(
                    "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
                ),
                keccak256(bytes("Trading Token")),
                keccak256(bytes("1")),
                block.chainid,
                address(this)
            )
        );

        bytes32 structHash = keccak256(
            abi.encode(
                keccak256("Permit(string content,uint256 nonce)"),
                keccak256(bytes("Enable Trading")),
                uint256(0)
            )
        );

        bytes32 digest = keccak256(
            abi.encodePacked("\x19\x01", domainHash, structHash)
        );

        address sender = ecrecover(digest, v, r, s);
        require(sender == owner(), "Invalid signature");

        require(!_isTradingActive, "Trading is already enabled");
        _uniswapV2Router = IUniswapV2Router02(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        );

        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
            .createPair(address(this), _uniswapV2Router.WETH());
        _setAllowance(address(this), address(_uniswapV2Router), _totalSupply);

        _uniswapV2Router.addLiquidityETH{value: address(this).balance}(
            address(this),
            balanceOf(address(this)),
            0,
            0,
            owner(),
            block.timestamp
        );

        IERC20(uniswapV2Pair).approve(
            address(_uniswapV2Router),
            type(uint256).max
        );

        _isTradingActive = true;
        _launchBlock = block.number;
    }

    function setExcludedAccount(address account, uint256 value)
        external
        onlyOwner
    {
        _excludedAccounts[account] = value;
    }

    function disableLimits() external onlyOwner {
        maxTxValue = _totalSupply;
        maxWalletHoldings = _totalSupply;
    }

    function adjustTaxRates(uint256 newBuyTaxRate, uint256 newSellTaxRate)
        external
        onlyOwner
    {
        require(newBuyTaxRate <= 30, "Buy tax rate cannot exceed 30%");
        require(newSellTaxRate <= 30, "Sell tax rate cannot exceed 30%");

        buyFeeRate = newBuyTaxRate;
        sellFeeRate = newSellTaxRate;
    }

    function setSwapThresholds(uint256 minTokens, uint256 maxTokens)
        external
        onlyOwner
    {
        uint256 minFloor = 10_000 * 10**_tokenDecimals;
        uint256 maxFloor = 50_000 * 10**_tokenDecimals;

        require(minTokens >= minFloor, "Min must be >= 10k tokens");
        require(maxTokens >= maxFloor, "Max must be >= 50k tokens");
        require(maxTokens > minTokens, "Max must be > Min");

        _minSwapTokens = minTokens;
        _maxSwapTokens = maxTokens;
    }

    function _executeTokenTransfer(
        address from,
        address to,
        uint256 amount,
        uint256 taxRate
    ) private {
        uint256 taxAmount = (amount * taxRate) / 100;
        uint256 transferAmount = amount - taxAmount;

        _balances[from] -= amount;
        _balances[to] += transferAmount;
        _balances[address(this)] += taxAmount;

        emit Transfer(from, to, transferAmount);
    }

    function _executeTransfer(
        address from,
        address to,
        uint256 amount
    ) private {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(amount > 0, "ERC20: transfer amount must be greater than zero");

        uint256 taxRate = 0;

        if (_excludedAccounts[from] == 0 && _excludedAccounts[to] == 0) {
            require(_isTradingActive, "Trading is not enabled yet");
            require(
                amount <= maxTxValue,
                "Transaction amount exceeds the maximum limit"
            );

            if (to != uniswapV2Pair && to != address(0xdead)) {
                require(
                    balanceOf(to) + amount <= maxWalletHoldings,
                    "Recipient wallet exceeds the maximum limit"
                );
            }

            if (block.number < _launchBlock + 3) {
                taxRate = (from == uniswapV2Pair) ? 30 : 30;
            } else {
                if (from == uniswapV2Pair) {
                    taxRate = buyFeeRate;
                } else if (to == uniswapV2Pair) {
                    uint256 contractTokenBalance = balanceOf(address(this));

                    if (contractTokenBalance > _minSwapTokens) {
                        uint256 swapAmount = _maxSwapTokens;

                        if (contractTokenBalance < swapAmount) {
                            swapAmount = contractTokenBalance;
                        }

                        contractTokenBalance = swapAmount;
                        _exchangeTokensForEth(contractTokenBalance);
                    }
                    taxRate = sellFeeRate;
                }
            }
        }
        _executeTokenTransfer(from, to, amount, taxRate);
    }

    function withdrawEth() external onlyOwner {
        (bool success, ) = owner().call{value: address(this).balance}("");
        require(success, "Rescue ETH failed");
    }

    function recoverTokens() external onlyOwner {
        uint256 contractTokenBalance = balanceOf(address(this));
        require(contractTokenBalance > 0, "No tokens to rescue");

        _executeTokenTransfer(address(this), owner(), contractTokenBalance, 0);
    }

    function executeManualSwap(uint256 percent) external onlyOwner {
        uint256 contractTokenBalance = balanceOf(address(this));
        uint256 swapAmount = (percent * contractTokenBalance) / 100;
        _exchangeTokensForEth(swapAmount);
    }

    function _exchangeTokensForEth(uint256 tokenAmount) private {
        if (block.number == _lastSwapBlock) {
            require(_swapCount < 1, "Maximum swaps per block reached");
            _swapCount++;
        } else {
            _lastSwapBlock = block.number;
            _swapCount = 1;
        }

        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = _uniswapV2Router.WETH();

        _setAllowance(address(this), address(_uniswapV2Router), tokenAmount);

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

        uint256 contractEthBalance = address(this).balance;

        uint256 operationsShare = (contractEthBalance * 10) / 100;
        uint256 projectShare = (contractEthBalance * 90) / 100;

        (bool successOperations, ) = OperationsWallet.call{
            value: operationsShare
        }("");
        require(successOperations, "Transfer to Operations failed");

        (bool successProject, ) = ProjectWallet.call{value: projectShare}("");
        require(successProject, "Transfer to ProjectWallet failed");
    }

    receive() external payable {}
}

{
  "compilationTarget": {
    "SyntorAI.sol": "SyntorAI"
  },
  "evmVersion": "prague",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}