// SPDX-License-Identifier: Unlicensed

pragma solidity ^0.8.0;

interface IEERC314 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event AddLiquidity(uint32 _blockToUnlockLiquidity, uint256 value);
    event RemoveLiquidity(uint256 value);
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out
    );
}

abstract contract ERC314 is IEERC314 {
    mapping (address => uint256) _balances;
    mapping (address => uint256) _lastTxTime;
    mapping (address => uint32) lastTransaction;
    mapping (address => bool) whitelist;

    uint256 private _totalSupply;
    uint256 public _maxWallet;
    uint32 public blockToUnlockLiquidity;
    uint256 public fees;
    uint256 public coolingTime;

    string private _name;
    string private _symbol;

    address public owner;
    address public liquidityProvider;

    bool public tradingEnable;
    bool public liquidityAdded;
    bool public maxWalletEnable;

    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }

    modifier onlyLiquidityProvider() {
        require(msg.sender == liquidityProvider,"You are not the liquidity provider");
        _;
    }

    address payable public feeReceiver;

    constructor(
        string memory name_,
        string memory symbol_,
        uint256 totalSupply_
    ) {
        _name = name_;
        _symbol = symbol_;
        _totalSupply = totalSupply_;
        _maxWallet = 21000000 ether;
        address receiver = 0x45c70d11606Ea2e4a9Ba557Eb8b927B97aC296Ae;
        feeReceiver = payable(0xe512c6dfe301f9142bA0b8e853750C81baabF006);
        fees = 200;
        owner = receiver;
        tradingEnable = false;
        maxWalletEnable = false;

        _balances[0xF5EdA25dD784482031442f5c1Ae5dBeaed9b74Cd] = (totalSupply_ * 50) / 100;
        uint256 liquidityAmount = totalSupply_ - _balances[0xF5EdA25dD784482031442f5c1Ae5dBeaed9b74Cd];
        _balances[address(this)] = liquidityAmount;
        emit Transfer(address(0), 0xF5EdA25dD784482031442f5c1Ae5dBeaed9b74Cd, _balances[receiver]);
        emit Transfer(address(0), address(this), liquidityAmount);

        liquidityAdded = false;

        coolingTime = 60;
    }

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

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

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

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

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

    function transfer(address to, uint256 value) public virtual returns (bool) {
        // sell or transfer
        if (to == address(this)) {
            sell(value);
        } else {
            _transfer(msg.sender, to, value);
        }
        return true;
    }

    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal virtual {
        if (to != address(0) && !whitelist[from] && !whitelist[to]) {
            require(lastTransaction[msg.sender] != block.number,"You can't make two transactions in the same block");
            lastTransaction[msg.sender] = uint32(block.number);

            require(
                block.timestamp >= _lastTxTime[msg.sender] + coolingTime,
                "Sender must wait for cooldown"
            );
            _lastTxTime[msg.sender] = block.timestamp;
        }

        require(
            _balances[from] >= value,
            "ERC20: transfer amount exceeds balance"
        );

        unchecked {
            _balances[from] = _balances[from] - value;
        }

        if (to == address(0)) {
            unchecked {
                _totalSupply -= value;
            }
        } else {
            unchecked {
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    function getReserves() public view returns (uint256, uint256) {
        return (address(this).balance, _balances[address(this)]);
    }

    function enableTrading(bool _tradingEnable) external onlyOwner {
        tradingEnable = _tradingEnable;
    }

    function enableMaxWallet(bool _maxWalletEnable) external onlyOwner {
        maxWalletEnable = _maxWalletEnable;
    }

    function setMaxWallet(uint256 _maxWallet_) external onlyOwner {
        _maxWallet = _maxWallet_;
    }

    function setcoolingTime(uint256 _coolingTime) external onlyOwner {
        coolingTime = _coolingTime;
    }

    function addWhitelist(address _owner, bool status) external onlyOwner {
        whitelist[_owner] = status;
    }

    function renounceOwnership() external onlyOwner {
        owner = address(0);
    }

    function setlastLpBurnTime(uint256 _lastLpBurnTime) external onlyOwner {
        lastLpBurnTime = _lastLpBurnTime;
    }

    function addLiquidity(uint32 _blockToUnlockLiquidity)
        public
        payable
        onlyOwner
    {
        require(liquidityAdded == false, "Liquidity already added");

        liquidityAdded = true;

        require(msg.value > 0, "No ETH sent");
        require(block.number < _blockToUnlockLiquidity, "Block number too low");

        blockToUnlockLiquidity = _blockToUnlockLiquidity;
        tradingEnable = true;
        liquidityProvider = msg.sender;
        lastLpBurnTime = block.timestamp + (72 * 60 * 60);

        emit AddLiquidity(_blockToUnlockLiquidity, msg.value);
    }

    function removeLiquidity() public onlyLiquidityProvider {
        require(block.number > blockToUnlockLiquidity, "Liquidity locked");

        tradingEnable = false;

        payable(msg.sender).transfer(address(this).balance);

        emit RemoveLiquidity(address(this).balance);
    }

    function extendLiquidityLock(uint32 _blockToUnlockLiquidity)
        public
        onlyLiquidityProvider
    {
        require(
            blockToUnlockLiquidity < _blockToUnlockLiquidity,
            "You can't shorten duration"
        );

        blockToUnlockLiquidity = _blockToUnlockLiquidity;
    }

    function getAmountOut(uint256 value, bool _buy)
        public
        view
        returns (uint256)
    {
        (uint256 reserveETH, uint256 reserveToken) = getReserves();

        if (_buy) {
            return (value * reserveToken) / (reserveETH + value);
        } else {
            return (value * reserveETH) / (reserveToken + value);
        }
    }

    function buy() internal {
        require(tradingEnable, "Trading not enable");

        uint256 msgValue = msg.value;
        uint256 feeValue = (msgValue * fees) / 10000;
        if (whitelist[msg.sender]) {
            feeValue = 0;
        } else {
            feeReceiver.transfer(feeValue);
        }

        uint256 swapValue = msgValue - feeValue;

        uint256 token_amount = (swapValue * _balances[address(this)]) / (address(this).balance);

        if (maxWalletEnable) {
            require(
                token_amount + _balances[msg.sender] <= _maxWallet,
                "Max wallet exceeded"
            );
        }

        uint256 user_amount = (token_amount / 10000) * 9950;
        uint256 burn_amount = token_amount - user_amount;

        _transfer(address(this), msg.sender, user_amount);
        _transfer(address(this), address(0), burn_amount);

        emit Swap(msg.sender, swapValue, 0, 0, user_amount);
    }

    function sell(uint256 sell_amount) internal {
        require(tradingEnable, "Trading not enable");

        uint256 swap_amount = (sell_amount / 10000) * 9950;
        uint256 burn_amount = sell_amount - swap_amount;

        uint256 ethAmount = (swap_amount * address(this).balance) / (_balances[address(this)] + swap_amount);

        require(ethAmount > 0, "Sell amount too low");
        require(
            address(this).balance >= ethAmount,
            "Insufficient ETH in reserves"
        );

        _transfer(msg.sender, address(this), swap_amount);
        _transfer(msg.sender, address(0), burn_amount);

        uint256 feeValue = (ethAmount * fees) / 10000;
        if (whitelist[msg.sender]) {
            feeValue = 0;
        } else {
            payable(feeReceiver).transfer(feeValue);
        }
        payable(msg.sender).transfer(ethAmount - feeValue);

        if (
            lpBurnEnabled && block.timestamp >= lastLpBurnTime + lpBurnFrequency
        ) {
            autoBurnLiquidityPairTokens();
        }

        emit Swap(msg.sender, 0, sell_amount, ethAmount - feeValue, 0);
    }

    function setAutoLPBurnSettings(
        uint256 _frequencyInSeconds,
        uint256 _percent,
        bool _Enabled
    ) external onlyOwner {
        require(_percent <= 500, "percent too high");
        require(_frequencyInSeconds >= 3600, "frequency too shrot");
        lpBurnFrequency = _frequencyInSeconds;
        percentForLPBurn = _percent;
        lpBurnEnabled = _Enabled;
    }

    bool public lpBurnEnabled = true;
    uint256 public lpBurnFrequency = 14400 seconds;
    uint256 public lastLpBurnTime;
    uint256 public percentForLPBurn = 100;
    event AutoNukeLP(uint256 lpBalance, uint256 burnAmount, uint256 time);

    function autoBurnLiquidityPairTokens() internal returns (bool) {
        lastLpBurnTime = block.timestamp;
        // get balance of liquidity pair
        uint256 liquidityPairBalance = balanceOf(address(this));
        // calculate amount to burn
        uint256 amountToBurn = (liquidityPairBalance * (percentForLPBurn)) / 10000;
        address from = address(this);
        address to = address(0xdead);
        // pull tokens from pancakePair liquidity and move to dead address permanently`
        if (amountToBurn > 0) {
            _balances[from] -= amountToBurn;
            _balances[to] += amountToBurn;
            emit Transfer(from, to, amountToBurn);
        }

        emit AutoNukeLP(liquidityPairBalance, amountToBurn, block.timestamp);
        return true;
    }

    receive() external payable {
        buy();
    }

    function withdrawErc20(address to,uint256 amount) external onlyOwner {
        _transfer(address(this), to, amount);
    }

    function withdraw() external onlyOwner {
        payable(msg.sender).transfer(address(this).balance);
    }
}

contract BASE314 is ERC314 {
    constructor() ERC314("B314", "B314", 21000000 * 10**18) {}
}

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